PyMOL Wiki - User contributions [en]

Bg gradient

2012-07-07T15:42:59Z

Cowsandmilk:

Enable background gradients in the viewer window. (Ray trace in pymol 1.5+)

[[Image:bg_grad.png|350px|set bg_gradient]]

= Usage =
<source lang="python">
# enable

set bg_gradient
</source>

= See Also =
[[bg_rgb_top]], [[bg_rgb_bottom]]

Git install scripts

2011-12-19T13:30:55Z

Cowsandmilk:

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

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

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

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

Add '''python.exe''' to your '''PATH''', so external .py scripts can be executed. 
Open control panel. Search for, and click: '''Edit environment variables for your account''' 
Add to end of variable PATH: ''';C:\Python27''' (Or other path to your python python.exe) 
Click start button, and open '''cmd.exe'''. Try starting python by writing: '''python'''

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

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

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

The project also have automatically plugin installer: http://www.pymolwiki.org/index.php/plugindirectory 
This is activated with: '''import plugins'''. 
'''You have to remove old installations of plugins first, to get the automatic plugin installation to work.'''
=== For Windows users ===
# Open notepad
# Write (Remember double backslashes)
import sys,os
sys.path.append('C:\\Users\\YOURNAME\\Documents\\pymol\\Pymol-script-repo')
os.environ['PYMOL_GIT_MOD']='C:\\Users\\YOURNAME\\Documents\\pymol\\Pymol-script-repo\\modules'
import plugins
os.chdir('C:\\Users\\YOURNAME\\Documents\\pymol') # Your standard working dir
Save under: '''C:\Users\YOURNAME\pymolrc.pym''' (Set: "Save as type" to "All files")

=== For Linux users ===
gedit ~/.pymolrc
Write
import sys,os
sys.path.append('/home/YOU/Software/pymol/Pymol-script-repo')
os.environ['PYMOL_GIT_MOD']='/home/YOU/Software/pymol/Pymol-script-repo/modules'
import plugins
os.chdir('/home/YOU/Software/pymol/') # Your standard working dir
Save and exit

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

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

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

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

Git install scripts

2011-12-19T13:28:29Z

Cowsandmilk: /* For Linux users */

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

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

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

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

Add '''python.exe''' to your '''PATH''', so external .py scripts can be executed. 
Open control panel. Search for, and click: '''Edit environment variables for your account''' 
Add to end of variable PATH: ''';C:\Python27''' (Or other path to your python python.exe) 
Click start button, and open '''cmd.exe'''. Try starting python by writing: '''python'''

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

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

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

The project also have automatically plugin installer: http://www.pymolwiki.org/index.php/plugindirectory 
This is activated with: '''import plugins'''. 
'''You have to remove old installations of plugins first, to get the automatic plugin installation to work.'''
=== For windows users ===
# Open notepad
# Write (Remember double backslashes)
import sys,os
sys.path.append('C:\\Users\\YOURNAME\\Documents\\pymol\\Pymol-script-repo')
os.environ['PYMOL_GIT_MOD']='C:\\Users\\YOURNAME\\Documents\\pymol\\Pymol-script-repo\\modules'
import plugins
os.chdir('C:\\Users\\YOURNAME\\Documents\\pymol') # Your standard working dir
Save under: '''C:\Users\YOURNAME\pymolrc.pym''' (Set: "Save as type" to "All files")

=== For Ubuntu/Mint users ===
gedit ~/.pymolrc
Write
import sys,os
sys.path.append('/home/YOU/Software/pymol/Pymol-script-repo')
os.environ['PYMOL_GIT_MOD']='/home/YOU/Software/pymol/Pymol-script-repo/modules'
import plugins
os.chdir('/home/YOU/Software/pymol/') # Your standard working dir
Save and exit

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

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

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

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

Git install scripts

2011-12-19T13:27:39Z

Cowsandmilk: /* Git install instructions */

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

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

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

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

Add '''python.exe''' to your '''PATH''', so external .py scripts can be executed. 
Open control panel. Search for, and click: '''Edit environment variables for your account''' 
Add to end of variable PATH: ''';C:\Python27''' (Or other path to your python python.exe) 
Click start button, and open '''cmd.exe'''. Try starting python by writing: '''python'''

=== For Linux users ===
# Install git
<source lang="bash">
# Debian/Ubuntu/Mint
sudo apt-get install git
# Fedora
su -c 'yum install git'
# openSUSE
sudo zypper in git
</source>
# Navigate to desired folder:
<source lang="bash">
cd /home/YOURNAME/Software/pymol
git clone git://github.com/Pymol-Scripts/Pymol-script-repo.git
</source>
You now have all the scripts available in: /home/YOURNAME/Software/pymol/Pymol-script-repo

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

The project also have automatically plugin installer: http://www.pymolwiki.org/index.php/plugindirectory 
This is activated with: '''import plugins'''. 
'''You have to remove old installations of plugins first, to get the automatic plugin installation to work.'''
=== For windows users ===
# Open notepad
# Write (Remember double backslashes)
import sys,os
sys.path.append('C:\\Users\\YOURNAME\\Documents\\pymol\\Pymol-script-repo')
os.environ['PYMOL_GIT_MOD']='C:\\Users\\YOURNAME\\Documents\\pymol\\Pymol-script-repo\\modules'
import plugins
os.chdir('C:\\Users\\YOURNAME\\Documents\\pymol') # Your standard working dir
Save under: '''C:\Users\YOURNAME\pymolrc.pym''' (Set: "Save as type" to "All files")

=== For Ubuntu/Mint users ===
gedit ~/.pymolrc
Write
import sys,os
sys.path.append('/home/YOU/Software/pymol/Pymol-script-repo')
os.environ['PYMOL_GIT_MOD']='/home/YOU/Software/pymol/Pymol-script-repo/modules'
import plugins
os.chdir('/home/YOU/Software/pymol/') # Your standard working dir
Save and exit

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

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

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

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

Linux Install

2011-12-02T16:06:11Z

Cowsandmilk: /* Install from Source */

This page describes how to install open-source PyMOL on Linux.

== Install Distribution-specific binary Package ==

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:

<source lang="bash">
# Debian/Ubuntu
sudo apt-get install pymol

# Fedora
yum install pymol

# Gentoo
emerge -av pymol

# openSUSE (12.1 and later)
sudo zypper install 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

On many Linux systems, one of the following commands installs all requirements:

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

# Fedora
yum install subversion python-devel freeglut-devel freetype-devel tkinter python-pmw

# 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
sudo zypper install python-devel freeglut-devel gcc-c++ glew-devel libpng-devel python-pmw subversion
</source>

=== Get latest Source from SVN ===

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

<source lang="bash">
cd /tmp
svn co https://pymol.svn.sourceforge.net/svnroot/pymol/trunk/pymol 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

python setup.py build install \
--home=$prefix \
--install-purelib=$modules \
--install-platlib=$modules

export PYTHONPATH=$modules:$PYTHONPATH
python setup2.py install
install pymol $prefix/
</source>

Now launch PyMOL like this (you may copy this launcher into your '''$PATH''',
like to '''/usr/local/bin'''):

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

== Problems ==

* gcc-4.5 is broken for pymol install, use gcc-4.4 (Mint11 Linux, PyMOL 1.4.1, reported by [[User:Tlinnet]])
<source lang="bash">
sudo apt-get install build-essential gcc-4.4 g++-4.4
export CC=/usr/bin/gcc-4.4
</source>

* If you get an error message "ImportError: No module named Pmw" and lack half of the user interface, then run the additional command
:<source lang="bash">
python setup2.py install pmw
</source>

:to install a copy of the Python MegaWidgets.

== Ubuntu/Mint Compile and install with MPEG support ==
Make a text file "installpymol.sh" and make it executable
<source lang="bash">
chmod u+x installpymol.sh
</source>

Put this in the file, modify the first 3 lines
<source lang="bash">
#!/bin/bash -e
pymolsvn=/home/tlinnet/Software/pymol/svnpymol
pymoldir=/home/tlinnet/Software/pymol
freemolsvn=/home/tlinnet/Software/pymol/svnfreemol

###################################################
[ -d $pymoldir ] || mkdir $pymoldir
[ -d $pymolsvn ] || mkdir $pymolsvn
[ -d $pymoldir/wikiscripts ] || mkdir $pymoldir/wikiscripts

sudo apt-get install subversion build-essential python-dev python-pmw \
libglew-dev freeglut3-dev libpng-dev libfreetype6-dev

# gcc 4.5 broken for install in ubuntu
sudo apt-get install gcc-4.4 g++-4.4
export CC=/usr/bin/gcc-4.4

svn co https://pymol.svn.sourceforge.net/svnroot/pymol/trunk/pymol $pymolsvn

modules=$pymoldir/modules
cd $pymolsvn
python setup.py build
sudo python setup.py install
sudo python setup.py install --home=$pymoldir --install-purelib=$modules --install-platlib=$modules
export PYTHONPATH=$modules:$PYTHONPATH
sudo python setup2.py install
install $pymolsvn/pymol $pymoldir/

## To add a path/folder where you can put pymol wikiscripts
t="'"
echo "import sys" >> ~/.pymolrc
echo "sys.path.append($t$pymoldir/wikiscripts$t)" >> ~/.pymolrc

########## Setup freemol - for MPEG support ############
[ -d $pymolsvn ] || mkdir $freemolsvn
svn co svn://bioinformatics.org/svnroot/freemol/trunk $freemolsvn

cd $freemolsvn/src/mpeg_encode
export FREEMOL=$freemolsvn/freemol
./configure
make
make install

## Make a shortcut to export freemol and then execute pymol
echo '#!/bin/bash' >> $pymoldir/pymolMPEG.sh
echo "export FREEMOL=$freemolsvn/freemol" >> $pymoldir/pymolMPEG.sh
echo "#$pymoldir/pymol" >> $pymoldir/pymolMPEG.sh
tail -n +2 $pymoldir/pymol >> $pymoldir/pymolMPEG.sh
chmod u+x $pymoldir/pymolMPEG.sh

## Make a link, so we can call execute pymol
sudo ln -s $pymoldir/pymolMPEG.sh /usr/bin/pymol
</source>

=== Update script ===
To pull and update PyMOL, one can make this script

Make a text file "updatepymol.sh" and make it executable
<source lang="bash">
chmod u+x updatepymol.sh
</source>

Put this in the file, modify the first 3 lines
<source lang="bash">
#!/bin/bash -e
pymolsvn=/home/tlinnet/Software/pymol/svnpymol
pymoldir=/home/tlinnet/Software/pymol
freemolsvn=/home/tlinnet/Software/pymol/svnfreemol

# gcc 4.5 broken for install in ubuntu
export CC=/usr/bin/gcc-4.4

svn up $pymolsvn
svn up $freemolsvn

modules=$pymoldir/modules
cd $pymolsvn
python setup.py build
sudo python setup.py install
sudo python setup.py install --home=$pymoldir --install-purelib=$modules --install-platlib=$modules
export PYTHONPATH=$modules:$PYTHONPATH
sudo python setup2.py install
install $pymolsvn/pymol $pymoldir/

########## Setup freemol - for MPEG support ############
cd $freemolsvn/src/mpeg_encode
export FREEMOL=$freemolsvn/freemol
./configure
make
make install
</source>

=== Change MPEG settings ===
Change settings in
<source lang="bash">
/home/tlinnet/Software/pymol/svnfreemol/freemol/libpy/freemol/mpeg_encode.py
</source>
For example, change in line 205: 
FRAME_RATE 24 
(Not, only legal values is allowed: 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60)

Then restart PyMOL.

[[Category:Installation|Linux Installation]]

Linux Install

2011-12-02T16:01:26Z

Cowsandmilk:

This page describes how to install open-source PyMOL on Linux.

== Install Distribution-specific binary Package ==

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:

<source lang="bash">
# Debian/Ubuntu
sudo apt-get install pymol

# Fedora
yum install pymol

# Gentoo
emerge -av pymol

# openSUSE (12.1 and later)
sudo zypper install 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

On many Linux systems, one of the following commands installs all requirements:

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

# Fedora
yum install subversion python-devel freeglut-devel freetype-devel tkinter python-pmw

# Gentoo
emerge -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 https://pymol.svn.sourceforge.net/svnroot/pymol/trunk/pymol 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

python setup.py build install \
--home=$prefix \
--install-purelib=$modules \
--install-platlib=$modules

export PYTHONPATH=$modules:$PYTHONPATH
python setup2.py install
install pymol $prefix/
</source>

Now launch PyMOL like this (you may copy this launcher into your '''$PATH''',
like to '''/usr/local/bin'''):

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

== Problems ==

* gcc-4.5 is broken for pymol install, use gcc-4.4 (Mint11 Linux, PyMOL 1.4.1, reported by [[User:Tlinnet]])
<source lang="bash">
sudo apt-get install build-essential gcc-4.4 g++-4.4
export CC=/usr/bin/gcc-4.4
</source>

* If you get an error message "ImportError: No module named Pmw" and lack half of the user interface, then run the additional command
:<source lang="bash">
python setup2.py install pmw
</source>

:to install a copy of the Python MegaWidgets.

== Ubuntu/Mint Compile and install with MPEG support ==
Make a text file "installpymol.sh" and make it executable
<source lang="bash">
chmod u+x installpymol.sh
</source>

Put this in the file, modify the first 3 lines
<source lang="bash">
#!/bin/bash -e
pymolsvn=/home/tlinnet/Software/pymol/svnpymol
pymoldir=/home/tlinnet/Software/pymol
freemolsvn=/home/tlinnet/Software/pymol/svnfreemol

###################################################
[ -d $pymoldir ] || mkdir $pymoldir
[ -d $pymolsvn ] || mkdir $pymolsvn
[ -d $pymoldir/wikiscripts ] || mkdir $pymoldir/wikiscripts

sudo apt-get install subversion build-essential python-dev python-pmw \
libglew-dev freeglut3-dev libpng-dev libfreetype6-dev

# gcc 4.5 broken for install in ubuntu
sudo apt-get install gcc-4.4 g++-4.4
export CC=/usr/bin/gcc-4.4

svn co https://pymol.svn.sourceforge.net/svnroot/pymol/trunk/pymol $pymolsvn

modules=$pymoldir/modules
cd $pymolsvn
python setup.py build
sudo python setup.py install
sudo python setup.py install --home=$pymoldir --install-purelib=$modules --install-platlib=$modules
export PYTHONPATH=$modules:$PYTHONPATH
sudo python setup2.py install
install $pymolsvn/pymol $pymoldir/

## To add a path/folder where you can put pymol wikiscripts
t="'"
echo "import sys" >> ~/.pymolrc
echo "sys.path.append($t$pymoldir/wikiscripts$t)" >> ~/.pymolrc

########## Setup freemol - for MPEG support ############
[ -d $pymolsvn ] || mkdir $freemolsvn
svn co svn://bioinformatics.org/svnroot/freemol/trunk $freemolsvn

cd $freemolsvn/src/mpeg_encode
export FREEMOL=$freemolsvn/freemol
./configure
make
make install

## Make a shortcut to export freemol and then execute pymol
echo '#!/bin/bash' >> $pymoldir/pymolMPEG.sh
echo "export FREEMOL=$freemolsvn/freemol" >> $pymoldir/pymolMPEG.sh
echo "#$pymoldir/pymol" >> $pymoldir/pymolMPEG.sh
tail -n +2 $pymoldir/pymol >> $pymoldir/pymolMPEG.sh
chmod u+x $pymoldir/pymolMPEG.sh

## Make a link, so we can call execute pymol
sudo ln -s $pymoldir/pymolMPEG.sh /usr/bin/pymol
</source>

=== Update script ===
To pull and update PyMOL, one can make this script

Make a text file "updatepymol.sh" and make it executable
<source lang="bash">
chmod u+x updatepymol.sh
</source>

Put this in the file, modify the first 3 lines
<source lang="bash">
#!/bin/bash -e
pymolsvn=/home/tlinnet/Software/pymol/svnpymol
pymoldir=/home/tlinnet/Software/pymol
freemolsvn=/home/tlinnet/Software/pymol/svnfreemol

# gcc 4.5 broken for install in ubuntu
export CC=/usr/bin/gcc-4.4

svn up $pymolsvn
svn up $freemolsvn

modules=$pymoldir/modules
cd $pymolsvn
python setup.py build
sudo python setup.py install
sudo python setup.py install --home=$pymoldir --install-purelib=$modules --install-platlib=$modules
export PYTHONPATH=$modules:$PYTHONPATH
sudo python setup2.py install
install $pymolsvn/pymol $pymoldir/

########## Setup freemol - for MPEG support ############
cd $freemolsvn/src/mpeg_encode
export FREEMOL=$freemolsvn/freemol
./configure
make
make install
</source>

=== Change MPEG settings ===
Change settings in
<source lang="bash">
/home/tlinnet/Software/pymol/svnfreemol/freemol/libpy/freemol/mpeg_encode.py
</source>
For example, change in line 205: 
FRAME_RATE 24 
(Not, only legal values is allowed: 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60)

Then restart PyMOL.

[[Category:Installation|Linux Installation]]

Linux Install

2011-12-02T15:44:31Z

Cowsandmilk:

This page describes how to install open-source PyMOL on Linux.

== Install Distribution-specific binary Package ==

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:

<source lang="bash">
# Debian/Ubuntu
sudo apt-get install pymol

# Fedora
yum install pymol

# Gentoo
emerge -av pymol

# OpenSUSE (12.1 and later)
sudo zypper install 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

On many Linux systems, one of the following commands installs all requirements:

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

# Fedora
yum install subversion python-devel freeglut-devel freetype-devel tkinter python-pmw

# Gentoo
emerge -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 https://pymol.svn.sourceforge.net/svnroot/pymol/trunk/pymol 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

python setup.py build install \
--home=$prefix \
--install-purelib=$modules \
--install-platlib=$modules

export PYTHONPATH=$modules:$PYTHONPATH
python setup2.py install
install pymol $prefix/
</source>

Now launch PyMOL like this (you may copy this launcher into your '''$PATH''',
like to '''/usr/local/bin'''):

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

== Problems ==

* gcc-4.5 is broken for pymol install, use gcc-4.4 (Mint11 Linux, PyMOL 1.4.1, reported by [[User:Tlinnet]])
<source lang="bash">
sudo apt-get install build-essential gcc-4.4 g++-4.4
export CC=/usr/bin/gcc-4.4
</source>

* If you get an error message "ImportError: No module named Pmw" and lack half of the user interface, then run the additional command
:<source lang="bash">
python setup2.py install pmw
</source>

:to install a copy of the Python MegaWidgets.

== Ubuntu/Mint Compile and install with MPEG support ==
Make a text file "installpymol.sh" and make it executable
<source lang="bash">
chmod u+x installpymol.sh
</source>

Put this in the file, modify the first 3 lines
<source lang="bash">
#!/bin/bash -e
pymolsvn=/home/tlinnet/Software/pymol/svnpymol
pymoldir=/home/tlinnet/Software/pymol
freemolsvn=/home/tlinnet/Software/pymol/svnfreemol

###################################################
[ -d $pymoldir ] || mkdir $pymoldir
[ -d $pymolsvn ] || mkdir $pymolsvn
[ -d $pymoldir/wikiscripts ] || mkdir $pymoldir/wikiscripts

sudo apt-get install subversion build-essential python-dev python-pmw \
libglew-dev freeglut3-dev libpng-dev libfreetype6-dev

# gcc 4.5 broken for install in ubuntu
sudo apt-get install gcc-4.4 g++-4.4
export CC=/usr/bin/gcc-4.4

svn co https://pymol.svn.sourceforge.net/svnroot/pymol/trunk/pymol $pymolsvn

modules=$pymoldir/modules
cd $pymolsvn
python setup.py build
sudo python setup.py install
sudo python setup.py install --home=$pymoldir --install-purelib=$modules --install-platlib=$modules
export PYTHONPATH=$modules:$PYTHONPATH
sudo python setup2.py install
install $pymolsvn/pymol $pymoldir/

## To add a path/folder where you can put pymol wikiscripts
t="'"
echo "import sys" >> ~/.pymolrc
echo "sys.path.append($t$pymoldir/wikiscripts$t)" >> ~/.pymolrc

########## Setup freemol - for MPEG support ############
[ -d $pymolsvn ] || mkdir $freemolsvn
svn co svn://bioinformatics.org/svnroot/freemol/trunk $freemolsvn

cd $freemolsvn/src/mpeg_encode
export FREEMOL=$freemolsvn/freemol
./configure
make
make install

## Make a shortcut to export freemol and then execute pymol
echo '#!/bin/bash' >> $pymoldir/pymolMPEG.sh
echo "export FREEMOL=$freemolsvn/freemol" >> $pymoldir/pymolMPEG.sh
echo "#$pymoldir/pymol" >> $pymoldir/pymolMPEG.sh
tail -n +2 $pymoldir/pymol >> $pymoldir/pymolMPEG.sh
chmod u+x $pymoldir/pymolMPEG.sh

## Make a link, so we can call execute pymol
sudo ln -s $pymoldir/pymolMPEG.sh /usr/bin/pymol
</source>

=== Update script ===
To pull and update PyMOL, one can make this script

Make a text file "updatepymol.sh" and make it executable
<source lang="bash">
chmod u+x updatepymol.sh
</source>

Put this in the file, modify the first 3 lines
<source lang="bash">
#!/bin/bash -e
pymolsvn=/home/tlinnet/Software/pymol/svnpymol
pymoldir=/home/tlinnet/Software/pymol
freemolsvn=/home/tlinnet/Software/pymol/svnfreemol

# gcc 4.5 broken for install in ubuntu
export CC=/usr/bin/gcc-4.4

svn up $pymolsvn
svn up $freemolsvn

modules=$pymoldir/modules
cd $pymolsvn
python setup.py build
sudo python setup.py install
sudo python setup.py install --home=$pymoldir --install-purelib=$modules --install-platlib=$modules
export PYTHONPATH=$modules:$PYTHONPATH
sudo python setup2.py install
install $pymolsvn/pymol $pymoldir/

########## Setup freemol - for MPEG support ############
cd $freemolsvn/src/mpeg_encode
export FREEMOL=$freemolsvn/freemol
./configure
make
make install
</source>

=== Change MPEG settings ===
Change settings in
<source lang="bash">
/home/tlinnet/Software/pymol/svnfreemol/freemol/libpy/freemol/mpeg_encode.py
</source>
For example, change in line 205: 
FRAME_RATE 24 
(Not, only legal values is allowed: 23.976, 24, 25, 29.97, 30, 50 ,59.94, 60)

Then restart PyMOL.

[[Category:Installation|Linux Installation]]

System

2010-05-05T00:38:10Z

Cowsandmilk: /* PYMOL API */ correct arguments

The '''system''' command, executes a command in a subshell under Unix or Windows.

===USAGE===
<source lang="python">
# execute 'command'
system command
</source>

===PYMOL API===
<source lang="python">
cmd.system(string command,int async=0)
</source>

===NOTES===
async can only be specified from the Python level (not the command language)
*if async is 0 (default), then the result code from "system" is returned in r
*if async is 1, then the command is run in a separate thread whose object is returned

===SEE ALSO===
[[ls]], [[cd]], [[pwd]]

[[Category:Commands|System]]

Connect mode

2010-04-22T20:02:06Z

Cowsandmilk: Created page with '= Overview = Sets how bonds are made when loading a file. Values: * 0 = distance-based and CONECT records * 1 = CONECT records * 2 = distance-based * 3 = (who knows, the code is…'

= Overview =
Sets how bonds are made when loading a file.

Values:
* 0 = distance-based and CONECT records
* 1 = CONECT records
* 2 = distance-based
* 3 = (who knows, the code is complicated)

= Syntax =
<source lang="python">
# ignore CONECT records
set connect_mode, 2

</source>

= See Also =

Kabsch

2010-02-14T19:17:43Z

Cowsandmilk: /* The Code */ indentation changes

==Intro==
The Kabsch algorithm uses linear and vector algebra to find the optimal rotation and translation of two sets of points in N-dimensional space as to minimize the RMSD between them. The following program is a Python implementation of the Kabsch algorithm.

This program when called will align the two selections, optimally, convert the proteins in the selection to ribbons and change the color of the selections to show the matched alignments.

'''WHAT THIS DOESN'T DO''': This program does NOT provide a pairwise alignment of two structures from scratch. You have to tell it what the equivlanced items are. See [[Cealign]].

'''NOTE:''' This has '''NOT''' been tested on any other machine than mine, by me. It works on all PyMols 0.97 and newer (haven't tested earlier versions) and I use Python 2.3's Numeric Version 23.3.

'''NOTE:''' I have added new Kabsch code. The new code uses SVD, and fixed an old bug. For ease of use, try the new code (requires numpy, though).

==To use==

# Save this script to Kabsch.py
# Open PyMol
# Load the alignment script: '''run Kabsch.py''' (The command '''optAlign''' is now defined in PyMol.)
# Load your proteins
# Align the proper segments (see below examples)

To align two equivalent sets of residues do:
<source lang="python">
optAlign SEL1 and n. CA and i. a-b, SEL2 and n. CA and i. c-d
</source>
where
* '''SEL1''' is the first protein
* '''a-b''' is the range of residues to align in the first protein
* '''SEL2''' is the second protein
* '''c-d''' is the range of residues to align in the second protein

===Caveats===
* Ensure that you're equivalencing '''N''' atoms to '''N''' atoms (run [[Count_Atoms]] over your two selections to ensure they are the same length).
* Sometimes PyMol doesn't seem to superimpose them right the first time. Hit the up-arrow and rerun the program if this happens. It always superimposes the correctly the second time. I think it has something to do with the orientation. I'll fix this when I find the error.
* The RMSD is only between the equivlanced atoms. Use PyMol's [[Rms_Cur]] if you want a full RMSD.
* Make sure your atom selections are numbered correctly. Many times PDB files start residue numbers at something other than 0 or 1. To ensure you're aligning the right things, do <source lang="python">set seq_view,1</source> to turn on the sequence viewer and double check your residue numbers. If a protein has residue one numbered as something other than one, say 2064, simply run <source lang="python">alter (SEL), resi=str(int(resi)-2064)</source> and then <source lang="python">sort</source> where '''SEL''' is the name of the protein and 2064 is the offset to adjust by. Your protein will now work as needed. See [[Alter]]. This capability is also provided in a script; See [[zero_residues]]. 

== Notes ==
<ol><li>Windows users are having problems running the script. Python tells them first off "TypeError: Can't convert rank-0 arrays to Python scalars." The fix to that breaks some code in Numeric -- which I don't maintain.</li> 
<li>However, to make this work, you can change the code in Numeric.py supplied with Pymol, located in the folder "<Pymol Home>\modules\Numeric\" (for example: "C:\Program Files\DeLano Scientific\PyMOL\modules\Numeric"). 
Essentially, you need to search for the line: <source lang="python"> if axis2 < 0: axis2 = axis1 + n # (should be around line 250) </source> and replace it with: <source lang="python">if axis2 < 0: axis2 = axis2 + n </source></li></ol>

===Examples===
optAlign 1cll and n. CA and i. 4-20+30-60, 1ggz and n. CA and i. 4-20+30-60

optAlign 1kao and n. CA and i. 20-50, 1ctq and n. CA and i. 20-50

<gallery>
Image:OptAlign1.png|1cll and 1ggz loaded
Image:OptAlign2.png|1cll and 1ggz aligned to residues 5-50+55-80 shown in red
</gallery>

Kabsch can also align hetero-atoms:
<source lang="python">
load 1cll.pdb
load 1ggz.pdb
optAlign 1cll and e. CA, 1ggz and e. CA
</source>
The above aligns the 4 Calciums in each structure.

==The Code==
<source lang="python">
#!python

##############################################################################
#
# @SUMMARY: -- QKabsch.py. A python implementation of the optimal superposition
# of two sets of vectors as proposed by Kabsch 1976 & 1978.
#
# @AUTHOR: Jason Vertrees
# @COPYRIGHT: Jason Vertrees (C), 2005-2007
# @LICENSE: Released under GPL:
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
# Street, Fifth Floor, Boston, MA 02110-1301, USA
#
# DATE : 2007-01-01
# REV : 2
# REQUIREMENTS: numpy
#
#############################################################################
from array import *

# system stuff
import os
import copy

# pretty printing
import pprint

# for importing as a plugin into PyMol
from pymol import cmd
from pymol import stored
from pymol import selector

# using numpy for linear algebra
import numpy

def optAlign( sel1, sel2 ):
"""
optAlign performs the Kabsch alignment algorithm upon the alpha-carbons of two selections.
Example: optAlign MOL1 and i. 20-40, MOL2 and i. 102-122
Example 2: optAlign 1GGZ and i. 4-146 and n. CA, 1CLL and i. 4-146 and n. CA

Two RMSDs are returned. One comes from the Kabsch algorithm and the other from
PyMol based upon your selections.

By default, this program will optimally align the ALPHA CARBONS of the selections provided.
To turn off this feature remove the lines between the commented "REMOVE ALPHA CARBONS" below.

@param sel1: First PyMol selection with N-atoms
@param sel2: Second PyMol selection with N-atoms
"""
cmd.reset()

# make the lists for holding coordinates
# partial lists
stored.sel1 = []
stored.sel2 = []
# full lists
stored.mol1 = []
stored.mol2 = []

# -- CUT HERE
sel1 = sel1 + " and N. CA"
sel2 = sel2 + " and N. CA"
# -- CUT HERE

# Get the selected coordinates. We
# align these coords.
cmd.iterate_state(1, selector.process(sel1), "stored.sel1.append([x,y,z])")
cmd.iterate_state(1, selector.process(sel2), "stored.sel2.append([x,y,z])")

# get molecule name
mol1 = cmd.identify(sel1,1)[0][0]
mol2 = cmd.identify(sel2,1)[0][0]

# Get all molecule coords. We do this because
# we have to rotate the whole molcule, not just
# the aligned selection
cmd.iterate_state(1, mol1, "stored.mol1.append([x,y,z])")
cmd.iterate_state(1, mol2, "stored.mol2.append([x,y,z])")

# check for consistency
assert( len(stored.sel1) == len(stored.sel2))
L = len(stored.sel1)
assert( L > 0 )

# must alway center the two proteins to avoid
# affine transformations. Center the two proteins
# to their selections.
COM1 = numpy.sum(stored.sel1,axis=0) / float(L)
COM2 = numpy.sum(stored.sel2,axis=0) / float(L)
stored.sel1 = stored.sel1 - COM1
stored.sel2 = stored.sel2 - COM2

# Initial residual, see Kabsch.
E0 = numpy.sum( numpy.sum(stored.sel1 * stored.sel1,axis=0),axis=0) + numpy.sum( numpy.sum(stored.sel2 * stored.sel2,axis=0),axis=0)

#
# This beautiful step provides the answer. V and Wt are the orthonormal
# bases that when multiplied by each other give us the rotation matrix, U.
# S, (Sigma, from SVD) provides us with the error! Isn't SVD great!
V, S, Wt = numpy.linalg.svd( numpy.dot( numpy.transpose(stored.sel2), stored.sel1))

# we already have our solution, in the results from SVD.
# we just need to check for reflections and then produce
# the rotation. V and Wt are orthonormal, so their det's
# are +/-1.
reflect = float(str(float(numpy.linalg.det(V) * numpy.linalg.det(Wt))))

if reflect == -1.0:
S[-1] = -S[-1]
V[:,-1] = -V[:,-1]

RMSD = E0 - (2.0 * sum(S))
RMSD = numpy.sqrt(abs(RMSD / L))

#U is simply V*Wt
U = numpy.dot(V, Wt)

# rotate and translate the molecule
stored.sel2 = numpy.dot((stored.mol2 - COM2), U)
stored.sel2 = stored.sel2.tolist()
# center the molecule
stored.sel1 = stored.mol1 - COM1
stored.sel1 = stored.sel1.tolist()

# let PyMol know about the changes to the coordinates
cmd.alter_state(1,mol1,"(x,y,z)=stored.sel1.pop(0)")
cmd.alter_state(1,mol2,"(x,y,z)=stored.sel2.pop(0)")

print "RMSD=%f" % RMSD

# make the alignment OBVIOUS
cmd.hide('everything')
cmd.show('ribbon', sel1 + ' or ' + sel2)
cmd.color('gray70', mol1 )
cmd.color('paleyellow', mol2 )
cmd.color('red', 'visible')
cmd.show('ribbon', 'not visible')
cmd.center('visible')
cmd.orient()
cmd.zoom('visible')

cmd.extend("optAlign", optAlign)
</source>

=== The Old Code ===

<source lang="python">
#!python

##############################################################################
#
# @SUMMARY: -- Kabsch.py. A python implementation of the optimal superposition
# of two sets of vectors as proposed by Kabsch 1976 & 1978.
#
# @AUTHOR: Jason Vertrees
# @COPYRIGHT: Jason Vertrees (C), 2005-2007
# @LICENSE: Released under GPL:
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
# Street, Fifth Floor, Boston, MA 02110-1301, USA
#
# DATE : 2005-04-07
# REV : 2
# NOTES: Updated RMSD, notes, cleaned up the code a little.
#
#############################################################################
# math imports
import math
import Numeric
import LinearAlgebra
import Matrix

from array import *

# system stuff
import os
import copy

# pretty printing
import pprint

# for importing as a plugin into PyMol
#import tkSimpleDialog
#import tkMessageBox
from pymol import cmd
from pymol import stored
from pymol import selector

class kabsch:
"""
Kabsch alignment of two set of vectors to produce and optimal alignemnt.

Steps
=====
1. Calculate the center of mass for each protein. Then, move the protein
to its center of mass. We choose as a convention, to use the origin as
the center of mass of the first set of coordinates. This will allow us to
return one translation vector, instead of two.

Update: Since any rotation around a point that's not the origin, is in fact
an affine rotation. So, to beat that, we translate both to the center.

NAME: superpose(c1, c2)
POST: T is now defined.

2. Calculate the matrix, R, by (eq7, 1976). r_{i,j} = sum_n w_n * y_{ni} * x_{nj},
where y_{ni} is the ith component of the vector y_n.
NAME: calcR
POST: R is now defined

3. Calculate RtR (R-transpose * R).
NAME: calcRtR
POST: RtR is now defined

4. Calculate the corresponding eigenpairs for RtR, and sort them accordingly:
m1 >= m2 >= m3; set v3 = v1 x v2 to ensure a RHS
NAME: calcEigenPairs
POST: The eigen pairs are calculated, sorted such that m1 >= m2 >= m3 and
v3 = v1 x v2.

5. Calculate R*v_k and normalize the first two vectors to obtain b_1, b_2 and set
b_3 = b_1 x b_2. This also takes care of m1 > m2 = 0.
NAME: calcBVectors
POST: b-Vectors are defined and returned

6. Calculate U=(u_{ij})=(sum n b_{ki} * a_{kj}) to obtain the best rotation. Set
sigma_3 = -1 if b3(Ra3) < 0 else sigma_3 = +1.
NAME: calcU
POST: U is defined

7. Calculate the RMSD. The residual error is then
The E = E0 - sqrt(m1) - sqrt(m2) - sigma_3(sqrt(m3)).
NAME: calcRMSD
POST: RMSD is computed.

@note: This should be a static method that takes three parameters

1. The first protein's coordinates, f. This program will
accept coordinates in the form an array of 3D vectors/lists

2. The second protein's coordinates, g.

3. The array of integer pairs representing the pairs to align.
Coordinates should be formatted as as array of 2D vectors/lists.

"""

def __init__(self):
"""
Constructor. @see kabsch.align.

"""

#
# Instance Variables: All three of these will be updated
# every time the user calls ~.align. Just to warn ya'.
#
# U, the rotation matrix
self.U = []
# T, the translation vector
self.T = []
# R, the RMSD
self.R = -1.0

#self.menuBar.addmenuitem('Plugin', 'command', 'Kabsch Align', label = "Align Selections to Optial RMSD", command = lamda s=self: fetchPDBDialog(s))

def align(self, c1, c2, pairs):
"""
Finds the best alignment of c1 and c2's pairs resulting in
the smallest possible RMSD.

@note:
- All weights in this first version are set to 1. Kabsch allows,
differential weighting. In the future, I may extend to this option,
and then pairs may become 3D (r1, r2, weight) or I may add another
parameter.

- Helper functions will soon be provided such that the user may
just use this package alone to compute the rotation.

@param c1: coordinats of the first vectors, as an array of 3D vectors.
@type c1: Python list

@param c2: coordinates of the second set of vectors, as an array of 3D vectors.
@type c2: Python list

@param pairs: the list of pairs as an array of 2D pairs.
@type pairs: Python list of 2D lists.

@return: U, the rotation matrix that gives the optimal rotation between the two proteins.

T, the translation vector given to align the two objects centers of mass.

R, the RMSD of the final rotation.
"""

#
# First we move the center of mass of one protein, to the
# center of mass of the other. This removes any translation
# between the two.
#
T1, T2, c1, c2 = self.superpose(c1, c2)
# Calculate the initial RMSD
E0 = self.calcE0(c1, c2)
# Calculate R via eq. 7.
R = self.calcR(c1, c2)
# Calculate R(transpose)*R
RtR = self.calcRtR(R)
# Determined the eigenpairs for the matrix RtR.
eValues, eVectors = self.calcEigenPairs(RtR)
# Determine the bVectors as required
bVectors = self.calcBVectors(R, eVectors)
# Calculate the roation matrix
U = self.calcU(eVectors, bVectors)
# Calculate the final RMSD using U.
RMSD = self.calcRMSD(E0, eValues, eVectors, bVectors, R, len(c1))

return U, T1, T2, RMSD, c1, c2

def superpose(self, c1, c2 ):
"""
Calculate the center of mass for each protein. Then, move the protein
to its center of mass. We choose as a convention, to use the origin as
the center of mass of the first set of coordinates. This will allow us to
return one translation vector, instead of two.
(CORRECT)

@precondition: c1 and c2 are well defined lists of N-dimensional points with length > 0.
@postcondition: T is now defined.

@param c1: coordinats of the first vectors, as an array of 3D vectors.
@type c1: Python list

@param c2: coordinates of the second set of vectors, as an array of 3D vectors.
@type c2: Python list

@return: T the translation vector.

c2 one list of coordinates that of c2 translated to the COM of c1.

"""

# make sure we don't get bad data
if (len(c1) != len(c2)):
print "Two different length selections, with lengths, %d and %d." % (len(c1), len(c2))
print "This algorithm must be used with selections of the same length."
print "In PyMol, type 'count_atoms sel1' where sel1 are your selections to find out their lengths."
print "Example: optAlign MOL1 and i. 20-40, MOL2 and i. 102-122"
print "Example 2: optAlign 1GGZ and i. 4-146 and n. CA, 1CLL and i. 4-146 and n. CA"

assert(len(c1) == len(c2) != 0)

L = len(c1)

#
# Centers of Mass
#
c1COM = Numeric.zeros((3,1), Numeric.Float64)
c2COM = Numeric.zeros((3,1), Numeric.Float64)

# calculate the CsOM
for i in range(0, L):
for j in range(0,3):
c1COM[j] = c1COM[j] + c1[i][j]
c2COM[j] = c2COM[j] + c2[i][j]

T1 = - c1COM / L
T2 = - c2COM / L

# move everything back to the origin.
for i in range(0, L):
for j in range(0,3):
c1[i][j] = c1[i][j] + T1[j]
c2[i][j] = c2[i][j] + T2[j]

return T1, T2, c1, c2

def calcR( self, c1, c2 ):
"""
Calculate the matrix, R, by (eq7, 1976). M{r_{i,j} = sum_n w_n * y_{ni} * x_{nj}},
where M{y_{ni}} is the ith component of the vector M{y_n}.
(CORRECT)

@param c1: coordinats of the first vectors, as an array of 3D vectors.
@type c1: Python list

@param c2: coordinates of the second set of vectors, as an array of 3D vectors.
@type c2: Python list

@postcondition: R is now defined.

@return: R
@rtype : 3x3 matrix

"""

# Create the 3x3 matrix
R = Numeric.zeros((3,3), Numeric.Float64)
L = len(c1)

for k in range(0, L):
for i in range(0, 3):
for j in range(0, 3):
R[i][j] = R[i][j] + (c2[k][i] * c1[k][j])

# return R the 3x3 PSD Matrix.
return R

def calcRtR( self, R ):
"""
Calculate RtR (R-transpose * R).
(CORRECT)

@param R: Matrix
@type R: 3x3 Matrix

@precondition: R is a the well formed matrix as per Kabsch.
@postcondition: RtR is now defined

@return: M{R^tR}
@rtype : 3x3 matrix

"""

RtR = Numeric.matrixmultiply(Numeric.transpose(R), R)

return RtR

def calcEigenPairs( self, RtR ):
"""
Calculate the corresponding eigenpairs for RtR, and sort them accordingly:
M{m1 >= m2 >= m3}; set M{v3 = v1 x v2} to ensure a RHS
(CORRECT)

@postcondition: The eigen pairs are calculated, sorted such that M{m1 >= m2 >= m3} and
M{v3 = v1 x v2}.

@param RtR: 3x3 Matrix of M{R^t * R}.
@type RtR: 3x3 Matrix
@return : Eigenpairs for the RtR matrix.
@rtype : List of stuff

"""

eVal, eVec = LinearAlgebra.eigenvectors(RtR)

# This is cool. We sort it using Numeric.sort(eVal)
# then we reverse it using nifty-crazy ass notation [::-1].
eVal2 = Numeric.sort(eVal)[::-1]
eVec2 = [[],[],[]] #Numeric.zeros((3,3), Numeric.Float64)

# Map the vectors to their appropriate owners
if ( eVal2[0] == eVal[0]):
eVec2[0] = eVec[0]
if ( eVal2[1] == eVal[1] ):
eVec2[1] = eVec[1]
eVec2[2] = eVec[2]
else:
eVec2[1] = eVec[2]
eVec2[2] = eVec[1]
elif( eVal2[0] == eVal[1]):
eVec2[0] = eVec[1]
if ( eVal2[1] == eVal[0] ):
eVec2[1] = eVec[0]
eVec2[2] = eVec[2]
else:
eVec2[1] = eVec[2]
eVec2[2] = eVec[0]
elif( eVal2[0] == eVal[2]):
eVec2[0] = eVec[2]
if ( eVal2[1] == eVal[1] ):
eVec2[1] = eVec[1]
eVec2[2] = eVec[0]
else:
eVec2[1] = eVec[0]
eVec2[2] = eVec[1]

eVec2[2][0] = eVec2[0][1]*eVec2[1][2] - eVec2[0][2]*eVec2[1][1]
eVec2[2][1] = eVec2[0][2]*eVec2[1][0] - eVec2[0][0]*eVec2[1][2]
eVec2[2][2] = eVec2[0][0]*eVec2[1][1] - eVec2[0][1]*eVec2[1][0]

return [eVal2, eVec2]

def calcBVectors( self, R, eVectors ):
"""
Calculate M{R*a_k} and normalize the first two vectors to obtain M{b_1, b_2} and set
M{b_3 = b_1 x b_2}. This also takes care of {m2 > m3 = 0}.
(CORRECT)

@postcondition: b-Vectors are defined and returned

@return: The three B-vectors
@rtype: List of 3D vectors (Python LOL).
"""

bVectors = Numeric.zeros((3,3), Numeric.Float64)

for i in range(0,3):
bVectors[i] = Numeric.matrixmultiply(R, eVectors[i])

bVectors[0] = bVectors[0] / Numeric.sqrt(Numeric.add.reduce(bVectors[0]**2))
bVectors[1] = bVectors[1] / Numeric.sqrt(Numeric.add.reduce(bVectors[1]**2))
bVectors[2] = bVectors[2] / Numeric.sqrt(Numeric.add.reduce(bVectors[2]**2))

bVectors[2][0] = bVectors[0][1]*bVectors[1][2] - bVectors[0][2]*bVectors[1][1]
bVectors[2][1] = bVectors[0][2]*bVectors[1][0] - bVectors[0][0]*bVectors[1][2]
bVectors[2][2] = bVectors[0][0]*bVectors[1][1] - bVectors[0][1]*bVectors[1][0]

return bVectors

def calcU( self, eVectors, bVectors ):
"""
Calculate M{U=(u_{ij})=(sum n b_{ki} * a_{kj})} to obtain the best rotation. Set
M{sigma_3 = -1 if b3(Ra3) < 0 else sigma_3 = +1}.
(CORRECT)

@postcondition: U is defined

@param eVectors: Eigenvectors for the system.
@type eVectors: Eigenvectors

@param bVectors: BVectors as described by Kabsch.
@type bVectors: BVectors

@return: U the rotation matrix.
@rtype :3x3 matrix.

"""

U = Numeric.zeros((3,3), Numeric.Float64)

for k in range(0,3):
for i in range(0,3):
for j in range(0,3):
U[i][j] = U[i][j] + Numeric.matrixmultiply(bVectors[k][i], eVectors[k][j])

return U

def calcE0( self, c1, c2 ):
"""
Calculates the initial RMSD, which Kacbsch called E0.
(CORRECT)

@param c1: coordinats of the first vectors, as an array of 3D vectors.
@type c1: Python list

@param c2: coordinates of the second set of vectors, as an array of 3D vectors.
@type c2: Python list

@return: E0 the initial RMSD.
@rtype : float.

"""

E0 = 0.0

L = len(c1)
for i in range( 0, L ):
for j in range(0, 3):
E0 = E0 + 0.5*( (c1[i][j]*c1[i][j])+(c2[i][j]*c2[i][j]))

return E0

def calcRMSD( self, E0, eValues, eVectors, bVectors, R, N):
"""
Calculate the RMSD. The residual error is then
The M{E = E0 - sqrt(m1) - sqrt(m2) - sigma_3(sqrt(m3))}.

@param E0: Initial RMSD as calculated in L{calcE0}.
@type E0: float.

@param eVectors: Eigenvectors as calculated from L{calcEigenPairs}
@type eVectors: vectors, dammit!

@param bVectors: B-vectors as calc. from L{calcBVectors}
@type bVectors: More vectors.

@param R: The matrix R, from L{calcR}.
@type R: 3x3 matrix.

@param N: Number of equivalenced points
@type N: integer

@postcondition: RMSD is computed.
@return: The RMSD.

"""
sigma3 = 0
if ( Numeric.matrixmultiply(bVectors[2], Numeric.matrixmultiply( R, eVectors[2])) < 0):
sigma3 = -1
else:
sigma3 = 1

E = math.sqrt( 2*(E0 - math.sqrt(eValues[0]) - math.sqrt(eValues[1]) - sigma3*(math.sqrt(eValues[2]))) / N)

return E

def calcSimpleRMSD( self, c1, c2 ):
"""
Calculates the usual concept of RMSD between two set of points. The CalcRMSD above
sticks to Kabsch's alignment method protocol and calculates something much different.
@see kabsch.calcRMSD

@param c1: List of points #1
@type c1: LOL

@param c2: List of points #2
@type c2: LOL

@return: RMSD between the two

"""

RMSD = 0.0
for i in range(0, len(c1)):
for j in range(0,3):
RMSD = RMSD + (c2[i][j]-c1[i][j])**2

RMSD = RMSD / len(c1)
RMSD = Numeric.sqrt(RMSD)
return RMSD

#####################################################################
#
# UTIL Functions
def rotatePoints(self, U, c2):
"""
Rotate all points in c2 based on the rotation matrix U.

@param U: 3x3 Rotation matrix
@type U: 3x3 matrix

@param c2: List of points to rotate
@type c2: List of 3D vectors

@return: List of rotated points

"""

L = len(c2)

for n in range(0,L):
c2[n][0] = c2[n][0] * U[0][0] + c2[n][1] * U[1][0] + c2[n][2] * U[2][0]
c2[n][1] = c2[n][0] * U[0][1] + c2[n][1] * U[1][1] + c2[n][2] * U[2][1]
c2[n][2] = c2[n][0] * U[0][2] + c2[n][1] * U[1][2] + c2[n][2] * U[2][2]

return c2

def writeU( self, U, fileName ):
"""
Convenience function. Writes U to disk.

"""

if ( len(fileName) == 0 ):
fileName = "./U"

outFile = open( fileName, "wb")
for i in range(0,3):
for j in range(0,3):
outFile.write( str(U[i][j]).ljust(20) )
outFile.write("\n")
outFile.close()

def optAlign( sel1, sel2 ):
"""
optAlign performs the Kabsch alignment algorithm upon the alpha-carbons of two selections.
Example: optAlign MOL1 and i. 20-40, MOL2 and i. 102-122
Example 2: optAlign 1GGZ and i. 4-146 and n. CA, 1CLL and i. 4-146 and n. CA

Two RMSDs are returned. One comes from the Kabsch algorithm and the other from
PyMol based upon your selections.

By default, this program will optimally align the ALPHA CARBONS of the selections provided.
To turn off this feature remove the lines between the commented "REMOVE ALPHA CARBONS" below.

@param sel1: First PyMol selection with N-atoms
@param sel2: Second PyMol selection with N-atoms
"""
cmd.reset()

# make the lists for holding coordinates
# partial lists
stored.sel1 = []
stored.sel2 = []
# full lists
stored.mol1 = []
stored.mol2 = []

# now put the coordinates into a list
# partials

# -- REMOVE ALPHA CARBONS
sel1 = sel1 + " and N. CA"
sel2 = sel2 + " and N. CA"
# -- REMOVE ALPHA CARBONS

cmd.iterate_state(1, selector.process(sel1), "stored.sel1.append([x,y,z])")
cmd.iterate_state(1, selector.process(sel2), "stored.sel2.append([x,y,z])")
# full molecule
mol1 = cmd.identify(sel1,1)[0][0]
mol2 = cmd.identify(sel2,1)[0][0]
cmd.iterate_state(1, mol1, "stored.mol1.append([x,y,z])")
cmd.iterate_state(1, mol2, "stored.mol2.append([x,y,z])")

K = kabsch()
U, T1, T2, RMSD, c1, c2 = K.align(stored.sel1, stored.sel2, [])

stored.mol2 = map(lambda v:[T2[0]+((v[0]*U[0][0])+(v[1]*U[1][0])+(v[2]*U[2][0])),T2[1]+((v[0]*U[0][1])+(v[1]*U[1][1])+(v[2]*U[2][1])),T2[2]+((v[0]*U[0][2])+(v[1]*U[1][2])+(v[2]*U[2][2]))],stored.mol2)
#stored.mol1 = map(lambda v:[ v[0]+T1[0], v[1]+T1[1], v[2]+T1[2] ], stored.mol1)
stored.mol1 = map(lambda v:[ v[0]+T1[0], v[1]+T1[1], v[2]+T1[2] ], stored.mol1)

cmd.alter_state(1,mol1,"(x,y,z)=stored.mol1.pop(0)")
cmd.alter_state(1,mol2,"(x,y,z)=stored.mol2.pop(0)")
cmd.alter( 'all',"segi=''")
cmd.alter('all', "chain=''")
print "RMSD=%f" % cmd.rms_cur(sel1, sel2)
print "MY RMSD=%f" % RMSD
cmd.hide('everything')
cmd.show('ribbon', sel1 + ' or ' + sel2)
cmd.color('gray70', mol1 )
cmd.color('paleyellow', mol2 )
cmd.color('red', 'visible')
cmd.show('ribbon', 'not visible')
cmd.center('visible')
cmd.orient()
cmd.zoom('visible')

cmd.extend("optAlign", optAlign)
</source>

==References==
'''[Kabsch, 1976]''' Kabsch, W. (1976).
A solution for the best rotation to relate two sets of vectors.
''Acta. Crystal'', 32A:922-923.

'''[Kabsch, 1978]''' Kabsch, W. (1978).
A discussion of the solution for the best rotation to related two sets of vectors.
''Acta. Crystal'', 34A:827-828.

[[Category:Script_Library|Kabsch Alignment]]
[[Category:Structure_Alignment|Kabsch Alignment]]

Rotamer Toggle

2010-02-14T19:12:21Z

Cowsandmilk: /* SCRIPTS (Rotamers.py ; MyMenu.py) */

===DESCRIPTION===
Backbone-Dependent Rotamer library (Dunbrack, Cohen ; see ref) is imported into pymol giving access to this information. There are a number of different ways to use the data, I've only implemented a few as well as added extra functions that seemed useful.
*Rotamer Menu - an added menu into menu.py, which displays the most common rotamers for the given(clicked) residue; you can also set the residue any of the common rotamers as well
*colorRotamers - color rotamers by closest matching rotamer angles from database; i.e. color by how common each rotamer of selection, blue - red (least to most common).
*set_rotamer - routine called by above menu, but can be called manually to set a specific residues side-chain angles
*set_phipsi - set all phi,psi angles of given selection to given angles (useful for creating secondary structures)
*createRotamerPDBs - create pdb for each rotamer of given selection ; filter by rotamer-probability

===IMAGES===
<gallery>
Image:RotamerMenu.png|Rotamer Menu for a GLN residue
Image:GLURotamerComparison5.png|Rotamer Comparison of crystal structure and most common for GLU; just as an example
</gallery>

Print out while selecting most common rotamer from above-left image (GLN residue):
Given GLN:40 PHI,PSI (-171.626373291,-96.0500335693) : bin (-170,-100)
CHIs: [179.18069458007812, 72.539344787597656, -47.217315673828125]
Setting Chi1 to -176.9
Setting Chi2 to 177.4
Setting Chi3 to 0.7

===SETUP===
run "rotamers.py" and use functions from commandline.

or

To setup a rotamer menu inside the residue menu (default windows pymol installation):
*copy rotamers.py to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/rotamers.py
*copy mymenu.py to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/menu.py (WARNING : overwrites default menu.py - use at your own risk)
*copy bbdep02.May.sortlib to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/bbdep02.May.sortlib (or newer version of sorted bbdep)
This is only one possible way to do this, I am sure there are many others. I'm not going to post the bbdep, but there is a link in the References section to Dunbrack's download page (get the "sorted" lib)

===NOTES / STATUS===
*Tested on Pymolv0.97, Windows platform, Red Hat Linux 9.0 and Fedora Core 4. Will test v0.98 and MacOSX later on.
*The way it's setup now, when you import rotamers , it will automatically read-in the rotamer database; this may not be what you want.
*Post problems in the discussion page, on 'my talk' page or just email me : dwkulp@mail.med.upenn.edu

TASKS TODO:
*Rotamer Movie, using mset, etc create movie to watch cycle through rotamers
*Code could be organized a bit better; due to time constraints this is good for now..

TASKS DONE:
*Store crystal structure in rotamer menu, so you can go back to original orientation

===USAGE===
colorRotamers selection
set_rotamer selection, chi1_angle [,chi2_angle] [,chi3_angle] [,chi4_angle]
set_phipsi selection phi_angle, psi_angle
createRotamerPBDs selection [,ncutoff] [,pcutoff] [,prefix]

===EXAMPLES===
colorRotamers chain A
set_rotamer resi 40, -60,-40 (only set chi1,chi2 angles)
set_phipsi resi 10-40, -60,-60 (create an alpha-helical-like section)
createRotamerPDBs resi 10-12, ncutoff=3 (create 9 PDBs; each with one of the 3 most probable rotamers for resi 10,11,12)
createRotamerPDBs resi 14, pcutoff=0.4 (create a pdb file for each rotamer of residue 14 with probablity > 0.4)

===REFERENCES===
Dunbrack and Cohen. Protein Science 1997

[http://dunbrack.fccc.edu/bbdep/index.php Dunbrack Lab Page (Contains backbone-dependent library)]

===SCRIPTS (Rotamers.py ; MyMenu.py)===
Rotamers.py
<source lang="python">
##################################################################
# File: Rotamers.py
# Author: Dan Kulp
# Creation Date: 6/8/05
# Contact: dwkulp@mail.med.upenn.edu
#
# Notes:
# Incorporation of Rotamer library
# readRotLib() - fills rotdat;
# indexed by "RES:PHI_BIN:PSI_BIN".
#
# Three main functions:
# 1. colorRotamers - colors according
# to rotamer probablitity
# 2. getBins(sel)
# phi,psi bin for rotamer
# 3. set_rotamer - set a side-chain
# to a specific rotamer
#
# To setup a rotamer menu in the
# right click, under "Residue"
# 1. cp mymenu.py modules/pymol/menu.py
# 2. cp rotamers.py modules/pymol/rotamers.py (update ROTLIB)
#
# Requirements:
# set ROTLIB to path for rotamer library
# Reference:
# Dunbrack and Cohen. Protein Science 1997
####################################################################

import colorsys,sys
import re
import editing
import os
import cmd
import math

# Path for library
ROTLIB=os.environ['PYMOL_PATH']+"/modules/pymol/bbdep02.May.sortlib"

# Place for library in memory..
rotdat = {}

def readRotLib():
# Column indexes in rotamer library..
RES = 0
PHI = 1
PSI = 2
PROB = 8
CHI1 = 9
CHI2 = 10
CHI3 = 11
CHI4 = 12

if os.path.exists(ROTLIB):
print "File exists: "+ROTLIB
input = open(ROTLIB, 'r')
for line in input:

# Parse by whitespace (I believe format is white space and not fixed-width columns)
dat = re.split("\s+",line)

# Add to rotamer library in memory :
# key format RES:PHI_BIN:PSI_BIN
# value format PROB, CHI1, CHI2, CHI3, CHI4
key=dat[RES]+":"+dat[PHI]+":"+dat[PSI]
if key in rotdat:
rotdat[key].append([ dat[PROB], dat[CHI1], dat[CHI2], dat[CHI3], dat[CHI4] ])
else:
rotdat[key] = [ [ dat[PROB], dat[CHI1], dat[CHI2], dat[CHI3], dat[CHI4] ] ]

else:
print "Couldn't find Rotamer library"

# Atoms for each side-chain angle for each residue
CHIS = {}
CHIS["ARG"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","NE" ],
["CG","CD","NE","CZ" ]
]

CHIS["ASN"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","OD2" ]
]

CHIS["ASP"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","OD1" ]
]
CHIS["CYS"] = [ ["N","CA","CB","SG" ]
]

CHIS["GLN"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","OE1"]
]

CHIS["GLU"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","OE1"]
]

CHIS["HIS"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","ND1"]
]

CHIS["ILE"] = [ ["N","CA","CB","CG1" ],
["CA","CB","CG1","CD1" ]
]

CHIS["LEU"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["LYS"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","CE"],
["CG","CD","CE","NZ"]
]

CHIS["MET"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","SD" ],
["CB","CG","SD","CE"]
]

CHIS["PHE"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["PRO"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ]
]

CHIS["SER"] = [ ["N","CA","CB","OG" ]
]

CHIS["THR"] = [ ["N","CA","CB","OG1" ]
]

CHIS["TRP"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1"]
]

CHIS["TYR"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["VAL"] = [ ["N","CA","CB","CG1" ]
]

# Color Rotamer by side-chain angle position
# 'bin' side-chain angles into closest
def colorRotamers(sel):
doRotamers(sel)

# Utility function, to set phi,psi angles for a given selection
# Note: Cartoon, Ribbon functionality will not display correctly after this
def set_phipsi(sel, phi,psi):
doRotamers(sel,angles=[phi,psi],type="set")

# Set a rotamer, based on a selection, a restype and chi angles
def set_rotamer(sel, chi1, chi2=0,chi3=0,chi4=0):
at = cmd.get_model("byres ("+sel+")").atom[0]

list = [chi1,chi2,chi3,chi4]
for i in range(len(CHIS[at.resn])):
print "Setting Chi"+str(i+1)+" to "+str(list[i])
editing.set_dihedral(sel + ' and name '+CHIS[at.resn][i][0],
sel + ' and name '+CHIS[at.resn][i][1],
sel + ' and name '+CHIS[at.resn][i][2],
sel + ' and name '+CHIS[at.resn][i][3], str(list[i]))

# Remove some objects that got created
cmd.delete("pk1")
cmd.delete("pk2")
cmd.delete("pkmol")

# Get Phi,Psi bins for given selection
# WARNING: assume selection is single residue (will only return first residue bins)
def getBins(sel):
return doRotamers(sel, type="bins")

# Color Ramp...
def rot_color(vals):
nbins = 10
vals.sort(key=lambda x:x[1])
# print "End sort: "+str(len(vals))+" : "+str(nbins)

# Coloring scheme...
j = 0
rgb = [0.0,0.0,0.0]
sel_str = ""
for i in range(len(vals)):
if int(len(vals)/nbins) == 0 or i % int(len(vals)/nbins) == 0:
hsv = (colorsys.TWO_THIRD - colorsys.TWO_THIRD * float(j) / (nbins-1), 1.0, 1.0)

#convert to rgb and append to color list
rgb = colorsys.hsv_to_rgb(hsv[0],hsv[1],hsv[2])
if j < nbins-1:
j += 1

cmd.set_color("RotProbColor"+str(i), rgb)
cmd.color("RotProbColor"+str(i), str(vals[i][0]))

# Main function
def doRotamers(sel,angles=[], type="color"):

# Read in Rotamer library if not already done
if len(rotdat) == 0:
readRotLib()

# Set up some variables..
residues = ['dummy'] # Keep track of residues already done
probs = [] # probability of each residue conformation
phi = 0 # phi,psi angles of current residue
psi = 0

# Get atoms from selection
atoms = cmd.get_model("byres ("+sel+")")

# Loop through atoms in selection
for at in atoms.atom:
try:
# Don't process Glycines or Alanines
if not (at.resn == 'GLY' or at.resn == 'ALA'):
if at.chain+":"+at.resn+":"+at.resi not in residues:
residues.append(at.chain+":"+at.resn+":"+at.resi)

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if at.chain != "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue i-1, i and i+1
residue_def = unit_select+'resi '+str(at.resi)
residue_def_prev = unit_select+'resi '+str(int(at.resi)-1)
residue_def_next = unit_select+'resi '+str(int(at.resi)+1)

# Compute phi/psi angle

phi = cmd.get_dihedral(residue_def_prev+' and name C',residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C')
psi = cmd.get_dihedral(residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',residue_def_next+' and name N')
if type == "set":
print "Changing "+at.resn+str(at.resi)+" from "+str(phi)+","+str(psi)+" to "+str(angles[0])+","+str(angles[1])
cmd.set_dihedral(residue_def_prev+' and name C',residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',angles[0])
cmd.set_dihedral(residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',residue_def_next+' and name N', angles[1])
continue

# Find correct 10x10 degree bin
phi_digit = abs(int(phi)) - abs(int(phi/10)*10)
psi_digit = abs(int(psi)) - abs(int(psi/10)*10)

# Remember sign of phi,psi angles
phi_sign = 1
if phi < 0: phi_sign = -1

psi_sign = 1
if psi < 0: psi_sign = -1

# Compute phi,psi bins
phi_bin = int(math.floor(abs(phi/10))*10*phi_sign)
if phi_digit >= 5: phi_bin = int(math.ceil(abs(phi/10))*10*phi_sign)

psi_bin = int(math.floor(abs(psi/10))*10*psi_sign)
if psi_digit >= 5: psi_bin = int(math.ceil(abs(psi/10))*10*psi_sign)

print "Given "+at.resn+":"+at.resi+" PHI,PSI ("+str(phi)+","+str(psi)+") : bin ("+str(phi_bin)+","+str(psi_bin)+")"

# Get current chi angle measurements
chi = []
for i in range(len(CHIS[at.resn])):
chi.append(cmd.get_dihedral(residue_def + ' and name '+CHIS[at.resn][i][0],
residue_def + ' and name '+CHIS[at.resn][i][1],
residue_def + ' and name '+CHIS[at.resn][i][2],
residue_def + ' and name '+CHIS[at.resn][i][3]))
print "CHIs: "+str(chi)
if type == 'bins':
return [at.resn, phi_bin,psi_bin]

# Compute probabilities for given chi angles
prob = 0
prob_box = 22
for item in range(len(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)])):
print "Rotamer from db: "+str(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item])
if chi[0]:
if chi[0] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][1]) - (prob_box/2) and \
chi[0] <= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][1]) + (prob_box/2):
if len(chi) == 1:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[1] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][2]) - (prob_box/2) and \
float(chi[1] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][2]) + (prob_box/2):
if len(chi) == 2:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[2] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][3]) - (prob_box/2) and \
float(chi[2] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][3]) + (prob_box/2):
if len(chi) == 3:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[3] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][4]) - (prob_box/2) and \
float(chi[3] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][4]) + (prob_box/2):
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break

print "PROB OF ROTAMER: "+str(prob)
print "---------------------------"
probs.append([residue_def, prob])

except:
# probs.append([residue_def, -1])
print "Exception found"
continue

# Color according to rotamer probability
rot_color(probs)

# Create PDB files containing most probable rotamers
def createRotamerPDBs(sel,ncutoff=10,pcutoff=0,prefix="ROTAMER"):

# Get atoms from selection
atoms = cmd.get_model("byres ("+sel+")")

# Set up some variables..
residues = ['dummy'] # Keep track of residues already done

# Loop through atoms in selection
for at in atoms.atom:
if at.resn in ('GLY','ALA') or "%s:%s:%s" % (at.chain,at.resn,at.resi) in residues:
continue

# Add to residue list (keep track of which ones we've done)
residues.append("%s:%s:%s" % (at.chain,at.resn,at.resi))

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if not at.chain == "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue
residue_def = unit_select+'resi '+str(at.resi)

# Get bin (phi,psi) definitions for this residue
bin = doRotamers(residue_def, type='bins')

# Store crystal angle
crystal_angles = [0.0,0.0,0.0,0.0]
for angle in range(3):
try:
crystal_angles[angle] = bin[3][angle]
except IndexError:
break

# Retreive list of rotamers for this phi,psi bin + residue type
match_rotamers = rotdat["%s:%s:%s" % (bin[0],str(bin[1]),str(bin[2]))]

count = 0
for item in range(len(match_rotamers)):

# Store probablity
prob = match_rotamers[item][0]

# Check cutoffs
if float(prob) <= float(pcutoff):
continue

if float(count) >= float(ncutoff):
break

# Increment count
count += 1

# Output to screen ...
print "Residue %s%s, rotamer %i, prob %s" % (str(at.resn),str(at.resi),int(item),str(prob))

# Set to new rotamer
set_rotamer(residue_def,match_rotamers[item][1],match_rotamers[item][2],match_rotamers[item][3],match_rotamers[item][4])

# Store in PDB file
cmd.save("%s_%s%s_%i_%s.pdb" % (prefix,str(at.resn),str(at.resi),int(item),str(prob)))

# Reset crystal angle
set_rotamer(residue_def,crystal_angles[0],crystal_angles[1],crystal_angles[2],crystal_angles[3])

# Uncommenting this is nice because it loads rotamer library upon startup
# however, it slows the PyMOL loading process a lot
# instead I've put this call into the menuing code..
# readRotLib()

cmd.extend('set_phipsi',set_phipsi)
cmd.extend('set_rotamer',set_rotamer)
cmd.extend('colorRotamers',colorRotamers)
cmd.extend('createRotamerPDBs',createRotamerPDBs)
</source>

MyMenu.py
Since menu.py is copyrighted I can't post my edited version, but you can create it very simply by adding these two peices of code

1. In the "pick_option(title,s,object=0)" function of menu.py add the following code after the first "result =" statement
<source lang="python">
# Edit dwkulp 6/11/05 , add a rotamer menu to residue menu
if title == 'Residue':
result.extend([[ 1, 'rotamers' , rotamer_menu(s)]])
</source>

2. At the end of the file add this:
<source lang="python">
###############################################
# Dan Kulp
# Added Rotamer list to residue menu..
# rotamer.py must be importable (I placed it in
# the same directory as menu.py)
###############################################

import rotamers

def rotamer_menu(s):
# Check for rotamer library being loaded
if not rotamers.rotdat:
rotamers.readRotLib()
# return [ [2, "Must run rotamers.py first",'']]

# Check for valid rotamer residue..
res = cmd.get_model("byres ("+s+")").atom[0].resn
if not res in rotamers.CHIS.keys():
return [ [2, "Residue: "+res+" not known sidechain or does not have rotamers", '']]

# Get PHI,PSI bins for rotamer (also prints out current phi,psi, chi1,chi2,chi3,chi4)
bins = rotamers.doRotamers(s,type='bins')

# Add a title to the menu
result = [ [2, bins[0]+' Rotamers in bin ('+str(bins[1])+','+str(bins[2])+')','' ], [1, ':::PROB,CHI1,CHI2,CHI3,CHI4:::','']]

# Grab the entries for this residue and phi,psi bins
match_rotamers = rotamers.rotdat[bins[0]+":"+str(bins[1])+":"+str(bins[2])]

# Set max number of rotamers to display (probably should be somewhere 'higher up' in the code)
max_rotamers = min(10, len(match_rotamers))

# Create menu entry for each possible rotamer
for item in range(max_rotamers):
result.append( [ 1, str(match_rotamers[item]), 'rotamers.set_rotamer("'+s+'","'\
+str(match_rotamers[item][1])+'","'\
+str(match_rotamers[item][2])+'","'\
+str(match_rotamers[item][3])+'","'\
+str(match_rotamers[item][4])+'")'])
return result

</source>

[[Category:Script_Library|Rotamer Toggle]]

[[Category:Structural_Biology_Scripts|Rotamer Toggle]]

Wfmesh

2010-02-14T19:10:01Z

Cowsandmilk: /* SCRIPTS (WFMesh.py) */

===DESCRIPTION===
This script will create an object for any Wavefront(.OBJ) mesh file. This is a way to extend the number of objects you can use. Also, you have more control over the coloring, transformations, etc than the CGOs. Although there are a number of these obj files on the web, you can also easily created them with open source tools ([http://www.openfx.org OpenFX], [http://synapses.mcg.edu/tools/xroads/xroads.stm Crossroads3D]). It takes literally, 2 min to get an object created and then loaded into pymol. Simply open OpenFX Designer, click File->Insert->Model, then choose any of the models (or create your own of course!), then export it as .3ds file. Then open the .3ds file from Crossroads3D and export as Wavefront OBJ.

*createWFMesh - create a mesh object from Wavefront (*.obj) formated file

===IMAGES===
[[Image:Starwars_pymol.png|thumb|left|Star Wars Anyone?]]
[[Image:Torus_pymol.png|thumb|left|A Torus, as an example shape you could do. Notice polygon normals are being used...need smoothing!]]

[[Category:ThirdParty_Scripts]]

===SETUP===
Simply "run WFMesh.py"

===NOTES / STATUS===
*Tested on Pymolv0.97, Windows platform, should work on linux as well.
*Coloring is fixed for grey and sections of mesh are stored, but not used.
*Simple opengl calls; not optimized (display lists, etc) or anything.
*Vertex Normal code is broken, so normals are per polygon right now.
*Post problems in the discussion page, on 'my talk' page or just email me : dwkulp@mail.med.upenn.edu

===USAGE===
createWFObj file, name [,translate=[0,0,0]] [,flip=0]

===EXAMPLES===
createWFObj "ship.obj" "Ship"
createWFObj "torus.obj" "Torus" flip=1 # Flip = 1, if OBJ created by openFX, crossroads3D combination
createWFObj "torus.obj" "Torus" translate=[10,10,0] flip=1

===REFERENCES===
[http://www.openfx.org OpenFX]
[http://synapses.mcg.edu/tools/xroads/xroads.stm Crossroads3D]

===SCRIPTS (WFMesh.py)===
WFMesh.py
<source lang="python">
###############################################
# File: WFObj.py
# Author: Dan Kulp
# Creation Date: 5/13/05
#
# Notes:
# Create openGL objects from a wavefront (obj) file
###############################################

import os
import re
import math
from pymol.opengl.gl import *
from pymol.callback import Callback

# Wrapper Function, to create a given WFObj with a specific name (flip = 1 if OpenFX + Crossroads used)
def createWFObj(file, name,translate=[0,0,0],flip=0):
obj = WFMesh(file,translate,flip)
cmd.load_callback(obj,name)

# Class for Wavefront Mesh
class WFMesh(Callback):

verts = [] # list of vertices
polys = [] # list of poylgons
pnorms = [] # list of polynomal normals
vnorms = {} # dict. of vertex normals
vavenorms = [] # list of vertex normals, redundant -- I'm far froma python pro.
sections = {} # list of sections of mesh

# Read mesh into memory
def readOBJ(self,file):
if os.path.exists(file):
input = open(file,'r')
for line in input:
dat = re.split("\s+", line)

# Find vertex line
if line[0] == 'v' and line[1] != 't' and line[1] != 'n': self.verts.append([dat[1],dat[2],dat[3]])

# Find polygon line
if line[0] == 'f': self.polys.append([dat[1],dat[2],dat[3]])

# Find section line
if line[0] == 'g': self.sections[len(self.polys)] = dat[1]

# Compute the normals for each polygon and each vertex
def computeNorms(self):

# Compute norms for each polygon
for p in self.polys:
v12 = [float(self.verts[int(p[1])-1][0]) - float(self.verts[int(p[0])-1][0]),\
float(self.verts[int(p[1])-1][1]) - float(self.verts[int(p[0])-1][1]),\
float(self.verts[int(p[1])-1][2]) - float(self.verts[int(p[0])-1][2]) \
]

v13 = [float(self.verts[int(p[2])-1][0]) - float(self.verts[int(p[0])-1][0]),\
float(self.verts[int(p[2])-1][1]) - float(self.verts[int(p[0])-1][1]),\
float(self.verts[int(p[2])-1][2]) - float(self.verts[int(p[0])-1][2]) \
]

# Compute poly normal
polynorm = self.cross(v12,v13)
norm = self.normalize(polynorm)

# Files created by OpenFX, Crossroads combination need have their normals flipped
if self.flip:
norm[0] = -norm[0]
norm[1] = -norm[1]
norm[2] = -norm[2]

# Append poly norm to polygonal norm array
self.pnorms.append(norm)

# Add norm to each vertexes norm..
try:
self.vnorms[int(p[0])-1] = [float(self.vnorms[int(p[0])-1][0]) + norm[0],
float(self.vnorms[int(p[0])-1][1]) + norm[1],
float(self.vnorms[int(p[0])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[0])-1] = [norm[0],norm[1],norm[2]]

try:
self.vnorms[int(p[1])-1] = [float(self.vnorms[int(p[1])-1][0]) + norm[0],
float(self.vnorms[int(p[1])-1][1]) + norm[1],
float(self.vnorms[int(p[1])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[1])-1] = [norm[0],norm[1],norm[2]]

try:
self.vnorms[int(p[2])-1] = [float(self.vnorms[int(p[1])-1][0]) + norm[0],
float(self.vnorms[int(p[1])-1][1]) + norm[1],
float(self.vnorms[int(p[1])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[2])-1] = [norm[0],norm[1],norm[2]]

# Average out each vnorm..
index = 0
for v in self.vnorms.values():
self.vavenorms.append([v[0]/4, v[1]/4, v[2]/4])
index += 1

# Utility function to normalize a given vector
def normalize(self,v):
mag = v[0]*v[0]+v[1]*v[1]+v[2]*v[2]
if mag <= 0:
mag = 1
else:
mag = math.sqrt(mag)

return [v[0]/mag, v[1]/mag,v[2]/mag]

# Utility cross product function
def cross(self,v1,v2):
x = 0
y = 1
z = 2

return [v1[y]*v2[z] - v1[z]*v2[y],\
v1[z]*v2[x] - v1[x]*v2[z],\
v1[x]*v2[y] - v1[y]*v2[x]
]

# Constructor
def __init__(self, file,translate=[0,0,0],flip=0):
self.verts = []
self.polys = []
self.pnorms = []
self.vnorms = {}
self.vavenorms = []
self.translate = translate
self.flip = flip

print "Read in file: "+str(file)
self.readOBJ(file)
print "Done reading in WFMesh, now compute norms"
self.computeNorms()
print "Done computing norms, now display WFMesh"

# Draw Function
def __call__(self):

glColorMaterial(GL_FRONT, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);

# Color Everything grey
glColor3f(0.5,0.5,0.5);

index = 0
glPushMatrix()
glTranslated(self.translate[0],self.translate[1],self.translate[2])
for p in self.polys:
glBegin(GL_POLYGON)
glNormal3f(float(self.pnorms[index][0]),float(self.pnorms[index][1]),float(self.pnorms[index][2]))

for i in range(0,len(p)):
glVertex3f(float(self.verts[int(p[i])-1][0]),float(self.verts[int(p[i])-1][1]),float(self.verts[int(p[i])-1][2]))

# Vertex Normals - not computed correctly, so commented out for now
# norm = self.vnorms[int(p[i])-1]
# glNormal3f(float(norm[0]),float(norm[1]),float(norm[2]))
glEnd()
index += 1
glPopMatrix()

cmd.extend("createWFObj", createWFObj)
</source>

===ADDITIONAL RESOURCES===
Torus.obj
[http://pymolwiki.org/images/9/98/Torus.zip Torus.zip]

[[Category:Script_Library|WFMesh]]

Wfmesh

2010-02-14T19:09:27Z

Cowsandmilk: Undo revision 8034 by Cowsandmilk (Talk)

===DESCRIPTION===
This script will create an object for any Wavefront(.OBJ) mesh file. This is a way to extend the number of objects you can use. Also, you have more control over the coloring, transformations, etc than the CGOs. Although there are a number of these obj files on the web, you can also easily created them with open source tools ([http://www.openfx.org OpenFX], [http://synapses.mcg.edu/tools/xroads/xroads.stm Crossroads3D]). It takes literally, 2 min to get an object created and then loaded into pymol. Simply open OpenFX Designer, click File->Insert->Model, then choose any of the models (or create your own of course!), then export it as .3ds file. Then open the .3ds file from Crossroads3D and export as Wavefront OBJ.

*createWFMesh - create a mesh object from Wavefront (*.obj) formated file

===IMAGES===
[[Image:Starwars_pymol.png|thumb|left|Star Wars Anyone?]]
[[Image:Torus_pymol.png|thumb|left|A Torus, as an example shape you could do. Notice polygon normals are being used...need smoothing!]]

[[Category:ThirdParty_Scripts]]

===SETUP===
Simply "run WFMesh.py"

===NOTES / STATUS===
*Tested on Pymolv0.97, Windows platform, should work on linux as well.
*Coloring is fixed for grey and sections of mesh are stored, but not used.
*Simple opengl calls; not optimized (display lists, etc) or anything.
*Vertex Normal code is broken, so normals are per polygon right now.
*Post problems in the discussion page, on 'my talk' page or just email me : dwkulp@mail.med.upenn.edu

===USAGE===
createWFObj file, name [,translate=[0,0,0]] [,flip=0]

===EXAMPLES===
createWFObj "ship.obj" "Ship"
createWFObj "torus.obj" "Torus" flip=1 # Flip = 1, if OBJ created by openFX, crossroads3D combination
createWFObj "torus.obj" "Torus" translate=[10,10,0] flip=1

===REFERENCES===
[http://www.openfx.org OpenFX]
[http://synapses.mcg.edu/tools/xroads/xroads.stm Crossroads3D]

===SCRIPTS (WFMesh.py)===
WFMesh.py
<source lang="python">
###############################################
# File: WFObj.py
# Author: Dan Kulp
# Creation Date: 5/13/05
#
# Notes:
# Create openGL objects from a wavefront (obj) file
###############################################

import os
import re
import math
from pymol.opengl.gl import *
from pymol.callback import Callback

# Wrapper Function, to create a given WFObj with a specific name (flip = 1 if OpenFX + Crossroads used)
def createWFObj(file, name,translate=[0,0,0],flip=0):
obj = WFMesh(file,translate,flip)
cmd.load_callback(obj,name)

# Class for Wavefront Mesh
class WFMesh(Callback):

verts = [] # list of vertices
polys = [] # list of poylgons
pnorms = [] # list of polynomal normals
vnorms = {} # dict. of vertex normals
vavenorms = [] # list of vertex normals, redundant -- I'm far froma python pro.
sections = {} # list of sections of mesh

# Read mesh into memory
def readOBJ(self,file):
if os.path.exists(file):
input = open(file,'r')
for line in input:
dat = re.split("\s+", line)

# Find vertex line
if line[0] == 'v' and line[1] != 't' and line[1] != 'n': self.verts.append([dat[1],dat[2],dat[3]])

# Find polygon line
if line[0] == 'f': self.polys.append([dat[1],dat[2],dat[3]])

# Find section line
if line[0] == 'g': self.sections[len(self.polys)] = dat[1]

# Compute the normals for each polygon and each vertex
def computeNorms(self):

# Compute norms for each polygon
for p in self.polys:
v12 = [float(self.verts[int(p[1])-1][0]) - float(self.verts[int(p[0])-1][0]),\
float(self.verts[int(p[1])-1][1]) - float(self.verts[int(p[0])-1][1]),\
float(self.verts[int(p[1])-1][2]) - float(self.verts[int(p[0])-1][2]) \
]

v13 = [float(self.verts[int(p[2])-1][0]) - float(self.verts[int(p[0])-1][0]),\
float(self.verts[int(p[2])-1][1]) - float(self.verts[int(p[0])-1][1]),\
float(self.verts[int(p[2])-1][2]) - float(self.verts[int(p[0])-1][2]) \
]

# Compute poly normal
polynorm = self.cross(v12,v13)
norm = self.normalize(polynorm)

# Files created by OpenFX, Crossroads combination need have their normals flipped
if self.flip:
norm[0] = -norm[0]
norm[1] = -norm[1]
norm[2] = -norm[2]

# Append poly norm to polygonal norm array
self.pnorms.append(norm)

# Add norm to each vertexes norm..
try:
self.vnorms[int(p[0])-1] = [float(self.vnorms[int(p[0])-1][0]) + norm[0],
float(self.vnorms[int(p[0])-1][1]) + norm[1],
float(self.vnorms[int(p[0])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[0])-1] = [norm[0],norm[1],norm[2]]

try:
self.vnorms[int(p[1])-1] = [float(self.vnorms[int(p[1])-1][0]) + norm[0],
float(self.vnorms[int(p[1])-1][1]) + norm[1],
float(self.vnorms[int(p[1])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[1])-1] = [norm[0],norm[1],norm[2]]

try:
self.vnorms[int(p[2])-1] = [float(self.vnorms[int(p[1])-1][0]) + norm[0],
float(self.vnorms[int(p[1])-1][1]) + norm[1],
float(self.vnorms[int(p[1])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[2])-1] = [norm[0],norm[1],norm[2]]

# Average out each vnorm..
index = 0
for v in self.vnorms.values():
self.vavenorms.append([v[0]/4, v[1]/4, v[2]/4])
index += 1

# Utility function to normalize a given vector
def normalize(self,v):
mag = v[0]*v[0]+v[1]*v[1]+v[2]*v[2]
if mag <= 0:
mag = 1
else:
mag = math.sqrt(mag)

return [v[0]/mag, v[1]/mag,v[2]/mag]

# Utility cross product function
def cross(self,v1,v2):
x = 0
y = 1
z = 2

return [v1[y]*v2[z] - v1[z]*v2[y],\
v1[z]*v2[x] - v1[x]*v2[z],\
v1[x]*v2[y] - v1[y]*v2[x]
]

# Constructor
def __init__(self, file,translate=[0,0,0],flip=0):
self.verts = []
self.polys = []
self.pnorms = []
self.vnorms = {}
self.vavenorms = []
self.translate = translate
self.flip = flip

print "Read in file: "+str(file)
self.readOBJ(file)
print "Done reading in WFMesh, now compute norms"
self.computeNorms()
print "Done computing norms, now display WFMesh"

# Draw Function
def __call__(self):

glColorMaterial(GL_FRONT, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);

# Color Everything grey
glColor3f(0.5,0.5,0.5);

index = 0
glPushMatrix()
glTranslated(self.translate[0],self.translate[1],self.translate[2])
for p in self.polys:
glBegin(GL_POLYGON)
glNormal3f(float(self.pnorms[index][0]),float(self.pnorms[index][1]),float(self.pnorms[index][2]))

for i in range(0,len(p)):
glVertex3f(float(self.verts[int(p[i])-1][0]),float(self.verts[int(p[i])-1][1]),float(self.verts[int(p[i])-1][2]))

# Vertex Normals - not computed correctly, so commented out for now
# norm = self.vnorms[int(p[i])-1]
# glNormal3f(float(norm[0]),float(norm[1]),float(norm[2]))
glEnd()
index += 1
glPopMatrix()

cmd.extend("createWFObj", createWFObj)

</source>

===ADDITIONAL RESOURCES===
Torus.obj
[http://pymolwiki.org/images/9/98/Torus.zip Torus.zip]

[[Category:Script_Library|WFMesh]]

DynoPlot

2010-02-14T19:08:37Z

Cowsandmilk: /* SCRIPTS (DynoPlot.py) */

===DESCRIPTION===
This script was setup to do generic plotting, that is given a set of data and axis labels it would create a plot. Initially, I had it setup to draw the plot directly in the PyMol window (allowing for both 2D and 3D style plots), but because I couldn't figure out how to billboard CGO objects (Warren told me at the time that it couldn't be done) I took a different approach. The plot now exists in it's own window and can only do 2D plots. It is however interactive. I only have here a Rama.(phi,psi) plot, but the code can be easily extended to other types of data. For instance, I had this working for an energy vs distance data that I had generated by another script.

This script will create a Phi vs Psi(Ramachandran) plot of the selection given. The plot will display data points which can be dragged around Phi,Psi space with the corresponding residue's Phi,Psi angles changing in the structure (PyMol window).

===IMAGES===
<gallery>
Image:RamaPlotInitComposite.png|Initial Ramachandran plot of 1ENV
Image:RamaPlotBentComposite.png|Modified pose and plot of 1ENV
</gallery>

===SETUP===
place the DynoPlot.py script into the appropriate startup directory then restart PyMol

==== LINUX old-style installation ====

$PYMOL_PATH/modules/pmg_tk/startup/

==== LINUX distutils installation ====

/usr/lib/pythonX.X/site-packages/pmg_tk/startup/

==== Windows ====

PYMOL_PATH/modules/pmg_tk/startup/ , where PYMOL_PATH on Windows is defaulted to C:/Program Files/DeLano Scientific/PyMol/start/

===NOTES / STATUS===
*Tested on Windows, PyMol version 0.97
*This is an initial version, which needs some work.
*Left, Right mouse buttons do different things; Right = identify data point, Left = drag data point around
*Post comments/questions or send them to: dwkulp@mail.med.upenn.edu

===USAGE===
rama SELECTION

===EXAMPLES===
*load pdb file 1ENV (download it or use the PDB loader plugin)
*select resi 129-136
*rama sel01
*rock # the object needs to be moving in order for the angles to be updated.

===REFERENCES===

===SCRIPTS (DynoPlot.py)===
DynoPlot.py
<source lang="python">
#!/usr/bin/env python
###############################################
# File: DynoPlot.py
# Author: Dan Kulp
# Creation Date: 8/29/05
#
# Notes:
# Draw plots that display interactive data.
# Phi,Psi plot shown.
###############################################

from __future__ import division
from __future__ import generators

import os,math
import Tkinter
from Tkinter import *
import Pmw
import distutils.spawn # used for find_executable
import random
from pymol import cmd

try:
import pymol
REAL_PYMOL = True
except ImportError:
print "Nope"

canvas = None
rootframe = None
init = 0

class SimplePlot(Tkinter.Canvas):

# Class variables
mark = 'Oval' # Only 'Oval' for now..
mark_size = 5
xlabels = [] # axis labels
ylabels = []
spacingx = 0 # spacing in x direction
spacingy = 0
xmin = 0 # min value from each axis
ymin = 0
lastx = 0 # previous x,y pos of mouse
lasty = 0
down = 0 # flag for mouse pressed
item = (0,) # items array used for clickable events
shapes = {} # store plot data, x,y etc..

def axis(self,xmin=40,xmax=300,ymin=10,ymax=290,xint=290,yint=40,xlabels=[],ylabels=[]):

# Store variables in self object
self.xlabels = xlabels
self.ylabels = ylabels
self.spacingx = (xmax-xmin) / (len(xlabels) - 1)
self.spacingy = (ymax-ymin) / (len(ylabels) - 1)
self.xmin = xmin
self.ymin = ymin

# Create axis lines
self.create_line((xmin,xint,xmax,xint),fill="black",width=3)
self.create_line((yint,ymin,yint,ymax),fill="black",width=3)

# Create tick marks and labels
nextspot = xmin
for label in xlabels:
self.create_line((nextspot, xint+5,nextspot, xint-5),fill="black",width=2)
self.create_text(nextspot, xint-15, text=label)
if len(xlabels) == 1:
nextspot = xmax
else:
nextspot += (xmax - xmin)/ (len(xlabels) - 1)

nextspot = ymax
for label in ylabels:
self.create_line((yint+5,nextspot,yint-5,nextspot),fill="black",width=2)
self.create_text(yint-20,nextspot,text=label)
if len(ylabels) == 1:
nextspot = ymin
else:
nextspot -= (ymax - ymin)/ (len(ylabels) - 1)

# Plot a point
def plot(self,xp,yp,meta):

# Convert from 'label' space to 'pixel' space
x = self.convertToPixel("X",xp)
y = self.convertToPixel("Y",yp)

if self.mark == "Oval":
oval = self.create_oval(x-self.mark_size,y-self.mark_size,x+self.mark_size,y+self.mark_size,width=1,outline="black",fill="SkyBlue2")

self.shapes[oval] = [x,y,0,xp,yp,meta]

# Repaint all points
def repaint(self):
for value in self.shapes.values():
x = value[0]
y = value[1]
self.create_oval(x-self.mark_size,y-self.mark_size,x+self.mark_size,y+self.mark_size,width=1,outline="black",fill="SkyBlue2")

# Convert from pixel space to label space
def convertToLabel(self,axis, value):

# Defaultly use X-axis info
label0 = self.xlabels[0]
label1 = self.xlabels[1]
spacing = self.spacingx
min = self.xmin

# Set info for Y-axis use
if axis == "Y":
label0 = self.ylabels[0]
label1 = self.ylabels[1]
spacing = self.spacingy
min = self.ymin

pixel = value - min
label = pixel / spacing
label = label0 + label * abs(label1 - label0)

if axis == "Y":
label = - label

return label

# Converts value from 'label' space to 'pixel' space
def convertToPixel(self,axis, value):

# Defaultly use X-axis info
label0 = self.xlabels[0]
label1 = self.xlabels[1]
spacing = self.spacingx
min = self.xmin

# Set info for Y-axis use
if axis == "Y":
label0 = self.ylabels[0]
label1 = self.ylabels[1]
spacing = self.spacingy
min = self.ymin

# Get axis increment in 'label' space
inc = abs(label1 - label0)

# 'Label' difference from value and smallest label (label0)
diff = float(value - label0)

# Get whole number in 'label' space
whole = int(diff / inc)

# Get fraction number in 'label' space
part = float(float(diff/inc) - whole)

# Return 'pixel' position value
pixel = whole * spacing + part * spacing

# print "Pixel: %f * %f + %f * %f = %f" % (whole, spacing, part, spacing,pixel)

# Reverse number by subtracting total number of pixels - value pixels
if axis == "Y":
tot_label_diff = float(self.ylabels[len(self.ylabels)- 1] - label0)
tot_label_whole = int(tot_label_diff / inc)
tot_label_part = float(float(tot_label_diff / inc) - tot_label_whole)
tot_label_pix = tot_label_whole * spacing + tot_label_part *spacing

pixel = tot_label_pix - pixel

# Add min edge pixels
pixel = pixel + min

return pixel

# Print out which data point you just clicked on..
def pickWhich(self,event):

# Find closest data point
x = event.widget.canvasx(event.x)
y = event.widget.canvasx(event.y)
spot = event.widget.find_closest(x,y)

# Print the shape's meta information corresponding with the shape that was picked
if spot[0] in self.shapes:
print "Residue(Ca): %s\n" % self.shapes[spot[0]][5][2]

# Mouse Down Event
def down(self,event):

# Store x,y position
self.lastx = event.x
self.lasty = event.y

# Find the currently selected item
x = event.widget.canvasx(event.x)
y = event.widget.canvasx(event.y)
self.item = event.widget.find_closest(x,y)

# Identify that the mouse is down
self.down = 1

# Mouse Up Event
def up(self,event):

# Get label space version of x,y
labelx = self.convertToLabel("X",event.x)
labely = self.convertToLabel("Y",event.y)

# Convert new position into label space..
if self.item[0] in self.shapes:
self.shapes[self.item[0]][0] = event.x
self.shapes[self.item[0]][1] = event.y
self.shapes[self.item[0]][2] = 1
self.shapes[self.item[0]][3] = labelx
self.shapes[self.item[0]][4] = labely

# Reset Flags
self.item = (0,)
self.down = 0

# Mouse Drag(Move) Event
def drag(self,event):

# Check that mouse is down and item clicked is a valid data point
if self.down and self.item[0] in self.shapes:

self.move(self.item, event.x - self.lastx, event.y - self.lasty)

self.lastx = event.x
self.lasty = event.y

def __init__(self):

self.menuBar.addcascademenu('Plugin', 'PlotTools', 'Plot Tools',
label='Plot Tools')
self.menuBar.addmenuitem('PlotTools', 'command',
'Launch Rama Plot',
label='Rama Plot',
command = lambda s=self: ramaplot())

def ramaplot(x=0,y=0,meta=[],clear=0):
global canvas
global rootframe
global init

# If no window is open
if init == 0:
rootframe=Tk()
rootframe.title(' Dynamic Angle Plotting ')
rootframe.protocol("WM_DELETE_WINDOW", close_callback)

canvas = SimplePlot(rootframe,width=320,height=320)
canvas.bind("<Button-2>",canvas.pickWhich)
canvas.bind("<Button-3>",canvas.pickWhich)
canvas.bind("<ButtonPress-1>",canvas.down)
canvas.bind("<ButtonRelease-1>",canvas.up)
canvas.bind("<Motion>",canvas.drag)
canvas.pack(side=Tkinter.LEFT,fill="both",expand=1)
canvas.axis(xint=150,xlabels=[-180,-150,-120,-90,-60,-30,0,30,60,90,120,150,180],ylabels=[-180,-150,-120,-90,-60,-30,0,30,60,90,120,150,180])
canvas.update()
init = 1
else:
canvas.plot(int(x), int(y),meta)

def close_callback():
global init
global rootframe
init = 0
rootframe.destroy()

# New Callback object, so that we can update the structure when phi,psi points are moved.
class DynoRamaObject:
global canvas

def start(self,sel):

# Get selection model
model = cmd.get_model(sel)
residues = ['dummy']
resnames = ['dummy']
phi = []
psi = []
dummy = []
i = 0

# Loop through each atom
for at in model.atom:

# Only plot once per residue
if at.chain+":"+at.resn+":"+at.resi not in residues:
residues.append(at.chain+":"+at.resn+":"+at.resi)
resnames.append(at.resn+at.resi)
dummy.append(i)
i += 1

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if at.chain != "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue i-1, i and i+1
residue_def = unit_select+'resi '+str(at.resi)
residue_def_prev = unit_select+'resi '+str(int(at.resi)-1)
residue_def_next = unit_select+'resi '+str(int(at.resi)+1)

try:
# Store phi,psi residue definitions to pass on to plot routine
phi_psi = [
# Phi angles
residue_def_prev+' and name C',
residue_def+' and name N',
residue_def+' and name CA',
residue_def+' and name C',
# Psi angles
residue_def+' and name N',
residue_def+' and name CA',
residue_def+' and name C',
residue_def_next+' and name N']

# Compute phi/psi angle
phi = cmd.get_dihedral(phi_psi[0],phi_psi[1],phi_psi[2],phi_psi[3])
psi = cmd.get_dihedral(phi_psi[4],phi_psi[5],phi_psi[6],phi_psi[7])

print "Plotting Phi,Psi: "+str(phi)+","+str(psi)
ramaplot(phi,psi,meta=phi_psi)
except:
continue

def __call__(self):

# Loop through each item on plot to see if updated
for key,value in canvas.shapes.items():
dihedrals = value[5]

# Look for update flag...
if value[2]:

# Set residue's phi,psi to new values
print "Re-setting Phi,Psi: %s,%s" % (value[3],value[4])
cmd.set_dihedral(dihedrals[0],dihedrals[1],dihedrals[2],dihedrals[3],value[3])
cmd.set_dihedral(dihedrals[4],dihedrals[5],dihedrals[6],dihedrals[7],value[4])

value[2] = 0

# The wrapper function, used to create the Ploting window and the PyMol callback object
def rama(sel):
rama = DynoRamaObject()
rama.start(sel)
cmd.load_callback(rama, "DynoRamaObject")
cmd.zoom("all")

# Extend these commands
cmd.extend('rama',rama)
cmd.extend('ramaplot',ramaplot)
</source>

===ADDITIONAL RESOURCES===

[[Category:Script_Library|DynoPlot]]
[[Category:Structural_Biology_Scripts|DynoPlot]]

DynoPlot

2010-02-14T19:07:09Z

Cowsandmilk: Undo revision 8032 by Cowsandmilk (Talk)

===DESCRIPTION===
This script was setup to do generic plotting, that is given a set of data and axis labels it would create a plot. Initially, I had it setup to draw the plot directly in the PyMol window (allowing for both 2D and 3D style plots), but because I couldn't figure out how to billboard CGO objects (Warren told me at the time that it couldn't be done) I took a different approach. The plot now exists in it's own window and can only do 2D plots. It is however interactive. I only have here a Rama.(phi,psi) plot, but the code can be easily extended to other types of data. For instance, I had this working for an energy vs distance data that I had generated by another script.

This script will create a Phi vs Psi(Ramachandran) plot of the selection given. The plot will display data points which can be dragged around Phi,Psi space with the corresponding residue's Phi,Psi angles changing in the structure (PyMol window).

===IMAGES===
<gallery>
Image:RamaPlotInitComposite.png|Initial Ramachandran plot of 1ENV
Image:RamaPlotBentComposite.png|Modified pose and plot of 1ENV
</gallery>

===SETUP===
place the DynoPlot.py script into the appropriate startup directory then restart PyMol

==== LINUX old-style installation ====

$PYMOL_PATH/modules/pmg_tk/startup/

==== LINUX distutils installation ====

/usr/lib/pythonX.X/site-packages/pmg_tk/startup/

==== Windows ====

PYMOL_PATH/modules/pmg_tk/startup/ , where PYMOL_PATH on Windows is defaulted to C:/Program Files/DeLano Scientific/PyMol/start/

===NOTES / STATUS===
*Tested on Windows, PyMol version 0.97
*This is an initial version, which needs some work.
*Left, Right mouse buttons do different things; Right = identify data point, Left = drag data point around
*Post comments/questions or send them to: dwkulp@mail.med.upenn.edu

===USAGE===
rama SELECTION

===EXAMPLES===
*load pdb file 1ENV (download it or use the PDB loader plugin)
*select resi 129-136
*rama sel01
*rock # the object needs to be moving in order for the angles to be updated.

===REFERENCES===

===SCRIPTS (DynoPlot.py)===
DynoPlot.py
<source lang="python">
#!/usr/bin/env python
###############################################
# File: DynoPlot.py
# Author: Dan Kulp
# Creation Date: 8/29/05
#
# Notes:
# Draw plots that display interactive data.
# Phi,Psi plot shown.
###############################################

from __future__ import division
from __future__ import generators

import os,math
import Tkinter
from Tkinter import *
import Pmw
import distutils.spawn # used for find_executable
import random
from pymol import cmd

try:
import pymol
REAL_PYMOL = True
except ImportError:
print "Nope"

canvas = None
init = 0

class SimplePlot(Tkinter.Canvas):

# Class variables
mark = 'Oval' # Only 'Oval' for now..
mark_size = 5
xlabels = [] # axis labels
ylabels = []
spacingx = 0 # spacing in x direction
spacingy = 0
xmin = 0 # min value from each axis
ymin = 0
lastx = 0 # previous x,y pos of mouse
lasty = 0
down = 0 # flag for mouse pressed
item = (0,) # items array used for clickable events
shapes = {} # store plot data, x,y etc..

def axis(self,xmin=40,xmax=300,ymin=10,ymax=290,xint=290,yint=40,xlabels=[],ylabels=[]):

# Store variables in self object
self.xlabels = xlabels
self.ylabels = ylabels
self.spacingx = (xmax-xmin) / (len(xlabels) - 1)
self.spacingy = (ymax-ymin) / (len(ylabels) - 1)
self.xmin = xmin
self.ymin = ymin

# Create axis lines
self.create_line((xmin,xint,xmax,xint),fill="black",width=3)
self.create_line((yint,ymin,yint,ymax),fill="black",width=3)

# Create tick marks and labels
nextspot = xmin
for label in xlabels:
self.create_line((nextspot, xint+5,nextspot, xint-5),fill="black",width=2)
self.create_text(nextspot, xint-15, text=label)
if len(xlabels) == 1:
nextspot = xmax
else:
nextspot += (xmax - xmin)/ (len(xlabels) - 1)

nextspot = ymax
for label in ylabels:
self.create_line((yint+5,nextspot,yint-5,nextspot),fill="black",width=2)
self.create_text(yint-20,nextspot,text=label)
if len(ylabels) == 1:
nextspot = ymin
else:
nextspot -= (ymax - ymin)/ (len(ylabels) - 1)

# Plot a point
def plot(self,xp,yp,meta):

# Convert from 'label' space to 'pixel' space
x = self.convertToPixel("X",xp)
y = self.convertToPixel("Y",yp)

if self.mark == "Oval":
oval = self.create_oval(x-self.mark_size,y-self.mark_size,x+self.mark_size,y+self.mark_size,width=1,outline="black",fill="SkyBlue2")

self.shapes[oval] = [x,y,0,xp,yp,meta]

# Repaint all points
def repaint(self):
for value in self.shapes.values():
x = value[0]
y = value[1]
self.create_oval(x-self.mark_size,y-self.mark_size,x+self.mark_size,y+self.mark_size,width=1,outline="black",fill="SkyBlue2")

# Convert from pixel space to label space
def convertToLabel(self,axis, value):

# Defaultly use X-axis info
label0 = self.xlabels[0]
label1 = self.xlabels[1]
spacing = self.spacingx
min = self.xmin

# Set info for Y-axis use
if axis == "Y":
label0 = self.ylabels[0]
label1 = self.ylabels[1]
spacing = self.spacingy
min = self.ymin

pixel = value - min
label = pixel / spacing
label = label0 + label * abs(label1 - label0)

if axis == "Y":
label = - label

return label

# Converts value from 'label' space to 'pixel' space
def convertToPixel(self,axis, value):

# Defaultly use X-axis info
label0 = self.xlabels[0]
label1 = self.xlabels[1]
spacing = self.spacingx
min = self.xmin

# Set info for Y-axis use
if axis == "Y":
label0 = self.ylabels[0]
label1 = self.ylabels[1]
spacing = self.spacingy
min = self.ymin

# Get axis increment in 'label' space
inc = abs(label1 - label0)

# 'Label' difference from value and smallest label (label0)
diff = float(value - label0)

# Get whole number in 'label' space
whole = int(diff / inc)

# Get fraction number in 'label' space
part = float(float(diff/inc) - whole)

# Return 'pixel' position value
pixel = whole * spacing + part * spacing

# print "Pixel: %f * %f + %f * %f = %f" % (whole, spacing, part, spacing,pixel)

# Reverse number by subtracting total number of pixels - value pixels
if axis == "Y":
tot_label_diff = float(self.ylabels[len(self.ylabels)- 1] - label0)
tot_label_whole = int(tot_label_diff / inc)
tot_label_part = float(float(tot_label_diff / inc) - tot_label_whole)
tot_label_pix = tot_label_whole * spacing + tot_label_part *spacing

pixel = tot_label_pix - pixel

# Add min edge pixels
pixel = pixel + min

return pixel

# Print out which data point you just clicked on..
def pickWhich(self,event):

# Find closest data point
x = event.widget.canvasx(event.x)
y = event.widget.canvasx(event.y)
spot = event.widget.find_closest(x,y)

# Print the shape's meta information corresponding with the shape that was picked
if spot[0] in self.shapes:
print "Residue(Ca): %s\n" % self.shapes[spot[0]][5][2]

# Mouse Down Event
def down(self,event):

# Store x,y position
self.lastx = event.x
self.lasty = event.y

# Find the currently selected item
x = event.widget.canvasx(event.x)
y = event.widget.canvasx(event.y)
self.item = event.widget.find_closest(x,y)

# Identify that the mouse is down
self.down = 1

# Mouse Up Event
def up(self,event):

# Get label space version of x,y
labelx = self.convertToLabel("X",event.x)
labely = self.convertToLabel("Y",event.y)

# Convert new position into label space..
if self.item[0] in self.shapes:
self.shapes[self.item[0]][0] = event.x
self.shapes[self.item[0]][1] = event.y
self.shapes[self.item[0]][2] = 1
self.shapes[self.item[0]][3] = labelx
self.shapes[self.item[0]][4] = labely

# Reset Flags
self.item = (0,)
self.down = 0

# Mouse Drag(Move) Event
def drag(self,event):

# Check that mouse is down and item clicked is a valid data point
if self.down and self.item[0] in self.shapes:

self.move(self.item, event.x - self.lastx, event.y - self.lasty)

self.lastx = event.x
self.lasty = event.y

def __init__(self):

self.menuBar.addcascademenu('Plugin', 'PlotTools', 'Plot Tools',
label='Plot Tools')
self.menuBar.addmenuitem('PlotTools', 'command',
'Launch Rama Plot',
label='Rama Plot',
command = lambda s=self: ramaplot())

def ramaplot(x=0,y=0,meta=[],clear=0):
global canvas
global init

# If no window is open
if init == 0:
rootframe=Tk()
rootframe.title(' Dynamic Angle Plotting ')

canvas = SimplePlot(rootframe,width=320,height=320)
canvas.bind("<Button-2>",canvas.pickWhich)
canvas.bind("<Button-3>",canvas.pickWhich)
canvas.bind("<ButtonPress-1>",canvas.down)
canvas.bind("<ButtonRelease-1>",canvas.up)
canvas.bind("<Motion>",canvas.drag)
canvas.pack(side=Tkinter.LEFT,fill="both",expand=1)
canvas.axis(xint=150,xlabels=[-180,-150,-120,-90,-60,-30,0,30,60,90,120,150,180],ylabels=[-180,-150,-120,-90,-60,-30,0,30,60,90,120,150,180])
canvas.update()
init = 1
else:
canvas.plot(int(x), int(y),meta)

# New Callback object, so that we can update the structure when phi,psi points are moved.
class DynoRamaObject:
global canvas

def start(self,sel):

# Get selection model
model = cmd.get_model(sel)
residues = ['dummy']
resnames = ['dummy']
phi = []
psi = []
dummy = []
i = 0

# Loop through each atom
for at in model.atom:

# Only plot once per residue
if at.chain+":"+at.resn+":"+at.resi not in residues:
residues.append(at.chain+":"+at.resn+":"+at.resi)
resnames.append(at.resn+at.resi)
dummy.append(i)
i += 1

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if at.chain != "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue i-1, i and i+1
residue_def = unit_select+'resi '+str(at.resi)
residue_def_prev = unit_select+'resi '+str(int(at.resi)-1)
residue_def_next = unit_select+'resi '+str(int(at.resi)+1)

try:
# Store phi,psi residue definitions to pass on to plot routine
phi_psi = [
# Phi angles
residue_def_prev+' and name C',
residue_def+' and name N',
residue_def+' and name CA',
residue_def+' and name C',
# Psi angles
residue_def+' and name N',
residue_def+' and name CA',
residue_def+' and name C',
residue_def_next+' and name N']

# Compute phi/psi angle
phi = cmd.get_dihedral(phi_psi[0],phi_psi[1],phi_psi[2],phi_psi[3])
psi = cmd.get_dihedral(phi_psi[4],phi_psi[5],phi_psi[6],phi_psi[7])

print "Plotting Phi,Psi: "+str(phi)+","+str(psi)
ramaplot(phi,psi,meta=phi_psi)
except:
continue

def __call__(self):

# Loop through each item on plot to see if updated
for key,value in canvas.shapes.items():
dihedrals = value[5]

# Look for update flag...
if value[2]:

# Set residue's phi,psi to new values
print "Re-setting Phi,Psi: %s,%s" % (value[3],value[4])
cmd.set_dihedral(dihedrals[0],dihedrals[1],dihedrals[2],dihedrals[3],value[3])
cmd.set_dihedral(dihedrals[4],dihedrals[5],dihedrals[6],dihedrals[7],value[4])

value[2] = 0

# The wrapper function, used to create the Ploting window and the PyMol callback object
def rama(sel):
rama = DynoRamaObject()
rama.start(sel)
cmd.load_callback(rama, "DynoRamaObject")
cmd.zoom("all")

# Extend these commands
cmd.extend('rama',rama)
cmd.extend('ramaplot',ramaplot)

</source>

===ADDITIONAL RESOURCES===

[[Category:Script_Library|DynoPlot]]
[[Category:Structural_Biology_Scripts|DynoPlot]]

Rotamer Toggle

2010-02-14T18:56:09Z

Cowsandmilk: Undo revision 8036 by Cowsandmilk (Talk)

===DESCRIPTION===
Backbone-Dependent Rotamer library (Dunbrack, Cohen ; see ref) is imported into pymol giving access to this information. There are a number of different ways to use the data, I've only implemented a few as well as added extra functions that seemed useful.
*Rotamer Menu - an added menu into menu.py, which displays the most common rotamers for the given(clicked) residue; you can also set the residue any of the common rotamers as well
*colorRotamers - color rotamers by closest matching rotamer angles from database; i.e. color by how common each rotamer of selection, blue - red (least to most common).
*set_rotamer - routine called by above menu, but can be called manually to set a specific residues side-chain angles
*set_phipsi - set all phi,psi angles of given selection to given angles (useful for creating secondary structures)
*createRotamerPDBs - create pdb for each rotamer of given selection ; filter by rotamer-probability

===IMAGES===
<gallery>
Image:RotamerMenu.png|Rotamer Menu for a GLN residue
Image:GLURotamerComparison5.png|Rotamer Comparison of crystal structure and most common for GLU; just as an example
</gallery>

Print out while selecting most common rotamer from above-left image (GLN residue):
Given GLN:40 PHI,PSI (-171.626373291,-96.0500335693) : bin (-170,-100)
CHIs: [179.18069458007812, 72.539344787597656, -47.217315673828125]
Setting Chi1 to -176.9
Setting Chi2 to 177.4
Setting Chi3 to 0.7

===SETUP===
run "rotamers.py" and use functions from commandline.

or

To setup a rotamer menu inside the residue menu (default windows pymol installation):
*copy rotamers.py to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/rotamers.py
*copy mymenu.py to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/menu.py (WARNING : overwrites default menu.py - use at your own risk)
*copy bbdep02.May.sortlib to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/bbdep02.May.sortlib (or newer version of sorted bbdep)
This is only one possible way to do this, I am sure there are many others. I'm not going to post the bbdep, but there is a link in the References section to Dunbrack's download page (get the "sorted" lib)

===NOTES / STATUS===
*Tested on Pymolv0.97, Windows platform, Red Hat Linux 9.0 and Fedora Core 4. Will test v0.98 and MacOSX later on.
*The way it's setup now, when you import rotamers , it will automatically read-in the rotamer database; this may not be what you want.
*Post problems in the discussion page, on 'my talk' page or just email me : dwkulp@mail.med.upenn.edu

TASKS TODO:
*Rotamer Movie, using mset, etc create movie to watch cycle through rotamers
*Code could be organized a bit better; due to time constraints this is good for now..

TASKS DONE:
*Store crystal structure in rotamer menu, so you can go back to original orientation

===USAGE===
colorRotamers selection
set_rotamer selection, chi1_angle [,chi2_angle] [,chi3_angle] [,chi4_angle]
set_phipsi selection phi_angle, psi_angle
createRotamerPBDs selection [,ncutoff] [,pcutoff] [,prefix]

===EXAMPLES===
colorRotamers chain A
set_rotamer resi 40, -60,-40 (only set chi1,chi2 angles)
set_phipsi resi 10-40, -60,-60 (create an alpha-helical-like section)
createRotamerPDBs resi 10-12, ncutoff=3 (create 9 PDBs; each with one of the 3 most probable rotamers for resi 10,11,12)
createRotamerPDBs resi 14, pcutoff=0.4 (create a pdb file for each rotamer of residue 14 with probablity > 0.4)

===REFERENCES===
Dunbrack and Cohen. Protein Science 1997

[http://dunbrack.fccc.edu/bbdep/index.php Dunbrack Lab Page (Contains backbone-dependent library)]

===SCRIPTS (Rotamers.py ; MyMenu.py)===
Rotamers.py
<source lang="python">
##################################################################
# File: Rotamers.py
# Author: Dan Kulp
# Creation Date: 6/8/05
# Contact: dwkulp@mail.med.upenn.edu
#
# Notes:
# Incorporation of Rotamer library
# readRotLib() - fills rotdat;
# indexed by "RES:PHI_BIN:PSI_BIN".
#
# Three main functions:
# 1. colorRotamers - colors according
# to rotamer probablitity
# 2. getBins(sel)
# phi,psi bin for rotamer
# 3. set_rotamer - set a side-chain
# to a specific rotamer
#
# To setup a rotamer menu in the
# right click, under "Residue"
# 1. cp mymenu.py modules/pymol/menu.py
# 2. cp rotamers.py modules/pymol/rotamers.py (update ROTLIB)
#
# Requirements:
# set ROTLIB to path for rotamer library
# Reference:
# Dunbrack and Cohen. Protein Science 1997
####################################################################

import colorsys,sys
import re
import editing
import os
import cmd
import math

# Path for library
ROTLIB=os.environ['PYMOL_PATH']+"/modules/pymol/bbdep02.May.sortlib"

# Place for library in memory..
rotdat = {}

def readRotLib():
# Column indexes in rotamer library..
RES = 0
PHI = 1
PSI = 2
PROB = 8
CHI1 = 9
CHI2 = 10
CHI3 = 11
CHI4 = 12

if os.path.exists(ROTLIB):
print "File exists: "+ROTLIB
input = open(ROTLIB, 'r')
for line in input:

# Parse by whitespace (I believe format is white space and not fixed-width columns)
dat = re.split("\s+",line)

# Add to rotamer library in memory :
# key format RES:PHI_BIN:PSI_BIN
# value format PROB, CHI1, CHI2, CHI3, CHI4
key = dat[RES]+":"+dat[PHI]+":"+dat[PSI]
if key in rotdat:
rotdat[key].append([ dat[PROB], dat[CHI1], dat[CHI2], dat[CHI3], dat[CHI4] ])
else:
rotdat[key] = [ [ dat[PROB], dat[CHI1], dat[CHI2], dat[CHI3], dat[CHI4] ] ]

else:
print "Couldn't find Rotamer library"

# Atoms for each side-chain angle for each residue
CHIS = {}
CHIS["ARG"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","NE" ],
["CG","CD","NE","CZ" ]
]

CHIS["ASN"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","OD2" ]
]

CHIS["ASP"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","OD1" ]
]
CHIS["CYS"] = [ ["N","CA","CB","SG" ]
]
CHIS["GLN"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","OE1"]
]

CHIS["GLU"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","OE1"]
]

CHIS["HIS"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","ND1"]
]

CHIS["ILE"] = [ ["N","CA","CB","CG1" ],
["CA","CB","CG1","CD1" ]
]

CHIS["LEU"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["LYS"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","CE"],
["CG","CD","CE","NZ"]
]

CHIS["MET"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","SD" ],
["CB","CG","SD","CE"]
]

CHIS["PHE"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["PRO"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ]
]

CHIS["SER"] = [ ["N","CA","CB","OG" ]
]

CHIS["THR"] = [ ["N","CA","CB","OG1" ]
]

CHIS["TRP"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1"]
]

CHIS["TYR"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["VAL"] = [ ["N","CA","CB","CG1" ]
]

# Color Rotamer by side-chain angle position
# 'bin' side-chain angles into closest
def colorRotamers(sel):
doRotamers(sel)

# Utility function, to set phi,psi angles for a given selection
# Note: Cartoon, Ribbon functionality will not display correctly after this
def set_phipsi(sel, phi,psi):
doRotamers(sel,angles=[phi,psi],type="set")

# Set a rotamer, based on a selection, a restype and chi angles
def set_rotamer(sel, chi1, chi2=0,chi3=0,chi4=0):
at = cmd.get_model("byres ("+sel+")").atom[0]

list = [chi1,chi2,chi3,chi4]
for i in range(len(CHIS[at.resn])):
print "Setting Chi"+str(i+1)+" to "+str(list[i])
editing.set_dihedral(sel + ' and name '+CHIS[at.resn][i][0],
sel + ' and name '+CHIS[at.resn][i][1],
sel + ' and name '+CHIS[at.resn][i][2],
sel + ' and name '+CHIS[at.resn][i][3], str(list[i]))

# Remove some objects that got created
cmd.delete("pk1")
cmd.delete("pk2")
cmd.delete("pkmol")

# Get Phi,Psi bins for given selection
# WARNING: assume selection is single residue (will only return first residue bins)
def getBins(sel):
return doRotamers(sel, type="bins")

# Color Ramp...
def rot_color(vals):
nbins = 10
vals.sort(key=lambda x: x[1])
# print "End sort: "+str(len(vals))+" : "+str(nbins)

# Coloring scheme...
j = 0
rgb = [0.0,0.0,0.0]
sel_str = ""
for i in range(len(vals)):
if int(len(vals)/nbins) == 0 or i % int(len(vals)/nbins) == 0:
hsv = (colorsys.TWO_THIRD - colorsys.TWO_THIRD * float(j) / (nbins-1), 1.0, 1.0)

#convert to rgb and append to color list
rgb = colorsys.hsv_to_rgb(hsv[0],hsv[1],hsv[2])
if j < nbins-1:
j += 1

cmd.set_color("RotProbColor"+str(i), rgb)
cmd.color("RotProbColor"+str(i), str(vals[i][0]))

# Main function
def doRotamers(sel,angles=[], type="color"):

# Read in Rotamer library if not already done
if len(rotdat) == 0:
readRotLib()

# Set up some variables..
residues = ['dummy'] # Keep track of residues already done
probs = [] # probability of each residue conformation
phi = 0 # phi,psi angles of current residue
psi = 0

# Get atoms from selection
atoms = cmd.get_model("byres ("+sel+")")

# Loop through atoms in selection
for at in atoms.atom:
try:
# Don't process Glycines or Alanines
if not (at.resn == 'GLY' or at.resn == 'ALA'):
if at.chain+":"+at.resn+":"+at.resi not in residues:
residues.append(at.chain+":"+at.resn+":"+at.resi)

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if at.chain != "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue i-1, i and i+1
residue_def = unit_select+'resi '+str(at.resi)
residue_def_prev = unit_select+'resi '+str(int(at.resi)-1)
residue_def_next = unit_select+'resi '+str(int(at.resi)+1)

# Compute phi/psi angle

phi = cmd.get_dihedral(residue_def_prev+' and name C',residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C')
psi = cmd.get_dihedral(residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',residue_def_next+' and name N')
if type == "set":
print "Changing "+at.resn+str(at.resi)+" from "+str(phi)+","+str(psi)+" to "+str(angles[0])+","+str(angles[1])
cmd.set_dihedral(residue_def_prev+' and name C',residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',angles[0])
cmd.set_dihedral(residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',residue_def_next+' and name N', angles[1])
continue

# Find correct 10x10 degree bin
phi_digit = abs(int(phi)) - abs(int(phi/10)*10)
psi_digit = abs(int(psi)) - abs(int(psi/10)*10)

# Remember sign of phi,psi angles
phi_sign = 1
if phi < 0: phi_sign = -1

psi_sign = 1
if psi < 0: psi_sign = -1

# Compute phi,psi bins
phi_bin = int(math.floor(abs(phi/10))*10*phi_sign)
if phi_digit >= 5: phi_bin = int(math.ceil(abs(phi/10))*10*phi_sign)

psi_bin = int(math.floor(abs(psi/10))*10*psi_sign)
if psi_digit >= 5: psi_bin = int(math.ceil(abs(psi/10))*10*psi_sign)

print "Given "+at.resn+":"+at.resi+" PHI,PSI ("+str(phi)+","+str(psi)+") : bin ("+str(phi_bin)+","+str(psi_bin)+")"

# Get current chi angle measurements
chi = []
for i in range(len(CHIS[at.resn])):
chi.append(cmd.get_dihedral(residue_def + ' and name '+CHIS[at.resn][i][0],
residue_def + ' and name '+CHIS[at.resn][i][1],
residue_def + ' and name '+CHIS[at.resn][i][2],
residue_def + ' and name '+CHIS[at.resn][i][3]))
print "CHIs: "+str(chi)
if type == 'bins':
return [at.resn, phi_bin,psi_bin]

# Compute probabilities for given chi angles
prob = 0
prob_box = 22
for item in range(len(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)])):
print "Rotamer from db: "+str(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item])
if chi[0]:
if chi[0] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][1]) - (prob_box/2) and \
chi[0] <= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][1]) + (prob_box/2):
if len(chi) == 1:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[1] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][2]) - (prob_box/2) and \
float(chi[1] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][2]) + (prob_box/2):
if len(chi) == 2:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[2] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][3]) - (prob_box/2) and \
float(chi[2] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][3]) + (prob_box/2):
if len(chi) == 3:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[3] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][4]) - (prob_box/2) and \
float(chi[3] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][4]) + (prob_box/2):
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break

print "PROB OF ROTAMER: "+str(prob)
print "---------------------------"
probs.append([residue_def, prob])

except:
# probs.append([residue_def, -1])
print "Exception found"
continue

# Color according to rotamer probability
rot_color(probs)

# Create PDB files containing most probable rotamers
def createRotamerPDBs(sel,ncutoff=10,pcutoff=0,prefix="ROTAMER"):

# Get atoms from selection
atoms = cmd.get_model("byres ("+sel+")")

# Set up some variables..
residues = ['dummy'] # Keep track of residues already done

# Loop through atoms in selection
for at in atoms.atom:
if at.resn in ('GLY', 'ALA') or "%s:%s:%s" % (at.chain,at.resn,at.resi) in residues:
continue

# Add to residue list (keep track of which ones we've done)
residues.append("%s:%s:%s" % (at.chain,at.resn,at.resi))

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if at.chain != "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue
residue_def = unit_select+'resi '+str(at.resi)

# Get bin (phi,psi) definitions for this residue
bin = doRotamers(residue_def, type='bins')

# Store crystal angle
crystal_angles = [0.0,0.0,0.0,0.0]
for angle in range(3):
try:
crystal_angles[angle] = bin[3][angle]
except IndexError:
break

# Retreive list of rotamers for this phi,psi bin + residue type
match_rotamers = rotdat["%s:%s:%s" % (bin[0],str(bin[1]),str(bin[2]))]

count = 0
for item in range(len(match_rotamers)):

# Store probablity
prob = match_rotamers[item][0]

# Check cutoffs
if float(prob) <= float(pcutoff):
continue

if float(count) >= float(ncutoff):
break

# Increment count
count += 1

# Output to screen ...
print "Residue %s%s, rotamer %i, prob %s" % (at.resn,at.resi,item,prob)

# Set to new rotamer
set_rotamer(residue_def,match_rotamers[item][1],match_rotamers[item][2],match_rotamers[item][3],match_rotamers[item][4])

# Store in PDB file
cmd.save("%s_%s%s_%i_%s.pdb" % (prefix,str(at.resn),str(at.resi),int(item),str(prob)))

# Reset crystal angle
set_rotamer(residue_def,crystal_angles[0],crystal_angles[1],crystal_angles[2],crystal_angles[3])

# Uncommenting this is nice because it loads rotamer library upon startup
# however, it slows the PyMOL loading process a lot
# instead I've put this call into the menuing code..
# readRotLib()

cmd.extend('set_phipsi',set_phipsi)
cmd.extend('set_rotamer',set_rotamer)
cmd.extend('colorRotamers',colorRotamers)
cmd.extend('createRotamerPDBs',createRotamerPDBs)

</source>

MyMenu.py
Since menu.py is copyrighted I can't post my edited version, but you can create it very simply by adding these two peices of code

1. In the "pick_option(title,s,object=0)" function of menu.py add the following code after the first "result =" statement
<source lang="python">
# Edit dwkulp 6/11/05 , add a rotamer menu to residue menu
if title == 'Residue':
result.extend([[ 1, 'rotamers' , rotamer_menu(s)]])
</source>

2. At the end of the file add this:
<source lang="python">
###############################################
# Dan Kulp
# Added Rotamer list to residue menu..
# rotamer.py must be importable (I placed it in
# the same directory as menu.py)
###############################################

import rotamers

def rotamer_menu(s):
# Check for rotamer library being loaded
if not rotamers.rotdat:
rotamers.readRotLib()
# return [ [2, "Must run rotamers.py first",'']]

# Check for valid rotamer residue..
res = cmd.get_model("byres ("+s+")").atom[0].resn
if not res in rotamers.CHIS.keys():
return [ [2, "Residue: "+res+" not known sidechain or does not have rotamers", '']]

# Get PHI,PSI bins for rotamer (also prints out current phi,psi, chi1,chi2,chi3,chi4)
bins = rotamers.doRotamers(s,type='bins')

# Add a title to the menu
result = [ [2, bins[0]+' Rotamers in bin ('+str(bins[1])+','+str(bins[2])+')','' ], [1, ':::PROB,CHI1,CHI2,CHI3,CHI4:::','']]

# Grab the entries for this residue and phi,psi bins
match_rotamers = rotamers.rotdat[bins[0]+":"+str(bins[1])+":"+str(bins[2])]

# Set max number of rotamers to display (probably should be somewhere 'higher up' in the code)
max_rotamers = min(10, len(match_rotamers))

# Create menu entry for each possible rotamer
for item in range(max_rotamers):
result.append( [ 1, str(match_rotamers[item]), 'rotamers.set_rotamer("'+s+'","'\
+str(match_rotamers[item][1])+'","'\
+str(match_rotamers[item][2])+'","'\
+str(match_rotamers[item][3])+'","'\
+str(match_rotamers[item][4])+'")'])
return result

</source>

[[Category:Script_Library|Rotamer Toggle]]

[[Category:Structural_Biology_Scripts|Rotamer Toggle]]

Rotamer Toggle

2010-02-02T13:03:30Z

Cowsandmilk:

===DESCRIPTION===
Backbone-Dependent Rotamer library (Dunbrack, Cohen ; see ref) is imported into pymol giving access to this information. There are a number of different ways to use the data, I've only implemented a few as well as added extra functions that seemed useful.
*Rotamer Menu - an added menu into menu.py, which displays the most common rotamers for the given(clicked) residue; you can also set the residue any of the common rotamers as well
*colorRotamers - color rotamers by closest matching rotamer angles from database; i.e. color by how common each rotamer of selection, blue - red (least to most common).
*set_rotamer - routine called by above menu, but can be called manually to set a specific residues side-chain angles
*set_phipsi - set all phi,psi angles of given selection to given angles (useful for creating secondary structures)
*createRotamerPDBs - create pdb for each rotamer of given selection ; filter by rotamer-probability

===IMAGES===
<gallery>
Image:RotamerMenu.png|Rotamer Menu for a GLN residue
Image:GLURotamerComparison5.png|Rotamer Comparison of crystal structure and most common for GLU; just as an example
</gallery>

Print out while selecting most common rotamer from above-left image (GLN residue):
Given GLN:40 PHI,PSI (-171.626373291,-96.0500335693) : bin (-170,-100)
CHIs: [179.18069458007812, 72.539344787597656, -47.217315673828125]
Setting Chi1 to -176.9
Setting Chi2 to 177.4
Setting Chi3 to 0.7

===SETUP===
run "rotamers.py" and use functions from commandline.

or

To setup a rotamer menu inside the residue menu (default windows pymol installation):
*copy rotamers.py to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/rotamers.py
*copy mymenu.py to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/menu.py (WARNING : overwrites default menu.py - use at your own risk)
*copy bbdep02.May.sortlib to C:/Program Files/DeLano Scientific/PyMol/modules/pymol/bbdep02.May.sortlib (or newer version of sorted bbdep)
This is only one possible way to do this, I am sure there are many others. I'm not going to post the bbdep, but there is a link in the References section to Dunbrack's download page (get the "sorted" lib)

===NOTES / STATUS===
*Tested on Pymolv0.97, Windows platform, Red Hat Linux 9.0 and Fedora Core 4. Will test v0.98 and MacOSX later on.
*The way it's setup now, when you import rotamers , it will automatically read-in the rotamer database; this may not be what you want.
*Post problems in the discussion page, on 'my talk' page or just email me : dwkulp@mail.med.upenn.edu

TASKS TODO:
*Rotamer Movie, using mset, etc create movie to watch cycle through rotamers
*Code could be organized a bit better; due to time constraints this is good for now..

TASKS DONE:
*Store crystal structure in rotamer menu, so you can go back to original orientation

===USAGE===
colorRotamers selection
set_rotamer selection, chi1_angle [,chi2_angle] [,chi3_angle] [,chi4_angle]
set_phipsi selection phi_angle, psi_angle
createRotamerPBDs selection [,ncutoff] [,pcutoff] [,prefix]

===EXAMPLES===
colorRotamers chain A
set_rotamer resi 40, -60,-40 (only set chi1,chi2 angles)
set_phipsi resi 10-40, -60,-60 (create an alpha-helical-like section)
createRotamerPDBs resi 10-12, ncutoff=3 (create 9 PDBs; each with one of the 3 most probable rotamers for resi 10,11,12)
createRotamerPDBs resi 14, pcutoff=0.4 (create a pdb file for each rotamer of residue 14 with probablity > 0.4)

===REFERENCES===
Dunbrack and Cohen. Protein Science 1997

[http://dunbrack.fccc.edu/bbdep/index.php Dunbrack Lab Page (Contains backbone-dependent library)]

===SCRIPTS (Rotamers.py ; MyMenu.py)===
Rotamers.py
<source lang="python">
##################################################################
# File: Rotamers.py
# Author: Dan Kulp
# Creation Date: 6/8/05
# Contact: dwkulp@mail.med.upenn.edu
#
# Notes:
# Incorporation of Rotamer library
# readRotLib() - fills rotdat;
# indexed by "RES:PHI_BIN:PSI_BIN".
#
# Three main functions:
# 1. colorRotamers - colors according
# to rotamer probablitity
# 2. getBins(sel)
# phi,psi bin for rotamer
# 3. set_rotamer - set a side-chain
# to a specific rotamer
#
# To setup a rotamer menu in the
# right click, under "Residue"
# 1. cp mymenu.py modules/pymol/menu.py
# 2. cp rotamers.py modules/pymol/rotamers.py (update ROTLIB)
#
# Requirements:
# set ROTLIB to path for rotamer library
# Reference:
# Dunbrack and Cohen. Protein Science 1997
####################################################################

import colorsys,sys
import string
import re
import editing
import os
import cmd
import math

# Path for library
ROTLIB=os.environ['PYMOL_PATH']+"/modules/pymol/bbdep02.May.sortlib"

# Place for library in memory..
rotdat = {}

def readRotLib():
# Column indexes in rotamer library..
RES = 0
PHI = 1
PSI = 2
PROB = 8
CHI1 = 9
CHI2 = 10
CHI3 = 11
CHI4 = 12

if os.path.exists(ROTLIB):
print "File exists: "+ROTLIB
input = open(ROTLIB, 'r')
for line in input:

# Parse by whitespace (I believe format is white space and not fixed-width columns)
dat = re.split("\s+",line)

# Add to rotamer library in memory :
# key format RES:PHI_BIN:PSI_BIN
# value format PROB, CHI1, CHI2, CHI3, CHI4
try:
rotdat[dat[RES]+":"+dat[PHI]+":"+dat[PSI]].append([ dat[PROB], dat[CHI1], dat[CHI2], dat[CHI3], dat[CHI4] ])
except KeyError:
rotdat[dat[RES]+":"+dat[PHI]+":"+dat[PSI]] = [ [ dat[PROB], dat[CHI1], dat[CHI2], dat[CHI3], dat[CHI4] ] ]

else:
print "Couldn't find Rotamer library"

# Atoms for each side-chain angle for each residue
CHIS = {}
CHIS["ARG"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","NE" ],
["CG","CD","NE","CZ" ]
]

CHIS["ASN"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","OD2" ]
]

CHIS["ASP"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","OD1" ]
]
CHIS["CYS"] = [ ["N","CA","CB","SG" ]
]

CHIS["GLN"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","OE1"]
]

CHIS["GLU"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","OE1"]
]

CHIS["HIS"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","ND1"]
]

CHIS["ILE"] = [ ["N","CA","CB","CG1" ],
["CA","CB","CG1","CD1" ]
]

CHIS["LEU"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["LYS"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ],
["CB","CG","CD","CE"],
["CG","CD","CE","NZ"]
]

CHIS["MET"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","SD" ],
["CB","CG","SD","CE"]
]

CHIS["PHE"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["PRO"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD" ]
]

CHIS["SER"] = [ ["N","CA","CB","OG" ]
]

CHIS["THR"] = [ ["N","CA","CB","OG1" ]
]

CHIS["TRP"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1"]
]

CHIS["TYR"] = [ ["N","CA","CB","CG" ],
["CA","CB","CG","CD1" ]
]

CHIS["VAL"] = [ ["N","CA","CB","CG1" ]
]

# Color Rotamer by side-chain angle position
# 'bin' side-chain angles into closest
def colorRotamers(sel):
doRotamers(sel)

# Utility function, to set phi,psi angles for a given selection
# Note: Cartoon, Ribbon functionality will not display correctly after this
def set_phipsi(sel, phi,psi):
doRotamers(sel,angles=[phi,psi],type="set")

# Set a rotamer, based on a selection, a restype and chi angles
def set_rotamer(sel, chi1, chi2=0,chi3=0,chi4=0):
at = cmd.get_model("byres ("+sel+")").atom[0]

list = [chi1,chi2,chi3,chi4]
for i in range(0,len(CHIS[at.resn])):
print "Setting Chi"+str(i+1)+" to "+str(list[i])
editing.set_dihedral(sel + ' and name '+CHIS[at.resn][i][0],
sel + ' and name '+CHIS[at.resn][i][1],
sel + ' and name '+CHIS[at.resn][i][2],
sel + ' and name '+CHIS[at.resn][i][3], str(list[i]))

# Remove some objects that got created
cmd.delete("pk1")
cmd.delete("pk2")
cmd.delete("pkmol")

# Get Phi,Psi bins for given selection
# WARNING: assume selection is single residue (will only return first residue bins)
def getBins(sel):
return doRotamers(sel, type="bins")

# Specific comparison operator for rotamer prob data
def mycmp(first, second):
return cmp( first[1], second[1])

# Color Ramp...
def rot_color(vals):
nbins = 10
vals.sort(mycmp)
# print "End sort: "+str(len(vals))+" : "+str(nbins)

# Coloring scheme...
i = 0
j = 0
rgb = [0.0,0.0,0.0]
sel_str = ""
while i < len(vals):
if int(len(vals)/nbins) == 0 or i % int(len(vals)/nbins) == 0:
hsv = (colorsys.TWO_THIRD - colorsys.TWO_THIRD * float(j) / (nbins-1), 1.0, 1.0)

#convert to rgb and append to color list
rgb = colorsys.hsv_to_rgb(hsv[0],hsv[1],hsv[2])
if j < nbins-1:
j += 1

cmd.set_color("RotProbColor"+str(i), rgb)
cmd.color("RotProbColor"+str(i), str(vals[i][0]))
i += 1

# Main function
def doRotamers(sel,angles=[], type="color"):

# Read in Rotamer library if not already done
if len(rotdat) == 0:
readRotLib()

# Set up some variables..
residues = ['dummy'] # Keep track of residues already done
probs = [] # probability of each residue conformation
phi = 0 # phi,psi angles of current residue
psi = 0

# Get atoms from selection
atoms = cmd.get_model("byres ("+sel+")")

# Loop through atoms in selection
for at in atoms.atom:
try:
# Don't process Glycines or Alanines
if not (at.resn == 'GLY' or at.resn == 'ALA'):
if not at.chain+":"+at.resn+":"+at.resi in residues:
residues.append(at.chain+":"+at.resn+":"+at.resi)

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if not at.chain == "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue i-1, i and i+1
residue_def = unit_select+'resi '+str(at.resi)
residue_def_prev = unit_select+'resi '+str(int(at.resi)-1)
residue_def_next = unit_select+'resi '+str(int(at.resi)+1)

# Compute phi/psi angle

phi = cmd.get_dihedral(residue_def_prev+' and name C',residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C')
psi = cmd.get_dihedral(residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',residue_def_next+' and name N')
if type == "set":
print "Changing "+at.resn+str(at.resi)+" from "+str(phi)+","+str(psi)+" to "+str(angles[0])+","+str(angles[1])
cmd.set_dihedral(residue_def_prev+' and name C',residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',angles[0])
cmd.set_dihedral(residue_def+' and name N',residue_def+' and name CA',residue_def+' and name C',residue_def_next+' and name N', angles[1])
continue

# Find correct 10x10 degree bin
phi_digit = abs(int(phi)) - abs(int(phi/10)*10)
psi_digit = abs(int(psi)) - abs(int(psi/10)*10)

# Remember sign of phi,psi angles
phi_sign = 1
if phi < 0: phi_sign = -1

psi_sign = 1
if psi < 0: psi_sign = -1

# Compute phi,psi bins
phi_bin = int(math.floor(abs(phi/10))*10*phi_sign)
if phi_digit >= 5: phi_bin = int(math.ceil(abs(phi/10))*10*phi_sign)

psi_bin = int(math.floor(abs(psi/10))*10*psi_sign)
if psi_digit >= 5: psi_bin = int(math.ceil(abs(psi/10))*10*psi_sign)

print "Given "+at.resn+":"+at.resi+" PHI,PSI ("+str(phi)+","+str(psi)+") : bin ("+str(phi_bin)+","+str(psi_bin)+")"

# Get current chi angle measurements
chi = []
for i in range(0,len(CHIS[at.resn])):
chi.append(cmd.get_dihedral(residue_def + ' and name '+CHIS[at.resn][i][0],
residue_def + ' and name '+CHIS[at.resn][i][1],
residue_def + ' and name '+CHIS[at.resn][i][2],
residue_def + ' and name '+CHIS[at.resn][i][3]))
print "CHIs: "+str(chi)
if type == 'bins':
return [at.resn, phi_bin,psi_bin]

# Compute probabilities for given chi angles
prob = 0
prob_box = 22
for item in range(0,len(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)])):
print "Rotamer from db: "+str(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item])
if chi[0]:
if chi[0] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][1]) - (prob_box/2) and \
chi[0] <= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][1]) + (prob_box/2):
if len(chi) == 1:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[1] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][2]) - (prob_box/2) and \
float(chi[1] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][2]) + (prob_box/2):
if len(chi) == 2:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[2] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][3]) - (prob_box/2) and \
float(chi[2] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][3]) + (prob_box/2):
if len(chi) == 3:
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break
if chi[3] >= float(rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][4]) - (prob_box/2) and \
float(chi[3] <= rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][4]) + (prob_box/2):
prob = rotdat[at.resn+":"+str(phi_bin)+":"+str(psi_bin)][item][0]
break

print "PROB OF ROTAMER: "+str(prob)
print "---------------------------"
probs.append([residue_def, prob])

except:
# probs.append([residue_def, -1])
print "Exception found"
continue

# Color according to rotamer probability
rot_color(probs)

# Create PDB files containing most probable rotamers
def createRotamerPDBs(sel,ncutoff=10,pcutoff=0,prefix="ROTAMER"):

# Get atoms from selection
atoms = cmd.get_model("byres ("+sel+")")

# Set up some variables..
residues = ['dummy'] # Keep track of residues already done

# Loop through atoms in selection
for at in atoms.atom:
if at.resn == 'GLY' or at.resn == 'ALA' or "%s:%s:%s" % (at.chain,at.resn,at.resi) in residues:
continue

# Add to residue list (keep track of which ones we've done)
residues.append("%s:%s:%s" % (at.chain,at.resn,at.resi))

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if not at.chain == "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue
residue_def = unit_select+'resi '+str(at.resi)

# Get bin (phi,psi) definitions for this residue
bin = doRotamers(residue_def, type='bins')

# Store crystal angle
crystal_angles = [0.0,0.0,0.0,0.0]
for angle in range(0,3):
try:
crystal_angles[angle] = bin[3][angle]
except IndexError:
break

# Retreive list of rotamers for this phi,psi bin + residue type
match_rotamers = rotdat["%s:%s:%s" % (bin[0],str(bin[1]),str(bin[2]))]

count = 0
for item in range(0, len(match_rotamers)):

# Store probablity
prob = match_rotamers[item][0]

# Check cutoffs
if float(prob) <= float(pcutoff):
continue

if float(count) >= float(ncutoff):
break

# Increment count
count += 1

# Output to screen ...
print "Residue %s%s, rotamer %i, prob %s" % (str(at.resn),str(at.resi),int(item),str(prob))

# Set to new rotamer
set_rotamer(residue_def,match_rotamers[item][1],match_rotamers[item][2],match_rotamers[item][3],match_rotamers[item][4])

# Store in PDB file
cmd.save("%s_%s%s_%i_%s.pdb" % (prefix,str(at.resn),str(at.resi),int(item),str(prob)))

# Reset crystal angle
set_rotamer(residue_def,crystal_angles[0],crystal_angles[1],crystal_angles[2],crystal_angles[3])

# Uncommenting this is nice because it loads rotamer library upon startup
# however, it slows the PyMOL loading process a lot
# instead I've put this call into the menuing code..
# readRotLib()

cmd.extend('set_phipsi',set_phipsi)
cmd.extend('set_rotamer',set_rotamer)
cmd.extend('colorRotamers',colorRotamers)
cmd.extend('createRotamerPDBs',createRotamerPDBs)
</source>

[[Category:Script_Library|Rotamer Toggle]]

[[Category:Structural_Biology_Scripts|Rotamer Toggle]]

Wfmesh

2010-02-02T12:58:28Z

Cowsandmilk:

===DESCRIPTION===
This script will create an object for any Wavefront(.OBJ) mesh file. This is a way to extend the number of objects you can use. Also, you have more control over the coloring, transformations, etc than the CGOs. Although there are a number of these obj files on the web, you can also easily created them with open source tools ([http://www.openfx.org OpenFX], [http://synapses.mcg.edu/tools/xroads/xroads.stm Crossroads3D]). It takes literally, 2 min to get an object created and then loaded into pymol. Simply open OpenFX Designer, click File->Insert->Model, then choose any of the models (or create your own of course!), then export it as .3ds file. Then open the .3ds file from Crossroads3D and export as Wavefront OBJ.

*createWFMesh - create a mesh object from Wavefront (*.obj) formated file

===IMAGES===
[[Image:Starwars_pymol.png|thumb|left|Star Wars Anyone?]]
[[Image:Torus_pymol.png|thumb|left|A Torus, as an example shape you could do. Notice polygon normals are being used...need smoothing!]]

[[Category:ThirdParty_Scripts]]

===SETUP===
Simply "run WFMesh.py"

===NOTES / STATUS===
*Tested on Pymolv0.97, Windows platform, should work on linux as well.
*Coloring is fixed for grey and sections of mesh are stored, but not used.
*Simple opengl calls; not optimized (display lists, etc) or anything.
*Vertex Normal code is broken, so normals are per polygon right now.
*Post problems in the discussion page, on 'my talk' page or just email me : dwkulp@mail.med.upenn.edu

===USAGE===
createWFObj file, name [,translate=[0,0,0]] [,flip=0]

===EXAMPLES===
createWFObj "ship.obj" "Ship"
createWFObj "torus.obj" "Torus" flip=1 # Flip = 1, if OBJ created by openFX, crossroads3D combination
createWFObj "torus.obj" "Torus" translate=[10,10,0] flip=1

===REFERENCES===
[http://www.openfx.org OpenFX]
[http://synapses.mcg.edu/tools/xroads/xroads.stm Crossroads3D]

===SCRIPTS (WFMesh.py)===
WFMesh.py
<source lang="python">
###############################################
# File: WFObj.py
# Author: Dan Kulp
# Creation Date: 5/13/05
#
# Notes:
# Create openGL objects from a wavefront (obj) file
###############################################

import os
import string
import re
import math
from pymol.opengl.gl import *
from pymol.callback import Callback

# Wrapper Function, to create a given WFObj with a specific name (flip = 1 if OpenFX + Crossroads used)
def createWFObj(file, name,translate=[0,0,0],flip=0):
obj = WFMesh(file,translate,flip)
cmd.load_callback(obj,name)

# Class for Wavefront Mesh
class WFMesh(Callback):

verts = [] # list of vertices
polys = [] # list of poylgons
pnorms = [] # list of polynomal normals
vnorms = {} # dict. of vertex normals
vavenorms = [] # list of vertex normals, redundant -- I'm far froma python pro.
sections = {} # list of sections of mesh

# Read mesh into memory
def readOBJ(self,file):
if os.path.exists(file):
input = open(file,'r')
for line in input:
dat = re.split("\s+", line)

# Find vertex line
if line[0] == 'v' and line[1] != 't' and line[1] != 'n': self.verts.append([dat[1],dat[2],dat[3]])

# Find polygon line
if line[0] == 'f': self.polys.append([dat[1],dat[2],dat[3]])

# Find section line
if line[0] == 'g': self.sections[len(self.polys)] = dat[1]

# Compute the normals for each polygon and each vertex
def computeNorms(self):

# Compute norms for each polygon
for p in self.polys:
v12 = [float(self.verts[int(p[1])-1][0]) - float(self.verts[int(p[0])-1][0]),\
float(self.verts[int(p[1])-1][1]) - float(self.verts[int(p[0])-1][1]),\
float(self.verts[int(p[1])-1][2]) - float(self.verts[int(p[0])-1][2]) \
]

v13 = [float(self.verts[int(p[2])-1][0]) - float(self.verts[int(p[0])-1][0]),\
float(self.verts[int(p[2])-1][1]) - float(self.verts[int(p[0])-1][1]),\
float(self.verts[int(p[2])-1][2]) - float(self.verts[int(p[0])-1][2]) \
]

# Compute poly normal
polynorm = self.cross(v12,v13)
norm = self.normalize(polynorm)

# Files created by OpenFX, Crossroads combination need have their normals flipped
if self.flip:
norm[0] = -norm[0]
norm[1] = -norm[1]
norm[2] = -norm[2]

# Append poly norm to polygonal norm array
self.pnorms.append(norm)

# Add norm to each vertexes norm..
try:
self.vnorms[int(p[0])-1] = [float(self.vnorms[int(p[0])-1][0]) + norm[0],
float(self.vnorms[int(p[0])-1][1]) + norm[1],
float(self.vnorms[int(p[0])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[0])-1] = [norm[0],norm[1],norm[2]]

try:
self.vnorms[int(p[1])-1] = [float(self.vnorms[int(p[1])-1][0]) + norm[0],
float(self.vnorms[int(p[1])-1][1]) + norm[1],
float(self.vnorms[int(p[1])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[1])-1] = [norm[0],norm[1],norm[2]]

try:
self.vnorms[int(p[2])-1] = [float(self.vnorms[int(p[1])-1][0]) + norm[0],
float(self.vnorms[int(p[1])-1][1]) + norm[1],
float(self.vnorms[int(p[1])-1][2]) + norm[2]
]
except:
self.vnorms[int(p[2])-1] = [norm[0],norm[1],norm[2]]

# Average out each vnorm..
index = 0
for v in self.vnorms.values():
self.vavenorms.append([v[0]/4, v[1]/4, v[2]/4])
index += 1

# Utility function to normalize a given vector
def normalize(self,v):
mag = v[0]*v[0]+v[1]*v[1]+v[2]*v[2]
if mag <= 0:
mag = 1
else:
mag = math.sqrt(mag)

return [v[0]/mag, v[1]/mag,v[2]/mag]

# Utility cross product function
def cross(self,v1,v2):
x = 0
y = 1
z = 2

return [v1[y]*v2[z] - v1[z]*v2[y],\
v1[z]*v2[x] - v1[x]*v2[z],\
v1[x]*v2[y] - v1[y]*v2[x]
]

# Constructor
def __init__(self, file,translate=[0,0,0],flip=0):
self.verts = []
self.polys = []
self.pnorms = []
self.vnorms = {}
self.vavenorms = []
self.translate = translate
self.flip = flip

print "Read in file: "+str(file)
self.readOBJ(file)
print "Done reading in WFMesh, now compute norms"
self.computeNorms()
print "Done computing norms, now display WFMesh"

# Draw Function
def __call__(self):

glColorMaterial(GL_FRONT, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);

# Color Everything grey
glColor3f(0.5,0.5,0.5);

index = 0
glPushMatrix()
glTranslated(self.translate[0],self.translate[1],self.translate[2])
for p in self.polys:
glBegin(GL_POLYGON)
glNormal3f(float(self.pnorms[index][0]),float(self.pnorms[index][1]),float(self.pnorms[index][2]))

for i in range(0,len(p)):
glVertex3f(float(self.verts[int(p[i])-1][0]),float(self.verts[int(p[i])-1][1]),float(self.verts[int(p[i])-1][2]))

# Vertex Normals - not computed correctly, so commented out for now
# norm = self.vnorms[int(p[i])-1]
# glNormal3f(float(norm[0]),float(norm[1]),float(norm[2]))
glEnd()
index += 1
glPopMatrix()

cmd.extend("createWFObj", createWFObj)

</source>

===ADDITIONAL RESOURCES===
Torus.obj
[http://pymolwiki.org/images/9/98/Torus.zip Torus.zip]

[[Category:Script_Library|WFMesh]]

Color Objects

2010-02-02T12:56:42Z

Cowsandmilk:

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

def color_obj(rainbow=0):

"""

AUTHOR

Gareth Stockwell

USAGE

color_obj(rainbow=0)

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

"""

# Process arguments
rainbow = int(rainbow)

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

if rainbow:

print "\nColouring objects as rainbow\n"

nobj = len(obj_list)

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

else:

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

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

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

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

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

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

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

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

return [r,g,b]

# Add color_obj to the PyMOL command list
cmd.extend("color_obj",color_obj)

</source>

[[Category:Script_Library|Color Objects]]
[[Category:Coloring]]
[[Category:ObjSel_Scripts]]

DynoPlot

2010-02-02T12:55:55Z

Cowsandmilk:

===DESCRIPTION===
This script was setup to do generic plotting, that is given a set of data and axis labels it would create a plot. Initially, I had it setup to draw the plot directly in the PyMol window (allowing for both 2D and 3D style plots), but because I couldn't figure out how to billboard CGO objects (Warren told me at the time that it couldn't be done) I took a different approach. The plot now exists in it's own window and can only do 2D plots. It is however interactive. I only have here a Rama.(phi,psi) plot, but the code can be easily extended to other types of data. For instance, I had this working for an energy vs distance data that I had generated by another script.

This script will create a Phi vs Psi(Ramachandran) plot of the selection given. The plot will display data points which can be dragged around Phi,Psi space with the corresponding residue's Phi,Psi angles changing in the structure (PyMol window).

===IMAGES===
<gallery>
Image:RamaPlotInitComposite.png|Initial Ramachandran plot of 1ENV
Image:RamaPlotBentComposite.png|Modified pose and plot of 1ENV
</gallery>

===SETUP===
place the DynoPlot.py script into the appropriate startup directory then restart PyMol

==== LINUX old-style installation ====

$PYMOL_PATH/modules/pmg_tk/startup/

==== LINUX distutils installation ====

/usr/lib/pythonX.X/site-packages/pmg_tk/startup/

==== Windows ====

PYMOL_PATH/modules/pmg_tk/startup/ , where PYMOL_PATH on Windows is defaulted to C:/Program Files/DeLano Scientific/PyMol/start/

===NOTES / STATUS===
*Tested on Windows, PyMol version 0.97
*This is an initial version, which needs some work.
*Left, Right mouse buttons do different things; Right = identify data point, Left = drag data point around
*Post comments/questions or send them to: dwkulp@mail.med.upenn.edu

===USAGE===
rama SELECTION

===EXAMPLES===
*load pdb file 1ENV (download it or use the PDB loader plugin)
*select resi 129-136
*rama sel01
*rock # the object needs to be moving in order for the angles to be updated.

===REFERENCES===

===SCRIPTS (DynoPlot.py)===
DynoPlot.py
<source lang="python">
#!/usr/bin/env python
###############################################
# File: DynoPlot.py
# Author: Dan Kulp
# Creation Date: 8/29/05
#
# Notes:
# Draw plots that display interactive data.
# Phi,Psi plot shown.
###############################################

from __future__ import division
from __future__ import generators

import os,math
import Tkinter
from Tkinter import *
import Pmw
import distutils.spawn # used for find_executable
import random
from pymol import cmd

try:
import pymol
REAL_PYMOL = True
except ImportError:
print "Nope"

canvas = None
rootframe = None
init = 0

class SimplePlot(Tkinter.Canvas):

# Class variables
mark = 'Oval' # Only 'Oval' for now..
mark_size = 5
xlabels = [] # axis labels
ylabels = []
spacingx = 0 # spacing in x direction
spacingy = 0
xmin = 0 # min value from each axis
ymin = 0
lastx = 0 # previous x,y pos of mouse
lasty = 0
down = 0 # flag for mouse pressed
item = (0,) # items array used for clickable events
shapes = {} # store plot data, x,y etc..

def axis(self,xmin=40,xmax=300,ymin=10,ymax=290,xint=290,yint=40,xlabels=[],ylabels=[]):

# Store variables in self object
self.xlabels = xlabels
self.ylabels = ylabels
self.spacingx = (xmax-xmin) / (len(xlabels) - 1)
self.spacingy = (ymax-ymin) / (len(ylabels) - 1)
self.xmin = xmin
self.ymin = ymin

# Create axis lines
self.create_line((xmin,xint,xmax,xint),fill="black",width=3)
self.create_line((yint,ymin,yint,ymax),fill="black",width=3)

# Create tick marks and labels
nextspot = xmin
for label in xlabels:
self.create_line((nextspot, xint+5,nextspot, xint-5),fill="black",width=2)
self.create_text(nextspot, xint-15, text=label)
if len(xlabels) == 1:
nextspot = xmax
else:
nextspot = nextspot + (xmax - xmin)/ (len(xlabels) - 1)

nextspot = ymax
for label in ylabels:
self.create_line((yint+5,nextspot,yint-5,nextspot),fill="black",width=2)
self.create_text(yint-20,nextspot,text=label)
if len(ylabels) == 1:
nextspot = ymin
else:
nextspot = nextspot - (ymax - ymin)/ (len(ylabels) - 1)

# Plot a point
def plot(self,xp,yp,meta):

# Convert from 'label' space to 'pixel' space
x = self.convertToPixel("X",xp)
y = self.convertToPixel("Y",yp)

if self.mark == "Oval":
oval = self.create_oval(x-self.mark_size,y-self.mark_size,x+self.mark_size,y+self.mark_size,width=1,outline="black",fill="SkyBlue2")

self.shapes[oval] = [x,y,0,xp,yp,meta]

# Repaint all points
def repaint(self):
for key,value in self.shapes.items():
x = value[0]
y = value[1]
self.create_oval(x-self.mark_size,y-self.mark_size,x+self.mark_size,y+self.mark_size,width=1,outline="black",fill="SkyBlue2")

# Convert from pixel space to label space
def convertToLabel(self,axis, value):

# Defaultly use X-axis info
label0 = self.xlabels[0]
label1 = self.xlabels[1]
spacing = self.spacingx
min = self.xmin

# Set info for Y-axis use
if axis == "Y":
label0 = self.ylabels[0]
label1 = self.ylabels[1]
spacing = self.spacingy
min = self.ymin

pixel = value - min
label = pixel / spacing
label = label0 + label * abs(label1 - label0)

if axis == "Y":
label = - label

return label

# Converts value from 'label' space to 'pixel' space
def convertToPixel(self,axis, value):

# Defaultly use X-axis info
label0 = self.xlabels[0]
label1 = self.xlabels[1]
spacing = self.spacingx
min = self.xmin

# Set info for Y-axis use
if axis == "Y":
label0 = self.ylabels[0]
label1 = self.ylabels[1]
spacing = self.spacingy
min = self.ymin

# Get axis increment in 'label' space
inc = abs(label1 - label0)

# 'Label' difference from value and smallest label (label0)
diff = float(value - label0)

# Get whole number in 'label' space
whole = int(diff / inc)

# Get fraction number in 'label' space
part = float(float(diff/inc) - whole)

# Return 'pixel' position value
pixel = whole * spacing + part * spacing

# print "Pixel: %f * %f + %f * %f = %f" % (whole, spacing, part, spacing,pixel)

# Reverse number by subtracting total number of pixels - value pixels
if axis == "Y":
tot_label_diff = float(self.ylabels[len(self.ylabels)- 1] - label0)
tot_label_whole = int(tot_label_diff / inc)
tot_label_part = float(float(tot_label_diff / inc) - tot_label_whole)
tot_label_pix = tot_label_whole * spacing + tot_label_part *spacing

pixel = tot_label_pix - pixel

# Add min edge pixels
pixel = pixel + min

return pixel

# Print out which data point you just clicked on..
def pickWhich(self,event):

# Find closest data point
x = event.widget.canvasx(event.x)
y = event.widget.canvasx(event.y)
spot = event.widget.find_closest(x,y)

# Print the shape's meta information corresponding with the shape that was picked
if self.shapes.has_key(spot[0]):
print "Residue(Ca): %s\n" % str(self.shapes[spot[0]][5][2])

# Mouse Down Event
def down(self,event):

# Store x,y position
self.lastx = event.x
self.lasty = event.y

# Find the currently selected item
x = event.widget.canvasx(event.x)
y = event.widget.canvasx(event.y)
self.item = event.widget.find_closest(x,y)

# Identify that the mouse is down
self.down = 1

# Mouse Up Event
def up(self,event):

# Get label space version of x,y
labelx = self.convertToLabel("X",event.x)
labely = self.convertToLabel("Y",event.y)

# Convert new position into label space..
if self.shapes.has_key(self.item[0]):
self.shapes[self.item[0]][0] = event.x
self.shapes[self.item[0]][1] = event.y
self.shapes[self.item[0]][2] = 1
self.shapes[self.item[0]][3] = labelx
self.shapes[self.item[0]][4] = labely

# Reset Flags
self.item = (0,)
self.down = 0

# Mouse Drag(Move) Event
def drag(self,event):

# Check that mouse is down and item clicked is a valid data point
if self.down and self.shapes.has_key(self.item[0]):

self.move(self.item, event.x - self.lastx, event.y - self.lasty)

self.lastx = event.x
self.lasty = event.y

def __init__(self):

self.menuBar.addcascademenu('Plugin', 'PlotTools', 'Plot Tools',
label='Plot Tools')
self.menuBar.addmenuitem('PlotTools', 'command',
'Launch Rama Plot',
label='Rama Plot',
command = lambda s=self: ramaplot())

def ramaplot(x=0,y=0,meta=[],clear=0):
global canvas
global rootframe
global init

# If no window is open
if init == 0:
rootframe=Tk()
rootframe.title(' Dynamic Angle Plotting ')
rootframe.protocol("WM_DELETE_WINDOW", close_callback)

canvas = SimplePlot(rootframe,width=320,height=320)
canvas.bind("<Button-2>",canvas.pickWhich)
canvas.bind("<Button-3>",canvas.pickWhich)
canvas.bind("<ButtonPress-1>",canvas.down)
canvas.bind("<ButtonRelease-1>",canvas.up)
canvas.bind("<Motion>",canvas.drag)
canvas.pack(side=Tkinter.LEFT,fill="both",expand=1)
canvas.axis(xint=150,xlabels=range(-180,181,30),ylabels=range(-180,181, 30))
canvas.update()
init = 1
else:
canvas.plot(int(x), int(y),meta)

def close_callback():
global init
global rootframe
init=0
rootframe.destroy()

# New Callback object, so that we can update the structure when phi,psi points are moved.
class DynoRamaObject:
global canvas

def start(self,sel):

# Get selection model
model = cmd.get_model(sel)
residues = ['dummy']
resnames = ['dummy']
phi = []
psi = []
dummy = []
i = 0

# Loop through each atom
for at in model.atom:

# Only plot once per residue
if not at.chain+":"+at.resn+":"+at.resi in residues:
residues.append(at.chain+":"+at.resn+":"+at.resi)
resnames.append(at.resn+at.resi)
dummy.append(i)
i += 1

# Check for a null chain id (some PDBs contain this)
unit_select = ""
if not at.chain == "":
unit_select = "chain "+str(at.chain)+" and "

# Define selections for residue i-1, i and i+1
residue_def = unit_select+'resi '+str(at.resi)
residue_def_prev = unit_select+'resi '+str(int(at.resi)-1)
residue_def_next = unit_select+'resi '+str(int(at.resi)+1)

try:
# Store phi,psi residue definitions to pass on to plot routine
phi_psi = [
# Phi angles
residue_def_prev+' and name C',
residue_def+' and name N',
residue_def+' and name CA',
residue_def+' and name C',
# Psi angles
residue_def+' and name N',
residue_def+' and name CA',
residue_def+' and name C',
residue_def_next+' and name N']

# Compute phi/psi angle
phi = cmd.get_dihedral(phi_psi[0],phi_psi[1],phi_psi[2],phi_psi[3])
psi = cmd.get_dihedral(phi_psi[4],phi_psi[5],phi_psi[6],phi_psi[7])

print "Plotting Phi,Psi: "+str(phi)+","+str(psi)
ramaplot(phi,psi,meta=phi_psi)
except:
continue

def __call__(self):

# Loop through each item on plot to see if updated
for key,value in canvas.shapes.items():
dihedrals = value[5]

# Look for update flag...
if value[2]:

# Set residue's phi,psi to new values
print "Re-setting Phi,Psi: "+str(value[3])+","+str(value[4])
cmd.set_dihedral(dihedrals[0],dihedrals[1],dihedrals[2],dihedrals[3],value[3])
cmd.set_dihedral(dihedrals[4],dihedrals[5],dihedrals[6],dihedrals[7],value[4])

value[2] = 0

# The wrapper function, used to create the Ploting window and the PyMol callback object
def rama(sel):
rama = DynoRamaObject()
rama.start(sel)
cmd.load_callback(rama, "DynoRamaObject")
cmd.zoom("all")

# Extend these commands
cmd.extend('rama',rama)
cmd.extend('ramaplot',ramaplot)
</source>

===ADDITIONAL RESOURCES===

[[Category:Script_Library|DynoPlot]]
[[Category:Structural_Biology_Scripts|DynoPlot]]

Process All Files In Directory

2010-02-02T12:54:19Z

Cowsandmilk:

=Explanation=
For a given directory with PDB files in it, the following code will output, for each PDB, the bound disulfide bond lengths like this:
<pre>
1alk.pdb
A CYS 168 SG
A CYS 178 SG
1.975
A CYS 286 SG
A CYS 336 SG
1.995
B CYS 168 SG
B CYS 178 SG
1.996
B CYS 286 SG
B CYS 336 SG
2.032
1btu.pdb
CYS 42 SG
CYS 58 SG
2.039
CYS 136 SG
CYS 201 SG
2.031
CYS 168 SG
CYS 182 SG
2.001
CYS 191 SG
CYS 220 SG
2.019
...
</pre>

=Bound Disulfides=
<source lang="python">
from pymol import cmd
from glob import glob

for file in glob("*.pdb"):
print file
cmd.load(file,'prot')
for a in cmd.index("elem s and bound_to elem s"):
if cmd.select("s1","%s`%d"%a) and \
cmd.select("s2","elem s and bound_to %s`%d"%a):
if cmd.select("(s1|s2) and not ?skip"):
cmd.iterate("s1|s2","print ' ',chain,resn,resi,name")
print ' ',round(cmd.dist("tmp","s1","s2"),3)
cmd.select("skip","s1|s2|?skip")
cmd.delete("all")
</source>

=All Sulfur Distances=
Note that the above is for bonded sulfurs in disulfides. For all intra-cysteine gamma sulfur distances, you'd want to do something more like:
<pre>
1alk.pdb
A CYS 168 SG
A CYS 178 SG
1.975
A CYS 168 SG
A CYS 286 SG
35.845
A CYS 168 SG
A CYS 336 SG
35.029
A CYS 168 SG
B CYS 168 SG
63.64
A CYS 168 SG
B CYS 178 SG
63.775
A CYS 168 SG
B CYS 286 SG
39.02
A CYS 168 SG
B CYS 336 SG
39.314
1btu.pdb
CYS 42 SG
CYS 58 SG
2.039
CYS 42 SG
CYS 136 SG
</pre>

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

for file in glob("*.pdb"):
print file
cmd.load(file,'prot')
for a in cmd.index("CYS/SG"):
for b in cmd.index("CYS/SG"):
if a[1]<b[1]:
cmd.select("s1","%s`%d"%a)
cmd.select("s2","%s`%d"%b)
if cmd.select("(s1|s2) and not ?skip"):
cmd.iterate("s1|s2","print ' ',chain,resn,resi,name")
print ' ',round(cmd.dist("tmp","s1","s2"),3)
cmd.select("skip","s1|s2|?skip")
cmd.delete("all")
</source>

[[Category:Script_Library|Processing All File in Directory]]
[[Category:System_Scripts]]

Ideas

2010-01-24T20:08:10Z

Cowsandmilk: /* High-Level Enhancement Ideas (Mostly Python-oriented) */

=== Ideas for PyMOL Development ===

This page was originally developed for the 2008 Google Summer of Code competition, but seeing as PyMOL wasn't selected, this page can instead serve as a resource for ongoing PyMOL development efforts.

== Where to Start ==

Always start with Python and only delve down into the C code when absolutely necessary. Although PyMOL is mostly a C-based application, much of the that code is opaque, fragile, and unforgiving. Although C code refactoring is an important project goal, such work may not be ideal since once mistake could potentially to destabilize the entire platform.

Fortunately, the Python interpreter and the PyMOL command and selection languages make it possible to extend PyMOL safely and quickly. Even when performance is critical, Python should be the interface between external C, C++, and Java code and PyMOL's internal C data structures.

== Choosing a Topic ==

The best open-source code is usually written by an end-users attempting to meet their own pressing needs. So if you have already have a specific need which relates to PyMOL, then we strongly encourage you to follow up on that first!

If you are looking for ideas, then try to seek out enhancements and/or integrations that will impact the largest potential user base. For example, imagine what new things might be useful to virtually all medicinal chemists, all structural biologists, all movie-makers, all paper-writers, and so forth.

The ideas below are organized by category. Right now, integration with other open-source projects seems like the approach most likely to yield significant benefit, so those ideas are first.

== Integration Ideas (Linking Out to Useful Open-Source Tools) ==

In most cases, depending on the need, integration can be accomplished through standalone Python scripts, through new PyMOL commands, through PyMOL Wizards, or via Tkinter plugins.

* APBS (electrostatics calculations): Improve the existing plugin. Michael Lerner is currently leading this effort. See [[APBS]]
:: yea ([[User:Inchoate|Tree]] [[User:Jedgold|Jedgold]]"[[User:Vcpmartin|Vcpmartin]]") / nay (0)
* RDKit (cheminformatics, depiction, UFF cleanup, etc.): Lots of potential here, however C++ coding may be necessary for more advanced integration tasks. [http://www.rdkit.org RDKit home]
:: yea ([[User:Markvanraaij|Markvanraaij]]) / nay (0)
* GIMP (image manipulation): Streamline & document the process of exporting images from PyMOL into GIMP and preparing them for submission to scientific Journals.
:: yea (0) / nay (0)
* Jmol (publishing visualizations inside of web pages): Liason between PyMOL & Jmol projects to develop a shared molecular visualization data model compatible with both applications.
:: yea (0) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Firefox (plugin): Develop an PyMOL plugin compatible with Firefox.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* MMTK (molecular mechanics -- Python/flexible): Develop the ability to round-trip molecular systems from PyMOL, into MMTK, and back.
:: yea (0) / nay (0)
* GROMACS (molecular mechanics -- C/fast) - Maybe some ideas can be shared with this guy. [http://www.kde-apps.org/content/show.php/Gromacs+GUI+?content=47665 Gromacs GUI]
:: yea ([[User:Jedgold|Jedgold]] [[User:Mglerner|Michael Lerner]]) / nay (0)
* OpenOffice (escape Microsoft hegemony): Develop an PyMOL plugin.
:: yea (0) / nay (0)
* IPython integration (interactive shell): a robust alternative to the PyMOL command line?
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* R (statistics): PyMOL a 3D viewer environment for visualizating & manipulating large statistical data sets?
:: yea (0) / nay (0)

Are there other key open-source packages we might specifically target for integration with PyMOL, either through GSoC or beyond?

== High-Level Enhancement Ideas (Mostly Python-oriented) ==

* Work on [[#More Ideas (Please add your own!)| MolViz]]
:: yea (0) / nay (0)
* Develop new plugins which automate routine tasks.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Improve the Python API documentation.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Flesh out the new "from pymol2 import PyMOL" instance-based PyMOL API.
:: yea (0) / nay (0)
* Develop alternate Tkinter "skins" (for custom OEM-like applications).
:: yea (0) / nay (0)
* Develop a Tkinter/TOGL widget which holds a PyMOL viewer instance.
:: yea (0) / nay (0)
* Develop a PyQt widget which holds a PyMOL viewer instance.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Create a plugin-manager GUI in the style of Firefox, Rythmbox, Gedit, Eclipse. A GUI where it is easy to turn off/on plugins, configure them and see help-contents for them. Maybe also some way to paste a url to install a new Plugin.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Add a plugin for a GUI window with the same functionality as the "Control Panel" window in SwissPDB Viewer.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Extend and modify the PyMOL command language so as to be compatible with existing RasMol and/or Jmol scripts.
:: yea (0) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Enhance the Mutagenesis Wizard in order to support Nucleic acids and/or Sugars.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Better tab completion for commands
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) /nay(0)

== Low-Level Enhancement Ideas (Mostly C-oriented) ==

* Enable editing of displayed sequence alignments.
:: yea ([[User:Jedgold|Jedgold]], [[User:Aschreyer|Aschreyer]], [[User:Lucajovine|Luca Jovine]]) / nay (0)
::: Would this then feed back to the structural alignment? [[User:Jedgold|Jedgold]]
* Add multi-line textual annotations
:: yea (0) / nay (0)
* Support additional annotation object including: arrow, lines, and blobs.
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Vvostri|Vvostri]]) / nay (0)
* Add display of secondary structure into the sequence viewer.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Enable per-object Z clipping (especially in the ray tracer)
:: yea ([[User:Gregori|Gregori]], [[User:Xevi|Xevi]], [[User:Johnm|Johnm]]) / nay (0)
::: I would go a step further with fully customizable selection-based clipping planes (XYZ, color and transparency) ([[User:Gregori|Gregori]])
* Highlight H-bonds, salt bridges, Pi-stacking, Pi-cations, etc.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Build in a simple forcefield and energy minimizer suitable for use with Mutagenesis.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Incorporate a suite of standard NMR visualizations (restraint violations, per-residue RMS, etc.)
:: yea ([[User:Vvostri|Vvostri]]"[[User:Vcpmartin|Vcpmartin]]") / nay (0)
* Enumeration and display of low-energy conformers.
:: yea ([[User:Jedgold|Jedgold]]) / nay (0)
::: This could be done by integrating RDKit, I think. [[User:Aschreyer|Aschreyer]]
* Automated structure grafting (poor-man's homology modeling).
:: yea (0) / nay ([[User:Jedgold|Jedgold]], [[User:Cowsandmilk|Cowsandmilk]])
::: Perhaps a plugin to Modeller instead? ([[User:Jedgold|Jedgold]], [[User:Lucajovine|Luca Jovine]])
* Import of alignment files.
:: yea ([[User:Jedgold|Jedgold]], [[User:Lucajovine|Luca Jovine]]) / nay (0)
* Implement IMD (Interactive Molecular Dynamics) Interface, see http://www.ks.uiuc.edu/Research/vmd/imd/
:: yea (0) / nay (0)
* Add buttons for '''Set ChainID''' and '''Renumber Residues From...''' to Edit menu or Actions (wrapper around Alter command)
:: yea ([[User:Sheehanj|Sheehanj]]) / nay (0)

== Difficult C-level Code Refactoring Ideas ==

* Assemble a test suite which thoroughly exercises the existing code (a prerequisite to major refactoring).
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Catch & handle memory-allocation failures gracefully (instead of crashing).
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Replace PyMOL's memory management & custom containers with a simple runtime object model.
:: yea (0) / nay (0)
* Separate the View and the Controllers from the Model so that they can all run asynchronously (on multiple cores).
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Enable generalized undo of changes made to the Model.
:: yea ([[User:Vvostri|Vvostri]]"[[User:Vcpmartin|Vcpmartin]], [[User:Lucajovine|Luca Jovine]]", [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Clean up the internal matrix handling code.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)

== Ideas Involving Proprietary APIs ==

Since these involve closed-source APIs and infrastructure, they aren't suitable for open-source development efforts. However, such requests are noted here for the sake of complete coverage.

* Create a Windows port with "native" look & feel. <- Could this be done in PyQT or PyGTK?. Then it would look "native", but be cross-platform and not proprietary.
:: yea (0) / nay (0)
* Integrate directly via Mathematica via MathLink.
:: yea (0) / nay ([[User:Aschreyer|Aschreyer]])
* Further enhance JyMOL (Java-JNI/wrapped PyMOL)
:: yea ([[User:Inchoate|Tree]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Integrate with Matlab.
:: yea (0) / nay ([[User:Aschreyer|Aschreyer]])
* Quicklook Plugin on the Mac
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)

== More Ideas (Please add your own!) ==
* [http://molviz.cs.toronto.edu/molviz MolViz] is a project to incorporate head tracking input into [http://pymol.sourceforge.net/ PyMol]. This is accomplished through a [[ImmersiveViz]] script written in Python to control the molecule's position using the existing [http://www.pymolwiki.org/index.php/Category:Commands PyMol API]. Related projects would include:
** Improving the existing [[ImmersiveViz]] PyMol plugin for more precise control of the environment.
** Developing new input drivers for the Wiimote form of control. This would require some bluetooth hacking.
** Implementing some other forms of input for head tracking, such as fisheye head tracking, IR webcam tracking, etc (refer to the end of this [[http://www.youtube.com/watch?v=ncShaY4VSac video]] for a better description).
:: yea (0) / nay (0)
* Provide a 2D chemical depiction of the current 3D view.
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
::: RDKit?
* Spreadsheet view with additional information (e.g. IC50's).
:: yea ([[User:Aschreyer|Aschreyer]]) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Create additional documentation, screen casts, & tutorials.
:: yea ([[User:Markvanraaij|Markvanraaij]]) / nay (0)
* Export 3D PDF images.
:: yea ([[User:Vvostri|Vvostri]], [[User:Lucajovine|Luca Jovine]]) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* <strike>Add extra "Single Word Selectors" like "nucleic", "protein", "water", "ions", "backbone" (for nucleic acids or proteins), "mainchain", "sidechain"</strike>
:: yea (0) / nay (0)
* Add functionality that allows you to select atoms based on their location (i.e. select (x_coordinate < 10) and (z_coordinate > 0))
:: yea (0) / nay (0)
* set pdb_mirror option to use PDB mirrors other than RCSB for fetching structures (PDBe, PDBj); the EBI mirror is much faster from Europe for example.
:: yea ([[User:Aschreyer|Aschreyer]]) / nay (0)
* have the ability to link the TK console to the viewer so that users don't have to constantly alt+tab between what they want
:: yea (0) / nay (0)
* have the ability to disable typing in the viewer and automatically type in the TK console (I like being able to cut/paste/home/end)
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* I see a lot of "can pymol do this" threads - any ideas of a good UI for a page of "things PyMOL can do?"
:: yea (0) / nay (0)
* make an option where I can turn on a coordinate grid - perhaps an object that is a cuboid grid around any object in the view so I can still alter how it's rendered?
:: yea (0) / nay (0)
* iPhone / Nexus One app(s)
:: yea (0) / nay (0)
* single-color bonds between nonidentical or any spherical atoms colored specifically
:: yea (0) / nay (0)
* double bonds as two parallel cylinders
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* export scenes as [http://www.khronos.org/webgl/ WebGL] / Could make mobile apps, presentation plugins obsolete
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* export images in vector format
:: yea ([[User:Vvostri|Vvostri]], [[User:Lucajovine|Luca Jovine]], [[User:Aschreyer|Aschreyer]]) / nay (0)
* Keynote plugin
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Electron density contour sliders
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Automatic electron density map generation from PDB mmcif files or user-supplied MTZ files
:: yea ([[User:Lucajovine|Luca Jovine]], [[User:Aschreyer|Aschreyer]], [[User:Johnm|Johnm]]) / nay (0)
* Display of crystallographic symmetry and NCS axes, with possibility of showing symbols indicating what kind of axes they are
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Automatic symmetry expansion to show overall crystal packing; automatic generation of scenes showing crystal packing interface details
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)

Ideas

2010-01-24T20:06:20Z

Cowsandmilk: /* Ideas Involving Proprietary APIs */

=== Ideas for PyMOL Development ===

This page was originally developed for the 2008 Google Summer of Code competition, but seeing as PyMOL wasn't selected, this page can instead serve as a resource for ongoing PyMOL development efforts.

== Where to Start ==

Always start with Python and only delve down into the C code when absolutely necessary. Although PyMOL is mostly a C-based application, much of the that code is opaque, fragile, and unforgiving. Although C code refactoring is an important project goal, such work may not be ideal since once mistake could potentially to destabilize the entire platform.

Fortunately, the Python interpreter and the PyMOL command and selection languages make it possible to extend PyMOL safely and quickly. Even when performance is critical, Python should be the interface between external C, C++, and Java code and PyMOL's internal C data structures.

== Choosing a Topic ==

The best open-source code is usually written by an end-users attempting to meet their own pressing needs. So if you have already have a specific need which relates to PyMOL, then we strongly encourage you to follow up on that first!

If you are looking for ideas, then try to seek out enhancements and/or integrations that will impact the largest potential user base. For example, imagine what new things might be useful to virtually all medicinal chemists, all structural biologists, all movie-makers, all paper-writers, and so forth.

The ideas below are organized by category. Right now, integration with other open-source projects seems like the approach most likely to yield significant benefit, so those ideas are first.

== Integration Ideas (Linking Out to Useful Open-Source Tools) ==

In most cases, depending on the need, integration can be accomplished through standalone Python scripts, through new PyMOL commands, through PyMOL Wizards, or via Tkinter plugins.

* APBS (electrostatics calculations): Improve the existing plugin. Michael Lerner is currently leading this effort. See [[APBS]]
:: yea ([[User:Inchoate|Tree]] [[User:Jedgold|Jedgold]]"[[User:Vcpmartin|Vcpmartin]]") / nay (0)
* RDKit (cheminformatics, depiction, UFF cleanup, etc.): Lots of potential here, however C++ coding may be necessary for more advanced integration tasks. [http://www.rdkit.org RDKit home]
:: yea ([[User:Markvanraaij|Markvanraaij]]) / nay (0)
* GIMP (image manipulation): Streamline & document the process of exporting images from PyMOL into GIMP and preparing them for submission to scientific Journals.
:: yea (0) / nay (0)
* Jmol (publishing visualizations inside of web pages): Liason between PyMOL & Jmol projects to develop a shared molecular visualization data model compatible with both applications.
:: yea (0) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Firefox (plugin): Develop an PyMOL plugin compatible with Firefox.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* MMTK (molecular mechanics -- Python/flexible): Develop the ability to round-trip molecular systems from PyMOL, into MMTK, and back.
:: yea (0) / nay (0)
* GROMACS (molecular mechanics -- C/fast) - Maybe some ideas can be shared with this guy. [http://www.kde-apps.org/content/show.php/Gromacs+GUI+?content=47665 Gromacs GUI]
:: yea ([[User:Jedgold|Jedgold]] [[User:Mglerner|Michael Lerner]]) / nay (0)
* OpenOffice (escape Microsoft hegemony): Develop an PyMOL plugin.
:: yea (0) / nay (0)
* IPython integration (interactive shell): a robust alternative to the PyMOL command line?
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* R (statistics): PyMOL a 3D viewer environment for visualizating & manipulating large statistical data sets?
:: yea (0) / nay (0)

Are there other key open-source packages we might specifically target for integration with PyMOL, either through GSoC or beyond?

== High-Level Enhancement Ideas (Mostly Python-oriented) ==

* Work on [[#More Ideas (Please add your own!)| MolViz]]
:: yea (0) / nay (0)
* Develop new plugins which automate routine tasks.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Improve the Python API documentation.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Flesh out the new "from pymol2 import PyMOL" instance-based PyMOL API.
:: yea (0) / nay (0)
* Develop alternate Tkinter "skins" (for custom OEM-like applications).
:: yea (0) / nay (0)
* Develop a Tkinter/TOGL widget which holds a PyMOL viewer instance.
:: yea (0) / nay (0)
* Develop a PyQt widget which holds a PyMOL viewer instance.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Create a plugin-manager GUI in the style of Firefox, Rythmbox, Gedit, Eclipse. A GUI where it is easy to turn off/on plugins, configure them and see help-contents for them. Maybe also some way to paste a url to install a new Plugin.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Add a plugin for a GUI window with the same functionality as the "Control Panel" window in SwissPDB Viewer.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Extend and modify the PyMOL command language so as to be compatible with existing RasMol and/or Jmol scripts.
:: yea (0) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Enhance the Mutagenesis Wizard in order to support Nucleic acids and/or Sugars.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)

== Low-Level Enhancement Ideas (Mostly C-oriented) ==

* Enable editing of displayed sequence alignments.
:: yea ([[User:Jedgold|Jedgold]], [[User:Aschreyer|Aschreyer]], [[User:Lucajovine|Luca Jovine]]) / nay (0)
::: Would this then feed back to the structural alignment? [[User:Jedgold|Jedgold]]
* Add multi-line textual annotations
:: yea (0) / nay (0)
* Support additional annotation object including: arrow, lines, and blobs.
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Vvostri|Vvostri]]) / nay (0)
* Add display of secondary structure into the sequence viewer.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Enable per-object Z clipping (especially in the ray tracer)
:: yea ([[User:Gregori|Gregori]], [[User:Xevi|Xevi]], [[User:Johnm|Johnm]]) / nay (0)
::: I would go a step further with fully customizable selection-based clipping planes (XYZ, color and transparency) ([[User:Gregori|Gregori]])
* Highlight H-bonds, salt bridges, Pi-stacking, Pi-cations, etc.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Build in a simple forcefield and energy minimizer suitable for use with Mutagenesis.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Incorporate a suite of standard NMR visualizations (restraint violations, per-residue RMS, etc.)
:: yea ([[User:Vvostri|Vvostri]]"[[User:Vcpmartin|Vcpmartin]]") / nay (0)
* Enumeration and display of low-energy conformers.
:: yea ([[User:Jedgold|Jedgold]]) / nay (0)
::: This could be done by integrating RDKit, I think. [[User:Aschreyer|Aschreyer]]
* Automated structure grafting (poor-man's homology modeling).
:: yea (0) / nay ([[User:Jedgold|Jedgold]], [[User:Cowsandmilk|Cowsandmilk]])
::: Perhaps a plugin to Modeller instead? ([[User:Jedgold|Jedgold]], [[User:Lucajovine|Luca Jovine]])
* Import of alignment files.
:: yea ([[User:Jedgold|Jedgold]], [[User:Lucajovine|Luca Jovine]]) / nay (0)
* Implement IMD (Interactive Molecular Dynamics) Interface, see http://www.ks.uiuc.edu/Research/vmd/imd/
:: yea (0) / nay (0)
* Add buttons for '''Set ChainID''' and '''Renumber Residues From...''' to Edit menu or Actions (wrapper around Alter command)
:: yea ([[User:Sheehanj|Sheehanj]]) / nay (0)

== Difficult C-level Code Refactoring Ideas ==

* Assemble a test suite which thoroughly exercises the existing code (a prerequisite to major refactoring).
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Catch & handle memory-allocation failures gracefully (instead of crashing).
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Replace PyMOL's memory management & custom containers with a simple runtime object model.
:: yea (0) / nay (0)
* Separate the View and the Controllers from the Model so that they can all run asynchronously (on multiple cores).
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Enable generalized undo of changes made to the Model.
:: yea ([[User:Vvostri|Vvostri]]"[[User:Vcpmartin|Vcpmartin]], [[User:Lucajovine|Luca Jovine]]", [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Clean up the internal matrix handling code.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)

== Ideas Involving Proprietary APIs ==

Since these involve closed-source APIs and infrastructure, they aren't suitable for open-source development efforts. However, such requests are noted here for the sake of complete coverage.

* Create a Windows port with "native" look & feel. <- Could this be done in PyQT or PyGTK?. Then it would look "native", but be cross-platform and not proprietary.
:: yea (0) / nay (0)
* Integrate directly via Mathematica via MathLink.
:: yea (0) / nay ([[User:Aschreyer|Aschreyer]])
* Further enhance JyMOL (Java-JNI/wrapped PyMOL)
:: yea ([[User:Inchoate|Tree]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Integrate with Matlab.
:: yea (0) / nay ([[User:Aschreyer|Aschreyer]])
* Quicklook Plugin on the Mac
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)

== More Ideas (Please add your own!) ==
* [http://molviz.cs.toronto.edu/molviz MolViz] is a project to incorporate head tracking input into [http://pymol.sourceforge.net/ PyMol]. This is accomplished through a [[ImmersiveViz]] script written in Python to control the molecule's position using the existing [http://www.pymolwiki.org/index.php/Category:Commands PyMol API]. Related projects would include:
** Improving the existing [[ImmersiveViz]] PyMol plugin for more precise control of the environment.
** Developing new input drivers for the Wiimote form of control. This would require some bluetooth hacking.
** Implementing some other forms of input for head tracking, such as fisheye head tracking, IR webcam tracking, etc (refer to the end of this [[http://www.youtube.com/watch?v=ncShaY4VSac video]] for a better description).
:: yea (0) / nay (0)
* Provide a 2D chemical depiction of the current 3D view.
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
::: RDKit?
* Spreadsheet view with additional information (e.g. IC50's).
:: yea ([[User:Aschreyer|Aschreyer]]) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Create additional documentation, screen casts, & tutorials.
:: yea ([[User:Markvanraaij|Markvanraaij]]) / nay (0)
* Export 3D PDF images.
:: yea ([[User:Vvostri|Vvostri]], [[User:Lucajovine|Luca Jovine]]) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* <strike>Add extra "Single Word Selectors" like "nucleic", "protein", "water", "ions", "backbone" (for nucleic acids or proteins), "mainchain", "sidechain"</strike>
:: yea (0) / nay (0)
* Add functionality that allows you to select atoms based on their location (i.e. select (x_coordinate < 10) and (z_coordinate > 0))
:: yea (0) / nay (0)
* set pdb_mirror option to use PDB mirrors other than RCSB for fetching structures (PDBe, PDBj); the EBI mirror is much faster from Europe for example.
:: yea ([[User:Aschreyer|Aschreyer]]) / nay (0)
* have the ability to link the TK console to the viewer so that users don't have to constantly alt+tab between what they want
:: yea (0) / nay (0)
* have the ability to disable typing in the viewer and automatically type in the TK console (I like being able to cut/paste/home/end)
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* I see a lot of "can pymol do this" threads - any ideas of a good UI for a page of "things PyMOL can do?"
:: yea (0) / nay (0)
* make an option where I can turn on a coordinate grid - perhaps an object that is a cuboid grid around any object in the view so I can still alter how it's rendered?
:: yea (0) / nay (0)
* iPhone / Nexus One app(s)
:: yea (0) / nay (0)
* single-color bonds between nonidentical or any spherical atoms colored specifically
:: yea (0) / nay (0)
* double bonds as two parallel cylinders
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* export scenes as [http://www.khronos.org/webgl/ WebGL] / Could make mobile apps, presentation plugins obsolete
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* export images in vector format
:: yea ([[User:Vvostri|Vvostri]], [[User:Lucajovine|Luca Jovine]], [[User:Aschreyer|Aschreyer]]) / nay (0)
* Keynote plugin
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Electron density contour sliders
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Automatic electron density map generation from PDB mmcif files or user-supplied MTZ files
:: yea ([[User:Lucajovine|Luca Jovine]], [[User:Aschreyer|Aschreyer]], [[User:Johnm|Johnm]]) / nay (0)
* Display of crystallographic symmetry and NCS axes, with possibility of showing symbols indicating what kind of axes they are
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Automatic symmetry expansion to show overall crystal packing; automatic generation of scenes showing crystal packing interface details
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)

Ideas

2010-01-24T19:54:38Z

Cowsandmilk:

=== Ideas for PyMOL Development ===

This page was originally developed for the 2008 Google Summer of Code competition, but seeing as PyMOL wasn't selected, this page can instead serve as a resource for ongoing PyMOL development efforts.

== Where to Start ==

Always start with Python and only delve down into the C code when absolutely necessary. Although PyMOL is mostly a C-based application, much of the that code is opaque, fragile, and unforgiving. Although C code refactoring is an important project goal, such work may not be ideal since once mistake could potentially to destabilize the entire platform.

Fortunately, the Python interpreter and the PyMOL command and selection languages make it possible to extend PyMOL safely and quickly. Even when performance is critical, Python should be the interface between external C, C++, and Java code and PyMOL's internal C data structures.

== Choosing a Topic ==

The best open-source code is usually written by an end-users attempting to meet their own pressing needs. So if you have already have a specific need which relates to PyMOL, then we strongly encourage you to follow up on that first!

If you are looking for ideas, then try to seek out enhancements and/or integrations that will impact the largest potential user base. For example, imagine what new things might be useful to virtually all medicinal chemists, all structural biologists, all movie-makers, all paper-writers, and so forth.

The ideas below are organized by category. Right now, integration with other open-source projects seems like the approach most likely to yield significant benefit, so those ideas are first.

== Integration Ideas (Linking Out to Useful Open-Source Tools) ==

In most cases, depending on the need, integration can be accomplished through standalone Python scripts, through new PyMOL commands, through PyMOL Wizards, or via Tkinter plugins.

* APBS (electrostatics calculations): Improve the existing plugin. Michael Lerner is currently leading this effort. See [[APBS]]
:: yea ([[User:Inchoate|Tree]] [[User:Jedgold|Jedgold]]"[[User:Vcpmartin|Vcpmartin]]") / nay (0)
* RDKit (cheminformatics, depiction, UFF cleanup, etc.): Lots of potential here, however C++ coding may be necessary for more advanced integration tasks. [http://www.rdkit.org RDKit home]
:: yea ([[User:Markvanraaij|Markvanraaij]]) / nay (0)
* GIMP (image manipulation): Streamline & document the process of exporting images from PyMOL into GIMP and preparing them for submission to scientific Journals.
:: yea (0) / nay (0)
* Jmol (publishing visualizations inside of web pages): Liason between PyMOL & Jmol projects to develop a shared molecular visualization data model compatible with both applications.
:: yea (0) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Firefox (plugin): Develop an PyMOL plugin compatible with Firefox.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* MMTK (molecular mechanics -- Python/flexible): Develop the ability to round-trip molecular systems from PyMOL, into MMTK, and back.
:: yea (0) / nay (0)
* GROMACS (molecular mechanics -- C/fast) - Maybe some ideas can be shared with this guy. [http://www.kde-apps.org/content/show.php/Gromacs+GUI+?content=47665 Gromacs GUI]
:: yea ([[User:Jedgold|Jedgold]] [[User:Mglerner|Michael Lerner]]) / nay (0)
* OpenOffice (escape Microsoft hegemony): Develop an PyMOL plugin.
:: yea (0) / nay (0)
* IPython integration (interactive shell): a robust alternative to the PyMOL command line?
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* R (statistics): PyMOL a 3D viewer environment for visualizating & manipulating large statistical data sets?
:: yea (0) / nay (0)

Are there other key open-source packages we might specifically target for integration with PyMOL, either through GSoC or beyond?

== High-Level Enhancement Ideas (Mostly Python-oriented) ==

* Work on [[#More Ideas (Please add your own!)| MolViz]]
:: yea (0) / nay (0)
* Develop new plugins which automate routine tasks.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Improve the Python API documentation.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Flesh out the new "from pymol2 import PyMOL" instance-based PyMOL API.
:: yea (0) / nay (0)
* Develop alternate Tkinter "skins" (for custom OEM-like applications).
:: yea (0) / nay (0)
* Develop a Tkinter/TOGL widget which holds a PyMOL viewer instance.
:: yea (0) / nay (0)
* Develop a PyQt widget which holds a PyMOL viewer instance.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Create a plugin-manager GUI in the style of Firefox, Rythmbox, Gedit, Eclipse. A GUI where it is easy to turn off/on plugins, configure them and see help-contents for them. Maybe also some way to paste a url to install a new Plugin.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Add a plugin for a GUI window with the same functionality as the "Control Panel" window in SwissPDB Viewer.
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Extend and modify the PyMOL command language so as to be compatible with existing RasMol and/or Jmol scripts.
:: yea (0) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Enhance the Mutagenesis Wizard in order to support Nucleic acids and/or Sugars.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)

== Low-Level Enhancement Ideas (Mostly C-oriented) ==

* Enable editing of displayed sequence alignments.
:: yea ([[User:Jedgold|Jedgold]], [[User:Aschreyer|Aschreyer]], [[User:Lucajovine|Luca Jovine]]) / nay (0)
::: Would this then feed back to the structural alignment? [[User:Jedgold|Jedgold]]
* Add multi-line textual annotations
:: yea (0) / nay (0)
* Support additional annotation object including: arrow, lines, and blobs.
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Vvostri|Vvostri]]) / nay (0)
* Add display of secondary structure into the sequence viewer.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Enable per-object Z clipping (especially in the ray tracer)
:: yea ([[User:Gregori|Gregori]], [[User:Xevi|Xevi]], [[User:Johnm|Johnm]]) / nay (0)
::: I would go a step further with fully customizable selection-based clipping planes (XYZ, color and transparency) ([[User:Gregori|Gregori]])
* Highlight H-bonds, salt bridges, Pi-stacking, Pi-cations, etc.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Build in a simple forcefield and energy minimizer suitable for use with Mutagenesis.
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Incorporate a suite of standard NMR visualizations (restraint violations, per-residue RMS, etc.)
:: yea ([[User:Vvostri|Vvostri]]"[[User:Vcpmartin|Vcpmartin]]") / nay (0)
* Enumeration and display of low-energy conformers.
:: yea ([[User:Jedgold|Jedgold]]) / nay (0)
::: This could be done by integrating RDKit, I think. [[User:Aschreyer|Aschreyer]]
* Automated structure grafting (poor-man's homology modeling).
:: yea (0) / nay ([[User:Jedgold|Jedgold]], [[User:Cowsandmilk|Cowsandmilk]])
::: Perhaps a plugin to Modeller instead? ([[User:Jedgold|Jedgold]], [[User:Lucajovine|Luca Jovine]])
* Import of alignment files.
:: yea ([[User:Jedgold|Jedgold]], [[User:Lucajovine|Luca Jovine]]) / nay (0)
* Implement IMD (Interactive Molecular Dynamics) Interface, see http://www.ks.uiuc.edu/Research/vmd/imd/
:: yea (0) / nay (0)
* Add buttons for '''Set ChainID''' and '''Renumber Residues From...''' to Edit menu or Actions (wrapper around Alter command)
:: yea ([[User:Sheehanj|Sheehanj]]) / nay (0)

== Difficult C-level Code Refactoring Ideas ==

* Assemble a test suite which thoroughly exercises the existing code (a prerequisite to major refactoring).
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Catch & handle memory-allocation failures gracefully (instead of crashing).
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Replace PyMOL's memory management & custom containers with a simple runtime object model.
:: yea (0) / nay (0)
* Separate the View and the Controllers from the Model so that they can all run asynchronously (on multiple cores).
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* Enable generalized undo of changes made to the Model.
:: yea ([[User:Vvostri|Vvostri]]"[[User:Vcpmartin|Vcpmartin]], [[User:Lucajovine|Luca Jovine]]", [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Clean up the internal matrix handling code.
:: yea ([[User:Cowsandmilk|Cowsandmilk]]) / nay (0)

== Ideas Involving Proprietary APIs ==

Since these involve closed-source APIs and infrastructure, they aren't suitable for open-source development efforts. However, such requests are noted here for the sake of complete coverage.

* Create a Windows port with "native" look & feel. <- Could this be done in PyQT or PyGTK?. Then it would look "native", but be cross-platform and not proprietary.
:: yea (0) / nay (0)
* Integrate directly via Mathematica via MathLink.
:: yea (0) / nay ([[User:Aschreyer|Aschreyer]])
* Further enhance JyMOL (Java-JNI/wrapped PyMOL)
:: yea ([[User:Inchoate|Tree]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* Integrate with Matlab.
:: yea (0) / nay ([[User:Aschreyer|Aschreyer]])

== More Ideas (Please add your own!) ==
* [http://molviz.cs.toronto.edu/molviz MolViz] is a project to incorporate head tracking input into [http://pymol.sourceforge.net/ PyMol]. This is accomplished through a [[ImmersiveViz]] script written in Python to control the molecule's position using the existing [http://www.pymolwiki.org/index.php/Category:Commands PyMol API]. Related projects would include:
** Improving the existing [[ImmersiveViz]] PyMol plugin for more precise control of the environment.
** Developing new input drivers for the Wiimote form of control. This would require some bluetooth hacking.
** Implementing some other forms of input for head tracking, such as fisheye head tracking, IR webcam tracking, etc (refer to the end of this [[http://www.youtube.com/watch?v=ncShaY4VSac video]] for a better description).
:: yea (0) / nay (0)
* Provide a 2D chemical depiction of the current 3D view.
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
::: RDKit?
* Spreadsheet view with additional information (e.g. IC50's).
:: yea ([[User:Aschreyer|Aschreyer]]) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* Create additional documentation, screen casts, & tutorials.
:: yea ([[User:Markvanraaij|Markvanraaij]]) / nay (0)
* Export 3D PDF images.
:: yea ([[User:Vvostri|Vvostri]], [[User:Lucajovine|Luca Jovine]]) / nay ([[User:Cowsandmilk|Cowsandmilk]])
* <strike>Add extra "Single Word Selectors" like "nucleic", "protein", "water", "ions", "backbone" (for nucleic acids or proteins), "mainchain", "sidechain"</strike>
:: yea (0) / nay (0)
* Add functionality that allows you to select atoms based on their location (i.e. select (x_coordinate < 10) and (z_coordinate > 0))
:: yea (0) / nay (0)
* set pdb_mirror option to use PDB mirrors other than RCSB for fetching structures (PDBe, PDBj); the EBI mirror is much faster from Europe for example.
:: yea ([[User:Aschreyer|Aschreyer]]) / nay (0)
* have the ability to link the TK console to the viewer so that users don't have to constantly alt+tab between what they want
:: yea (0) / nay (0)
* have the ability to disable typing in the viewer and automatically type in the TK console (I like being able to cut/paste/home/end)
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* I see a lot of "can pymol do this" threads - any ideas of a good UI for a page of "things PyMOL can do?"
:: yea (0) / nay (0)
* make an option where I can turn on a coordinate grid - perhaps an object that is a cuboid grid around any object in the view so I can still alter how it's rendered?
:: yea (0) / nay (0)
* iPhone / Nexus One app(s)
:: yea (0) / nay (0)
* single-color bonds between nonidentical or any spherical atoms colored specifically
:: yea (0) / nay (0)
* double bonds as two parallel cylinders
:: yea ([[User:Vvostri|Vvostri]]) / nay (0)
* export scenes as [http://www.khronos.org/webgl/ WebGL] / Could make mobile apps, presentation plugins obsolete
:: yea ([[User:Aschreyer|Aschreyer]], [[User:Cowsandmilk|Cowsandmilk]]) / nay (0)
* export images in vector format
:: yea ([[User:Vvostri|Vvostri]], [[User:Lucajovine|Luca Jovine]], [[User:Aschreyer|Aschreyer]]) / nay (0)
* Keynote plugin
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Electron density contour sliders
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Automatic electron density map generation from PDB mmcif files or user-supplied MTZ files
:: yea ([[User:Lucajovine|Luca Jovine]], [[User:Aschreyer|Aschreyer]], [[User:Johnm|Johnm]]) / nay (0)
* Display of crystallographic symmetry and NCS axes, with possibility of showing symbols indicating what kind of axes they are
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)
* Automatic symmetry expansion to show overall crystal packing; automatic generation of scenes showing crystal packing interface details
:: yea ([[User:Lucajovine|Luca Jovine]]) / nay (0)

Plugins Tutorial

2008-07-29T17:21:45Z

Cowsandmilk: mediawiki formatted the code with a space on the left side, which makes copying and pasting the code annoying

==Learn By Example==
This tutorial is a more sophisticated version of the [[PDB Loader Service]] plugin that is bundled with PyMol. It is a relatively simple plugin, but should prove to be a good starting point for developing new plugins.

===Registering your Plugin===
First you must add your plugin to the ''Plugins'' menu. This is most easily done in the ''__init__'' method of your plugin. A callback, fetchPDBDialog, is added. It is passed a reference to the main Tk app. It will need this in order to create new content in the main Tkinter loop. It is not strictly required in this example, but is needed in more complex interfaces.

<source lang="python">
def __init__(self):
self.menuBar.addmenuitem('Plugin', 'command',
'PDB Loader Service',
label = 'PDB Loader Service',
command = lambda s=self : fetchPDBDialog(s))
</source>

===Adding Functionality===
For this example we are going to dynamically download and load a pdb structure into the pymol interface. Here is a simple method which does that given a pdbCode.

<source lang="python">
def remote(pdbCode):
pdbCode = pdbCode.upper()
try:
pdbFile = urllib2.urlopen('<nowiki>http://www.rcsb.org/pdb/cgi/export.cgi/</nowiki>' +
pdbCode + '.pdb.gz?format=PDB&pdbId=' +
pdbCode + '&compression=gz')
cmd.read_pdbstr(zlib.decompress(pdbFile.read()[22:], -zlib.MAX_WBITS), pdbCode)
except:
print "Unexpected error:", sys.exc_info()[0]
tkMessageBox.showerror('Invalid Code',
'You entered an invalid pdb code:' + pdbCode)
</source>

===Creating the Interface===
Now we need to write the callback method, ''fetchPDBDialog'', which creates the interface.

<source lang="python">
def fetchPDBDialog(app):
pdbCode = tkSimpleDialog.askstring('PDB Loader Service',
'Please enter a 4-digit pdb code:',
parent=app.root)
remote(pdbCode)
</source>

Pretty simple! As of now you have a fully functional plugin that will prompt the user for a pdb code, download it from [http://www.rcsb.org/pdb/ RCSB], and load it into the PyMol interface.

===Extending Plugins to the Command Line===
Opening the dialog can be tedious, so let's add a command line callback to make use of this new functionality.

<source lang="python">
cmd.extend('remote', remote)
</source>

Now you can type ''remote 1di9'', for example, to load the the corresponding pdb.

==Full Source==
Here is the complete example. You can save this file and load it into PyMol with the ''Plugin -> Install Plugin...'' menu item. I also include the sample license that Warren provides for plugin developers. It is optional, of course.

<source lang="python">
# Copyright Notice
# ================
#
# The PyMOL Plugin source code in this file is copyrighted, but you can
# freely use and copy it as long as you don't change or remove any of
# the copyright notices.
#
# ----------------------------------------------------------------------
# This PyMOL Plugin is Copyright (C) 2004 by Charles Moad <cmoad@indiana.edu>
#
# All Rights Reserved
#
# Permission to use, copy, modify, distribute, and distribute modified
# versions of this software and its documentation for any purpose and
# without fee is hereby granted, provided that the above copyright
# notice appear in all copies and that both the copyright notice and
# this permission notice appear in supporting documentation, and that
# the name(s) of the author(s) not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# THE AUTHOR(S) DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
# NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
# USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
# ----------------------------------------------------------------------

import tkSimpleDialog
import tkMessageBox
from pymol import cmd
import sys, urllib2, zlib

def __init__(self):
self.menuBar.addmenuitem('Plugin', 'command',
'PDB Loader Service',
label = 'PDB Loader Service',
command = lambda s=self : fetchPDBDialog(s))

def remote(pdbCode):
pdbCode = pdbCode.upper()
try:
pdbFile = urllib2.urlopen('http://www.rcsb.org/pdb/cgi/export.cgi/' +
pdbCode + '.pdb.gz?format=PDB&pdbId=' +
pdbCode + '&compression=gz')
cmd.read_pdbstr(zlib.decompress(pdbFile.read()[22:], -zlib.MAX_WBITS), pdbCode)
except:
print "Unexpected error:", sys.exc_info()[0]
tkMessageBox.showerror('Invalid Code',
'You entered an invalid pdb code:' + pdbCode)

def fetchPDBDialog(app):
pdbCode = tkSimpleDialog.askstring('PDB Loader Service',
'Please enter a 4-digit pdb code:',
parent=app.root)

remote(pdbCode)

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

[[Category:Developers|Plugins_Tutorial]]
[[Category:Plugins|Plugins_Tutorial]]
[[Category:Tutorials]]

Label

2008-07-11T22:27:29Z

Cowsandmilk: /* UTF8 Fonts */ fix typo of setting

[[Image:Label_pre.png|thumb|PyMol Labels]]
===DESCRIPTION===
'''label''' allows one to configure the appearance of text labels for PyMOL objects. It, labels one or more atoms properties over a selection using the python evaluator with a separate name space for each atom. The symbols defined in the name space are:
* '''name''', the atom name
* '''resn''', the residue name
*'''resi''', the residue number/identifier
*'''chain''', the chain name
*'''q''',
*'''b''', the occupancy/b-factor
*'''segi''', the segment identifier
*'''type''' ''(ATOM,HETATM)'', the type of atom
*'''formal_charge''', the formal charge
*'''partial_charge''', the partial charge
*'''numeric_type''', the numeric type
*'''text_type''', the text type

All strings in the expression must be explicitly quoted. This operation typically takes several seconds per thousand atoms altered. To clear labels, simply omit the expression or set it to ''.

===USAGE===
label (selection),expression

===SETTINGS===
====FONT====
There are 10 different scalable fonts.
<source lang="python">set label_font_id, number</source>
where number is 5 through 14.
=====UTF8 Fonts=====

[[Image:New_fonts.jpeg|thumb|New fonts in PyMol. Notice the alpha and beta characters.]]

Newer versions support UTF8 fonts; use '''label_font_id''' from above to 15 or 16. The good news about the UTF8 fonts is that they support the alpha and beta characters. (See image.)

Here's some example code for the image at right:
<source lang="python">
# roman
set label_font_id, 15
set label_shadow_mode, 3
label 5/CA, "\316\261-Helix"
label 10/CA, "\316\262-Sheet"

# italic
set label_font_id, 16

# make bigger
set label_size, 50
</source>

====SIZE====
The font size can be adjusted
<source lang="python">set label_size, number</source>
where number is the point size (or -number for Angstroms)

====COLOR====
Set a label's color by
set label_color, color
where color is a valid PyMol color.

====EXPRESSION====
To set what the label reads (see above)
<source lang="python">label selection, expression</source>
For example
<source lang="python">
label all, name
label resi 10, b
</source>

====POSITION====
To position labels
edit_mode
then
ctrl-middle-click-and-drag to position the label in space. (On Windows systems this appears to be shift-left-click-and-drag, presumably because those mice lack a true middle button.)

ctrl-shift-left-click-and-drag alters a label's z-plane. (Windows only? This may use the middle button, rather than shift-left, under *NIX / 3-button mice systems.)

===EXAMPLES===
label (chain A),chain
label (n;ca),"%s-%s" % (resn,resi)
label (resi 200),"%1.3f" % partial_charge

The following image was created with
<source lang="python">
label (resi 200),"%1.3f" % b
set label_font_id, 10
set label_size, 10
</source>
and finally, some labels were moved around in '''edit_mode'''.
[[Image:Label_ex.png|thumb|Labels.]]

===Users Comments===
====Labels Using ID Numbers====
The following commnent,
label SELECTION, " %s" % ID
labels the SELECTION with atom ID numbers.

You can make more complicated selections/lables such as
label SELECTION, " %s:%s %s" % (resi, resn, name)
which will give you something like "GLU:139 CG"

====Labels Using One Letter Abbreviations====
* First, Add this to your $HOME/.pymolrc file:
<source lang="python">
# start $HOME/.pymolrc modification
one_letter ={'VAL':'V', 'ILE':'I', 'LEU':'L', 'GLU':'E', 'GLN':'Q', \
'ASP':'D', 'ASN':'N', 'HIS':'H', 'TRP':'W', 'PHE':'F', 'TYR':'Y', \
'ARG':'R', 'LYS':'K', 'SER':'S', 'THR':'T', 'MET':'M', 'ALA':'A', \
'GLY':'G', 'PRO':'P', 'CYS':'C'}
# end modification
</source>

*. Second, instead of:
label n. ca, resn
use:
label n. ca, one_letter[resn]

[[Category:Commands|label]]

Gallery

2008-06-08T03:52:25Z

Cowsandmilk: Link Grid Mode to the correct page

{| align="center"
|+ style="width: 90%; font-size:190%; font-weight: bold; color:#038; text-align:center; padding: 5px; margin-bottom: 15px; colspan:4" | PyMOLWiki Gallery
|- style="text-align:center; font-weight: bold; font-size:120%; color:#333;"
| Cool PyMOL-generated Images and their Scripts. ''[[Talk:Gallery#Adding|Add Your Own]]''
|}

{{GalleryImage
|image=Gm2.png|size=200px|title=Grid Mode|description=This image shows [[Grid mode|Grid Mode]] in action.
|cmdString=<source lang="python">
fetch 1cll 1sra 1ggz 5pnt 1rlw 1cdy;
set grid_mode
</source>
|seeAlso=
*[[Fetch]]
*[[Set]]
*[[grid_mode]]
}}

{{GalleryImage
|image=Fov60.png|size=200px|title=Cool Perspective|description=This image shows a perspective through [[Field_Of_View]].
|cmdString=<source lang="python">
load prot.pdb;
zoom i. 46-49 and n. CA
set field_of_view, 60
ray
</source>
|seeAlso=
*[[Load]]
*[[Ray]]
*[[Zoom]]
*[[Set]]
}}

{{GalleryImage
|image=Pocket.png|size=200px|title=Representing a binding pocket|description=This image shows a nice way to show binding surfaces
|cmdString=<source lang="python">
load $TUT/1hpv.pdb, tmp
extract lig, organic
extract prot, polymer
delete tmp

set surface_carve_cutoff, 4.5
set surface_carve_selection, lig
set surface_carve_normal_cutoff, -0.1

show surface, prot within 8 of lig
set two_sided_lighting
set transparency, 0.5
show sticks, lig
orient lig

set surface_color, white
set surface_type, 2 # mesh
unset ray_shadows
</source>
|seeAlso=
*[[extract]]
*[[delete]]
*[[show]]
*[[set]]
*[[orient]]
*[[surface_carve_cutoff]]
*[[surface_carve_selection]]
*[[surface_carve_normal_cutoff]]
*[[surface_color]]
*[[surface_type]]
}}