PyMOL Wiki - User contributions [en]

User:Speleo3

2016-03-07T03:47:42Z

Bell: 1 revision

My name is Thomas Holder and I work for PyMOL at [http://schrodinger.com Schrödinger].

I was awarded the [http://pymol.org/fellowship Warren L. DeLano Memorial PyMOL Open-Source Fellowship] for 2011-2012.

== Contact ==

* speleo3/users.sourceforge.net
* thomas.holder/schrodinger.com

== Scripts written by me ==

* [[AAindex]]
* [[AngleBetweenHelices]]
* [[Extra fit]]
* [[PluginDirectory]]
* [[Pml2py]]
* [[Polarpairs]]
* [[Save settings]]
* [[Show bumps]]
* [[Sidechaincenters]]
* [[Spectrumany]]
* [[Spectrum states]]
* [[Supercell]]

== Scripts Pastebin ==

Some random scripts with no dedicated PyMOLWiki page.

Launch interactive python terminal with PyMOL process:
(see also [[Launching From a Script]])

<source lang="python">
#!/usr/bin/python2.6 -i

import sys, os

# autocompletion
import readline
import rlcompleter
readline.parse_and_bind('tab: complete')

# pymol environment
moddir='/opt/pymol-svn/modules'
sys.path.insert(0, moddir)
os.putenv('PYMOL_PATH', os.path.join(moddir, 'pymol/pymol_path'))

# pymol launching
import pymol
pymol.pymol_argv = ['pymol','-qc'] + sys.argv[1:]
pymol.finish_launching()
cmd = pymol.cmd
</source>

Build PyMOL:
(see also [[Linux Install]])

<source lang="bash">
#!/bin/bash -e

src=/tmp
prefix=/opt/pymol-git

pyinstall() {
cd $src
name=$(basename $2)

if [[ -e $name ]]; then
cd $name && $1 pull
else
$1 clone $2 && cd $name
fi

python setup.py build install \
--home=$prefix \
--install-lib=$prefix/modules \
--install-scripts=$prefix
}

pyinstall git git@github.com:speleo3/pymol
pyinstall git git@github.com:speleo3/pymol-psico
pyinstall hg https://hg.codeplex.com/csb
</source>

Build FREEMOL (see also [[MovieSchool 6]])

<source lang="bash">
#!/bin/bash -e

src=/tmp
prefix=/opt/pymol-git
export FREEMOL=$prefix/freemol

freemoltrunk=$src/freemol-trunk
if [[ ! -e $freemoltrunk ]]; then
svn co svn://bioinformatics.org/svnroot/freemol/trunk $freemoltrunk
fi

cd $freemoltrunk

sed -i 's/vdwtype\[11\]/vdwtype[14]/' src/mengine/src/field.h

for name in mpeg_encode mengine apbs pdb2pqr; do
(cd src/$name && ./configure && make && make install)
done

cp -na freemol/libpy/freemol $prefix/modules/

ln -sfT $FREEMOL $prefix/modules/pymol/pymol_path/freemol
</source>

Download all PyMOL scripts from Robert L. Campbell's website:

<source lang="bash">
wget -r -np -nd --level=1 -A .py \
http://pldserver1.biochem.queensu.ca/~rlc/work/pymol/
</source>

Render movie from PNG files (save as <code>png2mpeg1.sh</code>):

<source lang="bash">
#!/bin/bash

set -e

usage="usage: $(basename $0) [-w width] [-f fps] [-b vbitrate] <indir> <outfile.mpeg>"
width=""
fps=25
vbitrate=16000

args="$(getopt w:f:b:h "$@")" || args="-h"
set -- $args

while [[ $# > 0 ]]; do
case "$1" in
--) shift; break ;;
-w) width=$2; shift 2 ;;
-f) fps=$2; shift 2 ;;
-b) vbitrate=$2; shift 2 ;;
-h) echo $usage; exit 1 ;;
*) echo "argument error: $1"; exit 1 ;;
esac
done

if [[ $# > 2 ]]; then
echo "too many arguments: $3 ..."
echo $usage
exit 1
fi

indir="$1"
outfile="$2"

if [[ -z "$indir" ]]; then
echo "error: indir missing"
echo $usage
exit 2
fi

if [[ -z "$outfile" ]]; then
echo "error: outfile missing"
echo $usage
exit 3
fi

MENCODER="mencoder -quiet"
MPEG1ARGS="-mf type=png:fps=$fps -ovc lavc -forceidx -noskip \
-of rawvideo -mpegopts format=mpeg1 \
-lavcopts vcodec=mpeg1video:vbitrate=$vbitrate:vhq:trell:keyint=25"

if [[ -n "$width" ]]; then
MPEG1ARGS="-zoom -xy $width -sws 9 $MPEG1ARGS"
fi

pattern="mf://$indir/*.png"
$MENCODER "$pattern" $MPEG1ARGS:vpass=1 -o /dev/null
$MENCODER "$pattern" $MPEG1ARGS:vpass=2 -o "$outfile"
</source>

=== load_mtz_cctbx: Load MTZ files with a [[CCTBX]] wrapper (3 files) ===

1) ~/bin/mtz2ccp4.sh

<source lang="bash">
#!/bin/bash
export PATH=/opt/ccp4/ccp4-6.5/bin:$PATH
exec cctbx.python ~/bin/mtz2ccp4.py "$@"
</source>

2) ~/bin/mtz2ccp4.py

<source lang="python">
#!/opt/ccp4/ccp4-6.5/bin/cctbx.python

import os
import sys
import tempfile

def mtz2ccp4maps(filename, prefix='map'):
'''
Creates a temporary directory and dumps all maps from the given MTZ file
into this directory as CCP4 maps files. Returns the path of the temporary
directory.
'''
from iotbx.reflection_file_reader import any_reflection_file

hkl_in = any_reflection_file(file_name=filename)

temp_dir = tempfile.mkdtemp()

for i_map, array in enumerate(hkl_in.as_miller_arrays()):
if array.is_complex_array():
fft_map = array.fft_map(resolution_factor=0.25).apply_sigma_scaling()
map_filename = os.path.join(temp_dir,
prefix + '_' + '_'.join(array.info().labels) + '.ccp4')
fft_map.as_ccp4_map(file_name=map_filename)

return temp_dir

# print the name of the temporary directory to standard output
print mtz2ccp4maps(*sys.argv[1:])
</source>

3) ~/.pymolrc.py

<source lang="python">
@cmd.extend
def load_mtz_cctbx(filename, prefix=''):
'''
DESCRIPTION

Load all maps from an MTZ file, using the mtz2ccp4.sh wrapper which
uses iotbx (cctbx).
'''
import subprocess
import glob
import shutil

if not prefix:
prefix = os.path.basename(filename).rpartition('.')[0]

outdir = subprocess.Popen([os.path.expanduser('~/bin/mtz2ccp4.sh'),
filename, prefix], stdout=subprocess.PIPE).stdout.readlines()[0].strip()

for mapfilename in glob.glob(os.path.join(outdir, '*.ccp4')):
cmd.load(mapfilename)

shutil.rmtree(outdir)
</source>

=== ccmutate ===

<source lang="python">
@cmd.extend
def ccmutate(code, selection='??sele|?pk1', sculpt=1):
'''
DESCRIPTION

Mutate selected residue.

ARGUMENTS

code = str: 3-letter PDBeChem chemical component identifier

selection = str: single residue selection {default: pk1 or sele}

sculpt = 0/1: try to adopt conformation of replaced sidechain, followed
by relaxation using sculpting {default: 1}

EXAMPLE

fetch 1ubq, async=0
ccmutate 0HG, resi 24

SEE ALSO

fetch ..., type=cc
wizard mutagenesis
'''
code = code.upper()

tmp_sele = cmd.get_unused_name('_sele')
tmp_frag = cmd.get_unused_name('_frag')
tmp_Nnbr = cmd.get_unused_name('_Nnbr')
tmp_back = cmd.get_unused_name('_back')
tmp_tmpl = cmd.get_unused_name('_tmpl')
tmp_sc_o = cmd.get_unused_name('_sc_o')
tmp_sc_n = cmd.get_unused_name('_sc_n')

try:
cmd.select(tmp_sele, 'byres (' + selection + ')', 0)

# check input selection
if cmd.count_atoms('name CA & ?' + tmp_sele) != 1:
raise pymol.CmdException('selection must include exactly one residue')
if cmd.count_atoms('name N+CA+C & ?' + tmp_sele) != 3:
raise pymol.CmdException("selected residue doesn't have N+CA+C atoms")

# PDBeChem fragment
cmd.fetch(code, tmp_frag, type='cc', zoom=0)

# check if fragment is amino acid
if cmd.count_atoms('name N+CA+C & ?' + tmp_frag) != 3:
raise pymol.CmdException("residue '%s' doesn't have N+CA+C atoms" % (code))

# only keep hydrogens if target also has hydrogens
if cmd.count_atoms('hydro & ?' + tmp_sele) == 0:
cmd.remove('hydro & ?' + tmp_frag)

# update residue name for old residue
cmd.alter(tmp_sele, 'resn = ' + repr(code))

# superpose fragment on backbone
cmd.align(
'name N+CA+C & ?' + tmp_frag,
'name N+CA+C & ?' + tmp_sele)

# extra N bonds, like in PRO
cmd.select(tmp_Nnbr, 'neighbor (name N & ?' + tmp_frag + ')', 0)

# backbone selection
cmd.select(tmp_back, 'name CA+C+O+N+OXT', 0)
cmd.select(tmp_back, 'hydro & neighbor ?' + tmp_back, 0, merge=1)

# remove complementary atoms
cmd.remove( '?' + tmp_frag + ' & ' + tmp_back)
cmd.extract(tmp_tmpl, '?' + tmp_sele + ' & !' + tmp_back, zoom=0)

if cmd.count_atoms(tmp_frag):
# attach new sidechain
cmd.fuse('name CB & ?' + tmp_frag, 'name CA & ?' + tmp_sele, mode=1, move=0)
cmd.unpick()

# new atom selections
cmd.select(tmp_sc_n, '(byres ?' + tmp_sele + ') & !?' + tmp_sele, 0)
cmd.select(tmp_sc_o, '?' + tmp_sc_n + ' like ?' + tmp_tmpl, 0)

# extra N bonds, like in PRO
if cmd.count_atoms(tmp_Nnbr):
cmd.bond('?' + tmp_sc_n + ' like ?' + tmp_Nnbr, 'name N & ?' + tmp_sele)

# adopt old conformation, if possible
if int(sculpt):
model = cmd.get_object_list('?' + tmp_sele)[0]
cmd.protect(model)
cmd.deprotect('?' + tmp_sc_n + ' & !?' + tmp_sc_o)
cmd.sculpt_activate(model)
if cmd.count_atoms(tmp_sc_o):
cmd.update(tmp_sc_o, tmp_tmpl)
cmd.set('sculpt_field_mask', 63) # local geom + vdw
cmd.sculpt_iterate(model, cycles=100)
cmd.deprotect(tmp_sc_o)
cmd.set('sculpt_field_mask', 0xff) # all
cmd.sculpt_iterate(model, cycles=200)
cmd.set('sculpt_field_mask', 31) # local geom
cmd.sculpt_iterate(model, cycles=200)

finally:
cmd.delete(tmp_sele)
cmd.delete(tmp_frag)
cmd.delete(tmp_Nnbr)
cmd.delete(tmp_back)
cmd.delete(tmp_tmpl)
cmd.delete(tmp_sc_o)
cmd.delete(tmp_sc_n)
</source>

Set Key

2016-03-07T03:47:41Z

Bell: 1 revision

'''set_key''' binds a Python function or PyMOL command to a key press.
Such key binding customization is typically done with your [[pymolrc]] startup script.

''Changes with PyMOL version:''

* 1.8: decorator support
* 1.7: second argument can also be a string in PyMOL command syntax

== PyMOL API ==

<source lang="python">
cmd.set_key(string key, function fn, tuple arg=(), dict kw={})
</source>

''Also supported since PyMOL 1.7:''
<source lang="python">
cmd.set_key(string key, string command)
</source>

''Decorator support since PyMOL 1.8:''
<source lang="python">
cmd.set_key(string key)(function fn)
</source>

== PyMOL Command (since PyMOL 1.7) ==

set_key key, command

== Examples ==

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

# define a custom function which colors a selection blue
def make_it_blue(selection): cmd.color("blue", selection)

# color "object1" blue when the F1 key is pressed
cmd.set_key( 'F1' , make_it_blue, [ "object1" ] )
</source>

<source lang="python">
# zoom on everything
cmd.set_key( 'CTRL-C' , cmd.zoom )
</source>

<source lang="python">
# turn camera by 90 degrees
cmd.set_key( 'ALT-A' , cmd.turn, ('x',90) )
</source>

# zoom on first ligand when pressing F1 (PyMOL 1.7+)
set_key F1, zoom byres (first organic), animate=1

<source lang="python">
# zoom on first ligand when pressing F1 (all PyMOL versions)
cmd.set_key('F1', cmd.zoom, ['byres (first organic)'], {'animate': 1})
</source>

<source lang="python">
# decorator syntax (PyMOL 1.8+)
@cmd.set_key('F1')
def zoom_ligand():
cmd.zoom('byres (first organic)', animate=1)
</source>

== KEYS WHICH CAN BE REDEFINED ==
F1 to F12
left, right, pgup, pgdn, home, insert
CTRL-A to CTRL-Z
ALT-0 to ALT-9, ALT-A to ALT-Z

== See Also ==

* [[alias]]
* [[extend|cmd.extend]]
* [[Button]]
* [[Check Key]]

[[Category:Commands|Set Key]]

Set Color

2016-03-07T03:47:40Z

Bell: 1 revision

[[Set_Color]] defines a new color with color indices (0.0-1.0). Numbers between 0 an 255 can be used as well. (If at least one value is larger than 1, pymol will interpret all 3 values as between 0 and 255). If an existing color name is used, the old color will be overridden.

===USAGE===
<source lang="python">
set_color name, [ red-float, green-float, blue-float ]
set_color name = [ red-float, green-float, blue-float ] #(DEPRECATED)
</source>

===PYMOL API===
<source lang="python">
cmd.set_color( string name, float-list rgb )
</source>

===EXAMPLES===
<source lang="python">
PyMOL>set_color red, [1,0.01,0.01]
Color: "red" defined as [ 1.000, 0.010, 0.010 ].
PyMOL>set_color khaki, [195,176,145]
Color: "khaki" defined as [ 0.765, 0.690, 0.569 ].
</source>

These will be added to the end of the list of Pymol's color indices that you can view the [[Get Color Indices]] command.

== See Also ==
* [[Get_Color_Tuples]]

[[Category:Commands|Set Color]]
[[Category:Coloring|Set Color]]

Load Traj

2016-03-07T03:47:39Z

Bell: 1 revision

'''load_traj''' loads a trajectory as "states" into an already loaded molecular object.

Since version 1.0, PyMOL uses the [http://www.ks.uiuc.edu/Research/vmd/plugins/molfile/ Molfile Plugin] backend, which supports a variety of trajectory file formats. Older versions only supported the ascii AMBER format (".trj" file extension).

Loading a large trajectory may take up a lot of RAM, unless the [[defer_builds_mode]] is set to 3.

== Usage ==

<source lang="python">
load_traj filename [,object [,state [,format [,interval [,average ]
[,start [,stop [,max [,selection [,image [,shift
[, plugin ]
]]]]]]]]]
</source>

== Arguments ==

* '''filename''' = str: trajectory file path
* '''object''' = str: name of the molecular object where the trajectory should be appended as states {default: guess from filename}
* '''state''' = int: object state where to start appending states. To discard the currently loaded coordinates, use ''state=1''. To append new states, use ''state=0'' {default: 0}
* '''format''' = str: specify file type instead of guessing from file extension (only affects AMBER .trj format, use "plugin" argument for Molfile Plugin types) {default: }

== Examples ==

<syntaxhighlight lang="python">
# topology from PDB file, trajectory from DCD file
load sampletrajectory.pdb
load_traj sampletrajectory.dcd

# gromacs trajectory, using "mytraj" as object name
load sampletrajectory.gro, mytraj
load_traj sampletrajectory.xtc, mytraj

# playing through states, memory optimized (but eventually slower)
set defer_builds_mode, 3
mplay
</syntaxhighlight>

== Notes ==
*PyMOL does not know how to wrap the truncated octahedron used by Amber You will need to use the [http://amber.scripps.edu/tutorials/basic/tutorial5/index.html ptraj] program first to do this.
*The average option is not a running average. To perform this type of average, use the [[smooth]] command after loading the trajectory file.
*For quickly viewing Trajectories as a movie, use the [[mset]] command to map each state to a movie frame.

useful notes from the email list:
<br/>
http://www.mail-archive.com/pymol-users@lists.sourceforge.net/msg04272.html
<br/>
http://www.mail-archive.com/pymol-users@lists.sourceforge.net/msg10266.html

in one line convert dcd and psf to pdb :

catdcd -o all.pdb -otype pdb -s autopsf.psf -stype psf out.dcd

== See Also ==
[[Load]], [[defer_builds_mode]]

[[Category:Commands|Load Traj]]
[[Category:Performance|Load Traj]]
[[Category:States|Load Traj]]

Lisica

2016-03-07T03:47:38Z

Bell: 2 revisions

{{Infobox script-repo
|type = plugin
|filename = plugins/lisica.py
|author = Janez Konc
|license =
}}

== Description ==

LiSiCA is a software for 2D and 3D ligand based virtual screening. It uses a fast maximum clique algorithm to find two- and three- dimensional similarities
between reference compound and a database of target compounds in Mol2 format. The similarities are expressed using Tanimoto coefficients and the target compounds are ranked accordingly.
LiSiCA is developed and maintained at '''National Institute of Chemistry, Slovenia'''.

LiSiCA Plugin is '''free for Academic (NON-COMMERCIAL) use'''. However, for '''COMMERCIAL use the potential users have to write to [mailto:konc@cmm.ki.si Janez Konc]'''.

== LiSiCA Plugin Features ==

# Graphical User Interface which facilitate the choice of parameters for LiSiCA.
# Results displayed according to the ranking in similarities as measured by Tanimoto coefficients.
# Structural similarity between molecules visualized using PyMOL viewer.

== Requirements ==

The plugin should work on Windows and all variety of Unix like systems. Most of the tests were performed on Windows 7, Ubuntu 14.04 and Linux Mint.
To work properly, the plugin requires Python with Tkinter and PyMOL. The plugin was mainly tested with PyMOL 1.7.x.

== Installation ==

This plugin is ready "out-of-box" for both Linux and Windows users through the project Pymol-script-repo.

The lisica.py script initializes the installation of the plugin. The script downloads and installs all the required files. On successful installation, a directory named .lisicagui is downloaded and saved in the home directory. This folder contains the executables, log files, icon files, python modules etc.

Once the files are properly installed, LiSiCA plugin version will be ready to use.

'''Important note''': For complete installation of the plugin, a stable INTERNET connection is required at the user end.
Note for Linux users : It is advisable to start PyMOL from the terminal using '''sudo pymol''' command.

== Usage ==

The plugin window has four tabs.

==== Input Tab ====

Both the reference and the target compound files need to be in the Tripos mol2 format. The reference file should contain only one (reference) compound;
the target file may contain many compounds. If the reference file contains more than one compound, the first molecule is used as a reference. The molecules
in the target file having the same name are considered as different conformers of the same molecule. By default only the best-scoring (by Tanimoto coefficient)
conformer will be shown in the final output for the 3D screening option.

In the mol2 input files, the name of the molecule (ZINC ID) must be specified under the line for @<TRIPOS>MOLECULE tag. For example,

@<TRIPOS>MOLECULE
'''ZINC73655097'''
46 48 0 0 0
SMALL
USER_CHARGES

@<TRIPOS>ATOM
...

LiSiCA checks similarities based on the mol2 atom types. Hence '''SYBYL''' atom types have to be specified in the mol2 files. For example, under the @<TRIPOS>ATOM tag, each atom specification should include the SYBYL atom type, as in:

1 C1 -0.0647 1.4496 -0.0592 '''C.3''' 1 <0> -0.167

In the above line from a mol2 file, in bold, in column 5, the SYBYL atom type is specified.

In 2D screening, the option '''Maximum Allowed Shortest path Difference''' corresponds to the maximum allowed difference in shortest-path length between
atoms of the two compared product graph vertices. Lesser values correspond to a more rigorous screening. By default this value is unit bond.

In 3D screening, the option '''Maximum Allowed Spatial Distance Difference''' corresponds to the maximum allowed difference in distances between atoms of
the two compared product graph vertices. Lesser values correspond to a more rigorous screening. By default this value is 1 Å.
The '''Number of Conformations''' option corresponds to the maximum number of outputted files of one molecule in different conformations and is to be used only for 3D screening.

[[File: InputTab2DLiSiCALinuxv1.0.0.png|550 px]] [[File: InputTab3DLiSiCALinuxv1.0.0.png|520 px]]

According to the value of '''Number of highest ranked molecules to be written to the output (say W)''', LiSiCA will create mol2 files of that many (W) highest scoring
target molecules with a comment section at the end of the file where the matching atom pairs are displayed. This value is by default 100. The resulting mol2 files
are written into a time-stamp directory in the folder specified in '''Save results in:'''. By default this folder is the user's home directory. Also, a text file named
lisica_results.txt with the target molecules with (in the descending order of) Tanimoto coefficients is written to the time-stamp folder.

The '''Number of CPU cores to be used''' allows selection of CPU threads used for LiSiCA. By default, it tries to detect the number of CPUs available.
The '''Consider Hydrogen''' options lets the user to choose if the hydrogen atoms are to be considered for the calculation of the similarity using the maximum clique algorithm.
By default, hydrogen atoms are not considered in finding the largest substructure common to the reference and target molecules, so as to obtain faster results.

==== Load Project Tab ====

The plugin also has a feature to load saved results. On the '''Load Project''' tab, the user can choose the directory with the saved results (mol2 files of each target
and the reference) and the lisica_results.txt file.
When the load button is clicked, the results will be loaded onto the output tab and the PyMOL Viewer window.

==== Output Tab ====

In the output tab, there are two listboxes:
* One contains ZINC ID and Tanimoto Coefficients of target molecules in the decreasing order of the Tanimoto coefficient values.
Any single target molecule can be selected on this listbox using a mouse click or using up/down arrow keys.
The selected target molecule is displayed with the reference molecule on the PyMOL viewer window.
* Depending on the target molecule chosen on the first listbox, the corresponding atoms from reference and the target molecules are displayed on the other listbox.
Any single pair of corresponding atoms can be selected on this listbox using a mouse click or using up/down arrow keys.
The selected pair is highlighted on the PyMOL viewer window.

For '''2D Screening''', the two molecules (the reference and the selected target) are visualized side by side on the PyMOL viewer screen.

[[File: 2DResultOutputtabPyMOLViewerLinux1.png|700 px|2D LiSiCA output- Note the reference and target molecules are aligned side by side]]

For '''3D Screening''', the 3D structures of the two molecules (the reference and the selected target) are superimposed on one another to visualize the similarity on the PyMOL viewer screen.

[[File: 3DResultsOutputtabPyMOLViewer1.png|700 px|3D LiSiCA output-Note that the reference and target molecules are superimposed]]

==== About Tab ====

The users can get information on new updates if available on the About tab.

== Reference ==

'''If you are using LiSiCA in your work, please cite:'''

S. Lesnik, T. Stular, B. Brus, D. Knez, S. Gobec, D. Janezic, J. Konc, LiSiCA: A Software for Ligand-Based Virtual Screening and Its Application for the Discovery of Butyrylcholinesterase Inhibitors, J. Chem. Inf. Model., 2015, 55, 1521–1528.

[http://pubs.acs.org/doi/abs/10.1021/acs.jcim.5b00136 Read the article]

[http://pubs.acs.org/doi/pdf/10.1021/acs.jcim.5b00136 PDF Link]

== Known Bugs ==

If you receive the error '''<class '_tkinter.TclError'>: can't find package treectrl''' during the LiSiCA installation process, you should fix this by installing tktreectrl: sudo apt-get install tktreectrl.

== Licensing ==

LiSiCA software is copyrighted by :

:'''Janez Konc'''
:National Institute of Chemistry
:Laboratory for Molecular Modeling
:Hajdrihova 19
:SI-1000 Ljubljana
:Slovenia.

The terms stated in the following agreement apply to all files associated with the software
unless explicitly disclaimed in individual files.

'''LiSiCA SOFTWARE LICENSE AGREEMENT'''

1. Grant Of Limited License; Software Use Restrictions. The programs received by you will be used only for NON COMMERCIAL purposes.
This license is issued to you as an individual.

For COMMERCIAL use of the software, please contact Janez Konc for details about commercial usage license agreements.
For any question regarding license agreements, please contact:

Janez Konc
National Institute of Chemistry
Laboratory for Molecular Modeling
Hajdrihova 19
SI-1000 Ljubljana
Slovenia.

2. COMMERCIAL USAGE is defined as revenues generating activities. These
include using this software for consulting activities and selling
applications built on top of, or using this software. Scientific
research in an academic environment and teaching are considered
NON COMMERCIAL.

3. Copying Restrictions. You will not sell or otherwise distribute commercially
these programs or derivatives to any other party, whether with or without
consideration.

4. Ownership of Software. You will not obtain, and will not attempt to
obtain copyright coverage thereon without the express purpose written
consent of Janez Konc.

5. IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

6. THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

[[Category:Plugins]]
[[Category:Pymol-script-repo]]

Ignore case

2016-03-07T03:47:36Z

Bell: 1 revision

The [[ignore_case]] setting (default: '''on''', ''except in PyMOL 1.8.0.0 - 1.8.0.4'') controls whether PyMOL does case sensitive matching of atomic identifiers and selection operators in the selection language. Most notably, it affects whether chain identifiers are matched case sensitive, which becomes relevant when using upper and lower case chain identifiers in a structure with more than 26 chains.

<div style="padding: 10px 20px; border: 1px solid #c33; background-color: #fcc">
The default value was changed to '''off''' in PyMOL 1.8.0.0. However, due to undesired side effects, the '''on''' default was restored in 1.8.0.5.

The next PyMOL version (expect 1.8.2) will introduce a new [[ignore_case_chain]] setting to address the issue of mixed case chain identifiers.

See also: https://sourceforge.net/p/pymol/mailman/message/34815599/
</div>

== Example ==

Load 1a00 which has chains A, B, C, D

PyMOL>fetch 1a00, async=0

1) case insensitive selection language (default for PyMOL <= 1.7.6 and >= 1.8.0.5)

PyMOL>set ignore_case
Setting: ignore_case set to on.
PyMOL>count_atoms chain A
count_atoms: 1164 atoms
PyMOL>count_atoms chain a
count_atoms: 1164 atoms

2) case sensitive selection language (default for PyMOL 1.8.0.0 - 1.8.0.4)

PyMOL>set ignore_case, off
Setting: ignore_case set to off.
PyMOL>count_atoms chain A
count_atoms: 1164 atoms
PyMOL>count_atoms chain a
count_atoms: 0 atoms

== Best Practice for Scripting ==

When writing scripts or plugins, all selection expressions should be strict about case (e.g. "name CA" and not "name ca") to not depend on the users setting of [[ignore_case]].

[[Category:Settings]]
[[Category:Selecting]]

Get Names

2016-03-07T03:47:36Z

Bell: 1 revision

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

Get Color Tuples

2016-03-07T03:47:36Z

Bell: 1 revision

#REDIRECT [[Get Color Indices]]

Get Color Indices

2016-03-07T03:47:36Z

Bell: 10 revisions

'''get_color_indices''' in combination with '''get_color_tuple''' will retrieve the RGB values for colors.

<source lang="python">
print cmd.get_color_indices()
</source>
will retrieve the Pymol color names and corresponding internal color indices. The Pymol names can be used to designate color for objects, see [[Color]].

<source lang="python">print cmd.get_color_tuple(index-number)</source> will retrieve individual RGB components when ''index-number'' is replaced with one of the color indices from above.

The color index, an integer, gets returned when color is returned while employing [[Iterate]]. You can thus use the '''get_color_tuple''' command above to convert that to RGB color values if you need to use the colors outside Pymol.

Tangentially related is the fact you can name additional colors,
<source lang="python">
set_color color-name, [r,b,g]
</source>

will create a new color that will appear in the GUI list. From the
open-source GUI you can use the "add" button in the color list viewer.
In MacPyMOL, enter the new name into the MacPyMOL color editor window,
set the RGBs, and then click Apply.
See [[Set Color]] for more details and examples.
The colors created will be added to the end of the list of Pymol's color indices that you can view the '''get_color_indices()''' command.

== See Also ==
* [[Get_Color_Tuples]]
* [[Iterate]]

[[Category:Commands|Get Color Indices]]
[[Category:Coloring|Get Color Indices]]

Fuse

2016-03-07T03:47:33Z

Bell: 1 revision

'''fuse''' joins two objects into one by forming a bond. A copy of
the object containing the first atom is moved so as to form an
approximately reasonable bond with the second, and is then merged
with the first object.

== Usage ==

fuse [ selection1 [, selection2 [, mode [, recolor [, move ]]]]]

== Arguments ==

* selection1 = str: single atom selection (will be copied to object 2) {default: (pk1)}
* selection2 = str: single atom selection {default: (pk2)}
* mode = int: {default: 0}
** mode=0:
** mode=1: adopt segi/chain/resn`resi
** mode=2: adopt segi/chain
** mode=3: don't move and don't create a bond, just combine into single object
* recolor = bool: recolor C atoms to match target {default: 1}
* move = bool: {default: 1}

== Example ==

Phosphorylate a serine residue:

fetch 1ubq, async=0

fragment phosphite
remove phosphite & elem H

fuse phosphite & elem P, /1ubq///65/OG, mode=1
delete phosphite

show sticks, resi 65
orient resi 65
unpick

== Notes ==

Each selection must include a single atom in each object.
The atoms can both be hydrogens, in which case they are
eliminated, or they can both be non-hydrogens, in which
case a bond is formed between the two atoms.

== See Also ==

[[Bond]], [[Unbond]], [[Attach]], [[Replace]], [[Remove_picked]]

[[Category:Commands|Fuse]]
[[Category:Editing Module|Fuse]]

Color

2016-03-07T03:47:32Z

Bell: 5 revisions

'''color''' sets the color of an object or an atom selection to a predefined, named color. For an overview of predifined colors, see [[Color Values]]. For a script that enumerates all the colors see, [[List_Colors]]. If you want to define your own colors, see [[Set_Color]].
===USAGE===
<source lang="python">
color color-name
color color-name, object-name
color color-name, (selection)
</source>

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

==EXAMPLES==
===Color all carbons yellow===
<source lang="python">color yellow, (name C*)</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, palette, object_name
</source>

For available palettes and more details see: [[spectrum]]

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

For more details see: [[spectrum]]

====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/)

====Reassigning B-Factors and Coloring - from file ====
<source lang="python">
reinitialize
prot="1XYZ"
cmd.fetch(prot,async=0)

# Set b value to zero
cmd.alter(prot,b=0.0)
cmd.show_as("cartoon",prot)

python
inFile = open("phi_values.txt", 'r')
val_list = []
for line in inFile.readlines()[1:]:
split = line.split()
resn = split[0][0]
resi = split[0][1:-1]
phi_ppm2 = float(split[1])
phi_ppm2_err = float(split[3])
R2_0 = float(split[4])
R2_0_err = float(split[6])
print "Resn=%s Resi=%s, phi_ppm2=%2.2f, phi_ppm2_err=%2.2f, R2_0=%2.2f, R2_0_err=%2.2f"%(resn,resi,phi_ppm2,phi_ppm2_err,R2_0,R2_0_err)

val_list.append(phi_ppm2)
cmd.alter("%s and resi %s and n. CA"%(prot,resi), "b=%s"%phi_ppm2)

python end
minval = min(val_list)
print minval
maxval = max(val_list)
print maxval
cmd.spectrum("b", "blue_white_red", "%s and n. CA"%prot, minimum=0, maximum=maxval)
cmd.ramp_new("ramp_obj", prot, range=[0, minval, maxval], color="[blue, white, red ]")
cmd.save("%s_newBFactors.pdb"%prot, "%s"%prot)
</source>

=== Expanding to Surface ===
See [[Expand_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.

=== Getting Atom Colors ===
<source lang="python">
stored.list = []
iterate all, stored.list.append(color) # use cmd.get_color_tuple(color) to convert color index to RGB values
print stored.list
</source>

Or, you can [[label]] each atom by it's color code:
<source lang="python">
label all, color
</source>

=== What colors does PyMOL currently have? ===
basic colors can be manually accessed and edited from the PyMOL menu under '''Setting''' --> '''Colors...'''<br>
At the Pymol prompt, you can use the command [[Get Color Indices]] to get a list of Pymols named colors.<br>
[[Get_colors]] is a script that allows accessing colors as well.<br>

=== Color States Individually ===
<source lang="python">
fetch 1nmr
set all_states

# the object has 20 states, so we can set separate line colors
# for each state as follows:
for a in range(1,21): cmd.set("line_color","auto","1nmr",a)
</source>
Or, we can do it differently,
<source lang="python">
# start over,
fetch 1nmr

# break apart the object by state
split_states 1nmr

# delete the original
dele 1nmr

# and color by object (carbons only)
util.color_objs("elem c")

# (all atoms)
util.color_objs("all")
</source>

== SEE ALSO ==

* [[Advanced Coloring]]
* [[Get Color Indices]]
* [[spectrum]]
* [[Ramp_New]]

[[Category:Objects_and_Selections|Color]]
[[Category:Commands|Color]]
[[Category:States|Coloring states individually]]
[[Category:Coloring|Color]]

COLLADA

2016-03-07T03:47:30Z

Bell: 2 revisions

'''COLLADA''' is an XML-based open 3D graphics format, designed to be used as an interchange format among various graphics programs. Beginning with version 1.7.3.2 (SVN rev4097) in the Open Source codebase, PyMOL is able to export COLLADA files, which have a ".dae" extension.

=Details=
COLLADA format defines a scene, with a camera and various geometric elements, which are colored and lit according to the properties of the material the object is made from and any effects (e.g. shaders) applied to it. PyMOL exports the scene exactly as it looks in the viewport when the save command is executed, so the orientations and colors of the objects should be the same. It currently saves every enabled object in the scene, regardless of any selection passed to the `save` command.

===USAGE===
<source lang="python">
save file.dae
</source>

== Features ==
* Full support of all standard representations (cartoon, stick, line, sphere, surface, etc.)
* Customizable output quality and file size, based on quality settings for active representations (e.g. [[surface_quality]])
* Transparency support

== Related Settings ==
* [[collada_export_lighting]] - Optionally include PyMOL's lighting information.
* [[collada_geometry_mode]] - Specify how geometry elements are presented.
* [[geometry_export_mode]] - Exclude camera as well as lighting information.

== Limitations ==
* '''Shaders.''' In version 1.4 of the COLLADA specification, only vertex-based meshes are defined, so all regular geometric shapes (e.g. spheres, cylinders, cones) have to be converted into a series of triangle meshes. This produces output similar to what you would see in PyMOL with `use_shaders` turned off. (Version 1.5 of the COLLADA spec includes "boundary representation" (<brep>) elements that define such geometric shapes as you might expect: a sphere is defined by a point and a radius, a cylinder by two points and a radius, a cone by two points and two radii. However, apparently due to the complexity of the physics portion of the 1.5 specification, few programs have even attempted to adopt it yet, so we're stuck with old-school triangle meshes.)

* '''Lighting.''' Whereas in PyMOL, the lighting of the object appears similar no matter how the object is rotated--that is, the lights move with the camera or viewport--in COLLADA, the lights are fixed in the scene with the objects, and therefore, with PyMOL `[[light_count]]` of 2 or higher, only one side of the objects is lit with the directional lights; the other side appears dark. For this reason, PyMOL's lights are excluded from COLLADA output files by default. To include lighting in the output file, turn on the `[[collada_export_lighting]]` setting.

* '''Labels.''' Like lights, labels would be fixed with the objects, so from all but a narrow range of orientations, the text would be unreadable.

* '''Volumes.''' PyMOL's volume representation consists of a series of evenly spaced planes perpendicular to the viewport, the orientation of which is changed whenever the view is changed. Unfortunately, this makes them essentially useless in a COLLADA scene as well, as, once the original orientation is changed, the planes would look less like a 3D volume projection, and more like a stack of flat images slicing through the rest of the scene.

== Increasing the Quality ==
You can increase the number of triangles exported, and therefore the smoothness of the resulting objects, by increasing the following settings.
* surface_quality
* sphere_quality
* stick_quality
* cartoon_sampling
Conversely, to decrease the file size, decrease the settings.

[[Category:OutputFormats]]

Auto show classified

2016-03-07T03:47:29Z

Bell: 1 revision

When loading structure files, the [[auto_show_classified]] setting sets up representations based on molecule classification (depends on [[auto_classify_atoms]]).

Available from the Tcl/Tk menu: '''Setting > Auto Show ... > ...'''

''New in PyMOL 1.8.2''

== Example ==

set auto_show_classified
fetch 1rx1

== Values ==

* 0: off (default)
* 1: show [[Single-word_Selectors|polymer]] as [[cartoon]], [[Single-word_Selectors|organic]] as [[sticks]], and [[Single-word_Selectors|inorganic]] as [[spheres]]
* 2: like 1, but apply [[auto_show_lines]] and [[auto_show_nonbonded]] in addition
* 3: simplified version, show polymer as [[ribbon]], organic and inorganic as [[lines]] or [[nonbonded]]

== See Also ==

* [[show]]
* [[hide]]
* [[auto_show_lines]]
* [[auto_show_nonbonded]]
* [[auto_classify_atoms]]

[[Category:Settings]]

Advanced Coloring

2016-03-07T03:47:29Z

Bell: 2 revisions

=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'''m'''
| light magenta
|-
| util.cba'''y'''
| yellow
|-
| util.cba'''s'''
| salmon
|-
| util.cba'''w'''
| white/grey
|-
| util.cba'''b'''
| slate
|-
| util.cba'''o'''
| bright 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.

The util.cnc command will color all the atoms according to type, as in the util.cba* commands stated above, except for the C-atoms.

For instance:
<source lang="python">
util.cnc three
</source>
will color the object ''three'' by atom type, but leave the color of the C-atom unaltered.

==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==
B-factor coloring can be done with the [[spectrum]] command. Example:

spectrum b, blue_white_red, minimum=20, maximum=50
as cartoon
cartoon putty

= See Also =
[[Color]], [[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>

The colors listed will be in terms of Pymol indexing system, see [[Get Color Indices]] for converting to names or rgb values.

== See also ==
* [[Ramp_New]]

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

Talk:SuperSym

2016-02-08T05:26:53Z

Bell: 1 revision

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)

Stereo 3D Display Options

2016-02-08T05:26:53Z

Bell: 1 revision

This page is for aggregating the latest know-how and links to current Stereo 3D display options best suited for molecular graphics applications like PyMOL. Please strive to provide objective factual information based on first-hand experiences while using the displays for real work and teaching.

Let's figure out together what stereo solutions work well in this brave new post-CRT world!

== Categories ==

* '''[[#Active_Stereo_3D|Active Stereo 3D]]''' -- requires expensive and/or bulky shutter glasses. For decades, this has been the standard solution for stereo 3D molecular visualization on the desktop.
* '''[[#Passive_Stereo_3D|Passive Stereo 3D]]''' -- requires inexpensive lightweight polarized glasses. This is the standard solution for delivering stereo 3D to audiences of more than a small group of people.
* '''[[#Autostereoscopic_3D|Autostereoscopic 3D]]''' -- means that no glasses are required. However, current autostereoscopic displays tend do not to work well for molecular graphics due to their inability to faithfully represent fine detail such as thin bonds and wire meshes.

== Active Stereo 3D (High-Refresh) Displays ==

This solution would be analogous to using desktop CRT monitors with shutter glasses.

=== LCD Displays (120 Hz)===

* [http://us.acer.com/ac/en/US/content/model/ET.UG5HP.001 ACER GD235HZ]. 1920x1080 120Hz 2ms .

* [http://www.planar3d.com/3d-products/sa2311w/ Planar SA2311W]. This is a high-end 23" 3D-ready monitor. The resolution is 1900x1280 and has a 2ms refresh time. This worked well for us.

* [http://www.engadget.com/2008/08/26/viewsonic-shows-off-a-120hz-lcd-display-for-computers ViewSonic VX2265wm] (VX2268wm in Europe) - [http://www.google.com/products?q=ViewSonic%20VX2265wm&btnG=Search+Froogle&lmode=unknown On the market] and [http://sourceforge.net/mailarchive/forum.php?thread_name=DED5C399-7534-4D3D-8B19-E3676C4F1867%40weizmann.ac.il&forum_name=pymol-users verified working under FC 12]

* [http://www.nvidia.com/object/product_GeForce_3D_VisionBundle_us.html Samsung 2233RZ] - On the market. Quad buffered stereo in Linux works with a [http://en.wikipedia.org/wiki/Nvidia_Quadro G8x based graphics core] or better Quadro FX card with the 3 pin mini din stereo connector (currently, the cheapest card that works in Linux is the Quadro FX 3700), 195.22 (or newer) nvidia linux binary driver, and the Nvidia 3d vision kit. Even though the Quadro FX 1400/3450/4000 cards have a 3 pin stereo connector, these will not work with Nvidia 3D vision since these have core versions less than G8x. For more information see this forum post [http://forums.nvidia.com/index.php?showtopic=91072&view=findpost&p=968627 at the Nvidia Forums]. - SP

* USB only based stereo with the 3D vision kit works only in MS Windows (e.g. with a low end Quadro FX 370 that has no 3 pin mini din stereo connector). For more information see this forum post [http://forums.nvidia.com/index.php?showtopic=91072&view=findpost&p=968627 at the Nvidia Forums]. - SP

* The 195.22 Nvidia linux drivers do not support the Samsung 2233RZ in Stereo mode 3 or 10 for quad buffered stereo with other stereo kits, emitters, or goggles such as those purchased from NuVision, Stereographics, or Edimensional. You cannot use NuVision, Stereographics, or Edimensional goggles with the Nvidia 3D Vision emitters. - SP

* NVidia 3D NVision kit only supports DirectX software for GeForce (gaming cards) on Windows; users are reporting that they are not able to run PyMOL with NVision with these cards. Get a newer model low end quadro (> G8x graphics core) without the 3 pin mini din (e.g. Quadro 370) or with the 3 pin mini din (e.g. Quadro 3700) for Windows.

==== NVidia NVision 3D Setup ====
The NVidia 3D NVision setup provides a very nice 3D experience. You need the following to enable PyMOL to show NVision 3D on Windows. Please review the hardware and software requirements before moving on to the installation and setup.

=====Necessary Hardware=====
* Monitor: 120 Hz LCD: a [http://www.samsung.com/us/consumer/office/monitors/specialty/LS22CMFKFV/ZA/index.idx?pagetype=prd_detail&returnurl=|Samsung 2233RZ] or a [http://www.viewsonic.com/products/desktop-monitors/lcd/x-series/vx2265wm-fuhzion-lcd.htm|ViewSonic Fuhzion vx2265wm]
* Cable: [http://images.google.com/imgres?imgurl=http://www.logicsupply.com/images/dvi_connector_types.gif&imgrefurl=http://www.logicsupply.com/faq&usg=__G2BLaVTqBN4ie8fz_LJR1zc3zBc=&h=261&w=440&sz=15&hl=en&start=0&sig2=_hFM6ICIsxPq5WIAv8BCqg&zoom=1&tbnid=NIcKIs_BW_2rmM:&tbnh=135&tbnw=228&ei=KHN2TL-UC8P_lgfr44nsCw&prev=/images%3Fq%3Ddual%2Blink%2Bdvi%26hl%3Den%26biw%3D1475%26bih%3D1042%26gbv%3D2%26tbs%3Disch:1&itbs=1&iact=hc&vpx=136&vpy=323&dur=3153&hovh=173&hovw=292&tx=227&ty=74&oei=KHN2TL-UC8P_lgfr44nsCw&esq=1&page=1&ndsp=30&ved=1t:429,r:6,s:0 Dual Link DVI cable]; most 120Hz monitors will come with this cable--regardless, the cable is necessary
* Quadro Card: recent [http://www.nvidia.com/page/quadrofx_family.html Quadro] series graphics card (not a GeForce card) such as an FX 380 or 570 or later. The GeForce cards do not support windowed openGL stereo, so we do not support these series of cards for the NVision 3D solution. For linux, you must have a quadro card that has a 3 pin mini din connector. The cheapest/oldest card that will work with linux is the Quadro 3700.
** '''WARNING''': The Quadro FX1400 does not support 3d vision stereo on Windows7 or Linux.
* Emitter: [http://www.nvidia.com/object/3d-vision-main.html|GeForce 3D Vision] hardware kit (an emitter with 3D shutter glasses). For Linux, make sure your kit comes with the 3 pin mini din "VESA" to 2.5mm stereo cable to connect from the stereo output on the video card into the emitter.
* GeForce Cards from series 400 onward have gained OpenGl support in recent Nvidia driver iterations (314+). This allows Pymol to be viewed in 3D using the quad buffered stereo setting with a GeForce card, 120Hz screen and 3D Vision kit.

=====Necessary Software=====
* Windows XP 32 bit (testing other OSs soon!), Windows Vista
* Latest Quadro [http://www.nvidia.com/Download/index.aspx?lang=en-us|Graphics Drivers from NVidia].
* Latest [http://www.nvidia.com/Download/index.aspx?lang=en-us|3D Graphics drivers for the NVision system]--under '''Product Type''' choose '''3D Vision'''.

=====Installation Instructions=====
======System Setup======
# Install the Quadro '''Graphics Drivers''' and reboot your machines
# Install the NVision Installation, hooking up the 3D emitter and glasses as directed in the instructions
## Make sure the 3D demos work
## Complete the '''3D Vision Drivers''' install (I had errors/warnings about old drivers but this did't matter)
# Specify how to drive the 3D by, click on
:::'''Windows Start Button''' > '''Control Panel''' > '''NVidia Control Panel''' > '''Manage 3D Settings''' (tab) > '''Global Settings''' (tab on the right) > '''Base Profile''' (tab). Then, under '''Settings''' choose '''Stereo - Display Mode'''. Next, select '''Generic Active Stereo (with NVidia IR Emitter)'''. If you have a DLP monitor/TV choose the corresponding DLP option. You '''must''' also set '''Stereo - Enable''' to '''on'''.

======Running PyMOL======
That's it! PyMOL should now work in Quad Buffered 3D Stereo using the NVidia 3D NVision system. To run PyMOL in 3D mode on:
*Windows
:: '''Start > PyMOL > PyMOL > PyMOL 3D Launch (last menu option) > PyMOL Stereo (Quad Buffered 3D)'''
*Linux
:: pymol -S -t 1
* Mac
:: Sorry, at this time the NVision system is not known to work on Macs.

=== DLP Projection Televisions ===

Projection televisions tend to be too large and fuzzy for desktop use. Also, a band of about 20 pixels around on the edge of the display are invisible, and this limitation cannot be eliminated through overscan since the image must be scanned at native resolution in order to support stereo 3D. The workaround is to shrink the PyMOL window to cover the visible portion of the screen. It is worth noting that true 3D-capable LCDs (as distinct from 3D-capable HDTVs) do not suffer from this problem.

Aside from the above concerns, the quality of the DLP stereo 3D effect is exceptional: there is absolutely no ghosting or cross-talk between the two images.

* [http://pages.samsung.com/us/dlp3d Samsung 3D-Ready DLP HDTVs] - work with PyMOL 1.2b3 & later without any special drivers. Quadro driver support is still lacking as of Feb. 1st, 2009 - WLD

* [http://www.mitsubishi-tv.com/ Mitsubishi 3D-Ready DLP HDTVs] - not yet tested, but are expected to work with PyMOL 1.2b3 & later without any special drivers. - WLD

See [http://www.3dmovielist.com/3dhdtvs.html The 3D HDTV List] for more 3D-capable HDTV options.

== Passive Stereo 3D Displays ==

=== One Piece Multi-layer LCD Displays ===

Affordable!

==== Zalman ====
'''iZ3D, the original supplier of Zalman display drivers has ceased operation and support as of 31 July 2012. DO NOT PURCHASE THESE MONITORS WITHOUT FURTHER CONFIRMATION of display support, the iZ3D support (required drivers, etc) is not activatable. If you do have further information, please post it here.''' [[User:Jedgold|Jedgold]] 12:21, 12 September 2012 (CDT)

* [http://www.zalman.co.kr/eng/product/Product_read.asp?Idx=219 Zalman 22-inch 3D LCD monitor] - works with PyMOL 1.2b3 & later without any special drivers. Great stereo quality provided that all drawn lines are at least 2 pixels thick. Menus are a bit awkward to use while in stereo mode, but even so, this 650 USD display provides excellent 3D molecular visualization in both full-screen in windowed modes. - WLD ('''The Zalman ZM-M220W is DeLano Scientific's RECOMMENDED SOLUTION as of Feb 11, 2009!''').
* [http://www.zalman.co.kr/Eng/product/Product_Read.asp?idx=391 Zalman 24-inch 3D LCD monitor] - also works with PyMOL 1.2b3 & later under LINUX (Centos 5 x86_64 plain kernel + NVidia driver from ELRepo). I'm using an NVidia Quadro FX 580 (G96GL) graphics card (£125). Monitor cost around £350. PyMOL automagically detects that quad buffered stereo is available on startup.--[[User:Bosmith|Bosmith]] 16:32, 2 December 2010 (UTC)

==== LG ====
* [http://www.lg.com/us/computer-products/monitors/LG-led-monitor-D2342P-PN.jsp LG D2342P-PN]
* [http://www.lg.com/uk/support-product/lg-DM2752D-PZ LG DM2752D] This (and other LG passive 3D monitors/TVs) work with PyMOL. I'm driving them using NVidia Quadro 600 graphics cards under LINUX (CentOSes 5, 6 & 7) with the NVidia driver from ELRepo.
===== On Linux =====
* setup by editing the xorg.conf file:
Option "Stereo" "7"

in the Screen section of xorg.conf and an additional:

Section "Extensions"
Option "Composite" "Disable"
EndSection

* launch using:
pymol -S -t 6

===== On Windows =====
# From the Start Menu: In the "PyMOL" folder, go into the "Stereo 3D Launch" subfolder, and select "PyMOL Zalman 3D (By Row)". You might want to control-drag a copy of that shortcut on to your desktop in order to drag & drop content files onto it for stereo 3D visualization
# From the Command Line:

"C:\Program Files\DeLano Scientific\PyMOL\PyMOLWin.exe" -S -t 6

===== On Mac =====
# MacPyMOL: Copy and rename the "MacPyMOL" application bundle to "MacPyMOLZalman". You can then double-click on the MacPyMOLZalman icon or drop data files directly onto it to visualize content in the Zalman stereo 3D mode.
# PyMOL X11 Hybrid Mode: Copy and rename the "MacPyMOL" appplication bundle to "PyMOLX11Zalman". After launching X11, you can then double-click on the PyMOLX11Zalman icon or drop data files directly onto it to visualize that content in the Zalman stereo 3D mode.

''For all platforms, remember to toggle stereo on and off using the "set stereo" command:''
set stereo, on

==== iZ3D ====
* [http://www.iz3d.com IZ3D] - works with PyMOL 1.2b3 & later without any special drivers. However, this display exhibits far too much cross-talk and interference between the two stereo images. Not suitable for professional use. - WLD

* IZ3D is closed as of 31 July 2012, and will not offer support to their products. [[User:Jedgold|Jedgold]] 12:26, 12 September 2012 (CDT)

=== Mirror-based Multi-LCD Solutions ===

Expensive!

* [http://www.planar3d.com Planar3D] "I have used these displays with nVidia Quadro graphics cards under both Windows and Linux running both PyMOL and Maestro. They work well, and the stereo quality is excellent!" - WLD.
* [http://www.inition.co.uk/inition/product.php?URL_=product_stereovis_omnia_mimo&SubCatID_=3 Omnia MIMO]

== Autostereoscopic LCD Displays ==

Some autostereoscopic displays have the ability to switch between 2D and 3D display modes. Others are built for 3D only.

* [http://www.dti3d.com Dimension Technologies Inc.]
* [http://www.seereal.com SeeReal Technologies]
* [http://www.newsight.com/3d-products/displays.html NewSight Corp.]

== Stereo 3D Projectors ==

Although these displays require shutter glasses out of the box, when combined with the adapters below and a special "silvered" screen, they can be used to project Passive Stereo 3D to a large audience.

=== Active Stereo 3D DLP Projectors ===

* [http://www.depthq.com DepthQ Stereoscopic] "The original DepthQ gave a very good stereo 3D effort with PyMOL, but I haven't seen their latest products." - WLD.
* [http://www.christiedigital.com/AMEN/Products/christieMirageS4K.htm Christie MIRAGE S+4K SXGA+ 6500 LUMEN DLP™ STEREOSCOPIC PROJECTOR] "I have been very impressed with the stereo 3D effect produced by MIRAGE projectors equipped with StereoGraphic ZScreens running PyMOL under Windows with a high-end nVidia Quadro card." - WLD.

=== Passive Stereo 3D Adaptor Hardware for Active Stereo 3D Projectors ===

These devices make it possible for a large audience to see projected stereo 3D using inexpensive polarized glasses.

* [http://reald-corporate.com/scientific/projectorzscreen.asp RealD StereoGraphics Projection ZScreen]

== Who Says What? ==

If you provide a specific quote or endorsement above, please say who you are so that everyone can know the source of the information.

* WLD = Warren L. DeLano of DeLano Scientific LLC
* SP = Sabuj Pattanayek of the Center For Structural Biology, Vanderbilt University

[[Category:Hardware_Options]]
[[Category:Stereo_3D_Display]]
[[Category:Stereo]]

Launching From a Script

2016-02-08T05:26:52Z

Bell: 5 revisions

<div style="background-color: #ccc; padding: 20px">
The recommended way to run PyMOL-Python scripts is by using PyMOL as the interpreter. This is supported by all versions of PyMOL, including the pre-compiled bundles provided by Schrödinger.

Example from a shell:

shell> pymol -cq script.py

Example from a running PyMOL instance:

PyMOL> run script.py

</div>

For advanced users, Open-Source PyMOL (as well as the Schrödinger-provided "[http://pymol.org/download Mac alternative X11-only build]") also allows to run PyMOL from an existing Python process. After importing the '''pymol''' module, PyMOL's event loop has to be started with a call to '''pymol.finish_launching()'''.

== Example 1 ==

Here is an example script that launches PyMol for stereo viewing on a [http://www.visbox.com/boxMain.html VisBox]. It runs PyMol fullscreen stereo, and disables the internal gui.
The environment (PYTHON_PATH and PYMOL_PATH) must already be set up for this example to work (see [[#Example 2|Example 2]] below for how to setup within the script).

<source lang="python">
#!/usr/bin/env python

# Tell PyMOL we don't want any GUI features.
import __main__
__main__.pymol_argv = [ 'pymol', '-qei' ]

# Importing the PyMOL module will create the window.
import pymol

# Call the function below before using any PyMOL modules.
pymol.finish_launching()

from pymol import cmd
cmd.stereo('walleye')
cmd.set('stereo_shift', 0.23)
cmd.set('stereo_angle', 1.0)
</source>

== Example 2 ==

This script launches PyMOL without any GUI for scripting only. It enables tab-completion on the python command line and does the PyMOL environment setup (you need to adjust the '''moddir''' variable!). ''Hint: You may save this as "pymol-cli" executable.''

<source lang="python">
#!/usr/bin/python2.6 -i

import sys, os

# autocompletion
import readline
import rlcompleter
readline.parse_and_bind('tab: complete')

# pymol environment
moddir='/opt/pymol-svn/modules'
sys.path.insert(0, moddir)
os.environ['PYMOL_PATH'] = os.path.join(moddir, 'pymol/pymol_path')

# pymol launching
import pymol
pymol.pymol_argv = ['pymol','-qc'] + sys.argv[1:]
pymol.finish_launching()
cmd = pymol.cmd
</source>

== STDOUT ==

PyMOL captures '''sys.stdout''' and '''sys.stderr''', to control it with it's own [[feedback]] mechanism. To prevent that, save and restore both streams, e.g.:

<source lang="python">
import sys
stdout = sys.stdout
stderr = sys.stderr
pymol.finish_launching(['pymol', '-xiq'])
sys.stdout = stdout
sys.stderr = stderr
</source>

== See Also ==

* [[Command Line Options]]

[[Category:Launching]]
[[Category:Script_Library]]

Dssr block

2016-02-08T05:26:51Z

Bell: 2 revisions

{{Infobox script-repo
|type = script
|filename = dssr_block.py
|author = [[User:Speleo3|Thomas Holder]]
|license = BSD-2-Clause
}}

This script adds the [[dssr_block]] command, which is a simple wrapper for the '''DSSR''' program and can create "block" shaped cartoons for nucleic acid bases and base pairs.

''Requires the '''x3dna-dssr''' executable, obtainable from http://x3dna.org''

See also the blog post by DSSR author Xiang-Jun Lu: http://x3dna.org/highlights/dssr-base-blocks-in-pymol-interactively

== Recommended Setup ==

Place the '''x3dna-dssr''' executable into '''$PATH'''. Examples:

* Linux/Mac: '''/usr/bin/x3dna-dssr'''
* Windows: '''C:\Program Files\PyMOL\PyMOL\x3dna-dssr.exe'''

The script can be [[run]], imported as a Python module, or installed with the [[Plugin Manager]].

== Usage ==

dssr_block [ selection [, state [, block_file [, block_depth
[, name [, exe ]]]]]]

== Arguments ==

* '''selection''' = str: atom selection {default: all}
* '''state''' = int: object state (0 for all states) {default: -1, current state}
* '''block_file''' = face|edge|wc|equal|minor|gray: Corresponds to the '''--block-file''' option (see [http://x3dna.org/ DSSR manual]). Values can be combined, e.g. "wc-minor". {default: face}
* '''block_depth''' = float: thickness of rectangular blocks {default: 0.5}
* '''name''' = str: name of new CGO object {default: dssr_block##}
* '''exe''' = str: path to "x3dna-dssr" executable {default: x3dna-dssr}

== Examples ==

Combining DSSR block representation with regular PyMOL cartoons:

<source lang="python">
fetch 1ehz, async=0
as cartoon
set cartoon_ladder_radius, 0.1
set cartoon_ladder_color, gray
set cartoon_nucleic_acid_mode, 1
dssr_block
</source>

Joined base-pair blocks (block_file=wc):

<source lang="python">
fetch 1ehz, async=0
dssr_block block_file=wc
</source>

Multi-state Example:

<source lang="python">
fetch 2n2d, async=0
dssr_block 2n2d, 0
set all_states
</source>

== See Also ==

* [[3DNA]] (old, obsoleted by x3dna-dssr)
* [[Overview of nucleic acid cartoons]]

[[Category:Structural_Biology_Scripts]]

3DNA

2016-02-08T05:26:51Z

Bell: 1 revision

'' '''Update:''' See also the [[dssr_block]] wrapper script for '''x3dna-dssr'''.''

3DNA[http://x3dna.org/] provides a ruby script (<b>blocview</b>) which produces Calladine-Drew style block representations based on the standard reference frame for nucleic acids. The produced files are in raster3D format, and are also processed by molscript. Therefore to produce the following representations you will need to install:

- 3DNA [http://x3dna.org/]

- Raster 3D [http://skuld.bmsc.washington.edu/raster3d/raster3d.html]

- Molscript [http://www.avatar.se/molscript/download.html]

Once you have the previous software installed, and the path to their binaries correctly configured, you can get the block representation for any nucleic acid. The next example shows how to do it for tRNA (PDB:ID 1ehz)

== Invoking ==
<source lang="bash">
pdb_get.py 1ehz
blocview -o 1ehz.pdb
</source>

The pdb_get python script comes from [http://pldserver1.biochem.queensu.ca/~rlc/work/scripts/pdb_get.py]Dr. Robert Campbell's website.

Once blocview is run it will generate various r3d files which can be combined with the original pdb files to produce the following image:

== Example 1 ==
<gallery>
Image:trna.png|Using tb.pdb and t2.r3d
</gallery>

To generate the previous image the following script was used:
trna.pml
== Syntax ==
<source lang="python">
load tb.pdb
load t2.r3d
bg_color white
hide lines
zoom *,-5
set ray_trace_mode, 3
set ray_trace_fog, 0
set ray_shadows, 0
set orthoscopic, 1
set antialias, 5
set valence, 1
util.cba(29)
color grey, (elem C)
cartoon arrow
set cartoon_ladder_mode, 0
set cartoon_rect_width, 0.2
set cartoon_rect_length, 0.5
show cartoon
set stick_radius, 0.14
show sticks
set_view (\
0.680474579, -0.153203458, -0.716576934,\
0.658882320, -0.300013036, 0.689829707,\
-0.320666909, -0.941552401, -0.103208199,\
-0.000084338, 0.000022471, -263.030426025,\
57.723434448, 45.338260651, 20.895099640,\
218.710235596, 307.348541260, 1.000000000 )
set cartoon_color, green, resn G
set cartoon_color, yellow, resn C
set cartoon_color, red, resn A
set cartoon_color, cyan, resn U
ray 1024,768
png trna.png
quit
</source>

== Example 2 ==

An automatically generated pymol ray traced image can also be obtained by running <b>blocview</b> from 3DNA v. 2.0 directly. Using the following command:

<pre>
blocview -o -t=100 1ehz.pdb
</pre>

And the result is:

<gallery>
Image:X3dna_r3d_pymol.png
</gallery>

== More ==

For more examples of figures obtained using 3DNA and pymol follow the next link:
[[http://mesguerra.org/render/render.htm]]

[[Category:Nucleic_Acids]]

Overview of nucleic acid cartoons

2016-02-08T05:26:50Z

Bell: 4 revisions

== Overview ==

Pymol has a complex group of settings for controlling the way nucleic acids are represented, broadly separated into:
* ring, for ribose and base ring(s)
* ladder, for the sticks connecting the backbone, ribose and base ring(s)
* nucleic acid, for the smooth backbone path

Each setting can be altered with the set command. The cartoon settings affect each other so experimentation may be necessary to achieve what you want. Many of the mode settings only seem to work at the global level and cannot be applied to individual objects or selections.

== Ring settings ==

=== Ring mode ===

Ring mode defines the representation of the ribose and base.
<pre>set cartoon_ring_mode, value</pre>
{|
!value !!align="left"| effect
|-
|align="center" | 0 || stick from backbone atom to N1 of purines and N3 of pyrimidines
|-
|align="center" | 1 || simple plane for ribose and base rings covering area between ring bonds
|-
|align="center" | 2 || simple plane for ribose and base rings covering area inside sticks (slightly smaller than mode 1)
|-
|align="center" | 3 || plane bounded by sticks for ribose and base rings
|-
|align="center" | 4 || large sphere of ring diameter at centre of ribose and each base ring
|-
|align="center" | 5 || small sphere of 1/10 diameter at centre of ribose and each base ring
|-
|align="center" | 6+ || appears to default to ring mode 2
|}
=== Ring finder ===

Ring finder defines the rings which are recognised
<pre>set cartoon_ring_finder, value</pre>
{|
!value !! align="left" | effect
|-
|align="center" | 0 || no rings or sticks joining them
|-
|align="center" | 1 || both ribose and base ring
|-
|align="center" | 2 || only base ring(s), stick connects directly from phosphate to ring
|-
|align="center" | 3 || very similar to ring finder 1, slight effect on transparency = distinct behaviour?
|-
|align="center" | 4 || very similar to ring finder 1, slight effect on transparency = distinct behaviour?
|-
|align="center" | 5 || sticks visible but rings invisible
|-
|align="center" | 6+ || appears to default to ring finder 5
|}

=== Other settings for ring ===
<pre>set cartoon_ring_xxx, value</pre>
{|
! align="center" | xxx !! value !! align="left" | effect
|-
|align="center" | color || align="center" |color || set the colour of the ring or sphere
|-
|align="center" | width || align="center" | float || thickness of ring for planes and sticks (modes 1, 2, 3)
|-
|align="center" | radius || align="center" |float || radius of ring for spheres (modes 4, 5), negative number gives sphere of same radius as ring in mode 4, approx 1/10 ring diameter in mode 5
|-
|align="center" | transparency || align="center" |float || transparency of ring or sphere, does not affect sticks in ring mode 3
|}

== Ladder settings ==

=== Ladder mode ===

Ladder mode affects the sticks connecting the backbone to ribose and ribose to base, and ring mode 0 or ring finder 5.
<pre>set cartoon_ladder_mode, value</pre>
{|
!value !! align="left" | effect
|-
|align="center" | 0 || no sticks shown
|-
|align="center" | 1 || sticks show
|-
|align="center" | 2+ || appears to default to ladder mode 1
|}
=== Other settings for ladder ===
<pre>set cartoon_ladder_xxx, value</pre>
{|
! align="center" | xxx !! value !! align="left" | effect
|-
|align="center" | color || color || colour of the stick
|-
|align="center" | radius || float || stick width for ring modes 1, 4 and 5 (default is 0.25), in other ring modes the ladder stick width is controlled by the ring width instead
|}

== Nucleic acid settings ==

=== Nucleic acid mode ===
<pre>set cartoon_nucleic_acid_mode, value</pre>
{|
!value !! align="left" | effect
|-
|align="center" |0 || smooth backbone passing through phosphorus atoms, backbone terminates at last phosphorus on either end of chain
|-
|align="center" | 1 || smooth backbone passing through ribose C3' atoms, backbone terminates at last C3' on either end of chain
|-
|align="center" | 2 || smooth backbone passing through phosphorus atoms, backbone terminates at last phosphorus on 5' end and O3' on 3' end (note takes O3' colour at terminus in default colouring)
|-
|align="center" | 3 || appears same as mode 0
|-
|align="center" | 4 || appears same as mode 2? Seems to be what Pymol uses when it first opens nucleic acid containing file because any other settings change ends and colors. 
|-
|align="center" | 5+ || appears to defult to nucleic acid mode 0
|}
==== Note ====
Note that in ring mode 0 or ring finder 2 the stick projects from the backbone at a point midway between phosphates
<pre>set ribbon_nucleic_acid_mode, value</pre>
{|
! align="center" |xxx !! value !! align="left" | effect
|-
|align="center" | ribbon_nucleic_acid_mode || align="center" | integer || has the equivalent behaviour to cartoon_nucleic_acid_mode
|}

=== Other settings for nucleic acid ===
<pre>set cartoon_nucleic_acid_xxx, value</pre>
{|
! xxx !! value !! align="left" | effect
|-
|align="center" | color || color || backbone colour (default is backbone atom colour)
|}

== Third-party Wrappers ==

* [[dssr_block]] can create "block" shaped base pair cartoons with DSSR

Protect

2016-02-08T05:26:50Z

Bell: 1 revision

'''protect''' protects a set of atoms from tranformations performed using the editing features. This is most useful when you are modifying an internal portion of a chain or cycle and do not wish to affect the rest of the molecule.

==USAGE==
protect (selection)

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

== Example ==
This example makes a very cool little, and fake, molecular movie. Copy/paste this into PyMOL:
<source lang="python">
load $PYMOL_PATH/test/dat/pept.pdb, obj

# create the fake trajectory (of states)
for a in range(2,31): cmd.create("obj","obj",1,a)
# remove the bond
unbond 5/C, 6/N
# This protects everything but all atoms witing 4
# Ang. of residue 5's carbon and residue 6's nitrogen.
protect not ((5/C or 6/N) extend 4)

# do some quick sculpting
sculpt_activate obj, 30
sculpt_iterate obj, 30, 100
smooth obj, 30, 3

# then program a bond-break/re-form movie
mset 1 x30 1 -30 30 x30 30 -1
mdo 45: unbond 5/C, 6/N, quiet=1
mdo 100: bond 5/C, 6/N, quiet=1

frame 100

as sticks
orient 5-6/N+CA+C
mplay
</source>

==SEE ALSO==
[[Deprotect]], [[Mask]], [[Unmask]]

[[Category:Commands|Protect]]
[[Category:Editing Module|Protect]]

Main Page

2016-02-08T05:26:50Z

Bell: 1 revision

__NOTOC__
{| align="center" style="padding-bottom: 4em;"
|+ style="font-size:210%; font-weight: bold; color:#032d45; text-align:center; padding: 5px; margin-bottom: 4px;" | Welcome to the PyMOL Wiki!
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
| The community-run support site for the [http://pymol.org PyMOL] molecular viewer.
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
| New accounts: email jason (dot) vertrees (@) gmail dot com
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
|}
{| align="center" width="45%" style="background: #EDEBD5; margin-bottom: 4em; border-bottom: 1px solid #AFB29E; border-left: 1px solid #AFB29E; border-right: 1px solid #AFB29E;"
|+ style="font-size: 1.4em; font-weight: bold; color: #032d45; text-align:center; background: #5F7F96; padding-top:0.5em; padding-bottom: 0.25em; border-top: 2px solid #AFB29E; border-bottom: 1px solid #fff;" |Quick Links
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[:Category:Tutorials|Tutorials]]''' || '''[[TOPTOC|Table of Contents]]''' || '''[[:Category:Commands|Commands]]'''
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[:Category:Script_Library|Script Library]]''' || '''[[:Category:Plugins|Plugins]]''' || '''[[:Category:FAQ|FAQ]]'''
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[Gallery]]''' | '''[[Covers]]'''
||'''[[CheatSheet|PyMOL Cheat Sheet]]''' (''[[Media:PymolRef.pdf|PDF]]'')
||'''[[PyMOL_mailing_list|Getting Help]]'''
|}

{| width="100%"
| style="vertical-align: top; width: 40%" |
{| class="jtable" style="float: left; width: 90%;"
|+ style="font-size: 1.4em; font-weight: bold; text-align:left; border-bottom: 2px solid #6678b1;" | News & Updates
|-
! New Script
| [[dssr_block]] is a wrapper for DSSR (3dna) and creates block-shaped nucleic acid cartoons
|-
! New Plugin
| [[Lisica|LiSiCA]] is a new plugin for 2D and 3D ligand based virtual screening using a fast maximum clique algorithm.
|-
! Official Release
| [http://pymol.org PyMOL v1.8.0 has been released] on Nov 18, 2015.
|-
! PyMOL Open-Source Fellowship
| Schrödinger is now accepting applications for the PyMOL Open-Source Fellowship program! Details on http://pymol.org/fellowship
|-
! Official Release
| [http://pymol.org PyMOL, AxPyMOL, and JyMOL v1.7.6 have all been released] on May 4, 2015.
|-
! New Plugin
| [[PyANM|PyANM]] is a new plugin for easier Anisotropic Network Model (ANM) building and visualising in PyMOL.
|-
! New Plugin
| [[Bondpack]] is a collection of PyMOL plugins for easy visualization of atomic bonds.
|-
! New Plugin
| [[MOLE 2.0: advanced approach for analysis of biomacromolecular channels|MOLE 2.0]] is a new plugin for rapid analysis of biomacromolecular channels in PyMOL.
|-
! 3D using Geforce
| PyMOL can now be [http://forums.geforce.com/default/topic/571604/3d-vision/3d-vision-working-with-qbs-in-opengl-software-using-geforce/2/ visualized in 3D using Nvidia GeForce video cards] (series 400+) with 120Hz monitors and Nvidia 3D Vision, this was previously only possible with Quadro video cards.
|-
! Older News
| See [[Older_News|Older News]].
|}
|style="vertical-align: top; width: 40%"|
{| class="jtable" style="float: right; width: 90%"
|+ style="font-size: 1.4em; font-weight: bold; text-align:left; border-bottom: 2px solid #6678b1;" |Did you know...
|-
|<div class="didyouknow" >
<DynamicPageList>
randomcount=1
category=Commands|Plugins|Script_Library|Settings
includepage=*
includemaxlength=1050
escapelinks=false
allowcachedresults=false
resultsheader=__NOTOC__ __NOEDITSECTION__
listseparators=,<h3>[[%PAGE%]]</h3>,,\n
</DynamicPageList>
</div>
<div style="clear: both;"></div>
|}
|
|style="vertical-align: top; width: 18%"|
<DynamicPageList>
imagecontainer=Covers
randomcount=1
escapelinks=false
openreferences=true
listseparators=[[,%PAGE%,|thumb|185px|A Random PyMOL-generated Cover. See [[Covers]].]],\n
ordermethod=none
allowcachedresults=false
</DynamicPageList>

|}

Load img stack

2016-02-08T05:26:45Z

Bell: 1 revision

{{Infobox script-repo
|type = script
|filename = load_img_stack.py
|author = [[User:Speleo3|Thomas Holder]]
|license = BSD-2-Clause
}}

This script adds the [[load_img_stack]] command, which loads a set of images as a map object. The images can either be individual files, or contained in a multi-page TIFF file.

== Usage ==

load_img_stack pattern [, name [, grid [, channel [, normalize [, extent ]]]]]

== Arguments ==

* '''pattern''' = str: image filename or pattern
* '''name''' = str: map object name to create
* '''grid''' = float: grid spacing in Angstrom {default: 1.0}
* '''channel''' = int: color channel for RGB images {default: 0}
* '''normalize''' = 0 or 1: normalize data {default: 1}
* '''extent''' = 3-float: (a,b,c) edge lengths in Angstrom, overwrites "grid" arguments if given {default: }

== Example ==

load_img_stack img*.png, name=map, extent=(10.0, 10.0, 5.0)
volume vol, map, rainbow

== See Also ==

* [[tiff2ccp4]]
* [[volume]]

[[Category:Script_Library]]

Windows Install

2016-02-08T05:26:45Z

Bell: 1 revision

This page describes how to install PyMOL on Microsoft Windows.

== Incentive PyMOL ==

[http://www.schrodinger.com Schrödinger] provides an MSI installer to paying sponsors. The bundle also includes ready-to-use [[APBS]], [[morph|RigiMOL]], an MPEG encoder for movie export, and a small molecule energy minimization engine.

Download: http://pymol.org/download

== Open-Source PyMOL ==

Open-Source PyMOL is available [https://sourceforge.net/p/pymol/code/HEAD/tree/trunk/pymol/LICENSE free of charge]. It also allows sponsors to create highly customized PyMOL installations which might not be possible with the MSI installer.

Pre-compiled Open-Source PyMOL is available free from [http://www.lfd.uci.edu/~gohlke/pythonlibs/#pymol Christoph Gohlke of the Laboratory for Fluorescence Dynamics, University of California, Irvine].

# Install Python 2.7 for Windows (e.g., by going to http://www.python.org/downloads/). Use the standard options (which should mean that the installation directory is C:\Python27). It may be useful if C:\Python27 is listed in your system PATH variable.
# Download the [http://www.lfd.uci.edu/~gohlke/pythonlibs/#pymol appropriate wheel files], along with all requirement wheel files (including [http://www.lfd.uci.edu/~gohlke/pythonlibs/#pip pip], [http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy Numpy] and [http://www.lfd.uci.edu/~gohlke/pythonlibs/#pmw PMW]) into a single file directory, e.g., <code>C:\PyMOL_installation</code>
# From this installation directory (to get there you can run <source lang = python>cd C:\PyMOL_installation</source> from the command prompt), run:
<source lang = python>C:\Python27\python.exe pip-6.x.x-py2.py3-none-any.whl/pip install --no-index --find-links="%CD%" pymol_launcher</source>

if <code>C:\Python27</code> is part of your PATH variable, then running (where x refers to the version number of pip):
<source lang = python>python pip-6.x.x-py2.py3-none-any.whl/pip install --no-index --find-links="%CD%" pymol_launcher</source>
should suffice. To update PyMOL update the files in the PyMOL install directory and run:

<source lang = python>pip install --upgrade --no-deps pymol.whl</source>

where <code>pymol.whl</code> is replaced by the PyMOL wheel file name (not the launcher, the launcher should not require updating).

=== Extend PyMOL with additional scripts ===
If you now want to extend the capabilities of PyMOL, and take advantage of all the available plugins+scripts "out there", then do the following. <br>
# First install "numpy" as an available module to Python. [http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy Select appropriate installer from here]
# Download the script/plugin collection [[Git | Pymol-script-repo]] from [https://github.com/Pymol-Scripts/Pymol-script-repo/zipball/master a .zip file from here]
git clone https://github.com/Pymol-Scripts/Pymol-script-repo
# Unpack it to here: '''C:\Python27\Lib\site-packages\pymol\pymol_path\Pymol-script-repo''' Double check that the folder name is correct and the same.
Open "Notepad" and write.
<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 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>
'''Then "File->Save as->All files-> C:\Python27\Lib\site-packages\pymol\pymol_path\run_on_startup.py'''

Now start pymol, and enjoy all the plugins available from the menu.

'''PyMOL''' shortcut<br>
Make a '''pymol''' directory in your homepath. '''mkdir %HOMEPATH%\pymol''' Then make sure, PyMOL starts here, when you open the shortcut.<br>
Make a shortcut to the .cmd file, and modify it. <br>
Target: C:\python27\PyMOL\pymol.cmd <br>
Start in: %HOMEPATH%\pymol

== See Also ==

* [[pymolrc]]
* [[Linux Install]]
* [[MAC Install]]

[[Category:Installation|Windows]]
[[Category:Technical Issues|Windows Install]]
[[Category:Windows]]

MAC Install

2016-02-08T05:26:44Z

Bell: 1 revision

This page describes how to install PyMOL on Mac OS X.

== Incentive PyMOL ==

=== MacPyMOL ===

MacPyMOL is available exclusively to paying sponsors. [http://www.schrodinger.com Schrödinger] provides a DMG package which also includes ready-to-use [[APBS]], [[morph|RigiMOL]], an MPEG encoder for movie export, and a small molecule energy minimization engine.

Download: http://pymol.org/download

Installation: Drag '''MacPyMOL.app''' on the '''/Applications''' shortcut. (In principle, you could drag it into any Finder window and run it from there, it doesn’t have to live in /Applications).

Uninstallation: Move '''/Applications/MacPyMOL.app''' to Trash

=== Launching from Command Line ===

The unix executable resides at '''/Applications/MacPyMOL.app/Contents/MacOS/MacPyMOL'''

=== X11 Hybrid ===

MacPyMOL can optionally run with the same two-window GUI which PyMOL uses on Windows and Linux. This GUI has some additional features, like the [[Plugins|Plugin]] menu and the [[Builder]].

Requires [http://xquartz.macosforge.org/ XQuartz].

There are two ways to launch the X11 interface:
# rename '''/Applications/MacPyMOL.app''' to '''/Applications/MacPyMOLX11Hybrid.app'''
# launch the unix executable with the '''-m''' flag: '''/Applications/MacPyMOL.app/Contents/MacOS/MacPyMOL -m'''

=== Stereo on Second Monitor ===
The trick to getting MacPyMOL to work in stereo on the second monitor is to force it to initially open on that display by providing an appropriate "-X #" (and perhaps -Y #) option on launch. That way the OpenGL context will be created with stereo support.
<source lang="python">
./MacPyMOL.app/Contents/MacOS/MacPyMOL -X -1000
./MacPyMOL.app/Contents/MacOS/MacPyMOL -X -1000 -Y 100
</source>

'''Source:''' ''Warren DeLano; PyMOL Users Archive''

== Open-Source PyMOL ==

=== Pre-compiled ===

Pre-compiled Open-Source PyMOL is available [https://sourceforge.net/p/pymol/code/HEAD/tree/trunk/pymol/LICENSE free of charge] with the [https://www.macports.org/ MacPorts], [http://www.finkproject.org/ Fink] and [http://brew.sh/ Homebrew] environments.

<source lang="bash">
# Fink
fink install pymol-py27

# MacPorts
sudo port install pymol

# Homebrew
brew install homebrew/science/pymol
</source>

Make sure that the dependencies are installed with the required flags:

<source lang="bash">
# MacPorts
sudo port install tcl -corefoundation
sudo port install tk -quartz

# Homebrew
brew install tcl-tk --with-threads --with-x11
brew install python --with-tcl-tk
</source>

=== Install from Source ===

If you want the latest PyMOL code (warning: might include experimental changes), then follow the [[Linux_Install#Install_from_source|Linux installation instructions]]. You will need an environment like Fink, MacPorts or Homebrew to install the dependencies. Make sure you use the appropriate python interpreter (e.g. '''/sw/bin/python2.7''' when using Fink).

=== Install APBS with Fink ===

To use the electrostatics plugin, you will need [http://apbs.sourceforge.net/ APBS] and its dependencies. These are also available as Fink packages, and include [http://pdb.finkproject.org/pdb/package.php/apbs APBS], [http://pdb.finkproject.org/pdb/package.php/maloc maloc] and [http://pdb.finkproject.org/pdb/package.php/pdb2pqr pdb2pqr]. If you have multiple processors available, you might wish to install the [http://pdb.finkproject.org/pdb/package.php/apbs-mpi-openmpi MPI version of APBS].

Issuing the command

fink install apbs

will install apbs and its required dependencies for you. The fink pymol package is already preconfigured to do the right thing to use apbs as a plugin.

=== Stereo issues ===
Some older Macs seem to crash with stereo graphics. If this happens to you, a workaround is to launch PyMOL explicitly in Mono mode with `pymol -M`. You can also set up an alias in your ~/.profile:

alias pymol='pymol -M'

== See Also ==

* [[pymolrc]]
* [[Linux Install]]
* [[Windows Install]]
* [[MovieSchool_6#Exporting_your_Movie|FreeMOL installation for MPEG movie export]]
* [[User:Wgscott|Bill Scott’s]] [[MacOSX-specific .pymolrc file]] and his crystallographic software [http://xanana.ucsc.edu/~wgscott/xtal/wiki/index.php/Main_Page wiki] and [http://chemistry.ucsc.edu/~wgscott/xtal/ website], including instructions on [http://xanana.ucsc.edu/~wgscott/xtal/wiki/index.php/Getting_your_fink_installation_to_use_packages_that_I_have_pre-compiled how to install precompiled binary packages using fink].
* [[Launching_PyMOL#MacOS_X]]

[[Category:Installation|Mac]]
[[Category:Nucleic_Acids|MAC Install]]
[[Category:Technical Issues|MAC Install]]
[[Category:Mac|MAC Install]]

Linux Install

2016-02-08T05:26:43Z

Bell: 2 revisions

This page describes how to install PyMOL on Linux.

== Incentive PyMOL ==

[http://www.schrodinger.com Schrödinger] provides pre-compiled (64 bit) PyMOL to paying sponsors. The bundle also includes ready-to-use [[APBS]], [[morph|RigiMOL]], an MPEG encoder for movie export, and a small molecule energy minimization engine.

Download: http://pymol.org/download

== Open-Source PyMOL in Linux Distros ==

Many Linux distributions provide binary packages for open-source PyMOL. They often do not provide the latest version, but if the provided package fits your needs this is the most convenient way to install PyMOL.

Command line install examples for some popular distributions (note that all of these commands must be run as root or superuser):

<source lang="bash">
# Arch/Manjaro
pacman -S pymol

# CentOS with EPEL
rpm -i http://download.fedoraproject.org/pub/epel/6/i386/epel-release-6-5.noarch.rpm
yum --enablerepo=epel install pymol

# Debian/Ubuntu/Mint
apt-get install pymol

# Fedora
dnf install pymol

# Gentoo
emerge -av pymol

# openSUSE (12.1 and later)
zypper install pymol

# Sabayon
equo i -av pymol
</source>

== Install from source ==

Installation from source gives you the latest version and is the generic way to install PyMOL.

=== Requirements ===

Libraries as well as development files (headers) of the following software is
required:

* [http://subversion.apache.org/ Subversion] to download the source code
* [http://www.python.org/ Python] (with distutils)
* [http://pmw.sf.net Pmw] (Python Megawidgets)
* OpenGL driver (I use [http://www.nvidia.com/object/unix.html NVidia])
* libpng
* freetype
* libxml2

On many Linux systems, one of the following commands installs all requirements (and must be run as root):

<source lang="bash">
# Debian/Ubuntu/Mint
apt-get install subversion build-essential python-dev python-pmw libglew-dev \
freeglut3-dev libpng-dev libfreetype6-dev libxml2-dev

# CentOS
yum install subversion gcc gcc-c++ kernel-devel python-devel tkinter python-pmw glew-devel \
freeglut-devel libpng-devel freetype-devel libxml2-devel

# Fedora
dnf install subversion gcc gcc-c++ kernel-devel python-devel tkinter python-pmw glew-devel \
freeglut-devel libpng-devel freetype-devel libxml2-devel

# Gentoo
emerge -av dev-vcs/subversion dev-lang/python dev-python/pmw media-libs/glew \
media-libs/freeglut media-libs/libpng media-libs/freetype

# openSUSE
zypper install python-devel freeglut-devel gcc-c++ glew-devel libpng-devel python-pmw subversion

# Sabayon
equo i -av dev-vcs/subversion dev-lang/python dev-python/pmw media-libs/glew \
media-libs/freeglut media-libs/libpng media-libs/freetype
</source>

=== Get latest source from SVN ===

This will download the latest source to '''/tmp/pymol''':

<source lang="bash">
cd /tmp
svn co svn://svn.code.sf.net/p/pymol/code/trunk/pymol
cd pymol
</source>

=== Compile and install ===

This will install PyMOL as normal user into '''/opt/pymol-svn'''. If you don't have write permissions to '''/opt''', change the <code>prefix</code> variable to something like '''$HOME/pymol-svn'''.

<source lang="bash">
#!/bin/bash -e

prefix=/opt/pymol-svn
modules=$prefix/modules

# enable c++11
export CPPFLAGS="-std=c++0x"

# If you want to install as root, then split this line up in "build"
# and "install" and run the "install" with "sudo"
python setup.py build install \
--home=$prefix \
--install-lib=$modules \
--install-scripts=$prefix
</source>

Now launch PyMOL like this:

<source lang="bash">
/opt/pymol-svn/pymol
</source>

Optionally, in order to allow running the command <code>pymol</code> from the terminal to launch the program do:
<source lang = "bash">
sudo ln -s /opt/pymol-svn/pymol /usr/bin/pymol
</source>

====Updating====
To update the installation merely run:
<source lang = "bash">
sudo rm -r /opt/pymol-svn/pymol
rm -r /tmp/pymol
</source>
and redo the installation from the beginning with the latest release.

=== Troubleshooting ===

* On Linux Mint 11 there have been reports of gcc-4.5 breaking Pymol. You could use gcc-4.4 instead. (reported by [[User:Tlinnet]])
<div style="margin-left: 2em;">
<source lang="bash">
sudo apt-get install build-essential gcc-4.4 g++-4.4
export CC=/usr/bin/gcc-4.4
</source>
</div>

* If you get an error message "ImportError: No module named Pmw" and lack half of the user interface, then append <code>--bundled-pmw</code> to the install command line.

* If you're using Ubuntu 11.10 with an Intel Sandy Bridge video card and get graphics oddities. Please see [https://launchpad.net/~glasen/+archive/intel-driver Intel Driver Post for Ubuntu].

* If you are using Ubuntu with a NVIDIA graphic card and generic drivers you may experience bad rendering, black pixelation and other graphical oddities. A guide to installing NVIDIA proprietary drivers can be found under [https://help.ubuntu.com/community/BinaryDriverHowto/Nvidia Ubuntu community Nvidia Drivers How To]

== Customized Installations ==

* [[User:Tlinnet/Linux_Install|Troels Linnet's installations scripts]]: Detailed installation scripts for Ubuntu, Mint 12 and RHEL 6, including MPEG support from FREEMOL

[[Category:Installation|Linux Installation]]

PluginArchitecture

2016-02-08T05:26:40Z

Bell: 1 revision

This page concerns the development for new PyMOL Plugin Architecture. We are requesting ideas, code, etc on how to best implement a successful plug in system.

= Overview =
PyMOL enjoys widespread use as 3D molecular visualization program with strengths in rendering and visualization. PyMOL at current does not have a robust extension mechanism for adding new plug-in based features to PyMOL. It only allows a script of one file and has very limited support for installation and removal. This project aims to correct that lacking functionality. We aim for simplicity and robustness especially in a cross-platform manner.

A '''Plug-In''' (or '''Plugin''') is a modular piece of software that extends PyMOL's functionality.

== Wanna' Help? ==
If you want to take part in helping out with this, please send Jason Vertrees an email letting him know as such.

= PyMOL OS Fellowship Project 2011/2012 =

[[User:Speleo3|Thomas Holder]] was working on the new plugin system as part of his [http://pymol.org/fellowship 2011-2012 Fellowship]. The improvements were incorporated into PyMOL 1.5.0.5.

* graphical [[Plugin Manager]]
* multiple files per plugin/module (see below: [[#More than one file per plugin]])
* user plugin directory
* rarely used plugins can be disabled for better performance and enabled on demand
* metadata support (version, author, description, citation, tags, ...)
* install from online repositories
* settings API for plugins (see below: [[#Config files]])

= Review of Current Plugin System =

Essentially the current system inits all the scripts in the startup directory, which adds their entry to the Plugins menu. When called, it fires off a command passing to it PyMOL's Tk menu. The instance can get access to pymol's cmd layer with, <source lang="python">from pymol import cmd</source>. Also, as it's in Python, the user can extend Python (even in C) or call low-level functions utilizing the web or touching the file system.

* For a tutorial on the current system. see [[Plugins_Tutorial]].

= Ideas/Features for the New Plugin System =
* Plugins must be ''safe''. That is, they must not destroy the users' data for file system.
* Plugins must be ''secure'' in that they do not transmit data the user doesn't want transmitted.
** We can take an approach like Warren did with sessions--warn the user on sessions s/he didn't create and ask for trusting or not.
* Plugins should be able to query PyMOL for features
* PyMOL should take care of unpacking, installing, uninstalling, updating (?) the plugins
* '''MUST''' be backwards compatible with the current system
* '''MUST''' run cross platform
* Save user-specific information
* Support proxy information/setup for downloading scripts

== More than one file per plugin ==

I'd like plugins that behave like proper Python modules with the ability to span multiple files/directories. One simple way to do this would be to distribute plugins as zip files. E.g. if we have a directory Foo that contains

<source lang="Python">
MyMod
__init__.py
"""Some documentation here"""
Foo.py
def doit():
print "It is done!"
</source>

We can zip it up like

<source lang="bash">
zip MyMod.zip Foo/*
</source>

If you stick MyMod.zip in a plugins directory like /blahblah/Pymol/plugins/MyMod.zip
you can then say this:

<source lang="Python">
sys.path.append('/blahblah/Pymol/plugins/MyMod.zip')
from MyMod import Foo
Foo.doit()
</source>

Python does not impose the restriction that the module/directory name (MyMod) should be the same as the zip file name (MyMod.zip), but we might want to.

Then we need to formally spell out the API by which the Plugin is launched.

This makes it very easy to install/uninstall plugins, and PyMOL can just have a simple loop that iterates over the plugins directory, adds the appropriate things to sys.path, verifies that the resulting objects support the API, and adds them to the menu.

== Config files ==

Some sort of persistent config files where users can store things like paths to relevant files, settings, etc. would be very useful. The APBS plugin, for instance, is a bit of a bother to use when you have APBS installed in a non-standard location. It would be very convenient if you could set the location once and have it persist.

== Meeting Notes ==
=== May 3, 2010 ===
In attendance: Nathan Baker, Mike Beachy, Greg Landrum, David Gohara, Yong Huang, Jay Ponder, Jason Vertrees

Additional ideas people wanted to see implemented:
* As scripts will be accessing internal data for computation, improved access to PyMOL internal data structures, like DX maps, is required.
** I/O for maps is the rate limiting step;
** data structures can be large, so skipping the disk would also be nice
* Skeleton code for plugins would help people write new ones; good tutorial as well; we need to make things easier for the novice
** Make a new site for plugins: plugins dot pymol dot org?

= Liked Plugin Systems =
* [https://addons.mozilla.org/en-US/developers FireFox Devel/Docs]
* Google Chrome -- URL?

= Disliked Plugin Systems =

= Links on the topic =
* [http://stackoverflow.com/questions/323202/designing-extensible-software-plugin-architecture StackOverflow Discussion]
* [http://en.wikipedia.org/wiki/Open/closed_principle Dr. Meyers' Open/Closed Principle]
* [http://www.codeguru.com/cpp/misc/misc/plug-insadd-ins/article.php/c3879 Nice overview in C]

= The Name =
* Plugins, Plug-Ins?
* Add-ons?
* Extensions?

[[Category:Development]]
[[Category:Developers]]

Morph

2016-02-08T05:26:40Z

Bell: 1 revision

The [[morph]] command is an incentive PyMOL feature (not available in open-source version). Given two or more conformations, either as two objects or one multi-state object, '''morph''' can create an interpolated trajectory from the first to the second conformation.

''This command is new in PyMOL 1.6, for older versions see [[rigimol.morph]], which requires some scripting.''

== Usage ==

morph name, sele1 [, sele2 [, state1 [, state2 [, refinement [, steps [, method [, match ]]]]]]]

== Arguments ==

* name = string: name of object to create
* sele1 = string: atom selection of first conformation
* sele2 = string: atom selection of second conformation {default: <sele1>}
* state1 = int: sele1 state {default: 1}. If state1=0 and sele1 has N states, create N morphings between all consecutive states and back from state N to 1 (so the morph will have N*steps states). If state2=0, create N-1 morphings and stop at last state.
* state2 = int: sele2 state {default: 2 if sele1=sele2, else 1}
* refinement = int: number of sculpting refinement cycles to clean distorted intermediates {default: 3}
* steps = int: number of states for sele2 object {default: 30}
* method = string: rigimol or linear {default: rigimol}
* match = string: method how to match '''sele1''' and '''sele2''' {default: align}
** in: match atoms by [[Selection Algebra|"in"]] selection operator
** like: match atoms by [[Selection Algebra|"like"]] selection operator
** align: match atoms with [[align]] function (with cycles=0)
** super: match atoms with [[super]] function (with cycles=0)
** ''name of alignment object'': use given alignment

== Example ==

=== Default Parameters ===

<syntaxhighlight lang="python">
fetch 1akeA 4akeA, async=0
align 1akeA, 4akeA
morph mout, 1akeA, 4akeA
</syntaxhighlight>

=== Morphing with Ligand ===

Since the default '''match=align''' method ignores ligands in most situations, we'll use the "in" match method. In this case, both input structures need matching identifiers. The default post-RigiMOL sculpting refinement tends to let all molecules that are not connected to the protein backbone bounce around; that's why '''refinement=0''' might give better results in this case.

<syntaxhighlight lang="python">
# get two hemoglobin beta chains, the "ligand" will be the heme hetero group
fetch 1hbb, async=0
create conf1, chain B
create conf2, chain D
delete 1hbb

# important: identifiers must be the same
alter conf2, chain="B"
alter all, segi=""

# optional: styling
as cartoon
show sticks, not polymer
show nb_spheres

# superpose and morph
align conf1, conf2
morph mout, conf1, conf2, match=in, refinement=0
</syntaxhighlight>

== GUI ==

The morph feature is available from the object menu panel: '''A > generate > morph'''

== See Also ==

* [[rigimol.morph]]

[[Category:Commands]]
[[Category:Modeling_and_Editing_Structures]]

Ignore case

2016-02-08T05:26:40Z

Bell: 2 revisions

The [[ignore_case]] setting (default: '''off''' in PyMOL 1.8, '''on''' in previous versions) controls whether PyMOL does case sensitive matching of atomic identifiers and selection operators in the selection language. Most notably, it affects whether chain identifiers are matched case sensitive, which becomes relevant when using upper and lower case chain identifiers in a structure with more than 26 chains.

''The default value was changed to '''off''' in PyMOL 1.8. With more and more "big" structures in the PDB, the old default was not practical anymore and led to confusion and unexpected results.''

== Example ==

Load 1a00 which has chains A, B, C, D

PyMOL>fetch 1a00, async=0

1) case insensitive selection language (default for PyMOL <= 1.7.6)

PyMOL>set ignore_case
Setting: ignore_case set to on.
PyMOL>count_atoms chain A
count_atoms: 1164 atoms
PyMOL>count_atoms chain a
count_atoms: 1164 atoms

2) case sensitive selection language (default for PyMOL > 1.7.6)

PyMOL>set ignore_case, off
Setting: ignore_case set to off.
PyMOL>count_atoms chain A
count_atoms: 1164 atoms
PyMOL>count_atoms chain a
count_atoms: 0 atoms

== Best Practice for Scripting ==

When writing scripts or plugins, all selection expressions should be strict about case (e.g. "name CA" and not "name ca") to not depend on the users setting of [[ignore_case]].

[[Category:Settings]]
[[Category:Selecting]]

BiologicalUnit/Quat

2016-02-08T05:26:39Z

Bell: 2 revisions

This script does more or less the same as [[BiologicalUnit]]. It creates the '''quat'''ernary structure (BIOMOLECULE 1 assembly) from the REMARK 350 header.

This script is convenient to use because it searches automatically for the PDB file in the current directory, in [[Fetch_Path|fetch_path]] and (if available) in your local PDB mirror.

= Example Usage =
<source lang="python">
fetch 3bw1, type=pdb
quat 3bw1
as cartoon
</source>

= The Code =
<source lang="python">
'''
(c) 2010-2011 Thomas Holder, MPI for Developmental Biology

Module for reading REMARK records from PDB files and in particular
generate quaterny structure from REMARK 350.
'''

import sys, os
from pymol import cmd, stored

local_mirror_divided = '/mnt/bio/db/pdb.divided'

def pdbremarks(filename):
'''
Read REMARK lines from PDB file. Return dictionary with remarkNum as key
and list of lines as value.
'''
remarks = dict()
if not isinstance(filename, basestring):
f = filename
elif filename[-3:] == '.gz':
import gzip
f = gzip.open(filename)
else:
f = open(filename)
for line in f:
recname = line[0:6]
if recname == 'REMARK':
num = int(line[7:10])
lstring = line[11:]
remarks.setdefault(num, []).append(lstring)
return remarks

def quat350(rem350):
'''
Get transformation matrices for biomolecule 1 from REMARK 350.
'''
biomt = dict()
chains = tuple()
seenbiomolecule = False
for line in rem350:
if line.startswith('BIOMOLECULE:'):
if seenbiomolecule:
break
seenbiomolecule = True
elif line.startswith('APPLY THE FOLLOWING TO CHAINS:'):
chains = tuple(chain.strip() for chain in line[30:].split(','))
elif line.startswith(' AND CHAINS:'):
chains += tuple(chain.strip() for chain in line[30:].split(','))
elif line.startswith(' BIOMT'):
row = int(line[7])
num = int(line[8:12])
vec = line[12:].split()
vec = map(float, vec)
biomt.setdefault(chains, dict()).setdefault(num, []).extend(vec)
return biomt

def quat(name=None, filename=None, prefix=None, quiet=0):
'''
DESCRIPTION

Read REMARK 350 from `filename` and create biological unit
(quaternary structure)

USAGE

quat [name [, filename [, prefix]]]

ARGUMENTS

name = string: name of object and basename of PDB file, if
filename is not given {default: first loaded object}

filename = string: file path {default: <name>.pdb}

prefix = string: prefix for new objects {default: <name>}

EXAMPLE

fetch 1rmv, type=pdb
quat 1rmv
'''
quiet = int(quiet)
if name is None:
name = cmd.get_object_list()[0]
if prefix is None:
prefix = name
if filename is None:
candidates = [
'%s.pdb' % (name),
'%s/%s.pdb' % (cmd.get('fetch_path'), name),
'%s/%s/pdb%s.ent.gz' % (local_mirror_divided, name[1:3], name),
]
for filename in candidates:
if os.path.exists(filename):
break
else:
print 'please provide filename'
return
if not quiet:
print 'loading from %s' % (filename)
remarks = pdbremarks(filename)
if 350 not in remarks:
print 'There is no REMARK 350 in', filename
return
quat = quat350(remarks[350])
for chains in quat:
matrices = quat[chains]
for num in matrices:
mat = matrices[num][0:12]
mat.extend([0,0,0,1])
copy = '%s_%d' % (prefix, num)
if not quiet:
print 'creating %s' % (copy)
cmd.create(copy, '/%s//%s' % (name, '+'.join(chains)))
cmd.alter(copy, 'segi="%d"' % (num))
cmd.transform_object(copy, mat)
cmd.disable(name)
cmd.group('%s_quat' % (prefix), '%s_*' % (prefix))

cmd.extend('quat', quat)

# vi:expandtab:smarttab
</source>

= See Also =
*[[BiologicalUnit]]
*[[Supercell]]

[[Category:Script_Library]]
[[Category:Math_Scripts]]
[[Category:Structural_Biology_Scripts]]

Azahar

2016-02-08T05:26:39Z

Bell: 1 revision

{{Infobox script-repo
|type = plugin
|download = https://github.com/agustinaarroyuelo/Azahar/releases/tag/v0.8.5-beta
|author = Agustina Arroyuelo and [[User:OsvaldoMartin|Osvaldo Martin]]
|license = GPL
}}

== Description ==
[[Image:Azahar_GUI.png|480px|thumb|Azahar GUI.]]

Azahar (pronounced /ɑːsɑːˈɑːr/) is a plugin that extends the PyMOL's capabilities to visualize, analyze and model glycans and glycoconjugated molecules.

== Installation ==
The plugin have been tested on Linux and Windows and should also works on Mac Os X.
To install the plugin just download [https://github.com/agustinaarroyuelo/Azahar/releases/tag/v0.8.5-beta this] zip file and install it using the plugin manager.

Azahar can be used without any dependencies (i.e. you don't need to install anything else) but if you have installed OpenBabel (and OpenBabel Python bindings) Azahar will use it to perform certain calculations like optimize the geometry of your newly created molecule. OpenBabel is also used during the Monte Carlo with Minimization routine.

If you still want to install OpenBabel on your computer see instructions [http://openbabel.org/wiki/Get_Open_Babel here]. Users of 64-bit Windows OS, please install OpenBabel 64-bit from [http://www.lfd.uci.edu/~gohlke/pythonlibs/#openbabel here]

== Usage ==

The plugin's GUI displays three interactive tabs: Creation, Visualization and Calculations.
Usage is described by tab:

=== Glycan Creation ===

The Creation tab contains:

*Three option menus, two of which are used to specify residues to be connected from a list of predefined templates. And the third one, selects the chemical bond to be used.

*Three entry boxes, the first one it's called "Repetitions", where the user can enter the number of residues to be connected. The "Position" entry box indicates the index of the residue to which the next bond will be added. On a typical glycan molecule constructed using this plugin, the user would use the "Position" entry box and the bonds menu to specify ramifications. And in the "New Molecule" entry box the user can write the name of the PyMOL object corresponding to the newly created glycan molecule.

*Finally, The "add" button, when clicked, writes a text file containing the connectivity of the glycan molecule to be created. The user can edit this file or provide it as input. The connectivity instructions are also printed in PyMOL's external GUI. When the "create" button is clicked, the molecule is constructed and displayed in the PyMOL's GUI. The "reset" button resets the entry box's parameters.

=== Visualization ===

On this tab the user will find options to visualize glycans with 3 different ''cartoon-like'' representations. The ''cartoon'' representation is build using PyMOL's [[CGO]] and hence the color of the object has to be define it before creating it. Azahar provides a color menu for that purpose, you can choose from a list of colors or use the ''auto'' option (default), that reads the atom colors from the object. For example if you want to color a glycan cartoon using the b-factors, you should first choose that option from the PyMOL's menu and then tell Azahar to create a cartoon representation with the ''auto'' color option.

You can ''cartoonize'' glycan molecules created by this plugin or loaded from other sources.

=== Calculations ===

Radius of gyration and Ramachandran Plot are useful tools for the analysis of glycan molecules. Through this plugin's GUI the user can easily select a range of states to compute these calculations, and in case of the RG, the result will be displayed in the PyMOL's external GUI.

=== Monte Carlo ===
This feature will be available in the next stable release (although is already available at [https://github.com/agustinaarroyuelo/Azahar github]).

A Monte Carlo with Minimization (MCM) is a global optimization method that have proven very efficient to sample the conformational states of complex molecules like proteins, It was first published by [http://www.ncbi.nlm.nih.gov/pmc/articles/PMC299132/ Li and Scheraga], and is some circles is also know as basin hopping. Briefly, the conformational search is done by perturbing a torsional angle (psi, psi, omega or chi), follow by and energy minimization and the new (minimized) conformation is accepted or rejected following the Metropolis-criteria. If the conformation is accepted the next iteration start from the new conformation, otherwise the old conformation is perturbed again.

From the GUI the user can choose the number of iterations to run, whether or not to use a SASA model to take into account the solvent contribution, and whether or not to start from a random conformation.

After the MCM procedure is completed the user will get:

* one .pdb file for each accepted conformation.
* one multi-state .pdb file (automatically uploaded at the end of the run)
* one .pdb file for the conformation with the minimum energy.
* a plain text listing the energy of each saved conformation

The internal energy is computed using the MMFF94 force field (as implemented on open-babel) and the contribution of the solvent is approximated using a SASA model (the validity of the SASA model for glycans and the relative weight of the internal and salvation energies needs further test).

== New templates ==

You can add your own templates by adding a .pdb file to the Azahar/db_glycans folder, that was created during the plugin installation. The residue number of the template should be 0 and atoms names should have certain names. When in doubt just take a look at one of the already available templates and do not hesitate to contact us.

== Change log ==

* 2015-10-2 (Version 0.8.5)
*# Fix templates: reorder atoms, standardize nomenclature and minimize conformations
*# Add new templates
*# Add Monte Carlo with Minimization Routine
*# fix cartoonize for 1-6 and 6-1 bonds
*# add 2 new cartoon-like representations
*# fix minor bugs, clean code and GUI

* 2015-08-31 (Version 0.8.1)
*# Several bugs fixed, including problems when creating branches.

* 2015-08-28 (Version 0.8)
*# First beta version and first public version (several bugs expected!).

[[Category:Plugins]]
[[Category:Pymol-script-repo]]

Morph

2016-01-30T06:03:05Z

Bell:

File:2DResultOutputtabPyMOLViewerLinux1.png

2016-01-11T06:43:25Z

Bell:

File:3DResultsOutputtabPyMOLViewer1.png

2016-01-11T06:43:25Z

Bell:

File:InputTab2DLiSiCALinuxv1.0.0.png

2016-01-11T06:43:25Z

Bell:

File:InputTab3DLiSiCALinuxv1.0.0.png

2016-01-11T06:43:25Z

Bell:

Scene

2016-01-11T06:32:24Z

Bell: 1 revision

'''scene''' makes it possible to save and restore multiple scenes scene within a single session. A scene consists of the view, all object activity information, all atom-wise visibility, color, representations, and the global frame index.

== Usage ==

scene [ key [, action [, message [, view [, color [, active [, rep
[, frame [, animate [, new_key ]]]]]]]]]]

=== Arguments ===
* '''key''' = string, new, auto, or *: use new for an automatically numbered new scene, use auto for the current scene (if one exists), and use * for all scenes (clear and recall actions only).
* '''action''' = store, recall, insert_after, insert_before, next, previous, update, rename, clear or append: (default = recall). If rename, then a new_key argument must be explicitly defined.
* '''message''' = string: a text message to display with the scene.
* '''view''' = 1 or 0: controls whether the view is stored {default: 1}
* '''color''' = 1 or 0: controls whether colors are stored {default: 1}
* '''active''' = 1 or 0: controls whether activity (objects enabled/disabled) is stored {default: 1}
* '''rep''' = 1 or 0: controls whether the representations are stored {default: 1}
* '''frame''' = 1 or 0: controls whether the frame is stored {default: 1}
* '''animate''' = float: animation duration in seconds {default: ''scene_animation_duration''}
* '''new_key''' = string: the new name for the scene

== Using Scene ==
The [[Scene]] command has quite a few actions/options that can be enabled by using the mouse and the keyboard through the usual [[Scene]] command or hot-keys. Also, you can shift the scenes around using the new [[Scene_buttons]] and just dragging the scene names.

=== Storing scenes ===
<source lang="python">
# store this scene in the next spot, giving it the default name.
scene auto, store
</source>
has the hot-key equivalent of '''CTRL-PageDown''' (FN+CTRL+DownArrow on the Mac). Try turning on [[Scene_Buttons]] and then doing CTRL-PageDown; see the scene buttons popping up?

=== Scenes as Movies ===
If you desire to make a movie that only has camera changes or representation changes, then scenes are your friend. Simply setup each view and then when ready you can do Scene->Store from the PyMOL menus (or ''scene auto, store'' on the command line or the third method Ctrl+PgDn (Fn+Ctrl+DownArrow on the Mac)). Do this for each view you setup. Once done, you can scroll through your scenes by pushing PgUp/PgDn. PyMOL automatically interpolates when you use the PgUp/PgDn buttons, so you get the desired smooth transitions. Mix this with [http://www.pymol.org/ax/ AxPyMOL] and you have movies in PowerPoint with very little work.

=== Auto-play through Scenes ===
With this simple trick you can auto-play through scenes. This is similar to "Movie > Program > Scene Loop" but uses only a single frame.
<syntaxhighlight lang="python">
cmd.mset('1x1')
cmd.set('scene_loop')
cmd.set('movie_fps', 1.0 / 5.0)
cmd.mdo(1, 'scene auto, next')
cmd.mplay()
</syntaxhighlight>

== Examples ==
Simple Examples.
<source lang="python">
scene F1, store
scene F2, store, This view shows you the critical hydrogen bond.

scene F1
scene F2

scene *
</source>

This example shows how to use scenes in a movie!
<source lang="python">
# SUMMARY
#

# This script demonstrates one way of creating a movie from scenes.
# It assumes that we have three scenes, each running for 10 seconds
# (300 frames apiece) including 2-second transitions.

# 1) Load or create content for three scenes (this could just as easily
# come from a session file).

load $TUT/1hpv.pdb
util.cbc
turn x,180
orient
as cartoon
scene 001, store

show sticks, organic
orient organic
scene 002, store

hide cartoon
show lines, byres organic expand 5
turn x,45
turn y,45
scene 003, store

# 2) Specify a 30-second movie -- state 1, 900 frames at 30 frames per second.

mset 1 x900

# 3) Program scene matrices as movie views at appopriate frames
# and also add y-axis rocking between scenes.

scene 001, animate=0
mview store, 1
mview store, 240

turn y,-30
mview store, 70
turn y,60
mview store, 170

scene 002, animate=0
mview store, 300
mview store, 540

turn y,-30
mview store, 370
turn y,60
mview store, 470

scene 003, animate=0
mview store, 600
mview store, 840

turn y,-30
mview store, 670
turn y,60
mview store, 770

# 4) Now interpolate the movie camera.

mview interpolate
mview smooth
mview smooth

# 5) Activate scene content at the appropriate movie frames.

mdo 1: scene 001, view=0, quiet=1
mdo 240: scene 002, view=0, quiet=1
mdo 540: scene 003, view=0, quiet=1
mdo 840: scene 001, view=0, quiet=1

# 6) Force frame 1 content to load.

rewind

# 6) And play the movie.

mplay
</source>

== PyMOL API ==
<source lang="python">
cmd.scene(str key='auto', str action='recall', str-or-list message=None, bool view=1, bool color=1,
bool active=1, bool rep=1, bool frame=1, float animate=-1, str new_key=None)
</source>

== Notes ==
* To scroll through your frames, as in a presentation, just use the PG-UP and PG-DN keys. Very handy.
*Scenes F1 through F12 are automatically bound to function keys provided that "set_key" hasn't been used to redefine the behaviour of the respective key.
*If you have a script that modifies the representation of the molecules and stores them, quickly, then the stored frames may not be up to date. I suggest calling "refresh" between the commands.

== See Also ==
[[View]], [[Set_View]], [[Get_View]], [[Movie_from_scenes]]

==DEVELOPMENT TO DO==
Add support for save/restore of a certain global and object-and-state specific settings, such as: state, surface_color, ribbon_color, stick_color, transparency, sphere_transparency, etc. This would probably best be done by defining a class of "scene" settings which are treated in this manner. The current workaround is to create separate objects which are enabled/disabled differentially.

[[Category:Scenes]]
[[Category:States]]

Main Page

2016-01-11T06:32:23Z

Bell: 2 revisions

__NOTOC__
{| align="center" style="padding-bottom: 4em;"
|+ style="font-size:210%; font-weight: bold; color:#032d45; text-align:center; padding: 5px; margin-bottom: 4px;" | Welcome to the PyMOL Wiki!
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
| The community-run support site for the [http://pymol.org PyMOL] molecular viewer.
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
| New accounts: email jason (dot) vertrees (@) gmail dot com
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
|}
{| align="center" width="45%" style="background: #EDEBD5; margin-bottom: 4em; border-bottom: 1px solid #AFB29E; border-left: 1px solid #AFB29E; border-right: 1px solid #AFB29E;"
|+ style="font-size: 1.4em; font-weight: bold; color: #032d45; text-align:center; background: #5F7F96; padding-top:0.5em; padding-bottom: 0.25em; border-top: 2px solid #AFB29E; border-bottom: 1px solid #fff;" |Quick Links
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[:Category:Tutorials|Tutorials]]''' || '''[[TOPTOC|Table of Contents]]''' || '''[[:Category:Commands|Commands]]'''
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[:Category:Script_Library|Script Library]]''' || '''[[:Category:Plugins|Plugins]]''' || '''[[:Category:FAQ|FAQ]]'''
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[Gallery]]''' | '''[[Covers]]'''
||'''[[CheatSheet|PyMOL Cheat Sheet]]''' (''[[Media:PymolRef.pdf|PDF]]'')
||'''[[PyMOL_mailing_list|Getting Help]]'''
|}

{| width="100%"
| style="vertical-align: top; width: 40%" |
{| class="jtable" style="float: left; width: 90%;"
|+ style="font-size: 1.4em; font-weight: bold; text-align:left; border-bottom: 2px solid #6678b1;" | News & Updates
|-
! New Plugin
| [[Lisica|LiSiCA]] is a new plugin for 2D and 3D ligand based virtual screening using a fast maximum clique algorithm.
|-
! Official Release
| [http://pymol.org PyMOL v1.8.0 has been released] on Nov 18, 2015.
|-
! PyMOL Open-Source Fellowship
| Schrödinger is now accepting applications for the PyMOL Open-Source Fellowship program! Details on http://pymol.org/fellowship
|-
! Official Release
| [http://pymol.org PyMOL, AxPyMOL, and JyMOL v1.7.6 have all been released] on May 4, 2015.
|-
! New Plugin
| [[PyANM|PyANM]] is a new plugin for easier Anisotropic Network Model (ANM) building and visualising in PyMOL.
|-
! New Plugin
| [[Bondpack]] is a collection of PyMOL plugins for easy visualization of atomic bonds.
|-
! New Plugin
| [[MOLE 2.0: advanced approach for analysis of biomacromolecular channels|MOLE 2.0]] is a new plugin for rapid analysis of biomacromolecular channels in PyMOL.
|-
! 3D using Geforce
| PyMOL can now be [http://forums.geforce.com/default/topic/571604/3d-vision/3d-vision-working-with-qbs-in-opengl-software-using-geforce/2/ visualized in 3D using Nvidia GeForce video cards] (series 400+) with 120Hz monitors and Nvidia 3D Vision, this was previously only possible with Quadro video cards.
|-
! Older News
| See [[Older_News|Older News]].
|}
|style="vertical-align: top; width: 40%"|
{| class="jtable" style="float: right; width: 90%"
|+ style="font-size: 1.4em; font-weight: bold; text-align:left; border-bottom: 2px solid #6678b1;" |Did you know...
|-
|<div class="didyouknow" >
<DynamicPageList>
randomcount=1
category=Commands|Plugins|Script_Library|Settings
includepage=*
includemaxlength=1050
escapelinks=false
allowcachedresults=false
resultsheader=__NOTOC__ __NOEDITSECTION__
listseparators=,<h3>[[%PAGE%]]</h3>,,\n
</DynamicPageList>
</div>
<div style="clear: both;"></div>
|}
|
|style="vertical-align: top; width: 18%"|
<DynamicPageList>
imagecontainer=Covers
randomcount=1
escapelinks=false
openreferences=true
listseparators=[[,%PAGE%,|thumb|185px|A Random PyMOL-generated Cover. See [[Covers]].]],\n
ordermethod=none
allowcachedresults=false
</DynamicPageList>

|}

Alter

2016-01-03T07:02:36Z

Bell: 1 revision

#REDIRECT [[iterate]]

'''alter''' changes one or more atomic properties over a selection using the python evaluator with a separate name space for each atom. The symbols defined in the name space, which are are explained in [[Iterate]] are:
name, resn, resi, chain, alt, elem, q, b, segi,
type (ATOM,HETATM), partial_charge, formal_charge,
text_type, numeric_type, ID, vdw

All strings must be explicitly quoted. This operation typically takes several seconds per thousand atoms altered.

'''WARNING''': You should always issue a '''sort''' command on an object
after modifying any property which might affect canonical atom
ordering (names, chains, etc.). Failure to do so will confound
subsequent "create" and "byres" operations.

===USAGE===
alter (selection),expression

===EXAMPLES===

====Change chain label and residue index====
<source lang="python">
alter (chain A),chain='B'
alter (all),resi=str(int(resi)+100)
sort
</source>

====Change van der Waals radius of a given atom====
<source lang="python">
alter (name P), vdw=1.90
</source>
Note that is if dots, spheres, mesh or surface representation is used. You have to refresh the view with
<source lang="python">
rebuild
</source>

====Renumber the amino acids in a protein, so that it starts from 0 instead of its offset as defined in the structure file====
<source lang="python">
# The first residue in the structure file for 1cll is 4. To change this to 0, maybe to match scripts
# outputted from other programs, just remove the offset of 4 from each atom
alter 1cll, resi=str(int(resi)-4)
# refresh (turn on seq_view to see what this command does).
sort
</source>

====Change the b values of all atoms to the distance of the atoms to a reference point====
<source lang="python">
# reference point
x0,y0,z0=[1,2,3]
# calculate distance values between the reference point and all the atoms
alldist = []
iterate_state 1, yourstruc, alldist.append(((x-x0)**2.0+(y-y0)**2.0+(z-z0)**2.0)**0.5)
# assign distance values to b-factors
di = iter(alldist)
alter yourstruc, b=di.next()
# visualize the distances
spectrum b, rainbow, yourstruc
</source>

====Copy (transfer) the color from one object to another====
<source lang="python">
stored.colors = {}
iterate obj1, stored.colors[chain,resi,name] = color
alter obj2, color = stored.colors.get((chain,resi,name), color)
recolor
</source>

=== PYMOL API ===

<source lang="python">
cmd.alter(string selection, string expression, int quiet=1, dict space=None)
</source>

As explained before, all strings must be explicitly quoted. For example to change all HETATM records to ATOM you should do:

<source lang="python">
cmd.alter('all', 'type="ATOM"')
</source>

===SEE ALSO===
[[Alter_State]], [[iterate]], [[Iterate_State]], [[sort]]

[[Category:Commands|Alter]]

Alter State

2016-01-03T07:02:36Z

Bell: 1 revision

#REDIRECT [[iterate]]

'''alter_state''' changes the atomic coordinates of a particular state using the python evaluator with a separate name space for each atom. The symbols defined in the name space are:
* x
* y
* z

===USAGE===
<source lang="python">
alter_state state,(selection),expression
</source>

===EXAMPLES===
<source lang="python">
# Alter the X coordinate for all
alter_state 1,(all),x=x+5

#Shift the coordinates of the entire PDB file
alter_state 1,selection,(x,y,z)=(newx,newy,newz)
</source>

===SEE ALSO===
[[Iterate_State]], [[alter]], [[iterate]]

[[Category:Commands|Alter State]]
[[Category:States|Alter State]]

Iterate State

2016-01-03T07:02:35Z

Bell: 1 revision

#REDIRECT [[iterate]]

Iterate state can be used to extract position data from an object or selection. The expression can use the variables x, y, and z which are the position of the current atom. One common usage is to extract the positions as a python list to alter then write back to the molecule using alter_state.

===USAGE===
iterate_state state, (selection), expression

=== ARGUMENTS ===

* state = integer: state-index if positive number or any of these:
** state = 0: all states
** state = -1: current state
* selection = string: atom selection
* expression = string: expression in valid [http://en.wikipedia.org/wiki/Python_syntax_and_semantics python syntax]
* space = dict: namespace dictionary (API only) {default: pymol namespace}
* atomic = 0/1: provide atomic properties as variables if 1, or only x/y/z if 0 (atomic=0 gives some speed improvement) {default: 1}

===EXAMPLES===
==From PyMOL command line==
To get the sum of x coordinates:
<source lang="python">
stored.sum_x = 0.0
iterate_state 1,(all),stored.sum_x = stored.sum_x + x
</source>
To get a list of the positions in a selection
<source lang="python">
stored.pos = []
iterate_state 1, (all), stored.pos.append((x,y,z))
</source>
==From Python==
To get a list of positions
<source lang="python">
# either with global stored object
from pymol import stored
stored.pos = []
cmd.iterate_state(1, 'all', 'stored.pos.append((x,y,z))')

# or with local object, passed with space argument
pos = []
cmd.iterate_state(1, 'all', 'pos.append((x,y,z))', space={'pos': pos})
</source>

===SEE ALSO===
[[iterate]], [[alter]], [[Alter_State]]

[[Category:Commands|Iterate State]]
[[Category:States|Iterate State]]

Iterate

2016-01-03T07:02:35Z

Bell: 2 revisions

The '''iterate''' command executes a Python expression for all atoms in a selection. The local namespace exposes all atomic identifiers and properties as read-only Python variables. The global namespace by default is the '''pymol''' module namespace, and thus exposes objects like '''cmd''' and '''stored'''. The order of iteration is that of the internal atom ordering.

The '''alter''' command is equivalent to '''iterate''', but provides read-write access to the exposed variables. This can for example be used to rename a chain or to assign new b-factors. If changing identifiers which would affect atom ordering, calling [[sort]] is necessary to reorder based on the new identifiers.

The '''iterate_state''' command is similar to '''iterate''', but iterates over the coordinates in the given state and selection, and exposes '''x, y, z''' in addition to the atomic identifiers and properties.

The '''alter_state''' command is equivalent to '''iterate_state''', but allows modification of '''x, y, z''' (and atom-state level settings in Incentive PyMOL 1.7+).

== Exposed Variables ==

All commands in the '''iterate'''-family expose the following variables:

*'''model''' (str): the object name (appearing in the selection panel on the right) (cannot be altered)
*'''name''' (str): the atom name
*'''resn''' (str): the residue name
*'''resi''' (str): the residue identifier (residue number) as a string, including optional insertion code
*'''resv''' (int): the residue identifier (residue number) as an integer, excluding insertion code
*'''chain''' (str): the chain name
*'''alt''' (str): alternate location identifier
*'''elem''' (str): the chemical element
*'''q''' (float): occupancy
*'''b''' (float): the B Factor
*'''segi''' (str): segment identifier (columns 73-76 in PDB file)
*'''type''' (str: ATOM,HETATM): the atom type (PDB convention for canonical polymer residues)
*'''formal_charge''' (int): the formal charge of the atom
*'''partial_charge''' (float): the partial charge of the atom
*'''numeric_type'''
*'''text_type''' (str): automatic mol2 atom typing (Incentive PyMOL 1.4+)
*'''stereo''' (str): automatic stereochemical R/S label (Incentive PyMOL 1.4+)
*'''ID''' (int): PDB atom id (not guaranteed to be unique)
*'''rank''' (int): atom index from original file import (not guaranteed to be unique)
*'''index''' (int): internal atom index (unique per object, sensitive to [[sort|sorting]] and [[remove|removing]] of atoms, cannot be altered)
*'''vdw''' (float): Van der Waals radius
*'''ss''' (str): secondary structure
*'''color''' (int): color index
*'''reps''' (int): numeric mask of shown representations (PyMOL 1.7.4+)
*'''protons''' (int): (PyMOL 1.7.4+)
*'''p''' (object): property object to access user-defined properties like '''p.abc''' (Incentive PyMOL 1.7+)
*'''s''' (object): settings object to access settings, e.g. '''s.sphere_scale''' (Incentive PyMOL 1.7+, Open-Source PyMOL 1.8.1+)

The '''iterate_state''' and '''alter_state''' commands in addition expose:

*'''x''' (float): x-coordinate
*'''y''' (float): y-coordinate
*'''z''' (float): z-coordinate

== Usage ==

iterate (selection), expression

iterate_state state, (selection), expression

alter (selection), expression

alter_state state, (selection), expression

=== Arguments ===

* '''state''' = int: object state, -1 for current state, 0 for all states
* '''selection''' = str: atom selection
* '''expression''' = str: expression in Python language

== Examples ==

=== Example: Print b-factors ===

The following prints the atom names ('''name''' variable) and b-factors ('''b''' variable) for residue #1.

<source lang="python">
iterate (resi 1), print name, round(b, 2)
</source>

=== Example: Get b-factor list ===

The following example fills a list, '''stored.bfactors''' with the f-factors ('''b''' variable) from residue #1.

<source lang="python">
stored.bfactors = []
iterate (resi 1), stored.bfactors.append(b)
print stored.bfactors
</source>

=== Example: Get coordinates ===

<source lang="python">
stored.coords = []
iterate_state 1, (all), stored.coords.append([x,y,z])
</source>

=== Example: Modify coordinates ===

This example shifts the selection by 10 Angstrom along the model x-axis.

<source lang="python">
alter_state 1, (all), x += 10.0
rebuild
</source>

=== Example: Rename chain ===

This renames chain '''A''' to '''C'''. Note the difference between the selection syntax (first argument) and the Python syntax with the quoted string (second argument). The [[sort]] call is necessary if let's say there is also a chain B, and you expect chain B to appear before chain C (formerly A) in the sequence viewer.

<source lang="python">
alter chain A, chain="C"
sort
</source>

=== Example: Sequence numbering offset ===

Assume the residue numbering in a PDB file starts at 100, then the following updates the residue numbers to start at 1.

<source lang="python">
alter (chain A), resv -= 99
sort
</source>

=== Example: Net Charge ===

The following example calculates the net charge of an object.

<source lang="python">
stored.net_charge = 0
iterate (all), stored.net_charge += partial_charge
print 'Net charge:', stored.net_charge
</source>

=== Example: Color transfer ===

Copy (transfer) the color from one object to another

<source lang="python">
stored.colors = {}
iterate obj1, stored.colors[chain,resi,name] = color
alter obj2, color = stored.colors.get((chain,resi,name), color)
recolor
</source>

== PYMOL API ==

<source lang="python">
cmd.iterate(str selection, str expression, int quiet=1, dict space=None)

cmd.iterate_state(int state, str selection, str expression, int quiet=1, dict space=None)

cmd.alter(str selection, str expression, int quiet=1, dict space=None)

cmd.alter_state(int state, str selection, str expression, int quiet=1, dict space=None)
</source>

=== Arguments ===

* '''state''' = int: state-index if positive number or any of these:
** '''state''' = 0: all states
** '''state''' = -1: current state
* '''selection''' = str: atom selection
* '''expression''' = str: expression in valid [http://en.wikipedia.org/wiki/Python_syntax_and_semantics python syntax]
* '''space''' = dict: namespace dictionary {default: pymol namespace}
* '''atomic''' = 0/1: provide atomic properties as variables if 1, or only x/y/z if 0 (in older PyMOL versions, atomic=0 gives some speed improvement) {default: 1}

=== "space" argument ===

The '''space''' argument can be used to pass local objects into the expression namespace, instead of evaluating the expression in the global '''pymol''' module namespace.

The b-factor list example from above but without the global '''pymol.stored''' variable:

<source lang="python">
myspace = {'bfactors': []}
cmd.iterate('(all)', 'bfactors.append(b)', space=myspace)
</source>

User defined functions can also be included in the namespace:

<source lang="python">
def myfunc(resi,resn,name):
print '%s`%s/%s' % (resn ,resi, name)

myspace = {'myfunc': myfunc}
cmd.iterate('(all)', 'myfunc(resi,resn,name)', space=myspace)
</source>

== See Also ==

* [[sort]]
* [[Get_Model|get_model]]

[[Category:Commands|Iterate]]

Get coordset

2016-01-03T07:02:34Z

Bell: 1 revision

[[get_coordset]] is an API only function that returns the coordinates of one object-state (one "coordinate set") as a numpy array.

''New in PyMOL 1.7.4''

The order of coordinates might differ from functions like [[iterate]] or [[get_coords]]. The function does '''not''' take the state or TTT matrices into account.

== PyMOL API ==

<source lang="python">
cmd.get_coordset(str name, int state=1, int copy=1)
</source>

'''Returns:''' ndarray, shape (N, 3), where N is the number of atoms.

== Arguments ==

* '''selection''' = str: atom selection
* '''state''' = int: state index {default: 1}
* '''copy''' = 0/1: {default: 1} '''Warning: only use copy=0 if you know what you're doing.''' copy=0 will return a numpy array which is a wrapper of the internal coordinate set memory and provides read-write access. If the internal memory gets freed or reallocated, this wrapper will become invalid.

== Examples ==

Move an object to its geometric center:

<source lang="python">
cs = cmd.get_coordset('1ubq', copy=0)
cs -= cs.mean(0)
cmd.rebuild()
</source>

== See Also ==

* [[load_coordset]]
* [[get_coords]]

[[Category:Scripting]]

Get coords

2016-01-03T07:02:34Z

Bell: 3 revisions

[[get_coords]] is an API only function that returns the coordinates of a selection as a numpy array.

''New in PyMOL 1.7.4''

The order of coordinates is that of the internal atom ordering, like in [[iterate]], and unlike in [[get_coordset]]. The function considers the object state and TTT matrices, like in [[Get_Model|get_model]].

== PyMOL API ==

<source lang="python">
cmd.get_coords(str selection='all', int state=1)
</source>

'''Returns:''' ndarray, shape (N, 3), where N is the number of atoms if '''state > 0''', or (natoms * nstates) if '''state=0'''.

== Arguments ==

* '''selection''' = str: atom selection {default: all}
* '''state''' = int: state index or all states if state=0 {default: 1}

== See Also ==

* [[load_coords]]
* [[get_coordset]]
* [[Get Coordinates I]]

For state > 0, the function is equivalent to:

<source lang="python">
numpy.array(cmd.get_model(selection, state).get_coord_list())
</source>

[[Category:Scripting]]

Get Coordinates I

2016-01-03T07:02:33Z

Bell: 6 revisions

There are several ways to extract or load atomic coordinates in PyMOL using the python API.

== Extract coordinates using [[get_coords]] ==

''New in PyMOL 1.7.4''. This is the fastest method to extract coordinates from a selection. It considers the object rotation matrix.

<source lang="python">
xyz = cmd.get_coords('sele', 1)
</source>

== Extract coordinates using [[get_coordset]] ==

''New in PyMOL 1.7.4''. Operates on the object-state level, not on selections. Does '''not''' consider the object rotation matrix. Retrieves coordinates in original order (e.g. PDB file atom order), not in sorted atom order. Faster than [[get_coords]].

<source lang="python">
xyz = cmd.get_coordset(objectname, 1)
</source>

== Extract coordinates using [[Get_Model|get_model]] ==

Before 1.7.4, this was the fastest method to extract coordinates. It considers the object rotation matrix.

<source lang="python">
xyz = cmd.get_model('sele', 1).get_coord_list()
</source>

== Extract coordinates using [[iterate_state]] ==

This is much slower than the first method. It does '''not''' consider the object rotation matrix.

<source lang="python">
xyz = []
cmd.iterate_state(1, 'sele', 'xyz.append([x,y,z])', space=locals(), atomic=0)
</source>

== Load coordinates using [[Alter_State|alter_state]] ==

This is the most convenient way to load coordinates and works equivalent to '''iterate_state'''.

<source lang="python">
xyz = [...] # some Nx3 list with coordinates
xyz_iter = iter(xyz)
cmd.alter_state(1, 'sele', '(x,y,z) = xyz_iter.next()', space=locals())
</source>

== Load coordinates using [[update]] ==

This example gets a copy of the coordinates in Python, rotates the object about the Z axis, and then updates the coordinates in the original object.

<source lang="python">
model = cmd.get_model('pept')
for a in model.atom:
a.coord = [ -a.coord[1], a.coord[0], a.coord[2]]

cmd.load_model(model, "_tmp")
cmd.update("pept", "_tmp")
cmd.delete("_tmp")
</source>

== Load coordinates using [[load_coords]] ==

''Changed in PyMOL 1.7.3''. Update selection coordinates from a Nx3 float array.

<source lang="python">
cmd.load_coords(xyz, selection)
</source>

== Load coordinates using [[load_coordset]] ==

''New in PyMOL 1.7.4''. Update object state coordinates from a Nx3 float array. Can also append a state. Order of coordinates equivalent to [[get_coordset]].

<source lang="python">
cmd.load_coordset(xyz, objectname, 1)
</source>

== Load coordinates using [[get_coordset]] ==

''New in PyMOL 1.7.4''. The [[get_coordset]] function can also return a memory view instead of a copy. This allows modifying the coordinates in place.

<source lang="python">
xyz = cmd.get_coordset(objectname, 1, copy=0)
xyz[:] = newxyz
</source>

[[Category:Script_Library|Get Coordinates I]]
[[Category:ObjSel_Scripts]]

Main Page

2016-01-03T07:02:33Z

Bell: 1 revision

__NOTOC__
{| align="center" style="padding-bottom: 4em;"
|+ style="font-size:210%; font-weight: bold; color:#032d45; text-align:center; padding: 5px; margin-bottom: 4px;" | Welcome to the PyMOL Wiki!
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
| The community-run support site for the [http://pymol.org PyMOL] molecular viewer.
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
| New accounts: email jason (dot) vertrees (@) gmail dot com
|- style="text-align:center; font-weight:bold; color: #6d6003; font-size: 140%; font-style: italic; font-family: serif;"
|}
{| align="center" width="45%" style="background: #EDEBD5; margin-bottom: 4em; border-bottom: 1px solid #AFB29E; border-left: 1px solid #AFB29E; border-right: 1px solid #AFB29E;"
|+ style="font-size: 1.4em; font-weight: bold; color: #032d45; text-align:center; background: #5F7F96; padding-top:0.5em; padding-bottom: 0.25em; border-top: 2px solid #AFB29E; border-bottom: 1px solid #fff;" |Quick Links
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[:Category:Tutorials|Tutorials]]''' || '''[[TOPTOC|Table of Contents]]''' || '''[[:Category:Commands|Commands]]'''
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[:Category:Script_Library|Script Library]]''' || '''[[:Category:Plugins|Plugins]]''' || '''[[:Category:FAQ|FAQ]]'''
|-
| style="font-size: 1.1em; color #61021F; padding: 0.5em 1em 0.5em 3em;"|'''[[Gallery]]''' | '''[[Covers]]'''
||'''[[CheatSheet|PyMOL Cheat Sheet]]''' (''[[Media:PymolRef.pdf|PDF]]'')
||'''[[PyMOL_mailing_list|Getting Help]]'''
|}

{| width="100%"
| style="vertical-align: top; width: 40%" |
{| class="jtable" style="float: left; width: 90%;"
|+ style="font-size: 1.4em; font-weight: bold; text-align:left; border-bottom: 2px solid #6678b1;" | News & Updates
|-
! New Plugin
| [[Lisica|LiSiCA]] is a new plugin for 2D and 3D ligand based virtual screening using a fast maximum clique algorithm.
|-
! Official Release
| [http://pymol.org PyMOL v1.8.0 has been released] on Nov 18, 2015.
|-
! PyMOL Open-Source Fellowship
| Schrödinger is now accepting applications for the PyMOL Open-Source Fellowship program! Details on http://pymol.org/fellowship
|-
! Official Release
| [http://pymol.org PyMOL, AxPyMOL, and JyMOL v1.7.6 have all been released] on May 4, 2015.
|-
! New Plugin
| [[PyANM|PyANM]] is a new plugin for easier Anisotropic Network Model (ANM) building and visualising in PyMOL.
|-
! New Plugin
| [[Bondpack]] is a collection of PyMOL plugins for easy visualization of atomic bonds.
|-
! New Plugin
| [[MOLE 2.0: advanced approach for analysis of biomacromolecular channels|MOLE 2.0]] is a new plugin for rapid analysis of biomacromolecular channels in PyMOL.
|-
! 3D using Geforce
| PyMOL can now be [http://forums.geforce.com/default/topic/571604/3d-vision/3d-vision-working-with-qbs-in-opengl-software-using-geforce/2/ visualized in 3D using Nvidia GeForce video cards] (series 400+) with 120Hz monitors and Nvidia 3D Vision, this was previously only possible with Quadro video cards.
|-
! Older News
| See [[Older_News|Older News]].
|}
|style="vertical-align: top; width: 40%"|
{| class="jtable" style="float: right; width: 90%"
|+ style="font-size: 1.4em; font-weight: bold; text-align:left; border-bottom: 2px solid #6678b1;" |Did you know...
|-
|<div class="didyouknow" >
<DynamicPageList>
namespace=
category=Commands|Plugins|Script_Library|Settings
includepage=*
includemaxlength=1050
escapelinks=false
resultsheader=__NOTOC__ __NOEDITSECTION__
randomcount=1
listseparators=,<h3>[[%PAGE%]]</h3>,,\n
</DynamicPageList>
</div>
<div style="clear: both;"></div>
|}
|
|style="vertical-align: top; width: 18%"|
<DynamicPageList>
imagecontainer=Covers
randomcount=1
escapelinks=false
openreferences=true
listseparators=[[,%PAGE%,|thumb|185px|A Random PyMOL-generated Cover. See [[Covers]].]],\n
ordermethod=none
</DynamicPageList>

|}

Draw Protein Dimensions

2016-01-03T07:02:29Z

Bell: 1 revision

{{Infobox script-repo
|type = script
|filename = Draw_Protein_Dimensions.py
|author = [[User:PabloGuardado|Pablo Guardado Calvo]]
}}

This script will draw the dimensions of a protein based on an Inertia Axis Aligned Bounding Box (IABB).

The idea behind this script is to calculate an approximate minimal bounding box (MBB) to extract the cell dimensions of a protein. To calculate the MBB is not trivial and usually the Axis Aligned Bounding Box (AABB) does not show up the real dimensions of the protein. This script calculates the inertia tensor of the object, extract the eigenvectors and use them to rotate the molecule (using as rotation matrix the transpose of the eigenvector matrix). The result is a molecule oriented with the inertia axis aligned with the cartesian axis. A new Bounding Box is calculated, which is called Inertia Axis Aligned Bounding Box (IABB), with a volume always lower than the AABB volume, and in many cases may correspond with the MBB.

As always with these type of things, you have to use at your own risk. I did not try all the possible combinations, but if you find a bug, do
not hesitate to contact me (pablo.guardado (at) gmail.com) or try to modify the code for yourself to correct it.

To load the script just type:

'''run path-to-the-script/Draw_Protein_Dimensions.py'''

or if you want something more permanent add the previous line to your .pymolrc file

The script works just typing:

'''draw_Protein_Dimensions ''selection'''''

This will draw the cell dimensions of your selection based on a IABB box. It also generates the IABB box and the inertia axis, you just need to do "show cgo" to display them.

You could also try:

'''draw_BB ''selection'''''

This will draw the AABB and IABB boxes with their cell dimensions and show up their volumes, you can compare them.

= Examples =
<source lang="python">
# download the source and save as Draw_Protein_Dimensions.py
run Draw_Protein_Dimensions.py
fetch 2vak
# calculate the dimensions of the full ASU
draw_Protein_Dimensions 2vak
</source>

<gallery perrow=3 widths=350 heights=350>
File:2vak_ASU.png |Dimensions of 2vak ASU
</gallery>

<source lang="python">
# you can extract only one chain and calculates the dimensions
draw_Protein_Dimensions obj01
</source>

<gallery perrow=3 widths=350 heights=350>
File:2vak_A.png |Dimensions of one protomer (chain A - 2vak)
</gallery>

<source lang="python">
# You can also draw the Bounding boxes (AABB and IABB) to compare them.
fetch 2vak
draw_BB 2vak
</source>

<gallery perrow=3 widths=350 heights=350>
File:2vak_AABB.png |Axis-aligned bounding box
File:2vak_IABB.png |Inertia-axis-aligned bounding box
</gallery>

[[Category:Script_Library]]
[[Category:Math_Scripts]]
[[Category:Structural_Biology_Scripts]]
[[Category:Pymol-script-repo]]

User:Tlinnet

2015-12-14T04:40:41Z

Bell: 3 revisions

== Author of following PyMOL scripts ==
[[Propka | PROPKA for PyMOL]] 2015/11/19 42k<br>
[[DisplacementMap | Displacement map for conformational changes]] 2015/11/19 43k<br>
[[Forster-distance-calculator | Forster distance calculator]] 2015/11/19 22k <br>
[[Rotkit | Rotation matrix calculator]] 015/11/19 17k <br>
[[ColorByDisplacement | Color by displacement]] 2015/11/19 13k <br>
[[Cyspka | Surface Cysteine pKa predictor]] 2015/11/19 12k

149 k

== Tutorial ==
[[Biochemistry_student_intro | Biochemistry student intro]] 2015/11/19 60k

== Test ==
<nowiki> <include src="https://raw.github.com/Pymol-Scripts/Pymol-script-repo/master/cyspka.py" /> </nowiki>

TransformSelectionByCameraView

2015-12-14T04:40:41Z

Bell: 1 revision

This little script was posted to the PyMol list. It will orient the molucule like cmd.orient() does, but does so by the camera view.

https://sourceforge.net/p/pymol/mailman/message/10097639/

<source lang="python">
# transform selection coordinates by the camera view
#
# The script answers this:
# Thanks!
# But translate[x,y,z] only translate the molecule.
# What I want is to put longest length of molecule in the X axes, the
# second Y axes, the third z axes.
# Just like what orient command does which change the view of camera but
# not the coordinates.
# Now I want the coordinates also change after orient it.
#
cv=list(cmd.get_view())

cmd.transform_selection("all", \
cv[0:3]+[0.0]+ \
cv[3:6]+[0.0]+ \
cv[6:9]+[0.0]+ \
cv[12:15]+[1.0], transpose=1)

cmd.reset()
</source>
[[Category:Script_Library]]
[[Category:Math_Scripts]]

Selection Algebra

2015-12-14T04:40:41Z

Bell: 1 revision

__FORCETOC__

Selections can be made more precise or inclusive by combining them with logical operators, including the boolean '''and''', '''or''', and '''not'''. The boolean '''and''' selects only those items that have both (or all) of the named properties, and the boolean '''or''' selects items that have either (or any) of them. Venn diagrams show that '''and ''' selects the areas of overlap, while '''or''' selects both areas.

See [http://pymol.sourceforge.net/newman/user/S0220venn.jpg simple logic Venn diagram].

== Selection Operator/Modifier Table ==
Selection operators and modifiers are listed below. The dummy variables ''s1'' and ''s2'' stand for selection-expressions such as "chain a" or "hydro."

{| border=1 cellpadding=10
|-
! Operator
! Short Form
! Effect

|-
| not ''s''1
| !''s''1
| Selects atoms that are not included in ''s''1.
<pre>PyMOL> select sidechains, ! bb</pre>

|-
| ''s''1 and ''s''2
| ''s''1 & ''s''2
| Selects atoms included in both ''s''1 and ''s''2.
<pre>PyMOL> select far_bb, bb &farfrm_ten</pre>

|-
| ''s''1 or ''s''2
| ''s''1 | ''s''2
| Selects atoms included in either ''s''1 or ''s''2.
<pre>PyMOL> select all_prot, bb | sidechain</pre>

|-
| ''s''1 in ''s''2
| ''s''1 in ''s''2
|Selects atoms in ''s''1 whose identifiers name, resi, resn, chain and segi <u>'''all'''</u> match atoms in ''s''2.
<pre>PyMOL> select same_atms, pept in prot</pre>

|-
| ''s''1 like ''s''2
| ''s''1 l. ''s''2
| Selects atoms in ''s''1 whose identifiers name and resi match atoms in ''s''2.
<pre>PyMOL> select similar_atms, pept like prot</pre>

|-
| ''s''1 gap ''X''
|
|Selects all atoms whose van der Waals radii are separated from the van der Waals radii of ''s''1 by a minimum of'' X'' Angstroms.
<pre>PyMOL> select farfrm_ten, resi 10 gap 5</pre>

|-
| ''s''1 around ''X''
| ''s''1 a. ''X''
|Selects atoms with centers within'' X'' Angstroms of the center of any atom in''s''1.
<pre>PyMOL> select near_ten, resi 10 around 5</pre>

|-
| ''s''1 expand ''X''
| ''s''1 x. ''X''
|Expands ''s''1 by all atoms within ''X'' Angstroms of the center of any atom in ''s''1.
<pre>PyMOL> select near_ten_x, near_ten expand 3</pre>

|-
| ''s''1 within ''X'' of ''s''2
| ''s''1 w. ''X'' of ''s''2
| Selects atoms in ''s''1 that are within ''X'' Angstroms of any atom in ''s''2.
<pre>PyMOL> select bbnearten, bb w. 4 of resi 10</pre>

|-
| ''s''1 near_to ''X'' of ''s''2
| ''s''1 nto. ''X'' of ''s''2
| Same as ''within'', but excludes ''s''2 from the selection (and thus is identical to <code>s1 and ''s2'' around X</code>).

|-
| ''s''1 beyond ''X'' of ''s''2
| ''s''1 be. ''X'' of ''s''2
| Selects atoms in ''s1'' that are at least ''X'' Anstroms away from ''s2''.

|-
| byres ''s''1
| br. ''s''1
| Expands selection to complete residues.
<pre>PyMOL> select complete_res, br. bbnear10</pre>

|-
| bymolecule ''s''1
| bm. ''s''1
| Expands selection to complete molecules.
<pre>PyMOL> select complete_mol, bm. bbnear10</pre>

|-
| byfragment ''s''1
| bf. ''s''1
| Expands selection to complete fragments.
<pre>PyMOL> select complete_frag, bf. bbnear10</pre>

|-
| bysegment ''s''1
| bs. ''s''1
| Expands selection to complete segments.
<pre>PyMOL> select complete_seg, bs. bbnear10</pre>

|-
| byobject ''s''1
| bo. ''s''1
| Expands selection to complete objects.
<pre>PyMOL> select near_obj, bo. near_res</pre>

|-
| bycell ''s''1
|
| Expands selection to unit cell.
<pre>PyMOL> select complete_cell, bycell orig_res</pre>

|-
| neighbor ''s''1
| nbr. ''s''1
| Selects atoms directly bonded to ''s''1, excludes ''s''1.
<pre>PyMOL> select vicinos, neighbor resi 10</pre>

|-
| bound_to ''s1''
| bto. ''s1''
| Selects atoms directly bonded to ''s1'', may include ''s1''.

|-
| ''s''1 extend ''X''
| ''s''1 xt. ''X''
| Extends ''s''1 by ''X'' bonds connected to atoms in ''s''1.
<pre>PyMOL> select connect_x, near10 extend 3</pre>

|-
| pepseq ''SEQ''
| ps. ''SEQ''
| Selects peptide sequence matching upper-case one-letter sequence ''SEQ'' (see also [[FindSeq]]).
<pre>PyMOL> select 1tvn and ps. FATEW</pre>

|-
| rep ''rep''
|
| Selects atoms which show representation ''rep''.
<pre>PyMOL> select sele, rep spheres</pre>

|}

== Comparison of distance operators ==

There are serveral very similar operators that select by pairwise atom distances. The following table lists the details how they differ.

'''Syntax 1''': ''s1'' operator X of ''s2''<br>
'''Syntax 2''': ''s1'' and (''s2'' operator X)

{| border=1 cellspacing=0 cellpadding=4 style="text-align:center" class=wikitable
! operator !! distance is ... !! measured from !! includes s2 !! syntax !! notes
|-
| near_to || ≤ X || center || never || 1 || equivalent to "around"
|-
| within || ≤ X || center ||if matches s1|| 1 ||
|-
| beyond || > X || center || never || 1 ||
|-
| gap || > X || center+vdw || never || 2 ||
|-
| around || ≤ X || center || never || 2 || equivalent to "near_to"
|-
| expand || ≤ X || center || always || 2 ||
|}

== Examples ==
Logical selections can be combined. For example, you might select atoms that are part of chain a, but not residue number 125:
<source lang="python">
# selects atoms that are part of chain a, but not residue number 125.
select chain a and (not resi 125)

# The following two selections are equivalent,
select (name cb or name cg1 or name cg2) and chain A

# select c-beta's, c-gamma-1's and c-gamma-2's
# that are in chain A.
select name cb+cg1+cg2 and chain A

# select all residues within 5 Ang. or any organic small molecules
select br. all within 5 of organic

# select helices
select ss 'h'

# select anything shown as a line
select rep lines

# select all residues with a b-factor less than 20, within 3 angstroms of any water
select br. b<20 & (all within 3 of resn HOH)

# select anything colored blue
select color blue

# select the 1st arginine
select first resn arg

# select 1foo's segment G's chain X's residue 444's alpha carbon
select 1foo/G/X/444/CA
# same thing
select 1foo and segi G and c. X and i. 444 and n. CA

# select the entire object that residue 23's beta caron is in:
select bo. i. 23 and n. CA

# select the molecule that chain C is in
select bm. c. C
</source>

Like the results of groups of arithmetic operations, the results of groups of logical operations depend on which operation is performed first. They have an order of precedence. To ensure that the operations are performed in the order you have in mind, use parentheses:

<source lang="python">byres ((chain a or (chain b and (not resi 125))) around 5)</source>

PyMOL will expand its logical selection out from the innermost parentheses.

== See Also ==

[[Single-word Selectors]], [[Selection Macros]], [[Property_Selectors]], [[Identify]]

[[Category:Selector Quick Reference]]
[[Category:Selecting|Selection Algebra]]