PyMOL Wiki - User contributions [en]

APBS

2014-10-24T12:10:02Z

Jlec:

== Introduction ==
[[Image:Rna_surface_apbs.png|thumb|APBS-generated electrostatic surface displayed in PyMOL]]
[http://www.poissonboltzmann.org/ APBS], the Adaptive Poisson-Boltzmann Solver, is a [http://www.oreilly.com/openbook/freedom/ freely] available macromolecular electrostatics calculation program released under the [http://www.gnu.org/copyleft/gpl.html GPL]. It is a cost-effective but uncompromised alternative to [http://trantor.bioc.columbia.edu/grasp/ GRASP], and it can be used within PyMOL. PyMOL can display the results of the calculations as an electrostatic potential molecular surface.

== APBS Plugin with New Features ==
=== Pre-release version ===
See also [[apbsplugin]] for the version control in the project [[Git_intro | Pymol-script-repo.]]

There is often a more current pre-release version available on my user page. If you're experiencing bugs, please test the pre-release version to see if they've already been fixed. Thanks! --[[User:Mglerner|michael]] 19:43, 29 October 2010 (UTC)
----
PyMol currently supports the '''APBS plugin''' written by [http://pymolwiki.org/index.php/User:Mglerner Michael Lerner]. This plugin makes it possible to run APBS from within PyMOL, and then display the results as a color-coded electrostatic surface (units <math>K_bT/e_c</math>) in the molecular display window (as with the image to the right). This wiki page has updated instructions on how to download, install and use the plugin.

'''Nucleic acids may prove problematic for the apbs plugin.''' If so, use the [http://pdb2pqr.sourceforge.net/ pdb2pqr] command-line tool to create a pqr file manually, instead of using the plugin to generate it. Then direct the APBS GUI on the [http://www-personal.umich.edu/~mlerner/PyMOL/images/main.png main menu] to read the pqr file you '''externally generated.'''

There is a new version of the PyMOL-APBS plugin and it's now ready for pre-release. There are several big advantages of the new version:

* It's been tested modern OS X, Windows and Linux systems and fixes several long-standing bugs.
* It allows you to call through to PDB2PQR directly.
* It allows you to show the electric field lines.
* It has two visualization panels to aid in showing multiple potential surfaces at once.
* It defaults to using PDB2PQR for PQR generation and APBS's psize.py for grid sizing/spacing.
* It has also an increased default maximum allowed memory since typical users have bigger and faster computers these days.
* It calls on the correct paths and binaries for multi-threaded APBS (apbs-mpi-openmpi).

The main reason it is not included in the latest PyMOL release is to receive bug reports. Once it's shown to be stable, it'll be included in the next PyMOL release. See [http://pymolwiki.org/index.php/User:Mglerner Michael Lerner]'s page.

==== How to get it ====

There are two ways to get the new plugin

* If you have subversion installed, you can always get the latest version via

<source lang="bash">
svn co http://pymolapbsplugin.svn.sourceforge.net/viewvc/pymolapbsplugin/trunk/src/apbsplugin.py
</source>

* You can download it from http://pymolapbsplugin.svn.sourceforge.net/viewvc/pymolapbsplugin/trunk/src/apbsplugin.py

That should give you a file called apbsplugin.py

Once you have the plugin, you can install it via PyMOL's plugin installer: Plugin --> Manage Plugins --> Install

You may have to run PyMOL with sudo privileges.

Note that the plugin will be installed as "APBS Tools2.1" so that you can continue to use your old version.

Further details, as well as screen shots, are given [http://www.pymolwiki.org/index.php/MAC_Install#Install_APBS_and_friends_with_fink elsewhere in this wiki].

==Required Dependencies==
[http://apbs.sourceforge.net APBS] and its dependencies like [http://pdb2pqr.sourceforge.net pdb2pqr] and [http://scicomp.ucsd.edu/~mholst/codes/maloc/ maloc] are [http://www.oreilly.com/openbook/freedom/ freely] available under the [http://www.gnu.org/copyleft/gpl.html GPL]. The author of the software however [http://agave.wustl.edu/apbs/download/ asks that users register] with him to aid him in obtaining grant funding.

----
===Installing the Dependencies on OS X===
#First, [http://agave.wustl.edu/apbs/download/ register] your use of the software. This will keep everyone happy.
#Second, if you don't already have the [http://fink.sourceforge.net fink package management system], now is a good time to get it. Here is a [http://xanana.ucsc.edu/~wgscott/xtal/wiki/index.php/Quick_Start quick-start set of instructions] for getting X-windows, compilers, and fink all installed.
#Once you are up and going, [http://xanana.ucsc.edu/~wgscott/xtal/wiki/index.php/How_to_Activate_the_Unstable_Branch activate the unstable branch in fink], and then issue the commands
<source lang="bash">
fink self-update
fink install apbs
</source>
or if you want to use the multi-processor version, issue
<source lang="bash">
fink self-update
fink install apbs-mpi-openmpi
</source>
Then install the X-windows based version of pymol using the command
<source lang="bash">
fink install pymol-py25
</source>
It is recommended to install the latest pdb2pqr as well as the APBS plugin makes use of it
<source lang="bash">
fink install pdb2pqr
</source>
Note that the fink version of PyMOL as of 1.3-4 does not have the latest version of the APBS plugin. Make sure you get the new version!

===Installing the Dependencies on Linux===

====From Scratch====
Note that this tutorial assumes you're using the bash shell and have root privileges
<OL><LI>
Obtain APBS and MALOC from...<br>
APBS = http://apbs.sourceforge.net (currently 0.4)<br>
MALOC = http://www.fetk.org/codes/maloc/index.html#download (currently 0.1-2)<BR>
<LI>Set up some environment variables & directories (temporary for building)
<source lang="bash">
$ export FETK_SRC=/<building directory>/temp_apbs
$ export FETK_PREFIX=/usr/local/apbs-0.4.0 (or wherever you want it to live)
$ export FETK_INCLUDE=${FETK_PREFIX}/include
$ export FETK_LIBRARY=${FETK_PREFIX}/lib
$ mkdir -p ${FETK_SRC} ${FETK_INCLUDE} ${FETK_LIBRARY}
</source></LI>
<LI>Unpack the source packages
<source lang="bash">
$ cd ${FETK_SRC}
$ gzip -dc maloc-0.1-2.tar.gz | tar xvf -
$ gzip -dc apbs-0.4.0.tar.gz | tar xvf -
</source>
</LI>
<LI>Compile MALOC
<source lang="bash">
$ cd ${FETK_SRC}/maloc
$ ./configure --prefix=${FETK_PREFIX}</source>
If everything went well, then
<source lang="bash">
$ make; make install</source></LI>
<LI>Go get a coffee. Compilation/installation takes about 15 minutes on a 3GHz computer with 1GB of RAM.</LI>
<LI>Now on to compiling APBS itself
<source lang="bash">
$ cd ${FETK_SRC}/apbs-0.4.0
$ ./configure --prefix=${FETK_PREFIX}</source>
If all goes well:
<source lang="bash">
$ make all; make install</source></LI>
<LI>No time for coffee. Takes about 5 minutes on that fast computer.</LI>
<LI> There will now be an APBS binary at
<source lang="bash">/usr/local/apbs-0.4.0/bin/i686-intel-linux/apbs</source></LI>
<LI> Make appropriate links
<source lang="bash">
$ ln -s /usr/local/apbs-0.4.0/bin/i686-intel-linux/apbs /usr/local/bin/apbs
</source></LI>
<LI> Get rid of /<building directory dir>/temp_apbs
<LI> Open PyMOL and make sure that the APBS plugin points to /usr/local/bin/apbs
<LI> Rock and or Roll.
</OL>

====Pre-Packaged====
=====RPMs=====

A variety of RPMs are available from the [http://sourceforge.net/project/showfiles.php?group_id=148472&package_id=163734&release_id=378273 APBS downloads website]. Again, please [http://agave.wustl.edu/apbs/download/ register] your use of the software if you have not yet done so.

=====Debian packages=====

For ubuntu and other debian linux distributions, probably the simplest thing is to download a promising looking rpm, convert it with the program [http://kitenet.net/programs/alien/ alien], and then install the [http://xanana.ucsc.edu/linux newly generated debian package] with the command
<source lang="bash">
sudo dpkg -i apbs*.deb
</source>

=====Gentoo=====

You have to install apbs and pdb2pqr. Both are masked via keywords atm. Type as root:
<source lang="bash">
echo sci-chemistry/pdb2pqr >> /etc/portage/package.keywords
echo sci-chemistry/apbs >> /etc/portage/package.keywords
emerge -av sci-chemistry/apbs sci-chemistry/pdb2pqr
</source>

== Troubleshooting ==
* If the B-factor is <math>\geq 100,</math> then APBS doesn't properly read in the PDB file and thus outputs garbage (or dies). To fix this, set all b factors to be less than 100. <source lang="python">alter all, b=min(b,99.9)</source> The problem stems from how to parse a PDB file. The PDB file originally was written when most people used FORTRAN programs, and so the file format was specified by columns, not by the more modern comma separated value format we tend to prefer today. For the latest on the PDB format see the [http://www.wwpdb.org/docs.html new PDB format docs].
* APBS has problems, sometimes, in reading atoms with alternate conformations. You can remove the alternate locations with a simple script [[removeAlt]].
* ObjectMapLoadDXFile-Error: as of this writing (9-23-2008) a known problem exists, and the Baker lab is working on it. It is typically caused by the use of directories with spaces in their names under Windows.

== Problems with the bundled version of APBS ==
There is an issue with the freemol version of APBS shipped with PyMOL 1.2r2 for OS X.

=== Leopard and Snow Leopard (10.5 and 10.6) ===
There are three fairly easy ways to resolve it

1. Download and install the most recent (post Dec. 1 2009) version of APBS from [http://www.poissonboltzmann.org/apbs/downloads]. Then copy the apbs binary into the freemol directory (mv it to /Applications/PyMOLX11Hybrid.app/pymol/freemol/bin/apbs.exe, overwriting the version that comes installed with PyMOL).

2. Download [[File:Libgfortran.3.dylib.bz2]], unzip it ("bunzip2 libgfortran.3.dylib.gz2") and move it to /usr/local/lib ("mv libgfortran.3.dylib /usr/local/lib" ... on some machines, you may need "sudo mv libgfortran.3.dylib /usr/local/lib").

<source lang="bash">
bunzip2 libgfortran.3.dylib.gz2
mv libgfortran.3.dylib /usr/local/lib
</source>

3. Use macports to install gcc 4.4.2 and link the appropriate library ("ln -s /opt/local/lib/gcc44/libgfortran.3.dylib /usr/local/lib/libgfortran.3.dylib" ... on some machines, you may need "sudo ln -s /opt/local/lib/gcc44/libgfortran.3.dylib /usr/local/lib/libgfortran.3.dylib").

<source lang="bash">
ln -s /opt/local/lib/gcc44/libgfortran.3.dylib /usr/local/lib/libgfortran.3.dylib
sudo ln -s /opt/local/lib/gcc44/libgfortran.3.dylib /usr/local/lib/libgfortran.3.dylib
</source>

If you're curious, the problem is that APBS is dynamically linked, but Apple does not provide FORTRAN libraries.

The version of libgfortran above is covered by the GNU General Public License (GPL). A copy of the GPL may be found at [http://www.gnu.org/licenses/licenses.html], and the source may be obtained from MacPorts ([http://www.macports.org/]).

=== Tiger (10.4) ===
You'll need to install APBS yourself via MacPorts or via fink. Fink instructions may be found on the [[APBS]] page. Installation via MacPorts requires first installing MacPorts from [http://www.macports.org/] and then typing

<source lang="bash">
sudo port install apbs
</source>

from the command line. This process could easily take several hours on an older machine, as MacPorts will recompile gcc, gfortran, and several other packages along the way.

[[Image:Apbs_ex.png|thumb|right|300px|PyMOL visualizing two maps at once]]

==Using APBS==
There is a nice tutorial on the APBS homepage: [http://www.poissonboltzmann.org/apbs/examples/visualization/apbs-electrostatics-in-pymol] For further help, there is a mailing list [https://lists.sourceforge.net/lists/listinfo/apbs-users] with the corresponding archive [http://sourceforge.net/mailarchive/forum.php?forum_name=apbs-users]

==Further contributions and edits are needed.==

[[Category:Electrostatics]]
[[Category:Biochemical_Properties]]
[[Category:Plugins]]

FocalBlur

2014-07-04T06:31:02Z

Jlec:

{{Infobox script-repo
|type = script
|filename = focal_blur.py
|author = [[User:Jarl.Underhaug|Jarl Underhaug]]
|license = -
}}

[[Image:StylizedFocalBlur.png|550px|right]]

==Description==

This script creates fancy figures by introducing a focal blur to the image. The object at the origin will be in focus.

===Usage===

Load the script using the [[run]] command. Execute the script using PyMOL syntax:
<source lang="python">
FocalBlur aperture=2.0,samples=20,ray=1
</source>
or using python syntax:
<source lang="python">
FocalBlur(aperture=2.0,samples=20,ray=1)
</source>

For additional options, see the script comments.

===Notes===

* When using raytracing, the image creation will take ''n'' times longer than normal, where ''n'' is the number of samples.
* The aperture is related to the aperture on a camera.

===Bugs===

* FocalBlur uses the Python Image Library (PIL), a necessary components of PIL is missing in the Windows version of PyMOL
* There is a bug when not using ray tracing with the free version of PyMOL

===Examples===

<gallery perrow=3 widths=300 heights=240>
Image:FocalBlur_a1.0_r1.png|FocalBlur aperture=1,samples=100,ray=1
Image:FocalBlur_a2.0_r1.png|FocalBlur aperture=2,samples=100,ray=1
Image:FocalBlur_a4.0_r1.png|FocalBlur aperture=4,samples=400,ray=1
Image:FocalBlur_a4.0_r0.png|FocalBlur aperture=4,samples=400,ray=0
Image:Focal_blur _ex6.png
Image:Focal blur_ex_ap3.png
Image:Focal blur_ex_ap3_mode1.png
Image:Focal blur_ex_ap3_mode2.png
Image:Focal blur_ex_ap3_mode3.png
</gallery>

==Script==
Load the script using the [[run]] command

<source lang="python">
from pymol import cmd
from tempfile import mkdtemp
from shutil import rmtree
from math import sin,cos,pi,sqrt
from PIL import Image

def FocalBlur(aperture=2.0,samples=10,ray=0,width=0,height=0):
'''
DESCRIPTION

Creates fancy figures by introducing a focal blur to the image. The object
at the origin will be in focus.

AUTHOR

Jarl Underhaug
University of Bergen
jarl_dot_underhaug_at_gmail_dot_com

Updates by Jason Vertrees and Thomas Holder

USAGE

FocalBlur aperture=float, samples=int, ray=0/1, width=int, height=int

EXAMPELS

FocalBlur aperture=1, samples=100
FocalBlur aperture=2, samples=100, ray=1, width=600, height=400
'''

# Formalize the parameter types
ray = (ray in ("True", "true", 1, "1"))
aperture, samples = float(aperture), int(samples)
width, height = int(width), int(height)

# Create a temporary directory
tmpdir = mkdtemp()

# Get the orientation of the protein and the light
light = cmd.get('light')[1:-1]
light = [float(s) for s in light.split(',')]
view = cmd.get_view()

# Rotate the protein and the light in order to create the blur
for frame in range(samples):
# Angles to rotate protein and light
# Populate angles as Fermat's spiral
theta = frame * pi * 110.0/144.0
radius = 0.5 * aperture * sqrt(frame/float(samples-1))
x = cos(theta) * radius
y = sin(theta) * radius
xr = x/180.0*pi
yr = y/180.0*pi

# Rotate the protein
cmd.turn('x',x)
cmd.turn('y',y)

# Rotate the light
ly = light[1]*cos(xr)-light[2]*sin(xr)
lz = light[2]*cos(xr)+light[1]*sin(xr)
lx = light[0]*cos(yr)+lz*sin(yr)
lz = lz*cos(yr)-lx*sin(yr)
cmd.set('light',[lx,ly,lz])

curFile = "%s/frame-%04d.png" % (tmpdir,frame)
print "Created frame %i/%i (%0.0f%%)" % (frame+1,samples,100*(frame+1)/samples)

# Save the image to temporary directory
if ray:
cmd.ray(width,height)
cmd.png(curFile)
else:
cmd.png(curFile,quiet=1)

# Create the average/blured image
try:
avg = Image.blend(avg,Image.open(curFile),1.0/(frame+1))
except:
avg = Image.open(curFile)

# Return the protein and the light to the original orientation
cmd.set('light',light)
cmd.set_view(view)

# Load the blured image
avg.save('%s/avg.png' % (tmpdir))
cmd.load('%s/avg.png' % (tmpdir))

# Delete the temporary files
rmtree(tmpdir)

cmd.extend('FocalBlur', FocalBlur)

</source>

[[Category:Script_Library]]

Cealign plugin

2009-05-01T11:59:00Z

Jlec:

== Introduction ==

'''Go directly to [[Cealign#Version_0.8-RBS|DOWNLOAD]]'''

This page is the home page of the open-source CEAlign PyMOL plugin. The CE algorithm is a fast and accurate protein structure alignment algorithm, pioneered by Drs. Shindyalov and Bourne (See
References). There are a few changes from the original CE publication (See Notes).

The source code is implemented in C with the rotations finally done by Numpy in Python. Because the computationally complex portion of the code is written in C, it's quick. That is, on my machines --- relatively fast 64-bit machines --- I can align two 400+ amino acid structures in about 0.300 s with the C++ implementation.

This plugs into PyMol very easily. See [[Cealign#The_Code|the code]] and [[Cealign#Examples|examples]] for installation and usage.

== Comparison to PyMol ==
'''Why should you use this?'''

PyMOL's structure alignment algorithm is fast and robust. However, its first step is to perform a sequence alignment of the two selections. Thus, proteins in the '''twilight zone''' or those having a low sequence identity, may not align well. Because CE is a structure-based alignment, this is not a problem. Consider the following example. The image at LEFT was the result of CE-aligning two proteins (1C0M chain B to 1BCO). The result is '''152''' aligned (alpha carbons) residues (not atoms) at '''4.96 Angstroms'''. The image on the RIGHT shows the results from PyMol's align command: an alignment of '''221 atoms''' (not residues) at an RMSD of '''15.7 Angstroms'''.

<gallery>
Image:cealign_ex1.png|Cealign's results (152 aligned; 4.96 Ang.)
Image:pymol_align.png|PyMol's results (763 atoms; 18.4 Ang. )
</gallery>

=== Fit vs. optAlign ===
====Take Home messages====
* [[fit]] and [[optAlign]] perform nearly equally as well
* if you need an algorithm with an appropriate reference, use [[optAlign]] (references at bottom of page).
* [[fit]] is faster -- if you're aligning many structures, use it over [[optAlign]]

====Discussion====
[[optAlign]] is a function within the [[Cealign]] package that performs the optimal superposition of two objects of equal length. [[optAlign]] follows the Kabsch algorithm which is a closed form, and provably optimal solution to the problem. [[fit]] on the other hand uses the Jacobi rotations to iteratively arrive at the solution of optimal superposition. The difference in error between [[optAilgn]] and [[fit]] seems to be a non-issue (see below) as they both arrive at equivalent solutions for the rotation matrix. The two algorithms are undertake different approaches to orthogonally diagonalizing the correlation matrix.

PyMOL's [[fit]] is fast and works well. If you have to use something with a known reference then check out the "optAlign" function from the qkabsch.py file that comes with this [[Calign]] package. If not, you can just use [[fit]] and avoid installing new software. :-)

optAlign is slower than fit. I just tested both on a sample NMR ensemble; and, while not an extensive validation of "fit" it shows that (1) fit is faster; and (2) fit gets the same exact RMSD as "optAlign" (when optAlign is told to use all atoms, not just CA). To make optAlign use all atoms and not just the alpha-carbon backbones, comment out (that is, put a "#" at the start of lines 183 and 184 in qkabsch.py, where it says "CUT HERE").

<source lang="python">
fetch 1nmr
split_states 1nmr
delete 1nmr

# compare fit and optAlign RMSDs
for x in cmd.get_names(): print cmd.fit("1nmr_0001", x)
for x in cmd.get_names(): optAlign(x, "1nmr_0001")
</source>
<source lang="bash">
# results from fit
0.0
4.50344991684
5.33588504791
5.78613853455
7.25597000122
6.67145586014
3.25131297112
3.36766290665
6.74802017212
5.1579709053
5.96959495544
6.68093347549
4.13217163086
5.51539039612
6.24266338348
6.03838825226
5.01363992691
5.33336305618
6.87617444992
7.797062397

#results from optAlign
RMSD=0.000000
RMSD=4.503450
RMSD=5.335886
RMSD=5.786138
RMSD=7.255970
RMSD=6.671456
RMSD=3.251313
RMSD=3.367663
RMSD=6.748021
RMSD=5.157971
RMSD=5.969595
RMSD=6.680934
RMSD=4.132172
RMSD=5.515390
RMSD=6.242664
RMSD=6.038388
RMSD=5.013640
RMSD=5.333363
RMSD=6.876174
RMSD=7.797062
</source>

== Examples ==
=== Usage ===
==== Syntax ====

CEAlign has the semantic, and syntactic formalism of
<source lang="python">
cealign MASTER, TARGET
</source>
where a post-condition of the algorithm is that the coordinates of the '''MASTER''' protein are unchanged. This allows for easier multi-protein alignments. For example,
<source lang="python">
cealign 1AUE, 1BZ4
cealign 1AUE, 1B68
cealign 1AUE, 1A7V
cealign 1AUE, 1CPR
</source>
will superimpose all the TARGETS onto the MASTER.

=====Examples=====
<source lang="python">
cealign 1cll and i. 42-55, 1ggz and c. A
cealign 1kao, 1ctq
cealign 1fao, 1eaz
</source>

=====Multiple Structure Alignments=====
Use the '''alignto''' command, now provided with cealign. Just type,
<source lang="python">
alignto PROT
</source>
to align all your proteins in PyMOL to the one called, '''PROT'''.

=== Results ===
See '''Changes''' for updates. But, overall, the results here are great.

<gallery>
Image:v7_1fao_1eaz.png|EASY: 1FAO vs. 1EAZ; 96 residues, 1.28 Ang
Image:v7_1cbs_1hmt.png|EASY: 1CBS vs. 1HMT; 128 residues, 2.01 Ang
Image:v7_1a15_1b50.png|MODERATE: 1A15 vs 1B50; 56 residues, 2.54 Ang.
Image:v7_1oan_1s6n.png|EASY: 1OAN vs. 1S6N (state 1); 96 residues aligned to 3.83 Ang. RMSD.
Image:v7_1rlw_1byn.png|HARD: 1RLW to 1BYN; 104 residues; 2.21 Ang.
Image:v7_1ten_3hhr.png|HARD: 1TEN vs. 3HHR; 80 residues, 2.91 Ang.
Image:v7_2sim_1nsb.png|HARD: 2SIM vs. 1NSB; 272 residues, 4.93 Ang.
Image:v7_1cew_1mol.png|HARD: 1CEW vs. 1MOL; 80 residues, 4.03 Ang.
</gallery>

== Installation ==

===Mac OS X (10.5)===
[[Image:Cealign mac os x.png|300px|thumb|center|CEAlign running on Mac OS X (10.5)]]
* Install PyMOL under fink.
* Install Numpy for fink:
<source lang="bash">
/sw/bin/fink install scipy-core-py25
</source>
* Download and install cealign (download instructions below)
<source lang="bash">
sudo /sw/bin/python setup.py install
</source>
* In PyMOL, run the two scripts needed for cealing: "cealign.py" and "qkabsch.py". These are located in the cealign directory you previously downloaded.
* Voila!
* Note that the above python version must match the same version that is used by PyMOL. If you are using the pre-compiled version of MacPyMOL, the above instructions won't work.

===Windows systems===
This is a quick and dirty method to get it working on Win32 right now, more details coming soon.
====Requirements====
* Latest PyMol, installed on your system
* Numpy for python 2.4 -- quick download of just what's needed: http://users.umassmed.edu/Shivender.Shandilya/pymol/numpy.zip
* Pre-compiled ccealign.pyd python module: http://users.umassmed.edu/Shivender.Shandilya/pymol/ccealign.zip
* Modified pymolrc: http://users.umassmed.edu/Shivender.Shandilya/pymol/pymolrc
* cealign.py and qkabsch.py from the Cealign-0.8-RBS package: download below

====Directions====
# Unzip the numpy.zip file, which will give you a folder named '''numpy'''
# Move this entire folder to: C:\Program Files\DeLano Scientific\PyMOL\modules\ (or the corresponding location on your system)
# Unzip ccealign.zip, which will give you a file called '''ccealign.pyd'''
# Move this pyd file to: C:\Program Files\DeLano Scientific\PyMOL\py24\DLLs\ (or the corresponding location on your system)
# Copy the downloaded '''pymolrc''' file to: C:\Program Files\DeLano Scientific\PyMOL\ (or the corresponding location on your system)
# Extract and copy the files cealign.py and qkabsch.py from the Cealign-0.8-RBS package to: C:\Program Files\DeLano Scientific\PyMOL\py24\Lib\ (or the corresponding location on your system)
# Run PyMol and load some molecules
# Run this command in Pymol: '''cealign molecule1, molecule2'''
# Enjoy!

===Gentoo Linux===
Add the science overlay via
layman -a sci
and emerge the cealign plugin
emerge pymol-plugins-cealign

===*nix systems===
====Requirements====
* C compiler
* Python 2.4+ with distutils
* Numpy
** for User-compiled PyMOL: <source lang="python">python setup.py install</source>
** for the precompiled version of PyMOL <source lang="python">python setup.py install --prefix "" --root /DIR_TO/pymol/ext/</source>

====Directions====
# uncompress the distribution file '''cealign-VERSION.tgz'''
# cd cealign-VERSION
# sudo python setup.py install # if you installed by PyMOL by hand
## python setup.py install --prefix "" --root /DIR/TO/pymol/ext/ # if you are using the precompiled binary download
# insert "run DIR_TO_CEALIGN/cealign.py" and "run DIR_TO_CEALIGN/qkabsch.py" into your '''.pymolrc''' file, or just run the two Python scripts by hand.
# load some molecules
# run, '''cealign molecule1, molecule2'''
# enjoy

=====Pre-compiled Hackish Install=====
For those people that prefer to use the pre-compiled version of PyMOL, here are the basics for your install. '''This is a poor method of installing Cealign. I suggest users compile and install their own PyMOL.''' The final goal is to get
# '''ccealign.so''' module into '''PYMOL/ext/lib/python2.4/site-packages'''
# numpy installed (get the numpy directory into (or linked into) '''PYMOL/ext/lib/python2.4/site-packages'''
# and be able to run cealign.py and qkabsch.py from PyMOL.
If you can do the above three steps, '''cealign''' should run from the pre-compiled PyMOL.

In more detail, on a completely fictitious machine --- that is, I created the following commands from a fake machine and I don't expect a copy/paste of this to work '''anywhere''', but the commands should be helpful enough to those who need it:
<source lang="python">
# NOTES:
# This is fake code: don't copy/paste it.
#
# PYMOL='dir to precompiled PyMOL install'
# CEALIGN='dir where you will unpack cealign'
# replace lib with lib64 for x86-64
# install numpy
apt-get install numpy

# link numpy to PyMOL
ln -s /usr/local/lib/python2.4/site-packages/numpy PYMOL/ext/lib/python2.4/site-packages

# download and install Cealign
wget http://www.pymolwiki.org/images/e/ed/Cealign-0.6.tar.bz2
tar -jxvf Cealign-0.6.tar.bz2
cd cealign-0.6
sudo python setup.py build
cp build/lib-XYZ-linux/ccealign.so PYMOL/ext/lib/python2.4/site-packages

# run pymol and try it out
pymol
run CEALIGN/cealign.py
run CEALIGN/qkabsch.py
fetch 1cew 1mol, async=0
cealign 1c, 1m
</source>

== The Code ==
Please unpack and read the documentation. All comments/questions should be directed to Jason Vertrees (javertre _at_ utmb ...dot... edu).

'''LATEST IS v0.8-RBS'''. (Dedicated to Bryan Sutton for allowing me to use his computer for testing.)

=== Version 0.8-RBS ===
* '''Download: [[Media:Cealign-0.8-RBS.tar.bz2|CE Align v0.8-RBS]] (bz2)'''
* '''Download: [[Media:Cealign-0.8-RBS.zip|CE Align v0.8-RBS]] (zip)'''

=== Beta Version 0.9 ===
Use at your own peril. Please report any problems or inconsistent alignments to this discussion page, or to me directly; my email address all over this page.

'''Improvements/Changes''':
* All C++
** So, faster
** comes with the dependencies built in
* No numpy

''' Download: [[Media:Cealign-0.9.zip|CE Align v0.9]] (zip)'''

== Coming Soon ==
* Windows binary
* Linux Binaries (32bit, x86-64)
* Better instructions for precompiled distributions
* Optimization

== Updates ==

=== 2008-03-25 ===
Pure C++ code released. See the beta version above.

=== 2007-04-14 ===
v0.8-RBS source updated. Found the bug that had been plaguing 32-bit machines. This should be the last release for a little while.

Also, I provide the option of aligning based solely upon RMSD or upon the better CE-Score. See the '''References''' for information on the '''CE Score'''.

== Troubleshooting ==

Post your problems/solutions here.

=== Unicode Issues in Python/Numpy ===
'''Problem''': Running/Installing cealign gives
<source lang="python">
Traceback (most recent call last):
File "/home/byron/software/pymol_1.00b17/pymol/modules/pymol/parser.py",
line 308, in parse
File "/home/byron/software/pymol_1.00b17/pymol/modules/pymol/parsing.py",
line 410, in run_file
File "qkabsch.py", line 86, in ?
import numpy
File "/usr/lib/python2.4/site-packages/numpy/__init__.py", line 36, in ?
import core
File "/usr/lib/python2.4/site-packages/numpy/core/__init__.py", line 5, in ?
import multiarray
ImportError: /home/byron/software/pymol/ext/lib/python2.4/site-packages/numpy/core/multiarray.so:
undefined symbol: _PyUnicodeUCS4_IsWhitespace
</source>
where the important line is
<source lang="python">
undefined symbol: _PyUnicodeUCS4_IsWhitespace
</source>

This problem indicates that your Numpy Unicode is using a different byte-size for unicode characters than is the Python distribution your PyMOL is running from. For example, this can happen if you use the pre-built PyMOL and some other pre-built Numpy package.

'''Solution''': Hand-install Numpy.

=== LinAlg Module Not Found ===
'''Problem''': Running CE Align gives the following error message:
<source lang="python">
run qkabsch.py
Traceback (most recent call last):
File "/usr/lib/python2.4/site-packages/pymol/parser.py", line 285, in parse
parsing.run_file(exp_path(args[nest][0]),pymol_names,pymol_names)
File "/usr/lib/python2.4/site-packages/pymol/parsing.py", line 407, in run_file
execfile(file,global_ns,local_ns)
File "qkabsch.py", line 86, in ?
import numpy
File "/usr/lib/python2.4/site-packages/numpy/__init__.py", line 40, in ?
import linalg
ImportError: No module named linalg
</source>

'''Solution''': You do not have the linear algebra module installed (or Python can't find it) on your machine. One workaround is to install [http://www.scipy.org/ Scientific Python]. (on debian/ubuntu this can be done by: sudo apt-get install python-scipy) Another is to reinstall the Numpy package from source, ensuring that you have the necessary requirements for the linear algebra module (linpack, lapack, fft, etc.).

=== CCEAlign & NumPy Modules Not Found ===
'''Problem''': Running CE Align gives the following error message:
<source lang="python">
PyMOL>run cealign.py
Traceback (most recent call last):
File "/home/local/warren/MacPyMOL060530/build/Deployment/MacPyMOL.app/pymol/modules/pymol/parser.py", line 297, in parse
File "/home/local/warren/MacPyMOL060530/build/Deployment/MacPyMOL.app/pymol/modules/pymol/parsing.py", line 408, in run_file
File "/usr/local/pymol/scripts/cealign-0.1/cealign.py", line 59, in ?
from ccealign import ccealign
ImportError: No module named ccealign
run qkabsch.py
Traceback (most recent call last):
File "/home/local/warren/MacPyMOL060530/build/Deployment/MacPyMOL.app/pymol/modules/pymol/parser.py", line 297, in parse
File "/home/local/warren/MacPyMOL060530/build/Deployment/MacPyMOL.app/pymol/modules/pymol/parsing.py", line 408, in run_file
File "qkabsch.py", line 86, in ?
import numpy
ImportError: No module named numpy
</source>

'''Solution''': This problem occurs under [http://www.apple.com/macosx Apple Mac OS X] if (a) the Apple's python executable on your machine (/usr/bin/python, currently version 2.3.5) is superseded by [http://fink.sourceforge.net/ Fink]'s python executable (/sw/bin/python, currently version 2.5) and (b) you are using [http://delsci.com/rel/099/#MacOSX precompiled versions of PyMOL] (MacPyMOL, PyMOLX11Hybrid or PyMOL for Mac OS X/X11). These executables ignore Fink's python and instead use Apple's - so, in order to run CE Align, one must install NumPy (as well as CE Align itself) using Apple's python. To do so, first download the [http://sourceforge.net/project/showfiles.php?group_id=1369&package_id=175103 Numpy source code archive] (currently version 1.0.1), unpack it, change directory to numpy-1.0.1 and specify the full path to Apple's python executable during installation: <tt>sudo /usr/bin/python setup.py install | tee install.log</tt>. Then, donwload the [http://www.pymolwiki.org/index.php/Cealign#The_Code CE Align source code archive] (currently version 0.2), unpack it, change directory to cealign-0.2 and finally install CE Align as follows: <tt>sudo /usr/bin/python setup.py install | tee install.log</tt>.
[[User:Lucajovine|Luca Jovine]] 05:11, 25 January 2007 (CST).

=== The Function SimpAlign() is not found ===
'''Problem''': Running CE Align gives the following error message:
<source lang="python">
PyMOL>cealign 1CLL,1GGZ
Traceback (most recent call last):
File "C:\Program Files (x86)\DeLano Scientific\PyMOL/modules\pymol\parser.py", line 203, in parse
result=apply(kw[nest][0],args[nest],kw_args[nest])
File "py24/Lib/cealign.py", line 177, in cealign
curScore = simpAlign( matA, matB, mol1, mol2, stored.mol1, stored.mol2, align=0, L=len(matA) )
NameError: global name 'simpAlign' is not defined
</source>
I am running PyMOL v. 0.99rc6 on Win XP Professional x64 edition version 2003 sp2 and have followed the windows install procedure as described above.

'''Answer''': This simply means that PyMOL couldn't find the simplAlign function. To let PyMOL know about this, you must run the following commands before running [[cealign]]:
<source lang="python">
run /your/path/to/cealign/qkabsch.py
run /your/path/to/cealign/cealign.py
</source>
but most people that use cealign would just put these two lines in their '''.pymolrc''' file.

=== Short Alignments Don't Work ===
If you are trying to align fewer than 16 residues then use [[align]], [[super]], or [[optAlign]]. CE uses a window size of 8; and to build a path of more than one window, you need 2*8=16 residues. I will insert some code to re-route small alignments to one of the aforementioned alignment algorithms.

=== It Worked A Second Ago! ===
[[Image:Rewind.png|thumb|right|Showing the rewind button to rewind to state 1.]]

If you were using cealign (or alignto) and now the commands don't work -- that is, they return an RMSD, but don't actually superimpose the objects, then you have a simple problem dealing with states. Most likely the cause of this oddness was (1) when you issued "cealign prot1, prot2" one of them was actually an ensemble of states or (2) you are trying to align to proteins with only one state, but are not looking at state one (because the last protein you were considering had more than one state and you quit editing that protein on a state that's not state 1). To fix this, use the rewind button to get the proteins back into state 1 & reissue the cealign/alignto command.

== References ==
Text taken from PubMed and formatted for the wiki. The first reference is the most important for this code.

# Shindyalov IN, Bourne PE. '''Protein structure alignment by incremental combinatorial extension (CE) of the optimal path.''' ''Protein Eng.'' 1998 Sep;11(9):739-47. PMID: 9796821 [PubMed - indexed for MEDLINE]
# Jia Y, Dewey TG, Shindyalov IN, Bourne PE. '''A new scoring function and associated statistical significance for structure alignment by CE.''' ''J Comput Biol.'' 2004;11(5):787-99. PMID: 15700402 [PubMed - indexed for MEDLINE]
# Pekurovsky D, Shindyalov IN, Bourne PE. '''A case study of high-throughput biological data processing on parallel platforms.''' ''Bioinformatics.'' 2004 Aug 12;20(12):1940-7. Epub 2004 Mar 25. PMID: 15044237 [PubMed - indexed for MEDLINE]
# Shindyalov IN, Bourne PE. '''An alternative view of protein fold space.''' ''Proteins.'' 2000 Feb 15;38(3):247-60. PMID: 10713986 [PubMed - indexed for MEDLINE]

== License ==
The CEAlign and all its subprograms that I wrote, are released under the open source Free BSD License (BSDL).

[[Category:Script_Library]]
[[Category:Structure_Alignment|Cealign]]

Cealign

2009-05-01T11:59:00Z

Jlec:

Category talk:Script Library

2009-05-01T10:10:03Z

Jlec:

== GitHub for Pymol-scripts==
I created a github for the pymol scripts. I think this is a good way to to collect and enlarge the collection of scripts. The repo is public accessible so contribute. If you need help on git just write me an email.

http://github.com/jlec/Pymol-script-repo

About the rasmolify script, there's a project to translate between the languages [http://arcib.dowling.edu/sbevsl/].
It's in pre-alpha, apparently, but this kind of language translation seems like a tricky problem. It's on my list of things to do...--[[User:Gilleain|Gilleain]] 19:27, 18 February 2008 (CST)

: To be honest I was thinking of a quick hack rather than anything fancy. Thanks very much for the pointer though! --[[User:Dan|Dan]] 02:45, 19 February 2008 (CST)

== Depositing Scripts ==
* Create a new page for your script
* Please provide
** an overview of what the script does
** any usage comments or hints
** the source code
* Please add the following to the bottom of your new page:<br><nowiki>[[Category:Script_Library]]
[[Category:PUT_SUBCATEGORY_NAME_HERE]]</nowiki>

== Feedback on Changes ==

Please let me know if you like the new changes.