PyMOL Wiki - User contributions [en]

Get Names

2016-02-19T15:31:53Z

Sbliven: Updating argument list

'''get_names''' returns a list of object and/or selection names.

===PYMOL API===
<source lang="python">
cmd.get_names(type,enabled_only,selection)
</source>

===ARGUMENTS===
* '''type : string''' determines the type of objects to be returned. It can take any of the following values:
** '''objects''' Structure objects
** '''selections''' All selection
** '''all''' Objects and Selections
** '''public_objects''' (default)
** '''public_selections'''
** '''public_nongroup_objects'''
** '''public_group_objects'''
** '''nongroup_objects'''
** '''group_objects'''
* '''enabled_only : boolean''' If 1, only enabled objects are returned. Default 0 (all objects)
* '''selection'''
===NOTES===
The default behavior is to return only object names.

=== EXAMPLES ===
Multiple alignments
<source lang="python">
# structure align all proteins in PyMOL to the protein named "PROT". Effectively a
# poor multiple method for multiple structure alignment.
for x in cmd.get_names("all"): cealign( "PROT", x)
</source>

Determine whether or not an object (objName) is enabled:
<source lang="python">
if objName in cmd.get_names(enabled_only=1):
print objName, "is enabled"
</source>

===SEE ALSO===
[[get_type]], [[get_names_of_type]], [[count_atoms]], [[count_states]]

[[Category:Commands|Get Names]]

Talk:SuperSym

2016-01-13T12:08:52Z

Sbliven: /* this script does not work */

Wow, nice contribution. If it's this large, can you package it up in a tar/zip file for easier download?
[[User:Inchoate|Tree]] 23:02, 1 September 2009 (UTC)

FYI, PyMOLWiki pages see more action and downloads when they have images/screenshots of what is being offered. Just a hint.
[[User:Inchoate|Tree]] 15:34, 18 September 2009 (UTC)

== this script does not work ==

I am running a six month old laptop with Windows 7. I have installed Python 3.1, cctbx and numpy 1.5 and this script still will not run at all. It keeps quitting saying "OOOPs" please install cctbx and numpy, which I can clearly see are installed. This script clearly needs more work.

: I was also unable to get this plugin working with a resonable amount of effort. The cctbx python modules are available using the cctbx-python script, but I was unable to get PyMOL to launch from that python environment. --[[User:Sbliven|Sbliven]] ([[User talk:Sbliven|talk]]) 12:08, 13 January 2016 (UTC)

Flatten obj

2015-11-03T13:29:20Z

Sbliven: Removing incorrect API section

{{Infobox script-repo
|type = script
|filename = flatten_obj.py
|author = [[User:sbliven|Spencer Bliven]]
|license = Public Domain
}}

= Description =

The <code>flatten_obj</code> python script combines multiple objects or states into a single object,
renaming chains where required.

This is particularly useful for dealing with biological assemblies, which are
loaded as multi-state objects when fetched using <code>[[fetch]] PDBID, type=pdb1</code>. It
can also be used as a quick way to combine multiple objects without causing
collisions between chain identifiers.

The command re-letters chains to avoid collisions. Older versions of PyMOL
restrict the chain id to a single character, so the script will fail for
assemblies with >62 chains. With more recent versions, this problem is solved
with multi-character chain IDs. Several options are available for how
re-lettering should occur.

= Usage =

flatten_obj name, selection[, state[, rename[, quiet[, chain_map]]]]

= Arguments =

* name = a unique name for the flattened object {default: flat}

* selection = the set of objects to include in the flattening. The selection will be expanded to include all atoms of objects. {default: all}

* state = the source state to select. Use 0 or -1 to flatten all states {default: 0}

* rename = The scheme to use for renaming chains: {default: 0}
** (0) preserve chains IDs where possible, rename other chains alphabetically
** (1) rename all chains alphabetically
** (2) rename chains using the original chain letter, object name, and state

* quiet = If set to 0, print some additional information about progress and chain renaming {default: 1}

* chain_map = An attribute name for the 'stored' scratch object. If specified, `stored.<chain_map>` will be populated with a dictionary mapping the new chain names to a tuple giving the originated object, state, and chainID. {default: ""}

= Notes =

Like the select command, if name is omitted then the default object name
("flat") is used as the name argument.

Chain renaming is tricky. PDB files originally limited chains to single
letter identifiers containing [A-Za-z0-9]. When this was found to be
limiting, multi-letter chains (ideally < 4 chars) were allowed. This is
supported as of PyMOL 1.7. Earlier versions do not accept rename=2, and
will raise an exception when flattening a structure with more than 62
chains.

= Examples =

flatten_obj flat, nmrObj
flatten_obj ( obj1 or obj2 )

= See Also =

* [[split_states]]

[[Category:Script_Library]] [[Category:ObjSel_Scripts]]

Flatten obj

2015-10-30T15:59:00Z

Sbliven: Replacing code with github link

{{Infobox script-repo
|type = script
|filename = flatten_obj.py
|author = [[User:sbliven|Spencer Bliven]]
|license = Public Domain
}}

= Description =

The <code>flatten_obj</code> python script combines multiple objects or states into a single object,
renaming chains where required.

This is particularly useful for dealing with biological assemblies, which are
loaded as multi-state objects when fetched using <code>[[fetch]] PDBID, type=pdb1</code>. It
can also be used as a quick way to combine multiple objects without causing
collisions between chain identifiers.

The command re-letters chains to avoid collisions. Older versions of PyMOL
restrict the chain id to a single character, so the script will fail for
assemblies with >62 chains. With more recent versions, this problem is solved
with multi-character chain IDs. Several options are available for how
re-lettering should occur.

= Usage =

flatten_obj name, selection[, state[, rename[, quiet[, chain_map]]]]

= Arguments =

* name = a unique name for the flattened object {default: flat}

* selection = the set of objects to include in the flattening. The selection will be expanded to include all atoms of objects. {default: all}

* state = the source state to select. Use 0 or -1 to flatten all states {default: 0}

* rename = The scheme to use for renaming chains: {default: 0}
** (0) preserve chains IDs where possible, rename other chains alphabetically
** (1) rename all chains alphabetically
** (2) rename chains using the original chain letter, object name, and state

* quiet = If set to 0, print some additional information about progress and chain renaming {default: 1}

* chain_map = An attribute name for the 'stored' scratch object. If specified, `stored.<chain_map>` will be populated with a dictionary mapping the new chain names to a tuple giving the originated object, state, and chainID. {default: ""}

= Notes =

Like the select command, if name is omitted then the default object name
("flat") is used as the name argument.

Chain renaming is tricky. PDB files originally limited chains to single
letter identifiers containing [A-Za-z0-9]. When this was found to be
limiting, multi-letter chains (ideally < 4 chars) were allowed. This is
supported as of PyMOL 1.7. Earlier versions do not accept rename=2, and
will raise an exception when flattening a structure with more than 62
chains.

= Examples =

flatten_obj flat, nmrObj
flatten_obj ( obj1 or obj2 )

= PyMol API =

cmd.flatten_obj(string name, string selection)

= See Also =

* [[split_states]]

[[Category:Script_Library]] [[Category:ObjSel_Scripts]]

Flatten obj

2015-10-30T14:15:33Z

Sbliven: Creating page

{{Infobox script-repo
|type = script
|download = Submitted to the [[Git_intro|Pymol-script-repo]] as flatten_obj.py
|author = [[User:sbliven|Spencer Bliven]]
|license = Public Domain
}}

= Description =

The <code>flatten_obj</code> python script combines multiple objects or states into a single object,
renaming chains where required.

This is particularly useful for dealing with biological assemblies, which are
loaded as multi-state objects when fetched using <code>[[fetch]] PDBID, type=pdb1</code>. It
can also be used as a quick way to combine multiple objects without causing
collisions between chain identifiers.

The command re-letters chains to avoid collisions. Older versions of PyMOL
restrict the chain id to a single character, so the script will fail for
assemblies with >62 chains. With more recent versions, this problem is solved
with multi-character chain IDs. Several options are available for how
re-lettering should occur.

= Usage =

flatten_obj name, selection[, state[, rename[, quiet[, chain_map]]]]

= Arguments =

* name = a unique name for the flattened object {default: flat}

* selection = the set of objects to include in the flattening. The selection will be expanded to include all atoms of objects. {default: all}

* state = the source state to select. Use 0 or -1 to flatten all states {default: 0}

* rename = The scheme to use for renaming chains: {default: 0}
** (0) preserve chains IDs where possible, rename other chains alphabetically
** (1) rename all chains alphabetically
** (2) rename chains using the original chain letter, object name, and state

* quiet = If set to 0, print some additional information about progress and chain renaming {default: 1}

* chain_map = An attribute name for the 'stored' scratch object. If specified, `stored.<chain_map>` will be populated with a dictionary mapping the new chain names to a tuple giving the originated object, state, and chainID. {default: ""}

= Notes =

Like the select command, if name is omitted then the default object name
("flat") is used as the name argument.

Chain renaming is tricky. PDB files originally limited chains to single
letter identifiers containing [A-Za-z0-9]. When this was found to be
limiting, multi-letter chains (ideally < 4 chars) were allowed. This is
supported as of PyMOL 1.7. Earlier versions do not accept rename=2, and
will raise an exception when flattening a structure with more than 62
chains.

= Examples =

flatten_obj flat, nmrObj
flatten_obj ( obj1 or obj2 )

= PyMol API =

cmd.flatten_obj(string name, string selection)

= Code =

<syntaxhighlight lang="python">
"""
flatten_obj.py - Flatten multi-state pymol objects into a single state.

This is particularly useful for dealing with biological assemblies, which are
loaded as multi-state objects when fetched using `fetch PDBID, type=pdb1`. It
can also be used as a quick way to combine multiple objects without causing
collisions between chain identifiers.

The command re-letters chains to avoid collisions. Older versions of PyMOL
restrict the chain id to a single character, so the script will fail for
assemblies with >62 chains. With more recent versions, this problem is solved
with multi-character chain IDs. Several options are available for how
re-lettering should occur.

Author: Spencer Bliven <spencer.bliven@gmail.com>
Date: October 30, 2015
Version: 1.0
License: Public Domain
"""
from pymol import cmd, stored
import re
try:
from collections import OrderedDict
_orderedDict = True
except ImportError:
_orderedDict = False

# PyMOL 1.7.4 introduces support for multi-letter chains, so we can afford to
# use a smaller alphabet. In earlier versions, use lower-case letters if needed
# (requires running `set ignore_case, 0`)
_long_chains = cmd.get_version()[1] >= 1.74
_default_base = 36 if _long_chains else 62

class OutOfChainsError(Exception):
def __init__(self,msg):
self.msg=msg
def __str__(self):
return str(self.msg)

class ChainSet(object):
"""
Base class for various methods to rename chains

Contains _chains, which maps from the renamed chain to a tuple with the
original (object,state,chain). All dict-like accessors work on ChainSets,
e.g.
chain_set["A"] -> ("obj",1,"A")

"""
def __init__(self):
# Use an OrderedDict in Python >= 1.7 for better printing
if _orderedDict:
self._chains = OrderedDict()
else:
self._chains = dict()

def map_chain(self, obj, state, origChain ):
"""
map_chain(string obj,int state, string chain]]) -> string

Maps a chain letter to a unique chainID. Results are unique within each
instance, and can be used as keys on this chain set.
"""
raise NotImplementedError("Base class")

# delegate most methods to _chains
def __getattr__(self,at):
if at in "pop popitem update setdefault".split():
raise AttributeError("type object '%s' has no attribute '%s'"%(type(self),at))
return getattr(self._chains,at)
def __cmp__(self,other): return self._chains.__cmp__(other)
def __eq__(self,other): return self._chains.__eq__(other)
def __ge__(self,other): return self._chains.__ge__(other)
def __gt__(self,other): return self._chains.__gt__(other)
def __le__(self,other): return self._chains.__le__(other)
def __lt__(self,other): return self._chains.__lt__(other)
def __ne__(self,other): return self._chains.__ne__(other)
def __len__(self): return self._chains.__len__()
def __contains__(self,key): return self._chains.__contains__(key)
def __getitem__(self,key): return self._chains.__getitem__(key)
def __iter__(self): return self._chains.__iter__()
def __str__(self): return str(self._chains)

@staticmethod
def _int_to_chain(i,base=_default_base):
"""
_int_to_chain(int,int) -> str

Converts a positive integer to a chain ID. Chain IDs include uppercase
characters, numbers, and optionally lowercase letters.

i = a positive integer to convert
base = the alphabet size to include. Typically 36 or 62.
"""
if i < 0:
raise ValueError("positive integers only")
if base < 0 or 62 < base:
raise ValueError("Invalid base")

quot = int(i)/base
rem = i%base
if rem < 26:
letter = chr( ord("A") + rem)
elif rem < 36:
letter = str( rem-26)
else:
letter = chr( ord("a") + rem - 36)
if quot == 0:
return letter
else:
return ChainSet._int_to_chain(quot-1,base) + letter

class DefaultChainSet(ChainSet):
"""
Avoids relettering chains if possible. If a chain has been used, uses the
next available chain letter. Note that this can potentially lead to
cascading renames, e.g. if chains are sorted alphabetically rather than by
object.

Used for rename = 0.
"""
def __init__(self):
super(DefaultChainSet,self).__init__()
self._next_chain = 0
def map_chain(self, obj, state, origChain ):
# Keep _next_chain up-to-date
while ChainSet._int_to_chain(self._next_chain) in self:
self._next_chain += 1
# Map this chain
if origChain in self:
# Rename
next_chain = ChainSet._int_to_chain(self._next_chain)
self._next_chain += 1
else:
next_chain = origChain
self._chains[next_chain] = (obj,state,origChain)
return next_chain

class SequentialChainSet(ChainSet):
"""
Renumbers all chains starting at A, continuing through the capital letters
and numbers, and then adding additional letters through 9999 (the last
valid chain for mmCIF) and beyond.

Used for rename=1
"""
def __init__(self):
super(SequentialChainSet,self).__init__()
self._next_chain = 0

def map_chain(self, obj, state, origChain ):
next_chain = ChainSet._int_to_chain(self._next_chain)
self._chains[next_chain] = (obj,state,origChain)
self._next_chain += 1
return next_chain

class LongChainSet(ChainSet):
"""
Uses long strings for the chain names. Chains are renamed like
"%s_%s_%04d"%(original_chainid,objectname,state).

Used for rename=2
"""
def map_chain(self, obj, state, origChain ):
ch = "%s_%s_%04d"%(origChain,obj,state)
if self.has_key(ch):
raise ValueError("Duplicate chain %s"%(ch))
self._chains[ch] = (obj,state,origChain)
return ch

def flatten_obj(name="",selection="",state=0,rename=0,quiet=1,chain_map=""):
"""
DESCRIPTION

"flatten_obj" combines multiple objects or states into a single object,
renaming chains where required

USAGE

flatten_obj name, selection[, state[, rename[, quiet[, chain_map]]]]

ARGUMENTS

name = a unique name for the flattened object {default: flat}

selection = the set of objects to include in the flattening. The selection
will be expanded to include all atoms of objects. {default: all}

state = the source state to select. Use 0 or -1 to flatten all states {default: 0}

rename = The scheme to use for renaming chains: {default: 0}
(0) preserve chains IDs where possible, rename other chains
alphabetically
(1) rename all chains alphabetically
(2) rename chains using the original chain letter, object name, and state

quiet = If set to 0, print some additional information about progress and
chain renaming {default: 1}

chain_map = An attribute name for the 'stored' scratch object. If
specified, `stored.<chain_map>` will be populated with a dictionary
mapping the new chain names to a tuple giving the originated object,
state, and chainID. {default: ""}

NOTES

Like the select command, if name is omitted then the default object name
("flat") is used as the name argument.

Chain renaming is tricky. PDB files originally limited chains to single
letter identifiers containing [A-Za-z0-9]. When this was found to be
limiting, multi-letter chains (ideally < 4 chars) were allowed. This is
supported as of PyMOL 1.7. Earlier versions do not accept rename=2, and
will raise an exception when flattening a structure with more than 62
chains.

EXAMPLES

flatten_obj flat, nmrObj
flatten_obj ( obj1 or obj2 )

PYMOL API

cmd.flatten_obj(string name, string selection)

SEE ALSO

split_states

"""

# arguments

# Single argument; treat as selection
if name and not selection:
selection = name
name = ""
# default name and selection
if not name:
name = "flat"
if not selection:
selection = "(all)"

state = int(state)
rename = int(rename)
quiet = int(quiet)

# Wrap in extra parantheses for get_object_list
selection = "( %s )" % selection

if rename == 0:
chainSet = DefaultChainSet()
elif rename == 1:
chainSet = SequentialChainSet()
elif rename == 2:
chainSet = LongChainSet()
else:
raise ValueError("Unrecognized rename option (Valid: 0,1,2)")

metaprefix = "temp" #TODO unique prefix

# store original value of retain_order, which causes weird interleaving of
# structures if enabled.
retain_order = cmd.get("retain_order")
try:
cmd.set("retain_order",0)

# create new object for each state
for obj in cmd.get_object_list(selection):

if state <= 0:
# all states
prefix = "%s_%s_"%(metaprefix,obj)
cmd.split_states(obj,prefix=prefix)
else:
prefix = "%s_%s_%04d"%(metaprefix,obj,state)
cmd.create(prefix, obj, state, 1)

# renumber all states
statere = re.compile("^%s_(.*)_(\d+)$" % metaprefix) # matches split object names

warn_lowercase = False

# Iterate over all objects with metaprefix
try:
for obj in cmd.get_object_list("(%s_*)"%(metaprefix) ):
m = statere.match(obj)
if m is None:
print("Failed to match object %s" %obj)
continue
origobj = m.group(1)
statenum = int(m.group(2))

chains = set([atom.chain for atom in cmd.get_model(obj).atom])

rev_chain_map = {} #old -> new, for this obj only
for chain in sorted(chains):
new_chain = chainSet.map_chain(origobj,statenum,chain)
rev_chain_map[chain] = new_chain
if not quiet:
print(" %s state %d chain %s -> %s"%(origobj,statenum,chain, new_chain) )
if not _long_chains:
if len(new_chain) > 1:
raise OutOfChainsError("No additional chains available (max 62).")

try:
stored_name = stored.get_unused_name()
except AttributeError:
# backup solution for PyMOL < 1.6
stored_name = "_flatten_obj_chainMapping"

setattr(stored,stored_name,rev_chain_map)
cmd.alter(obj,"chain = stored.%s[chain]"%stored_name)
delattr(stored,stored_name)

print("Creating object from %s_*"%metaprefix)
# Recombine into a single object
cmd.create(name,"%s_*"%metaprefix)

# Set chain_map
if chain_map:
setattr(stored,chain_map,chainSet)

# Warn if lowercase chains were generated
if cmd.get("ignore_case") == "on" and any([c.upper() != c for c in chainSet.keys()]):
print("Warning: using lower-case chain IDs. Consider running the "
"following command:\n set ignore_case, 0" )

finally:
# Clean up
print("Cleaning up intermediates")
cmd.delete("%s_*"%metaprefix)
finally:
# restore original parameters
print("Resetting variables")
cmd.set("retain_order",retain_order)

cmd.extend('flatten_obj', flatten_obj)

# tab-completion of arguments
cmd.auto_arg[0]['flatten_obj'] = [ cmd.object_sc, 'name or selection', '']
cmd.auto_arg[1]['flatten_obj'] = [ cmd.object_sc, 'selection', '']
</syntaxhighlight>

= See Also =

* [[split_states]]

[[Category:Script_Library]] [[Category:ObjSel_Scripts]]

Template talk:PymolScriptRepoInclude

2015-10-30T13:58:50Z

Sbliven: Created page with "== Not working == This template doesn't seem to work? --~~~~"

== Not working ==
This template doesn't seem to work? --[[User:Sbliven|Sbliven]] 13:58, 30 October 2015 (UTC)

User:Sbliven/Sandbox

2015-10-30T13:57:26Z

Sbliven:

== Pymol Inclusion ==
Conclusion: the include plugin doesn't work as a template.

Through Template:
{{Template:PymolScriptRepoInclude/Test|removealt.py}}

Subst:
<nowiki>{{{lt|<}}}include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/{{{1}}}" highlight="{{{2|python}}}" /{{{gt|>}}}</nowiki>

This code has been put under version control in the project [http://www.pymolwiki.org/index.php/Git_intro Pymol-script-repo].

This code has been put under version control in the project [http://www.pymolwiki.org/index.php/Git_intro Pymol-script-repo].

Direct:
<include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/removealt.py" highlight="python" />

Template:PymolScriptRepoInclude/Test

2015-10-30T13:56:52Z

Sbliven:

<includeonly><nowiki>{{{lt|<}}}include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/{{{1}}}" highlight="{{{2|python}}}" /{{{gt|>}}}</nowiki>

This code has been put under version control in the project [http://www.pymolwiki.org/index.php/Git_intro Pymol-script-repo].</includeonly><noinclude>
Automatically includes current script code from Pymol-script-repo on github.

Usage: <code><nowiki>{{PymolScriptRepoInclude|filename|language}}</nowiki></code>, where filename gives the path on github and language gives the programming language (default python).
</noinclude>

User:Sbliven/Sandbox

2015-10-30T13:48:32Z

Sbliven: /* Pymol Inclusion */

== Pymol Inclusion ==
Conclusion: the include plugin doesn't work as a template.

Through Template:
{{Template:PymolScriptRepoInclude/Test|removealt.py}}

Subst:
<nowiki><include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/{{{1}}}" highlight="{{{2|python}}}" /></nowiki>

This code has been put under version control in the project [http://www.pymolwiki.org/index.php/Git_intro Pymol-script-repo].

Direct:
<include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/removealt.py" highlight="python" />

Template:PymolScriptRepoInclude/Test

2015-10-30T12:19:08Z

Sbliven: testing ways to delay include parsing

<includeonly><nowiki><include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/{{{1}}}" highlight="{{{2|python}}}" /></nowiki>

This code has been put under version control in the project [http://www.pymolwiki.org/index.php/Git_intro Pymol-script-repo].</includeonly><noinclude>
Automatically includes current script code from Pymol-script-repo on github.

Usage: <code><nowiki>{{PymolScriptRepoInclude|filename|language}}</nowiki></code>, where filename gives the path on github and language gives the programming language (default python).
</noinclude>

User:Sbliven/Sandbox

2015-10-30T12:11:50Z

Sbliven: /* Pymol Inclusion */

== Pymol Inclusion ==
Through Template:
{{Template:PymolScriptRepoInclude|removealt.py}}

Direct:
<include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/removealt.py" highlight="python" />

Subst:
<include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/{{{1}}}" highlight="{{{2|python}}}" />

This code has been put under version control in the project [http://www.pymolwiki.org/index.php/Git_intro Pymol-script-repo].

User:Sbliven/Sandbox

2015-10-30T12:10:47Z

Sbliven: /* Pymol Inclusion */

User:Sbliven/Sandbox

2015-10-30T12:09:31Z

Sbliven: Pymol inclusion

== Pymol Inclusion ==
Direct:
<include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/findseq.py" highlight="python" />

Through Template:
{{Template:PymolScriptRepoInclude|findseq.py}}

Template:PymolScriptRepoInclude

2015-10-30T12:04:52Z

Sbliven: Adding documentation

<includeonly><include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/{{{1}}}" highlight="{{{2|python}}}" />

This code has been put under version control in the project [http://www.pymolwiki.org/index.php/Git_intro Pymol-script-repo].</includeonly><noinclude>
Automatically includes current script code from Pymol-script-repo on github.

Usage: <code><nowiki>{{PymolScriptRepoInclude|filename|language}}</nowiki></code>, where filename gives the path on github and language gives the programming language (default python).
</noinclude>

Get color tuple

2015-09-08T09:48:00Z

Sbliven: Documenting cmd.get_color_tuple

= Overview =

Converts a pymol color name into a RGB tuple.

= Example =

PyMOL>print cmd.get_color_tuple("raspberry")
(0.699999988079071, 0.30000001192092896, 0.4000000059604645)

Talk:Bounding Box

2015-08-26T12:41:07Z

Sbliven: /* Port to Numpy */

== Port to Numpy ==
The dependencies on numarray and scientific python are rather dated now. It would be great if someone could port this to numpy, which should be much more common. [[User:Sbliven|Sbliven]] 08:41, 26 August 2015 (EDT)

Transform selection

2015-06-01T10:56:31Z

Sbliven: Added description from 1.7.0 docstring

== Overview ==
'''transform_selection''' applies a transformation matrix to a selection. The matrix should actually be passed in as a single list -- not a list of lists.

=== PYMOL API ===

cmd.transform_selection(string selection, list matrix, int state, int log, int homogenous, int transpose):

=== Details ===

Note that when homogenous is zero, the input matrix is NOT a
standard homogenous 4x4 transformation matrix. Instead it is
something PyMOL-specific which consists of the following:

# a 3x3 matrix containing the rotation in the upper-left quadrant
# a 1x3 translation to be applied '''before''' rotation in the bottom row (matrix[12],matrix[13],matrix[14]).
# a 3x1 translation to be applied '''after''' rotation in the right-hand column (matrix[3],matrix[7],matrix[11])

So, you can translate+rotate+translate with this one matrix.

In other words, if the matrix is:

[ m0 m1 m2 m3 \
m4 m5 m6 m7 \
m8 m9 m10 m11 \
m12 m13 m14 m15 ]

Atoms will be transformed as follows

Y = M X

y0 = m0*(x0+m12) + m1*(x1+m13) + m2*(x2+m14) + m3 \
y1 = m4*(x0+m12) + m5*(x1+m13) + m6*(x2+m14) + m7 \
y2 = m8*(x0+m12) + m9*(x1+m13) + m10*(x2+m14) + m11

== Example ==

=== Real-World Example ===
I wrote a structure alignment program that needs to update the coordinates of the 2nd protein by translating it, rotating it and then translating it on top of the other molecule. It's done as follows:
<source lang="c">
//
// C code
//
// ...after the magic is done, pack all the values into the TTT matrix.
PyObject* pyU = Py_BuildValue( "[f,f,f,f, f,f,f,f, f,f,f,f, f,f,f,f]",
bestU[0][0], bestU[1][0], bestU[2][0], bestCOM1[0],
bestU[0][1], bestU[1][1], bestU[2][1], bestCOM1[1],
bestU[0][2], bestU[1][2], bestU[2][2], bestCOM1[2],
-bestCOM2[0], -bestCOM2[1], -bestCOM2[2], 1.);
</source>
where bestU is the transpose of the best rotation matrix, bestCOM1 is the center of mass (COM) for molecule 1, and bestCOM2 is for molecule two. '''pyU''' becomes '''rotMat'''. The call in Python is then,
<source lang="python">
#
# Python code.
#
cmd.transform_selection( mol2, rotMat, homogenous=0 );
</source>

Were I '''not''' to use bestCOM1 or bestCOM2, each of those entries would be 0. The last element should always be 1.

== See Also ==
[[transform_odb]]

Get Symmetry

2015-06-01T09:55:08Z

Sbliven: Adding description of return value

'''get_symmetry''' can be used to obtain the crystal and spacegroup parameters for a molecule
(FUTURE - map object - FUTURE)

===USAGE===
get_symmetry object-name-or-selection

===DESCRIPTION===

Returns a tuple containing the following 7 values:

* The unit cell lengths (a,b,c)
* The unit cell angles (alpha, beta, gamma)
* The space group name (e.g. "P 21 21 21")

===PYMOL API===
<source lang="python">
cmd.get_symmetry(string selection)
</source>

===See Also===

* [[Supercell]]

[[Category:Commands|Get Symmetry]]

Get symmetry

2015-06-01T09:50:32Z

Sbliven: oops, wrong case

#REDIRECT [[Get Symmetry]]

Get symmetry

2015-06-01T09:49:54Z

Sbliven: Redirected page to Get symmetry

#REDIRECT [[Get symmetry]]

Talk:Transform odb

2015-06-01T09:36:52Z

Sbliven: question about format

==ODB==
Can anyone post an example ODB file? From the code, it seems like it should be a tab-delimited file containing the first three rows of the transformation matrix, but in column-first order? That seems weird since it would suggest the transpose of the matrix. --[[User:Sbliven|Sbliven]] 05:36, 1 June 2015 (EDT)

Load

2015-03-18T14:00:30Z

Sbliven: Adding argument explainations

'''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", PyMOL session files must end in ".pse", and pickled ChemPy models with a ".pkl" can also be directly read.

If an object is specified, then the file is loaded into that object. Otherwise, an object is created with the same name as the file prefix.

===USAGE===
<source lang="python">
load filename [,object [,state [,format [,finish [,discrete [,multiplex ]]]]]]
</source>

===PYMOL API===
<source lang="python">
cmd.load( filename [,object [,state [,format [,finish [,discrete [,multiplex ]]]]]] )
</source>

===ARGUMENTS===

* '''filename : string''' Path to the file to load.
* '''object : string''' Name of Pymol object to store the structure in. Defaults to the filename prefix.
* '''state : integer''' State number to store the object in, or 0 to append (default:0)
* '''format : string''' Format for the file (see notes). Defaults to the filename extension.
* '''finish : integer'''
* '''discrete : integer''' For multi-model structures, a value of 0 indicates that models have the same set of atoms (e.g. trajectory files or NMR structures), allowing memory savings, while a value of 1 forces the creation of independent atom sets for each model
* '''quiet : integer''' (default 1)
* '''multiplex : integer'''
* '''zoom : integer'''
* '''partial : integer''' (default 0)
* '''mimic : integer''' (default 1)

===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)
'trj' : AMBER trajectory (use load_traj command for more control)
'top' : AMBER topology file 'rst' : AMBER restart file
'cex' : Metaphorics CEX format
'pse' : PyMOL Session file
'pqr' : PQR (a modified PDB file with charges and radii)
'mol2' : MOL2

* A new feature has been added to load. You can specify an URL to a PDB and PyMOL will download it. This is a very handy feature for loading experimental/theoretical data from servers across the web. Just copy the link they give you and do,
<source lang="python">
load http://www.theurl.com/path/toYourData
</source>
or you can open a remote file just from the command line
<source lang="bash">
# load a PDB file; I placed one example file on the PyMOL Wiki
pymol http://www.pymolwiki.org/1rsy.pdb

# PyMOL can also handle the gzipped files on the PDB. :-)
pymol ftp://ftp.wwpdb.org/pub/pdb/data/structures/divided/pdb/00/pdb100d.ent.gz
</source>

===User Comments/Examples===
*Load xyz.pdb using the PyMOL API:
<source lang="python">
cmd.load("xyz.pdb")
</source>

* Loading multiple PDBs into one object with many states:
<source lang="python">
load trj0001.pdb, mov
load trj0002.pdb, mov
load trj0003.pdb, mov
etc.
</source>
or, if you have too many states to do that by hand,
<source lang="python">
for idx in range(1,1001):cmd.load("trj%04d.pdb"%idx,"mov")
</source>
or, you can use "glob" from Python,
<source lang="python">
from glob import glob
lst = glob("trj*.pdb")
lst.sort()
for fil in lst: cmd.load(fil,"mov")
</source>

*Load a NAMD multi-PDB file. These are just concatenated PDB files.
<source lang="python">
load NAMDtrajFile.pdb, multiplex=0
</source>

* Hint: You can save some time & a lot of memory by loading the file and removing the atoms in a single-line compound statement (with a semicolon
after the load statement).
<source lang="python">
load 1E3M.pdb; remove not A-C+F//
</source>

* Decorating the load command to include technical info about the loaded object
<source lang="python">
def load_with_props(fileName, objName):
# store whatever info you want, like the filename
obj_info[objName] = fileName
# ... do more recording of properties you choose
# ask PyMOL to now load the file
cmd.load(fileName,objName)
</source>
Then on can query obj_info based on the object name:
<source lang="python">
for obj in cmd.get_names():
print obj_info[obj]
</source>

===SEE ALSO===
[[Fetch]] [[Save]] [[Load Traj]]

[[Category:Commands|Load]]
[[Category:States|Load]]
[[Category:Input Output Module|Load]]

User:Sbliven

2014-12-10T10:15:22Z

Sbliven: Created page with "Spencer Bliven, Structural Bioinformatician"

Spencer Bliven, Structural Bioinformatician

Talk:Select

2014-12-10T10:10:42Z

Sbliven: Additional parameters

== Additional parameters ==

The help string lists a number of additional parameters to select, but I haven't been able to find any further discussion of them:

select name, selection [, enable [, quiet [, merge [, state [, domain ]]]]]

The ''state'' parameter doesn't seem to have any effect (at least it definitely doesn't limit selection to one state), and I'm not sure what the others are intended to do. Can anyone add descriptions of those parameters?

--[[User:Sbliven|Sbliven]] 05:10, 10 December 2014 (EST)

Talk:Plugin Manager

2014-11-26T12:08:29Z

Sbliven: /* Startup path */ new section

== Version introduced ==

Does anyone know when the Plugin Manager was introduced? I've verified it wasn't present in 1.3 and is present in 1.5, but I don't have access to 1.4 to test it. --[[User:Sbliven|Sbliven]] 07:00, 26 November 2014 (EST)

== Startup path ==

I'm a bit skeptical about this line in the script:

os.path.join(sys.prefix, 'Lib', 'site-packages', 'pmg_tk', 'startup')

On my system, <tt>sys.prefix</tt> resolves to <tt>PYTHON_HOME/ext</tt>. I do have a <tt>/ext/lib</tt> (lower case), but my site-packages is at <tt>/ext/lib/python1.7/site-packages</tt>, and it doesn't contain a pmg_tk module. Perhaps what was really intended was to add <tt>PYTHON_HOME/modules/pmg_tk/startup</tt>, which is the only entry in my startup path by default (and therefore doesn't need to be included with the set_startup_path command).

Is the Lib path needed for Windows or some other OS?
--[[User:Sbliven|Sbliven]] 07:08, 26 November 2014 (EST)

Talk:Plugin Manager

2014-11-26T12:00:47Z

Sbliven: /* Version introduced */

Cgo grid

2014-11-24T09:24:34Z

Sbliven: Fixing capitalization

{{Infobox script-repo
|type = Python Module
|filename = cgo_grid.py
|author = [[User:Andwar|Andreas Warnecke]]
|license = BSD-2-Clause
}}
[[Image:cgo_grid.gif|right|cgo_grid creates flowing mesh objects]]

==About cgo_grid==
'''cgo_grid''' will generate a flowing mesh object using the points provided or the current view. By default is will generate a flowing membrane. The shape is affected substantially by the arguments! 
* For instruction on setting up plugin import see [[Git intro]] or [[Plugin Manager]]

==Usage==
'''cgo_grid''' has many arguments, but not all need to be set necessarily (see arguments or examples).
{|
|<source lang="python">
cgo_grid [ pos1 [, pos2 [, pos3 [, length_x [, length_z [, npoints_x [, npoints_z
[, nwaves_x [, nwaves_z [, offset_x [, offset_z [, gain_x [, gain_z
[, thickness [, color [, nstates [, startframe [, endframe
[, mode [, view [, name [, quiet ]]]]]]]]]]]]]]]]]]]]]]
</source>
||
|}

==Arguments==
{|
|- style="vertical-align:top;"
|
<pre>
pos1 = single atom selection (='pk1') or list of 3 floats {default: [0,0,0]}

pos2 = single atom selection (='pk2') or list of 3 floats {default: [1,0,0]}

pos3 = single atom selection (='pk3') or list of 3 floats {default: [0,0,1]}

--> the plane is defined by pos1 (origin) and vectors to pos2 and pos3, respectively

length_x = <float>: length of membrane {default: 30}
length_z = <float>: length of membrane {default: ''} # same as length_x

npoints_x = <int>: number of points(lines) along x-direction
{default: ''} #will be set to give a ~1 unit grid
npoints_z = <int>: number of points(lines) along z-direction
{default: ''} #will be set to give a ~1 unit grid
{minimum: 1 # automatic}

nwaves_x = <float>: number of complete sin waves along object x-axis
{default: 2}
nwaves_z = <float>: number of complete sin waves along object z-axis
{default: ''} # same as nwaves_x
define separately to adjust number of waves in each direction

offset_x = <float> phase delay (in degrees) of sin wave in x-axis
can be set to affect shape and starting amplitude {default: 0}
offset_z = <float> phase delay (in degrees) of sin wave in z-axis
can be set to affect shape and starting amplitude
{default: ''} # same as offset_x
offset_x and offset_z can be used together to phase
otherwise identical objects

gain_x = <float>: multiplication factor for y-amplitude for x-direction
{default: 1}
gain_z = <float>: multiplication factor for y-amplitude for z-direction
{default: ''} #=gain_x

thickness = <float>: line thickness {default: 2}

color = color name <string> (e.g. 'skyblue') OR
rgb-value list of 3 floats (e.g. [1.0,1.0,1.0]) OR
{default: ''} // opposite of background
input illegal values for random coloring

nstates = <int>: number of states; {default: 60}
this setting will define how many states
the object will have (per wave) and how fluent and fast the
animation will be.
Higher values will promote 'fluent' transitions,
but decrease flow speed.
Note: Frame animation cycles thought the states one at a time
and needs to be set accordingly. Can also be used to phase
otherwise identical objects.
Set to 1 for static object {automatic minimum}

startframe: specify starting frame <int> or set (='') to use current frame
set to 'append' to extend movie from the last frame {default: 1}
endframe: specify end frame <int> or set (='') to use last frame
if 'append' is used for startframe,
endframe becomes the number of frames to be appended instead
{default: 1}
Note: if start- and endframe are the same, movie animation will
be skipped, the object will be loaded and can be used afterwards

mode: defines positioning {default: 0}:
0: pos1 is center
1: pos1 is corner

view {default: 0}:
'0': off/ uses provided points to create CGO
'1': overrides atom selections and uses current orienatation for positioning
- pos1 = origin/center
- pos2 = origin +1 in camera y
- pos3 = origin +1 in camera z

name: <string> name of cgo object {default: ''} / automatic

quiet: <boolean> toggles output
</pre>

| text-align:center;" | Concept sketch: [[Image:cgo_grid.png|500px|cgo_grid concept sketch]]
|}

==Examples==
The behaviour or shape of the cgo_grid object are substantially influenced by the arguments
{|
|
<source lang="python">
delete all
set_view (\
0.263772517, -0.113038681, 0.957937598,\
-0.040853567, 0.990910411, 0.128179103,\
-0.963716805, -0.072944686, 0.256756991,\
0.000000000, 0.000000000, -131.816467285,\
0.000000000, 0.000000000, 0.000000000,\
-50.008331299, 353.641235352, -20.000000000 )

#membrane
cgo_grid color=blue

#swimming worm, random color
cgo_grid \
pos1=[0,-5,0], pos2=[1,-5,1], pos3=[0,-5,1],\
length_x=15,\
npoints_z=1,\
gain_x=2,\
gain_z=0,\
thickness=20,\
color=3,\
mode=1,\
name="worm"

#Moving Ladder
cgo_grid \
length_x=15,\
pos1=[0,10,0], pos2=[0,10,1], pos3=[0,9,0],\
npoints_x=2, npoints_z=30,\
name="ladder"

#Roof
cgo_grid \
nstates=1,\
npoints_x=15,\
npoints_z=15,\
gain_x=20,\
gain_z=20,\
nwaves_x=0.5,\
thickness=5,\
color=cyan,\
name="roof"

#Boxes
cgo_grid \
pos1=[0,-10,0], pos2=[1,-10,0], pos3=[0,-10,1],\
nstates=1,\
npoints_x=50,\
npoints_z=50,\
nwaves_x=0,\
color=[0.00 , 0.53 , 0.22],\
thickness=5,\
name="bottom"

cgo_grid \
nstates=1,\
npoints_x=2,\
npoints_z=2,\
nwaves_x=0,\
color=gray60,\
thickness=10,\
name="top"

cgo_grid \
pos1=[-15,-10,15], pos2=[-14,-10,15], pos3=[-15,-9,15],\
nstates=1,\
npoints_x=5,\
npoints_z=5,\
gain_x=0,\
gain_z=-2,\
length_z=10,\
nwaves_x=0.5,\
color=gray60,\
thickness=5,\
mode=1,\
name="front"

cgo_grid \
pos1=[-15,-10,-15], pos2=[-14,-10,-15], pos3=[-15,-9,-15],\
nstates=1,\
npoints_x=5,\
npoints_z=5,\
gain_x=0,\
gain_z=2,\
length_z=10,\
nwaves_x=0.5,\
color=gray60,\
thickness=5,\
mode=1,\
name="back"

set ray_trace_frames, 0
set movie_loop,1
mplay

# play around with the ARGUMENTS! :-)
</source>
||
|}

==SEE ALSO==
* [[CgoCircle]]

[[Category:Script_Library]]
[[Category:Math_Scripts]]
[[Category:CGO]]

Distancetoatom

2014-11-24T09:24:14Z

Sbliven: Fixing capitalization

{{Infobox script-repo
|type = Python Module
|filename = distancetoatom.py
|author = [[User:Andwar|Andreas Warnecke]] and [[User:Jaredsampson|Jared Sampson]]
|license = BSD-2-Clause
}}
[[Image:distancetoatom_0.png|right|300px|get distance to atoms within cutoff]]

==About distancetoatom==
'''distancetoatom''' prints all distances between a specified atom, coordinate or group selection center and all atoms within cutoff distance that are part of the selection. 
All coordinates and distances can be saved in a csv-style text file report and/or can be stored in a (custom) atom property, if defined.
* For instruction on setting up plugin import see [[Git intro]] or [[Plugin Manager]]

==Usage==
{|-
||
<source lang="python">
distancetoatom [ origin [, cutoff [, filename [, selection [, state [, property_name [, coordinates [, decimals [, sort [, quiet ]]]]]]]]]]
</source>
||
|}

===Arguments===
{| class="wikitable"
!colspan="3;"|Arguments for distancetoatom
|- style="text-align:center;"
! scope="col"| Keyword
! scope="col"| Default
! scope="col"| What it does
|-
! scope="row"| origin
| style="text-align:center;"| pk1
| "origin" defines the coordinates for the origin and can be:
1. a list with coordinates [x,y,z] 
2. a single atom selection string 
3. a multi-atom selection string (center will be used)
|-
! scope="row"| cutoff
| style="text-align:center;"| 10
| "cutoff" defines the maximum distance, atoms further away are not considered
|-
! scope="row"| filename
| style="text-align:center;"| None
| "filename" is the name of a report file that will be created (optional).
set to e.g. 'report.txt' to create a report. This file is CSV style and can be imported into EXCEL. 
(omit or set to "", None, 0 or False to disable)
|-
! scope="row"| selection
| style="text-align:center;"| all
| only atoms within "selection" (and cutoff distance) will be used for calculation
|-
! scope="row"| state
| style="text-align:center;"| 0
| "state" is the state that will be used for calculations
use 0 (omit), to automatically use the current state
|-
! scope="row"| property_name
| style="text-align:center;"| p.dist
| "property_name" defines a (custom) property in which the calculated distance will be stored.
This can be used e.g. for labeling or spectrum coloring etc. (cf. examples) 
NB! older PyMOL versions only support b or q and the distance will overwrite this property if set.
|-
! scope="row"| coordinates
| style="text-align:center;"| 0
| "coordinates" toggles whether, besides distance, the atom coordinates will be included in the report.
|-
! scope="row"| decimals
| style="text-align:center;"| 3
| "decimals" is the number of decimal places calculated.
Note that PDB files do not support a higher resolution than 3.
|-
! scope="row"| sort
| style="text-align:center;"| 1
| "sort" defines how the output will be sorted:
1: ascending (default) 
0: no sorting (by selection) 
-1: descending
|-
! scope="row"| quiet
| style="text-align:center;"| 1
| toggle verbosity
|}

==Examples==
{|-
||
<source lang="python">
# make function available to PyMOL
import distancetoatom

##############################
# Example 1: print all distances
frag LYS
edit name CA
distancetoatom

##############################
# Example 2: print all distances to file
fetch 1cll, async=0
distancetoatom origin=/1cll//A/CA`150/CA, filename=distances.txt, selection=elem O, property_name=b
# the file is CSV-format and can be imported, e.g. to EXCEL

# format
hide everything
select byres (resi 150 expand 5 and not resn hoh)
show_as sticks, sele
util.cbaw sele
show_as spheres, resi 150
zoom sele

##########
# Label by stored distance (property_name)
label sele and elem O, "%.2f"%b

##############################
# Example 3: color an object by distance to a coordinate

fetch 1cll, async=0
distancetoatom [0,0,0], cutoff=1000, property_name=b
# the distance is stored in the b-factor in this case
# newer PyMOL versions support custom properties, e.g. "p.dist"
spectrum b, rainbow_rev
</source>
||
[[Image:distancetoatom_2.png|300px|Example 2]] 
[[Image:distancetoatom_1.png|300px|Example 3]]
|}

==SEE ALSO==
* [[Distance]]
* [[Get Distance]]
* [[Get raw distances]]

[[Category:Script_Library]]
[[Category:UI_Scripts]]
[[Category:Math_Scripts]]
[[Category:Biochemical_Properties]]
[[Category:Biochemical_Scripts]]

Movie color fade

2014-11-24T09:23:59Z

Sbliven: Fixing capitalization

{{Infobox script-repo
|type = Python Module
|filename = movie_color_fade.py
|author = [[User:Andwar|Andreas Warnecke]]
|license = BSD-2-Clause
}}
[[Image:movie_color_fade_example_1.gif|right|movie_color_fade example]]

'''movie_color_fade''' is like [[Movie_fade|movie_fade]], but will fade colors in a movie. Simply specify the arguments (see below).
* For instruction on setting up plugin import see [[Git intro]] or [[Plugin Manager]]

==Usage==
{|-
||
<source lang="python">
movie_color_fade [ startframe [, startcolor [, endframe [, endcolor [, selection ]]]]]
help movie_color_fade
</source>
||
|}

===Arguments===
* startframe, endframe = beginning and end movie frame for fading
** if omitted, the current or last frame will be respectively set automatically
* startcolor, endcolor = coloring at start and end
* selection: target selection

==Examples==
This example yields the movie to the top right
{|-
||
<source lang="python">
# make function available to PyMOL
import movie_color_fade

# object prep
bg black
delete all
fetch 1hpv, async=0
as cartoon
orient
color yellow, chain A
color skyblue, chain B
# movie prep
mset 1x120

# color fading
movie_color_fade 1, yellow, 60, skyblue, chain A
movie_color_fade 60, skyblue, 120, yellow, chain A
movie_color_fade 1, skyblue, 60, yellow, chain B
movie_color_fade 60, yellow, 120, skyblue, chain B
</source>
||
|}

==SEE ALSO==
* [[Movie_fade]]
* [[mappend]]
* [[Color]]

[[Category:Script_Library]]
[[Category:UI_Scripts]]

Get colors

2014-11-24T09:23:33Z

Sbliven: Fixing capitalization

{{Infobox script-repo
|type = Python Module
|filename = get_colors.py
|author = [[User:Andwar|Andreas Warnecke]]
|license = BSD-2-Clause
}}

* '''get_colors''' contains two functions that can be useful when working with colors
** ''get_colors'' : returns all available PyMOL colors
** ''get_random_color'' : returns a random available PyMOL color

* Note that basic colors can be accessed manually without this script from the PyMOL menu under '''Setting''' --> '''Colors...'''
* For instruction on setting up plugin import see [[Git intro]] or [[Plugin Manager]]

[[Image:1LSD_random_colors.png|right|300px|1LSD colored randomly by residue]]

==Usage==
get_colors [ selection [, quiet ]]
get_random_color [ selection [, quiet ]]

==Examples==
{|-
||
<source lang="python">
# basic example
get_colors # basic colors
get colors all # larger range with intermediates
</source>

<source lang="python">
#get disco funky
import get_colors
from get_colors import get_colors
from get_colors import get_random_color

cmd.delete('all')
cmd.fetch('1LSD', async=0) # :P
cmd.hide('everything')
cmd.show_as('sticks','not hetatm')
cmd.orient()

python # start a python block
from pymol import stored
stored.atom_list=[]
cmd.iterate('name CA','stored.atom_list.append([model, resi])')
resi_list=["model %s and resi %s"%(value[0],value[1]) for value in stored.atom_list]
for resi in resi_list: cmd.color(get_random_color(),resi)
python end # end python block
cmd.ray()
</source>
||
|}

==SEE ALSO==
* [[Color]]
* [[Get Color Indices]]

[[Category:Script_Library]]
[[Category:UI_Scripts]]

Quickdisplays

2014-11-24T09:23:18Z

Sbliven: Fixing capitalization

{{Infobox script-repo
|type = Python Module
|filename = quickdisplays.py
|author = [[User:Andwar|Andreas Warnecke]]
|license = BSD-2-Clause
}}

The module '''quickdisplays''' is a package containing several functions for quick standard displays: 

{| class="wikitable"
!colspan="3;"|List of functions
|- style="text-align:center;"
! scope="col"| Function
! scope="col"| What it does
! scope="col"| Usage
|-
! scope="row"| disp_list
| style="text-align:center;"| prints a list of functions
| disp_list
|-
! scope="row"| disp_ss
| style="text-align:center;"| secondary structure
| disp_ss [ selection [, colors [, only ]]]
|-
! scope="row"| disp_ball_stick
| style="text-align:center;"| balls and sticks
|disp_ball_stick [ selection [, hydrogens [, only ]]]
|-
! scope="row"| disp_mesh
| style="text-align:center;"| surface mesh
| disp_mesh [ selection [, color_m [, hydrogens [, only [, limits ]]]]]
|-
! scope="row"| disp_surf
| style="text-align:center;"| surface
| disp_surf [ selection [, color_s [, transparency [, hydrogens [, solvent [, ramp_above [, only [, limits ]]]]]]]]
|-
! scope="row"| disp_putty
| style="text-align:center;"| putty b-factor sausage
| disp_putty [ selection [, limits [, only ]]]
|}

* Note that each function has an '''individual help destription''', callable by entering, e.g.:
help disp_surf
* For instruction on setting up plugin import see [[Git intro]] or [[Plugin Manager]]

{| class="wikitable"
!colspan="5;"|Examples
|- style="text-align:center;"
| [[Image:Quickdisplays_disp_surf.png|center|300px]]'''disp_surf''' ''surface''
| [[Image:Quickdisplays_disp_ss.png|center|300px]]'''disp_ss''' ''secondary structure''
| [[Image:Quickdisplays_disp_putty.png|center|300px]]'''disp_putty''' ''putty b-factor sausage''
| colspan="2;" rowspan="2;" style="text-align:left;" |

The ''combined displays'' example was produced like this:
<source lang="python">
import quickdisplays
fetch 1hpv, async=0

disp_putty all, limits=10
disp_surf color_s=lightblue, transparency=0.8
disp_ss chain B
disp_ball_stick hetatm
util.cbao hetatm
set mesh_mode, 1 # make sure hetams are meshed
set mesh_cutoff, 4.5
disp_mesh resn 478, color_m=green
</source>
|- style="text-align:center;"
| [[Image:Quickdisplays_disp_mesh.png|center|300px]]'''disp_mesh''' ''mesh''
| [[Image:Quickdisplays_disp_ball_stick.png|center|300px]]'''disp_ball_stick''' ''balls and sticks''
| [[Image:Quickdisplays_combo.png|center|300px]]''combined displays'' see example
|}

==Some notes on the arguments==
* '''selection''' can be used to restrict the display to certain objects or selections, the default is 'all'
* '''only''' can be ''True'' or ''False'' and will toggle whether the display will be added (''show'') or replace others (''show_as'')
* '''disp_mesh''' and '''disp_surf''' support the color '''putty''', which will color the object/selection by b-factor
* '''limits''' defines the b-factor color range:
** a list entry will define absolute values '''[min;max]'''
** a float value will calculate the corresponding percentiles '''±value%''', ''default=5''
* setting '''hydrogens''' will add hydrogen to the model; if set to ''=False'', hydrogens are removed, if omitted the state of hydogens will be 'as is'
* '''colors''' in '''disp_ss''' is flexible:
** set e.g. three colors, e.g. 'red green blue' for sheets, helices and loops, respectively (cf. example)
** alternatively certain 'util.' functions can be used (cf. example)
** setting ''False'' once or for individual colors will suppress coloring

== Applied example ==
Enter the following lines one-by-one and observe how the display will be affected
<source lang="python">
# import function to PyMOL
import quickdisplays

# prep
fetch 1hpv, async=0
bg black
orient
disp_list # list of functions

help disp_ss # check out help
disp_ss
disp_ss only=T
disp_ss colors=smudge orange grey
disp_ss colors=chartreuse False False # False suppresses coloring
disp_ss colors=util.chainbow # You can use util.cbc, util.rainbow, ...

help disp_ball_stick # check out help
disp_ball_stick hetatm
disp_ball_stick all, only=T
util.cbaw
disp_ball_stick hydrogens=1
disp_ball_stick hydrogens=-1
disp_stick_ball # will this work?

help disp_mesh # check out help
disp_mesh
disp_mesh color_m=green, only=False
disp_mesh color_m=green, only=T
disp_ball_stick hetatm
set mesh_skip, 2 # omits lines in mesh
disp_mesh color_m=default, hydrogens=1, only=T
disp_mesh color_m=putty, hydrogens=0, limits=20
disp_mesh color_m=putty, limits=30
disp_mesh color_m=putty, limits=[15,50]

help disp_putty # check out help
disp_putty chain A, only=False, limits=[15,50] #only default is True
disp_putty all, limits=0
disp_putty all, limits=10

help disp_surf # check out help
disp_surf color_s=white, solvent=1
disp_surf color_s=white# solvent=0
disp_surf color_s=lightblue, transparency=0.8
</source>

==SEE ALSO==
[[Git intro]], [[Displaying Biochemical Properties]]

[[Category:Script_Library]]
[[Category:Biochemical_Properties]]
[[Category:UI_Scripts]]
[[Category:Biochemical_Scripts]]

Git install scripts

2014-11-24T09:22:49Z

Sbliven: Fixing capitalization

== Manual download of scripts ==
If you don't have the option or don't feel like installing git on your system, then go to:
https://github.com/Pymol-Scripts/Pymol-script-repo
Click the "ZIP" button, near the top left corner.
Now unpack the files to a directory. For example:
C:/Users/YOURNAME/Pymol-script-repo
/home/YOURNAME/Pymol-script-repo

Now go to: '''Adding Pymol-script-repo to PyMOL search path''' [http://www.pymolwiki.org/index.php/Git_install#Adding_Pymol-script-repo_to_PyMOL_search_path]

== Git install instructions ==
=== For Windows users ===
# Install [http://code.google.com/p/msysgit/downloads/list?can=3&q=official+Git Git for Windows].
Use following settings in options, [http://www.geekgumbo.com/2010/04/09/installing-git-on-windows/ (You can read more here)].
* Windows Explorer Integration -> Context Menu Entries -> Git Bash Here + Git GUI here
* Run Git and included Unix tools from Windows Command prompts
* Checkout Windows style, commit Unix-style endings

# Navigate to: '''C:\Users\YOURNAME'''
# Right click in folder -> Select: Git Gui -> Clone Existing Repository
# Source Location: git://github.com/Pymol-Scripts/Pymol-script-repo.git
# Target Directory: C:\\Users\\YOURNAME\\Pymol-script-repo
#: A backslash "\" in a string is [http://effbot.org/pyref/string-literals.htm is used for escape sequences]. To get a real backslash in a string, use double backslash "\\"
You now have all the scripts available in your directory.

=== For Linux users ===
# Install git
# Debian/Ubuntu/Mint
sudo apt-get install git
# Fedora
su -c 'yum install git'
# openSUSE
sudo zypper in git

# Navigate to desired folder:
cd /home/YOURNAME/
git clone git://github.com/Pymol-Scripts/Pymol-script-repo.git
You now have all the scripts available in: /home/YOURNAME/Pymol-script-repo

== Adding Pymol-script-repo to PyMOL search path ==
You now have to add the "Pymol-script-repo" directory to the PyMOL search path.

PyMOL has since revision 3997 (30 April 2012) an improved plugin/script manager.
You have to remove old installations of plugins first, to get the automatic plugin installation to work.
=== Making a personal "pymolrc" file - for personal use ===
# Open notepad/gedit and save under:
## Win: '''C:\Users\YOURNAME\pymolrc.pym''' (Set: "Save as type" to "All files")
## Linux: '''~/.pymolrc'''
<syntaxhighlight lang="python">
# Add paths to sys.path so PyMOL can find modules and scripts
import sys, os
pymol_git = os.path.abspath(os.path.join(os.path.expanduser('~'), 'Pymol-script-repo'))
os.environ['PYMOL_GIT_MOD'] = os.path.join(pymol_git,'modules')
sys.path.append(pymol_git)
sys.path.append(os.environ['PYMOL_GIT_MOD'])

# Make starting directory and change to it.
home_dir = os.path.abspath(os.path.join(os.path.expanduser('~'), 'pymol'))
if not os.path.exists(home_dir): os.makedirs(home_dir)
os.chdir(home_dir)
</syntaxhighlight>

Then open PyMOL. Go to top menu: Plugin->Plugin Manager
# Installed plugins: Unclick "apbs_tools" as "load on startup". (The Pymol-script-repo has a fine-tuned version, "apbsplugin")
# Settings->Add new directory: Point to: /custom/path/Pymol-script-repo/plugins
# Restart PyMOL

=== Making a general "run_on_startup.py" - for all users ===
This section describes automatic loading of plugins using PyMOL's [[Plugin Manager]], which is available in newer PyMOL versions (e.g. 1.7, or higher). 

If you have a shared PyMOL installation for several linux computers, you can make general wide changes for the startup of PyMOL. 
First locate your PYMOL_PATH. Start PyMOL, and write:
import os
print os.environ['PYMOL_PATH']
In this folder, you place "run_on_startup.py" and the Pymol-script-repo directory. 
Write in "run_on_startup.py" :
<syntaxhighlight lang="python">
# Add paths to sys.path so PyMOL can find modules and scripts
import sys, os
pymol_git = os.path.abspath(os.path.join(os.environ['PYMOL_PATH'], 'Pymol-script-repo'))
os.environ['PYMOL_GIT_MOD'] = os.path.join(pymol_git,'modules')
sys.path.append(pymol_git)
sys.path.append(os.environ['PYMOL_GIT_MOD'])

# Make starting directory and change to it.
home_dir = os.path.abspath(os.path.join(os.path.expanduser('~'), 'pymol'))
if not os.path.exists(home_dir): os.makedirs(home_dir)
os.chdir(home_dir)

# Make setting changes to Plugin Manager
import pymol.plugins
pymol.plugins.preferences = {'instantsave': False, 'verbose': False}
pymol.plugins.autoload = {'apbs_tools': False}
pymol.plugins.set_startup_path([os.path.join(pymol_git, 'plugins'), os.path.join(sys.prefix, 'Lib', 'site-packages', 'pmg_tk', 'startup')])
pymol.plugins.preferences = {'instantsave': True, 'verbose': False}
</syntaxhighlight>

== Test the Scripts ==
Now start PyMOL, and test in PyMOL.
print sys.path
import colorbydisplacement
help(colorbydisplacement)

== Get latest changes to scripts ==
If new scripts are available or changes have been made, then:
=== For windows users ===
# Navigate to '''C:\Users\YOURNAME\Pymol-script-repo'''
# Right click in folder -> Select: Git Bash
# Write in terminal
git pull origin master

=== For Ubuntu/Mint users ===
# Navigate to '''/home/YOURNAME/Pymol-script-repo'''
# Write in terminal.
git pull origin master

= Do you want to contribute with a script? =
Information how to contribute scripts to the repository. It's easy! 
http://www.pymolwiki.org/index.php/git_authors

Plugin Manager

2014-11-24T09:21:25Z

Sbliven: moved Plugin manager to Plugin Manager: Fixing capitalization

Newer versions of PyMOL come with a '''Plugin Manager''', which can be used to load plugins such as those in the [https://github.com/Pymol-Scripts/Pymol-script-repo# PyMOL Script Repo]. 

=Manual Setup=
In the PyMOL menu naviagte to '''Plugins''' > '''Plugin Manager''' 
Here you can manually add directories or scripts that will be loaded upon startup. 
Older versions have a basic version of this manager: '''Plugin''' > '''Manage Plugins''', however, here the scripts need to be added individually. 

=Scripted setup during PyMOL launching=
===Creating run_on_startup.py===
'''run_on_startup.py''' can easily be created using a text editor such as notepad. The '''run_on_startup.py''' is handled similar to [[Pymolrc|pymolrc]] files and is executed every time PyMOL launches. An important distinction is that '''run_on_startup.py''' is executed before the [[Pymolrc|pymolrc]] files and is purely written in python.

The recommended location of '''run_on_startup.py''' is the [[PYMOL_PATH|PyMOL home directory]]. An advantage is that should PyMOL be installed on a computer with several users, this will be run for all users, while the pymolrc files can be individual (e.g. in the USER directory).

<syntaxhighlight lang="python">
#this can be copy-pasted to create run_on_startup.py in the home directory

# Add paths to sys.path so PyMOL can find modules and scripts
import sys
import os

pymol_git = os.path.realpath(os.path.join(os.environ['PYMOL_PATH'], 'Pymol-script-repo'))

os.environ['PYMOL_GIT_MOD'] = os.path.join(pymol_git,'modules')
sys.path.append(pymol_git)
sys.path.append(os.environ['PYMOL_GIT_MOD'])

# Make setting changes to Plugin Manager
try: # in case the PyMOL is older and doe not have the module pymol.plugins
import pymol.plugins

#THIS IS WHERE THE PATH IS ADDED TO INITIALIZE PLUGINS USING THE PLUGIN MANAGER
pymol.plugins.set_startup_path([os.path.join(pymol_git, 'plugins'), os.path.join(sys.prefix, 'Lib', 'site-packages', 'pmg_tk', 'startup')])

pymol.plugins.preferences = {'instantsave': False, 'verbose': False}
pymol.plugins.autoload = {'apbs_tools': False}
pymol.plugins.preferences = {'instantsave': True, 'verbose': False}
# This can be used to trace if PyMOL executed the file correctly
print 'Loaded run_on_stratup.py'
except:
print 'NB! Plugin Manager not present!'
</syntaxhighlight>

Note that this block will also add the '''Pymol-script-repo''' and the subfolder '''Pymol-script-repo/modules''' to PyMOL's search path. This is something that is required in earlier PyMOL version to allow import of scripts. Thus this version of '''run_on_startup.py''' can be used for older versions, too.

Note that the settings specific for the ''new'' version of the '''Plugin Manager''' will not have an effect.

===What if the 'Pymol-script-repo' is not in the PyMOL directory?===
If the '''Pymol-script-repo''' is located somewhere else the first section of the '''run_on_startup.py''' file will be different. 
E.g. in the USER directory:
<syntaxhighlight lang="python">
# This would replace the first section in '''run_on_startup.py'''.
import sys
import os

pymol_git = os.path.abspath(os.path.join(os.path.expanduser('~'), 'Pymol-script-repo'))

os.environ['PYMOL_GIT_MOD'] = os.path.join(pymol_git,'modules')
sys.path.append(pymol_git)
sys.path.append(os.environ['PYMOL_GIT_MOD'])
</syntaxhighlight>

E.g. in any other path:
<syntaxhighlight lang="python">
# This would replace the first section in '''run_on_startup.py'''.
import sys
import os

pymol_git = os.path.realpath('D:/MY/RANDOM/PATH/TO/Pymol-script-repo') # Adjust this line
# Note the slash ('/') instead of backslash ('\'), beware Windows users!

os.environ['PYMOL_GIT_MOD'] = os.path.join(pymol_git,'modules')
sys.path.append(pymol_git)
sys.path.append(os.environ['PYMOL_GIT_MOD'])
</syntaxhighlight>

===Appending additional paths to the Plugin Manager===
Should your scripts be located in several alternative locations, it is possible to append additional directories to the '''Plugin Manager'''. 
In the example below, a directory called 'plugins_private', which is located in the PyMOL directory, is added to the Plugin Manger. 
Should the folder be somewhere else the example below can be adjusted as outlined above. 
<syntaxhighlight lang="python">
#copy paste into PyMOL's command line or into the pymolrc

python
import os
import sys
import pymol.plugins # Note that this requires the 'new' Plugin Manager

PRIVATE_PATH=os.path.realpath(os.path.join(os.environ['PYMOL_PATH'], 'plugins_private'))
startupdirectories=list(pymol.plugins.get_startup_path(True))
if PRIVATE_PATH not in startupdirectories:
startupdirectories.append(PRIVATE_PATH)
if PRIVATE_PATH not in sys.path:
sys.path.append(PRIVATE_PATH)
pymol.plugins.set_startup_path(startupdirectories)
python end
</syntaxhighlight>

Note that the '''Plugin Manager''' supports loading entire folders with scripts ('modules'). 
If you have such a folder, make sure it contains a file called '__init__.py', which can be empty.

=If you don't have a Plugin Manager=
If you are running an older PyMOL without '''Plugin Manager''' you can either upgrade to the newest version or load plugins the traditional way. 
For detailed instructions see: [[Git install scripts]] 
Essentially, make sure that the folder is added to PyMOL's search paths.
<syntaxhighlight lang="python">
import sys
import os
pymol_git = os.path.realpath(os.path.join(os.environ['PYMOL_PATH'], 'Pymol-script-repo'))
sys.path.append(pymol_git)
</syntaxhighlight>
Import a plugin manually:
<syntaxhighlight lang="python">
# EXAMPLE
delete all
frag LYS
cgo_arrow name N, name O # will not work if 'cgo_arrow' is not loaded

import cgo_arrow # PyMOL will look for this file and load it
cgo_arrow name N, name O # should work if it is loaded
</syntaxhighlight>

=SEE ALSO=
[[Git install scripts]]

[[Category:Launching]]

Plugin manager

2014-11-24T09:21:25Z

Sbliven: moved Plugin manager to Plugin Manager: Fixing capitalization

#REDIRECT [[Plugin Manager]]

Plugin Manager

2014-11-24T09:19:37Z

Sbliven: /* Creating run_on_startup.py */ Adding link to PYMOL_PATH + some minor formatting

PYMOL PATH

2014-11-24T09:14:57Z

Sbliven: Creating PYMOL_PATH page

The '''PYMOL_PATH''' environmental variable points to the root PyMOL directory. It contains internal PyMol code and core modules. It is also the location for plugins installed via the [[Plugin Manager]]. The variable should be set automatically by PyMOL, and should not normally need to be changed by the user.

= Standard Locations =

'''Windows:''' <tt>C:\Program Files\PyMOL\</tt>

'''Mac:''' <tt>/Applications/MacPyMOL.app/pymol</tt>

'''Ubuntu''' (Open-source PyMOL): <tt>/usr/lib/python2.7/dist-packages/pymol</tt>

= Determining the location =

For other operating systems or non-standard installation locations, the PYMOL_PATH can be determined by running the following command from within PyMOL:

print os.environ['PYMOL_PATH']

= Contents =

The contents of PYTHON_PATH should generally not be modified, but a few locations can be useful to know:

* '''<tt>PYMOL_PATH/examples/</tt>''' Example PyMOL and Python scripts
* '''<tt>PYMOL_PATH/modules/pmg_tk/startup/
* '''<tt>PYMOL_PATH/run_on_startup.py</tt>''' A python script run at startup, before <tt>.pymolrc</tt>. See [[Plugin Manager]] for details.

Selector

2014-05-19T07:58:23Z

Sbliven: Redirect to Property Selectors, which is more appropriate.

#REDIRECT [[Property Selectors]]

Selectors

2014-05-19T07:57:51Z

Sbliven: Redirect to Property Selectors

#REDIRECT [[Property Selectors]]

Selector

2014-05-19T07:56:04Z

Sbliven: Redirect to Selection Algebra

#REDIRECT [[Selection Algebra]]

Selection

2014-05-19T07:55:41Z

Sbliven: Redirect to Selection Algebra

#REDIRECT [[Selection Algebra]]

Talk:H Add

2013-08-06T23:25:39Z

Sbliven: /* Atom names */

==Atom names==

The names assigned to hydrogens take the form H01, H02, ..., and they seem to be assigned consistently to each amino acid. Is there a way to get h_add to use the standard PDB atom names instead? Or is this a deliberate attempt to break compatibility with other software packages, since the protonation states are assigned arbitrarily by h_add?

--[[User:Sbliven|Sbliven]] 18:25, 6 August 2013 (CDT)

Editing atoms

2012-07-23T20:49:54Z

Sbliven: /* Get coordinates from Python */ Fixed list numbering

==Altering atom types/elements==
Example:

To transform a carbon into an oxygen,
pick an atom by a ''select'' command or CTRL+middle.
<source lang="python">
alter pk1,elem='O'
alter pk1,name='O2'
</source>
Note that the ''name'' field should contain something more descriptive than just the element symbol.
For reasons unknown (?), util.cbag() and similar methods will not recognize the new element.

==Altering atom coordinates==
Example:
<source lang="python">
alter_state 1,(pdb1cse),x=x-10.0
</source>
The latter section can contain formulae involving at least the xyz coordinates, lots of constants and the (+-*/) operators.

==Translate or rotate individual objects==
There is a "translate" function similar to "rotate", the docs for these don't exist yet, because the implementation isn't finished. However, feel free to use them in the following forms:
<source lang="python">
translate vector,object-name,state
vector needs to be something like [x,y,z]

translate [1,0,0],pept
</source>

<source lang="python">
rotate axis,angle,object-name,state
axis can be either the letter x,y,z or a 3D vector [x,y,z]

rotate x,90,pept
rotate [1,1,1],10,pept
</source>

==Get coordinates from Python==

# The actual C-langauge arrays aren't exposed, but there are at least three different ways you can modify coordinates from within Python: You can get a python object which contains the molecular information, modify the coordinates in that object, load the modified molecule into PyMOL, update the modified coordinates to the original model, and then delete the modified object. (link to example)
# Another approach is the "alter_state" function, which can perform the same transformation in a single PyMOL command statement:<source lang="python">
alter_state 1,pept,(x,y)=(-y,x)
</source>Likewise sub-selections can be transformed as well:<source lang="python">
alter_state 1,(pept and name ca),(x,y,z)=(x+5,y,z)
</source>
# A third approach is to use alter_state with the global "stored" object: Example in a Python script)
Approaches 2 gives the best [[:Category:Performance|performance]], approach 3 gives more flexibility, and approach 1 gives you a reusable and fully modifiable Python object.

[[Category:Modeling_and_Editing_Structures|Editing Atoms]]
[[Category:Performance]]
[[Category:States]]

Talk:Color Objects

2010-05-17T00:46:02Z

Sbliven: Pointed out bug with get_names('models')

== Bugs ==

Using MacPyMol 1.2edu, I get an error from the line "obj_list = cmd.get_names('models')" stating that 'models' can't be found. This can be fixed by changing 'models' to 'objects'. If someone confirms that this is still a problem in the current build of pymol we should change it in the script. [[User:Sbliven|Sbliven]] 00:46, 17 May 2010 (UTC)

Advanced Coloring

2010-05-17T00:31:24Z

Sbliven: Changed a broken external link for color_obj.py to point to the proper page on this wiki

=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:
{|
! command
! carbon color
|-
| util.cba'''g'''
| green
|-
| util.cba'''c'''
| cyan
|-
| util.cba?
| magenta
|-
| util.cba'''y'''
| yellow
|-
| util.cba'''s'''
| salmon
|-
| util.cba'''w'''
| white/grey
|-
| util.cba'''b'''
| slate
|-
| util.cba?
| orange
|-
| util.cba'''o'''
| light orange
|-
| util.cba'''p'''
| purple
|-
| util.cba'''k'''
| pink
|}
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 not 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).

Also, see the newly created [[spectrumbar]] script!

==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_Objects |color_obj.py]] that does the job.

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]]