Cealign plugin: Difference between revisions

From PyMOLWiki
Jump to navigation Jump to search
m (moved Cealign to Cealign plugin: cealign is built into PyMOL since 1.3)
 
(79 intermediate revisions by 9 users not shown)
Line 1: Line 1:
'''Go directly to [[Cealign#Version_0.8-RBS|DOWNLOAD]]'''
Note: CEAlign is now built into PyMOL as a native command.  See the open-source project page.
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). 
== Introduction ==
== Introduction ==
This script is a Python implementation of the CE algorithm pioneered by Drs. Shindyalov and Bourne (See References).  It is a fast, accurate structure-based protein alignment algorithm.  There are a few changes from the original code (See Notes), and "fast" depends on your machine and the implementation.  That is, on my machine --- a relatively fast 64-bit machine --- I can align two 400+ amino acid structures in about 0.300 s with the C++ implementation.  In Python however, two 165 amino acid proteins took about 35 seconds!
There are a few changes from the original CE publication (See Notes).  The source code is implemented in C (and another in C++) with the rotations finally done by Numpy in Python (or C++ in version 0.9).  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.
 
When coupled to the Kabsch algorithm, this should be able to align any two protein structures, using just the alpha carbon coordinates.


This plugs into PyMol very easily.  See [[Cealign#The_Code|the code]] and [[Cealign#Examples|examples]] for installation and usage.
This plugs into PyMol very easily.  See [[Cealign#The_Code|the code]] and [[Cealign#Examples|examples]] for installation and usage.
Line 9: Line 14:
'''Why should you use this?'''
'''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.  Look at the following example.  The image at LEFT was the result of CE-aligning two proteins (1C0M to 1BCO). The result is '''88''' aligned (alpha carbons) residues (not atoms) at '''2.78 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'''.  To make the alignment easier to see, cealign (actually the [[Kabsch]] code) colors the aligned residues differently.
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 two images below demonstrate the difference superimposing [http://www.rcsb.org/pdb/explore/explore.do?structureId=1C0m 1C0M] chain B onto [http://www.rcsb.org/pdb/explore/explore.do?structureId=1BCO 1BCO]. The first image below shows the results from PyMol's `align` command: an alignment of '''221 atoms''' (not residues) to an RMSD of '''15.7 Angstroms'''.  The second image is the result of CEAlign, which used alpha carbons of '''152 residues''' with an RMSD of '''4.96 Angstroms'''.


<gallery>
<gallery>
Image:Ce_works.png|Cealign's results
Image:pymol_align.png|PyMol's results (221 atoms; 15.7 Ang. )
Image:Pymol_align.png|PyMol's results
Image:cealign_ex1.png|Cealign's results (152 aligned; 4.96 Ang.)
</gallery>
</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 [[Cealign]] 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 ==
== Examples ==
Line 23: Line 95:
CEAlign has the semantic, and syntactic formalism of
CEAlign has the semantic, and syntactic formalism of
<source lang="python">
<source lang="python">
cealign MASTER, TARGET
cealign MASTER, TARGET
</source>
</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,
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">
<source lang="python">
cealign 1AUE, 1BZ4
cealign 1AUE, 1BZ4
cealign 1AUE, 1B68
cealign 1AUE, 1B68
cealign 1AUE, 1A7V
cealign 1AUE, 1A7V
cealign 1AUE, 1CPR
cealign 1AUE, 1CPR
</source>
</source>
will superimpose all the TARGETS onto the MASTER.
will superimpose all the TARGETS onto the MASTER.
Line 42: Line 114:


=====Multiple Structure Alignments=====
=====Multiple Structure Alignments=====
To use '''cealign''' to do a multiple structure alignment, simple load all your proteins and execute the following command:
Use the '''alignto''' command, now provided with cealign.  Just type,
<source lang="python">
<source lang="python">
for x in cmd.get_names("*"): cealign("MASTER", x)
alignto PROT
</source>
where '''MASTER''' is the protein to align all others to.
For example, load the following proteins: 1A15, 1EOT, 1ESR, 1F9R, 1G2S, 1NR4, 1QE6.  Now, execute the command,
<source lang="python">
for x in cmd.get_names("*"): cealign("1A15", x)
</source>
</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.
* Note: PyMOL v1.5.0.4 (svn revision 4001) has updates that improve some alignments slightly. These improved results are shown here.


<gallery>
<gallery>
Image:unali.png|Proteins Unaligned, just loaded into PyMOL.
Image:v7_1fao_1eaz.png|EASY: 1FAO vs. 1EAZ; 96 residues, 1.09 Ang
Image:ali_all.png|All proteins aligned to 1A15
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 2.66 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.96 Ang.
Image:v7_2sim_1nsb.png|HARD: 2SIM vs. 1NSB; 272 residues, 4.92 Ang.
Image:v7_1cew_1mol.png|HARD: 1CEW vs. 1MOL; 80 residues, 3.67 Ang.
</gallery>
</gallery>


Paste the following code into the end of the '''cealign.py''' file that comes in the distribution.  This function will define the '''alignto''' command in PyMOL.  The function will align every object in PyMOL to the specified object.
== Installation ==
<source lang="python">
def alignto(sel1):
        """Just a quick & dirty multiple structure alignment"""
        for x in cmd.get_names("*"): cealign( sel1, x )


## Let PyMOL know about the alignto command
===Mac OS X (10.5, 10.6)===
cmd.extend("alignto", alignto)
[[Image:Cealign mac os x.png|300px|thumb|center|CEAlign running on Mac OS X (10.5)]]
</source>
* Install PyMOL under fink.
Once the code is in place, and PyMOL (or the cealign.py script) is reloaded, you can now execute,
* Download and install cealign (download instructions below)
<source lang="python">
<source lang="bash">
alignto X
sudo /sw/bin/python setup.py install
</source>
</source>
will align all objects in PyMOL to protein '''X'''.
* In PyMOL, run the two scripts needed for cealign: "cealign.py" and "qkabsch.py". These are located in the cealign directory you previously downloaded.
For example,
* Voila!
<source lang="python">
* 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.
# for showing pretty representation
* Note: if you get an error about '''-Wno-long-double''' then your gcc is mismatched.  I fixed this by pointing the symbolic link ''/usr/bin/gcc'' from ''/usr/bin/gcc-4.2'' to ''/usr/bin/gcc-4.0''. Or, in code,
import preset
<source lang="bash">
 
# These command are commented out to stop people from copy/pasting b/c
# get a bunch of similar structures and
# these are possibly dangerous for your system.  Ensure that /usr/bin/gcc
# load them all at once.
# is a symbolic link and not a real binary. If so, I used the following
fetch 1a2p 1bni 2f4y 2f56 2f5m 2f5w, async=0
# to fix the -Wno-long-double error.
 
# sudo rm /usr/bin/gcc
# poor-man's multiple structure alignment
# sudo ln -s /usr/bin/gcc-4.0 /usr/bin/gcc
alignto 1bni
 
# make them 'pretty'.
preset.pretty("*")
 
# center the results (since they may all have
# moved out of frame).
center
</source>
</source>


=== Results From v0.2 ===
===Windows systems===
Versions of CE Align, later than v0.2, should beat these alignments.
====CEAlign 0.9====
 
This is a Win32 build of CEAlign 0.9 [http://pymolwiki.org/index.php/Cealign#Beta_Version_0.9]
<gallery>
=====Requirements=====
Image:Cealign1.png|EASY: 1FAO vs. 1EAZ; 88 residues, 1.16 Ang
* Christoph Gohlke's latest '''unofficial''' PyMol build: http://www.lfd.uci.edu/~gohlke/#pythonlibs
Image:Cealign2.png|EASY: 1CBS vs. 1HMT; 120 residues, 2.07 Ang
* "Python 2.6.2 Windows installer" from python.org: http://www.python.org/download/
Image:Cealign3.png|MODERATE: 1A15 vs 1B50; 56 residues, 6.67 Ang.
* '''CEAlign09Win32.zip''' from: http://users.umassmed.edu/shivender.shandilya/pymol/CEAlign09Win32.zip
Image:Align.png|EASY: 1OAN vs. 1S6N; aligned to 2.26 Ang. RMSD.
=====Directions=====
Image:Cealign_ex_hard.png|HARD: 1RLW to 1BYN; 104 residues; 3.94 Ang.
# Download the '''CEAlign09Win32.zip''' file
Image:1ten_3hhr.png|HARD: 1TEN vs. 3HHR; 72 residues, 3.13 Ang.
# Unzip the downloaded file and follow the directions as per the included README.txt
Image:2SIM_1NSB.png|HARD: 2SIM vs. 1NSB; 280 residues, 5.00 Ang.
# Enjoy the ''awesomeness'' that is CEAlign!
Image:1CEW_1MOL.png|HARD: 1CEW vs. 1MOL; 72 residues, 3.63 Ang.
====CEAlign 0.8====
</gallery>
This is a quick and dirty method to use CEAlign 0.8 on Win32 system with the '''official''' Pymol builds...
=====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/cealign08/numpy.zip
[Note: If this file is corrupt, you may download the latest 'Numpy for Python 2.4' directly from SourceForge.net
* Pre-compiled ccealign.pyd python module: http://users.umassmed.edu/Shivender.Shandilya/pymol/cealign08/ccealign.zip
* Modified pymolrc: http://users.umassmed.edu/Shivender.Shandilya/pymol/cealign08/pymolrc
* cealign.py and qkabsch.py from the Cealign-0.8-RBS package: download below


== Installation ==
=====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!


'''note:''' Windows installer coming soon.
===Gentoo Linux===
Add the science overlay via
layman -a sci
and emerge the cealign plugin
emerge pymol-plugins-cealign


===Requirements===
===*nix systems===
# Numpy
====Requirements====
# Python 2.4+ with distutils
* C compiler
# 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===
====Directions====
# uncompress the distribution file '''cealign-VERSION.tgz'''
# uncompress the distribution file '''cealign-VERSION.tgz'''
# cd cealign-VERSION
# cd cealign-VERSION
# sudo python setup.py install
# 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.
# 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
# load some molecules
Line 123: Line 214:
# enjoy
# enjoy


== The Code ==
=====Pre-compiled Hackish Install=====
Please unpack and read the documentation.  All comments/questions should be directed to Jason Vertrees (javertre _at_ utmb ...dot... edu).
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.


'''LATEST IS v0.5'''.
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">
=== Version 0.5 ===
# NOTES:
* BZ2 File [[Media:Cealign-0.5.tar.bz2|CE Align v0.5]]
# This is fake code: don't copy/paste it.
* ZIP File [[Media:Cealign-0.5.zip|CE Align v0.5]]
#
 
# PYMOL='dir to precompiled PyMOL install'
=== Version 0.4 ===
# CEALIGN='dir where you will unpack cealign'
* BZ2 File [[Media:Cealign-0.4.tar.bz2|CE Align v0.4]]
# replace lib with lib64 for x86-64
* ZIP File [[Media:Cealign-0.4.zip|CE Align v0.4]]
# install numpy
 
apt-get install numpy
=== Version 0.3 ===
* BZ2 File [[Media:Cealign-0.3.tar.bz2|CE Align v0.3]]
* ZIP File [[Media:Cealign-0.3.zip|CE Align v0.3]]
 
=== Version 0.2 ===
* BZ2 File [[Media:Cealign-0.2.tar.bz2|CE Align v0.2]]
* ZIP File [[MEdia:Cealign-0.2.zip|CE Align v0.2]]
 
=== Version 0.1 ===
* BZ2 File [[Media:Cealign-0.1.tar.bz2|CE Align v0.1]]
* ZIP File [[Media:Cealign-0.1.zip|CE Align v0.1]]
 
== Updates ==


===2007-03-07===
# link numpy to PyMOL
This change was too small to make a whole new release.  I just added a small script to do multiple structure alignments.  Skip to the [[Cealign#Multiple_Structure_Alignments|Multiple Structure Alignment Section]] on this page.
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


===2007-02-20===
# run pymol and try it out
A HUGE thanks to '''Dan Kulp'''' for spotting the bug in the reflections!  I have fixed the code and repackaged it.
pymol
Briefly, I found bug in the way Numpy was returning values from its' det
run CEALIGN/cealign.py
function.  It was returning something that was not casting correctly to
run CEALIGN/qkabsch.py
Python's internal types.  For example, the determinant of an orthonormal
fetch 1cew 1mol, async=0
matrix must be +/- 1.0 -- and hence the product of two orthonormal
cealign 1c, 1m
matrices must also be +/- 1.0 -- but here were the test results from
Numpy:
<source lang="python">
        Reflect => -1.0
                Does reflect equal 1.0 => False
        Reflect => -1.0
                Does reflect equal -1.0 =>False
</source>
</source>
The second case is obviously wrong, and the program was never properly
detecting reflections.  The fix is:
<source lang="python">
        reflect = float(str(float(numpy.linalg.det(V) * numpy.linalg.det(Wt))))


        if reflect == -1.0:
== The Code ==
                S[-1] = -S[-1]
Please unpack and read the documentation.  All comments/questions should be directed to Jason Vertrees (javertre _at_ utmb ...dot... edu).
                V[:,-1] = -V[:,-1]
</source>
 
===2007-02-01===
Argh!  Found another stupid bug. The alignments are now longer and more accurate. v0.4 soon.


===2007-01-31===
'''LATEST IS v0.8-RBS'''.  (Dedicated to Bryan Sutton for allowing me to use his computer for testing.)
Found a small bug.  Will update code soon.


===2007-01-25===
=== Version 0.8-RBS ===
CE Align v0.2 released.
* '''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)'''


Found a "feature" I don't like; so, I fixed it. The new version of cealign has the formal syntax of
=== Beta Version 0.9 ===
<source lang="python">
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.
cealign MASTER, TARGET
</source>
and cealign is now guaranteed not to change the coordinates of the '''MASTER''' protein.  This is useful is you want to align 10 structures on top of one.  Before, cealign would center the two molecules; now it just overlaps the TARGET onto the MASTER.


===2007-01-17===
'''Improvements/Changes''':
CE Align V0.1 released.
* All C++
** So, faster
** comes with the dependencies built in
* No numpy


===2007-01-11===
''' Download: [[Media:Cealign-0.9.zip|CE Align v0.9]] (zip)'''
The first version of the C-module code is complete. I fixed handling (multiple) missing residues, the centering problem, and the problem of multiple chains.  I'll package and provide the code soon.


===2007-01-10===
== Coming Soon ==
Trying to remedy missing residues.  If a user's selections are '''protA and i. 10-20''' and '''prot2 and i. 10-20''', and if prot2 is missing residue 14, the SVD is undefined/inappropriate.  I have to weed out residues that don't have partners in the PDB file.  Alignments do this implicitly since the XYZ values it sees are only the ones with coordinates.  Also, CE only works on individual chains.  If someone can find a consistent method to map residues and chains to ints and then back to residues and chains -- that might work.  Ha! 
* Windows binary
* Linux Binaries (32bit, x86-64)
* Better instructions for precompiled distributions
* Optimization


If more than a week lapses after this comment, I'll just wrap up the code and post the first version.  There seems to be some interest in this plugin, so the more eyes the easier it may be to fix the bugs.  I will also need testers for the Mac and Windows editions.
== Updates ==


=== 2007-01-08===
=== 2008-03-25 ===
'''Yeah!'''
Pure C++ code released.  See the beta version above.
The C code that plugs into PyMol has been completed.  It's a little slower than the plain C++ code I wrote, but that's what you get when passing data from PyMol to Python to C, fiddle with it,  pass it back to Python to PyMol for some more quick math.  The alignment times for the two proteins mentioned below (1B50 and 1C0M) on my machine with the new C module is about 1-3 second (with a full CPU load for other intensive tasks running in the background; this shows great improvement over the pure Python alignment times).  Once the code is cleaned up (and I'm not too embarrassed to post it) and some bugs are worked out, I'll post it. The current bugs are:
# Some alignments don't center right
# Missing residues cause problems
# Memory leaks galore, I'm sure


The code consists of:
=== 2007-04-14 ===
* qkabsch.py
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.
* cealign.py
* ccealignmodule.c
* ccealignmodule.h
* setup.py


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'''.
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'''.
Line 271: Line 337:




'''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]. 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.).
'''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 ===
=== CCEAlign & NumPy Modules Not Found ===
Line 296: Line 362:
'''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>.
'''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).
[[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.
=== file is not of required architecture ===
This error happens on a Mac when you compile one bit of code with gcc-4.0/g++-4.0 and then try to make a library with code compiled from gcc-4.2/g++-4.2.  If you recent installed Snow Leopard (Mac OS X 10.6) then this might bother you when you try to install Cealign or even PyMOL.  To get around this, ensure that you're building all components with the same gcc/g++ executable.  Here's how I did it,
<source lang="bash">
# sudo rm /usr/bin/gcc /usr/bin/g++
# sudo ln -s /usr/bin/gcc-4.0 /usr/bin/gcc
# sudo ln -s /usr/bin/g++-4.0 /usr/bin/g++
</source>
I commented out those lines to stop people from blindly copy/pasting possible harmful lines.  Please ensure that your /usr/bin/gcc and /usr/bin/g++ are actually symbolic links, otherwise you could be doing bad things to your computer.  In my case, I only relinked gcc and not g++, hence the error.


== References ==
== References ==
Line 307: Line 411:
== License ==
== License ==
The CEAlign and all its subprograms that I wrote, are released under the open source Free BSD License (BSDL).
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]]

Latest revision as of 16:19, 29 September 2014

Go directly to DOWNLOAD

Note: CEAlign is now built into PyMOL as a native command. See the open-source project page.

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).

Introduction

There are a few changes from the original CE publication (See Notes). The source code is implemented in C (and another in C++) with the rotations finally done by Numpy in Python (or C++ in version 0.9). 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 the code and 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 two images below demonstrate the difference superimposing 1C0M chain B onto 1BCO. The first image below shows the results from PyMol's `align` command: an alignment of 221 atoms (not residues) to an RMSD of 15.7 Angstroms. The second image is the result of CEAlign, which used alpha carbons of 152 residues with an RMSD of 4.96 Angstroms.

  • PyMol's results (221 atoms; 15.7 Ang. )

    PyMol's results (221 atoms; 15.7 Ang. )

  • Cealign's results (152 aligned; 4.96 Ang.)

    Cealign's results (152 aligned; 4.96 Ang.)

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 Cealign 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." 

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")

# 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

Examples

Usage

Syntax

CEAlign has the semantic, and syntactic formalism of 

cealign MASTER, TARGET

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, 

cealign 1AUE, 1BZ4
cealign 1AUE, 1B68
cealign 1AUE, 1A7V
cealign 1AUE, 1CPR

will superimpose all the TARGETS onto the MASTER.

Examples
cealign 1cll and i. 42-55, 1ggz and c. A
cealign 1kao, 1ctq
cealign 1fao, 1eaz
Multiple Structure Alignments

Use the alignto command, now provided with cealign. Just type, 

alignto PROT

to align all your proteins in PyMOL to the one called, PROT.

Results

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

  • Note: PyMOL v1.5.0.4 (svn revision 4001) has updates that improve some alignments slightly. These improved results are shown here.
  • EASY: 1FAO vs. 1EAZ; 96 residues, 1.09 Ang

    EASY: 1FAO vs. 1EAZ; 96 residues, 1.09 Ang

  • EASY: 1CBS vs. 1HMT; 128 residues, 2.01 Ang

    EASY: 1CBS vs. 1HMT; 128 residues, 2.01 Ang

  • MODERATE: 1A15 vs 1B50; 56 residues, 2.54 Ang.

    MODERATE: 1A15 vs 1B50; 56 residues, 2.54 Ang.

  • EASY: 1OAN vs. 1S6N (state 1); 96 residues aligned to 2.66 Ang. RMSD.

    EASY: 1OAN vs. 1S6N (state 1); 96 residues aligned to 2.66 Ang. RMSD.

  • HARD: 1RLW to 1BYN; 104 residues; 2.21 Ang.

    HARD: 1RLW to 1BYN; 104 residues; 2.21 Ang.

  • HARD: 1TEN vs. 3HHR; 80 residues, 2.96 Ang.

    HARD: 1TEN vs. 3HHR; 80 residues, 2.96 Ang.

  • HARD: 2SIM vs. 1NSB; 272 residues, 4.92 Ang.

    HARD: 2SIM vs. 1NSB; 272 residues, 4.92 Ang.

  • HARD: 1CEW vs. 1MOL; 80 residues, 3.67 Ang.

    HARD: 1CEW vs. 1MOL; 80 residues, 3.67 Ang.

Installation

Mac OS X (10.5, 10.6)

CEAlign running on Mac OS X (10.5)
  • Install PyMOL under fink.
  • Download and install cealign (download instructions below)
sudo /sw/bin/python setup.py install
  • In PyMOL, run the two scripts needed for cealign: "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.
  • Note: if you get an error about -Wno-long-double then your gcc is mismatched. I fixed this by pointing the symbolic link /usr/bin/gcc from /usr/bin/gcc-4.2 to /usr/bin/gcc-4.0. Or, in code,
# These command are commented out to stop people from copy/pasting b/c 
# these are possibly dangerous for your system.  Ensure that /usr/bin/gcc
# is a symbolic link and not a real binary.  If so, I used the following
# to fix the -Wno-long-double error.
# sudo rm /usr/bin/gcc
# sudo ln -s /usr/bin/gcc-4.0 /usr/bin/gcc

Windows systems

CEAlign 0.9

This is a Win32 build of CEAlign 0.9 [1]

Requirements
Directions
  1. Download the CEAlign09Win32.zip file
  2. Unzip the downloaded file and follow the directions as per the included README.txt
  3. Enjoy the awesomeness that is CEAlign!

CEAlign 0.8

This is a quick and dirty method to use CEAlign 0.8 on Win32 system with the official Pymol builds...

Requirements

[Note: If this file is corrupt, you may download the latest 'Numpy for Python 2.4' directly from SourceForge.net

Directions
  1. Unzip the numpy.zip file, which will give you a folder named numpy
  2. Move this entire folder to: C:\Program Files\DeLano Scientific\PyMOL\modules\ (or the corresponding location on your system)
  3. Unzip ccealign.zip, which will give you a file called ccealign.pyd
  4. Move this pyd file to: C:\Program Files\DeLano Scientific\PyMOL\py24\DLLs\ (or the corresponding location on your system)
  5. Copy the downloaded pymolrc file to: C:\Program Files\DeLano Scientific\PyMOL\ (or the corresponding location on your system)
  6. 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)
  7. Run PyMol and load some molecules
  8. Run this command in Pymol: cealign molecule1, molecule2
  9. 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: 
      python setup.py install
    • for the precompiled version of PyMOL 
      python setup.py install --prefix "" --root /DIR_TO/pymol/ext/

Directions

  1. uncompress the distribution file cealign-VERSION.tgz
  2. cd cealign-VERSION
  3. sudo python setup.py install # if you installed by PyMOL by hand
    1. python setup.py install --prefix "" --root /DIR/TO/pymol/ext/ # if you are using the precompiled binary download
  4. 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.
  5. load some molecules
  6. run, cealign molecule1, molecule2
  7. 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

  1. ccealign.so module into PYMOL/ext/lib/python2.4/site-packages
  2. numpy installed (get the numpy directory into (or linked into) PYMOL/ext/lib/python2.4/site-packages
  3. 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: 

# 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

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

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

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

where the important line is 

undefined symbol: _PyUnicodeUCS4_IsWhitespace

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: 

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


Solution: You do not have the linear algebra module installed (or Python can't find it) on your machine. One workaround is to install 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: 

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


Solution: This problem occurs under 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 Fink's python executable (/sw/bin/python, currently version 2.5) and (b) you are using 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 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: sudo /usr/bin/python setup.py install | tee install.log. Then, donwload the CE Align source code archive (currently version 0.2), unpack it, change directory to cealign-0.2 and finally install CE Align as follows: sudo /usr/bin/python setup.py install | tee install.log. Luca Jovine 05:11, 25 January 2007 (CST).

The Function SimpAlign() is not found

Problem: Running CE Align gives the following error message: 

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

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: 

run /your/path/to/cealign/qkabsch.py
run /your/path/to/cealign/cealign.py

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!

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.

file is not of required architecture

This error happens on a Mac when you compile one bit of code with gcc-4.0/g++-4.0 and then try to make a library with code compiled from gcc-4.2/g++-4.2. If you recent installed Snow Leopard (Mac OS X 10.6) then this might bother you when you try to install Cealign or even PyMOL. To get around this, ensure that you're building all components with the same gcc/g++ executable. Here's how I did it, 

# sudo rm /usr/bin/gcc /usr/bin/g++
# sudo ln -s /usr/bin/gcc-4.0 /usr/bin/gcc
# sudo ln -s /usr/bin/g++-4.0 /usr/bin/g++

I commented out those lines to stop people from blindly copy/pasting possible harmful lines. Please ensure that your /usr/bin/gcc and /usr/bin/g++ are actually symbolic links, otherwise you could be doing bad things to your computer. In my case, I only relinked gcc and not g++, hence the error.

References

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

  1. 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]
  2. 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]
  3. 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]
  4. 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).

Retrieved from "https://pymolwiki.org/index.php?title=Cealign_plugin&oldid=11715"