PyMOL Wiki - User contributions [en]

Cluster mols

2017-12-01T15:23:07Z

Mpb21: Added full page of description

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular fingerprints [http://openbabel.org/wiki/FP2] and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through BitBucket at: https://bitbucket.org/mpb21/cluster_mols_py/overview

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from http://openbabel.org

Recent versions of cluster_mols do not require sdsorter, but it is still a very useful tool for dealing with sdf files.
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: http://www.smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the clusters using the keyboard. Familiar to gamers, you can move through clusters using the WASD keys, (W for up, S for down, A for left, D for right).
The one important caveat is that due to [[Set_Key#KEYS_WHICH_CAN_BE_REDEFINED|limitations]] in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning Ctrl-W moves up. It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Ctrl-F -- Check for vendors

If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (http://www.docking.zinc.org) or a MolPort ID (http://www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors available.

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls. Pressing F3 will append the current compounds into a new object with the suffix '_selected'.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

== show_contacts ==
show_contacts is an expanded version of list_hbonds[http://pldserver1.biochem.queensu.ca/~rlc/work/pymol/] that shows both favorable and unfavorable contacts between ligands and a protein receptor. show_contacts has been integrated into cluster_mols as a function and is executed automatically when clustering. It can also be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
#selection -- pymol selection string for the protein
#selection2 -- pymol selection string for the ligands
#results -- prefix of the object that the distances should be shown in. (Default "contacts")
#cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
#bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Server =
A client-server architecture has been implemented as well to allow for offloading the calculations to a remote server. The cluster_mols_server.py runs on the server and listens for input from clients and returns the results. Use of the remote server can be enable or disabled with the boolean near the top of the cluster_mols.py script. Setting RUN_REMOTELY = True attempts to offload the work to the remote server and setting it to False runs it locally.

= Citing ClusterMols =
If you use ClusterMols in your work, please cite the following.

Baumgartner, Matthew (2016) IMPROVING RATIONAL DRUG DESIGN BY INCORPORATING NOVEL BIOPHYSICAL INSIGHT. Doctoral Dissertation, University of Pittsburgh.

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to matthew.p.baumgartner [at] gmail.com.

[[Category:Plugins]]

Frame slider

2015-03-24T18:27:49Z

Mpb21: added picture

{{Infobox script-repo
|type = script
|filename = frame_slider.py
|author = Matthew Baumgartner
|license = MIT
}}

The Frame slider plugin provides a simple slider bar that allows you to quickly skip through frames in PyMOL. It also has a text field that you can type the desired frame in and it will automatically go to that frame.

[[File:frame_slider.png]]

[[Category:Script_Library]]
[[Category:UI_Scripts]]
[[Category:Pymol-script-repo]]

Frame slider

2015-03-24T18:16:27Z

Mpb21: added installation instructions

{{Infobox script-repo
|type = script
|filename = frame_slider.py
|author = Matthew Baumgartner
|license = MIT
}}

The Frame slider plugin provides a simple slider bar that allows you to quickly skip through frames in PyMOL. It also has a text field that you can type the desired frame in and it will automatically go to that frame.

[[File:frame_slider.png]]

== Installation ==
The frame slider plugin can be installed through the Plugin Manager in the Plugin Menu of PyMOL.

Frame slider

2015-03-24T18:12:41Z

Mpb21: added picture

Frame slider

2015-03-24T18:11:00Z

Mpb21: Creation of page for frame slider plugin

Get Names

2015-03-18T16:04:18Z

Mpb21: /* EXAMPLES */ Changed the example so that it will print the actual object name

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

===PYMOL API===
<source lang="python">
cmd.get_names( [string: "objects"|"selections"|"all"|"public_objects"|"public_selections"] )
</source>

===NOTES===
The default behavior is to return only object names.

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

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

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

[[Category:Commands|Get Names]]

Spectrum

2014-09-18T14:50:28Z

Mpb21: /* Notes */ Added some missing bullets

[[Image:Spectrum_ex2.png|right|thumb|185px]]
= Overview =
[[Spectrum]] colors atoms with a spectrum of colors based on an atomic property.

= Usage =
<source lang="python">
spectrum [expression [, palette [, selection [, minimum [, maximum [, byres ]]]]]]
</source>

''expression''
::count, b, q, or pc: respectively, atom count, temperature factor, occupancy, or partial charge {default: count}

''palette''
::string: palette name {default: rainbow}

''selection''
::string: atoms to color {default: (all)}

''minimum''
::float: {default: None (automatic)}

''maximum''
::float: {default: None (automatic)}

''byres''
::integer: controls whether coloring is applied per-residue {default: 0}

= Notes =
Minimum and maximum are determined automatically unless '''both''' arguments are provided and ''minimum < maximum''.

Available palettes include:
*blue_green
*blue_magenta
*blue_red
*blue_white_green
*blue_white_magenta
*blue_white_red
*blue_white_yellow
*blue_yellow
*cbmr
*cyan_magenta
*cyan_red
*cyan_white_magenta
*cyan_white_red
*cyan_white_yellow
*cyan_yellow
*gcbmry
*green_blue
*green_magenta
*green_red
*green_white_blue
*green_white_magenta
*green_white_red
*green_white_yellow
*green_yellow
*green_yellow_red
*magenta_blue
*magenta_cyan
*magenta_green
*magenta_white_blue
*magenta_white_cyan
*magenta_white_green
*magenta_white_yellow
*magenta_yellow
*rainbow
*rainbow2
*rainbow2_rev
*rainbow_cycle
*rainbow_cycle_rev
*rainbow_rev
*red_blue
*red_cyan
*red_green
*red_white_blue
*red_white_cyan
*red_white_green
*red_white_yellow
*red_yellow
*red_yellow_green
*rmbc
*yellow_blue
*yellow_cyan
*yellow_cyan_white
*yellow_green
*yellow_magenta
*yellow_red
*yellow_white_blue
*yellow_white_green
*yellow_white_magenta
*yellow_white_red
*yrmbcg

= Examples =
== Simple ==
<source lang="python">
spectrum b, blue_red, minimum=10, maximum=50

spectrum count, rainbow_rev, chain A, byres=1
</source>

== Intermediate ==
The following script will create this image:

[[Image:Spectrum_example.png|385px]]

<source lang="python">
# color atoms based on their distance from a point
# returns the length of the distance between atom A and atom B

diff_len = lambda x,y : math.sqrt((x[0]-y[0])*(x[0]-y[0]) + (x[1]-y[1])*(x[1]-y[1]) + (x[2]-y[2])*(x[2]-y[2]))

# fetch 1hug from the PDB

fetch 1hug, async=0

# show it as surface

as surface

# create the pseudoatom at the origin

pseudoatom pOrig, pos=(0,0,0), label=origin

# these are special PyMOL variables that will hold # the coordinates of
# the atoms and the pseudoatom

stored.origCoord = []
stored.distCoord = []

# copy the coordinates into those special variables

iterate_state 1, pOrig, stored.origCoord.append((x,y,z))
iterate_state 1, 1hug, stored.distCoord.append((x,y,z))

# extend origCoord to be the same length as the other

stored.origCoord *= len(stored.distCoord)

# calculate the distances

newB = map(lambda x,y: diff_len(x,y), stored.distCoord, stored.origCoord)

# put them into the b-factor of the protein

alter 1hug, b=newB.pop(0)

# color by rainbow_rev or any other
# palette listed in "help spectrum"

spectrum b, rainbow_rev, 1hug
</source>

= See Also =

* [[Advanced Coloring]]
* [[Palette Colorbars]]
* [[Advanced_Coloring#Coloring_with_.27chainbows.27_from_a_script|chainbow]]
* [[spectrumany]]
* [[Ramp_New]]
* [[spectrumbar]]

Cluster mols

2014-09-17T13:11:55Z

Mpb21: Removed all text. Note to other editors, this is the author and I need to take down this page for a bit and I don't see a way to hide the page.

Placeholder

Cluster mols

2014-09-17T13:05:50Z

Mpb21: Edited dependencies and changed Download link

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular fingerprints [http://openbabel.org/wiki/FP2] and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: [[ Currently Unavailable ]]

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from http://openbabel.org

Recent versions of cluster_mols do not require sdsorter, but it is still a very useful tool for dealing with sdf files.
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: http://www.smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the clusters using the keyboard. Familiar to gamers, you can move through clusters using the WASD keys, (W for up, S for down, A for left, D for right).
The one important caveat is that due to [[Set_Key#KEYS_WHICH_CAN_BE_REDEFINED|limitations]] in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning Ctrl-W moves up. It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Ctrl-F -- Check for vendors

If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (http://www.docking.zinc.org) or a MolPort ID (http://www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors available.

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls. Pressing F3 will append the current compounds into a new object with the suffix '_selected'.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

== show_contacts ==
show_contacts is an expanded version of list_hbonds[http://pldserver1.biochem.queensu.ca/~rlc/work/pymol/] that shows both favorable and unfavorable contacts between ligands and a protein receptor. show_contacts has been integrated into cluster_mols as a function and is executed automatically when clustering. It can also be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
#selection -- pymol selection string for the protein
#selection2 -- pymol selection string for the ligands
#results -- prefix of the object that the distances should be shown in. (Default "contacts")
#cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
#bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-25T19:08:16Z

Mpb21: fixed some broken links and updated some of the formatting

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular fingerprints [http://openbabel.org/wiki/FP2] and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from http://openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: http://www.smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the clusters using the keyboard. Familiar to gamers, you can move through clusters using the WASD keys, (W for up, S for down, A for left, D for right).
The one important caveat is that due to [[Set_Key#KEYS_WHICH_CAN_BE_REDEFINED|limitations]] in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning Ctrl-W moves up. It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Ctrl-F -- Check for vendors

If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (http://www.docking.zinc.org) or a MolPort ID (http://www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors available.

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls. Pressing F3 will append the current compounds into a new object with the suffix '_selected'.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

== show_contacts ==
show_contacts is an expanded version of list_hbonds[http://pldserver1.biochem.queensu.ca/~rlc/work/pymol/] that shows both favorable and unfavorable contacts between ligands and a protein receptor. show_contacts has been integrated into cluster_mols as a function and is executed automatically when clustering. It can also be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
#selection -- pymol selection string for the protein
#selection2 -- pymol selection string for the ligands
#results -- prefix of the object that the distances should be shown in. (Default "contacts")
#cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
#bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T19:07:27Z

Mpb21: /* show_contacts */ minor edits

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to [[Set_Key#KEYS_WHICH_CAN_BE_REDEFINED|limitations]] in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Ctrl-F -- Check for vendors

If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors available.

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts has been integrated into cluster_mols as a function and is executed automatically when clustering. It can also be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T19:05:51Z

Mpb21: /* Keyboard Controls */

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to [[Set_Key#KEYS_WHICH_CAN_BE_REDEFINED|limitations]] in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Ctrl-F -- Check for vendors

If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors available.

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T19:04:48Z

Mpb21: /* Keyboard Controls */ added link

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to [[Set_Key#KEYS_WHICH_CAN_BE_REDEFINED|limitations]] in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T18:50:20Z

Mpb21: moved up a section heading

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to limitations in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T18:49:18Z

Mpb21: /* GUI Options */ cleaned up the language a bit

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]
The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (An enhanced version of AutoDock Vina. Available at: smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file, or by the Title (alphabetically) or by the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. Play around with the cutoff until you get a clustering that you like. The third option is a check box for whether to group clusters with only one compound into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described below. There is also a field to enter a PyMOL selection string to compute the hydrogen bonds to. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to limitations in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T18:45:01Z

Mpb21: /* Usage */ removed abbreviation

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straightforward, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]
The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file they have including the Title or the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. The third option is a check box for whether to group clusters with only one compound in them into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described in the next section. There is also a field to enter the name of a PyMOL object to compute the hydrogen bonds to, it accepts PyMOL selection strings. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to limitations in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T18:13:18Z

Mpb21: /* Keyboard Controls */

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straight forward IMHO, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]
The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file they have including the Title or the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. The third option is a check box for whether to group clusters with only one compound in them into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described in the next section. There is also a field to enter the name of a PyMOL object to compute the hydrogen bonds to, it accepts PyMOL selection strings. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to limitations in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls

Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection

In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T17:51:27Z

Mpb21:

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

= Description =
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

= Download =
The most up to date version (recommended) of cluster_mols is available through SourceForge at: https://sourceforge.net/projects/clustermolspy/

= Installation =

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straight forward IMHO, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]
The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file they have including the Title or the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. The third option is a check box for whether to group clusters with only one compound in them into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described in the next section. There is also a field to enter the name of a PyMOL object to compute the hydrogen bonds to, it accepts PyMOL selection strings. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to limitations in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls
Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection.
In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

= Authors =
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T17:49:45Z

Mpb21:

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

== Description ==
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

== Download ==
The most up to date version (recommended) of cluster_mols is available through SourceForge at: [https://sourceforge.net/projects/clustermolspy/]

== Installation ==

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straight forward IMHO, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]
The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file they have including the Title or the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. The third option is a check box for whether to group clusters with only one compound in them into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described in the next section. There is also a field to enter the name of a PyMOL object to compute the hydrogen bonds to, it accepts PyMOL selection strings. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to limitations in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls
Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection.
In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

== Authors ==
The main cluster_mols.py script was conceived of by Matthew P Baumgartner (mpb21 [at] pitt.edu) and Dr. David Koes while working in the lab of Dr. Carlos Camacho at the University of Pittsburgh. The cluster_mols.py script was implemented (and later rewritten) by MPB. The show_contacts functionality and the first version of the objectfocus.py keyboard controls was written by DK.

Please send questions/comments/bug reports to mpb21 [at] pitt.edu.

[[Category:Plugins]]

Cluster mols

2014-07-24T17:46:32Z

Mpb21: Created page with "right cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesize..."

[[File:cluster_mols_py_pymol.png|450px|right]]
cluster_mols is a PyMOL plugin that allows the user to quickly select compounds from a virtual screen to be purchased or synthesized.

It helps the user by automatically clustering input compounds based on their molecular scaffolds and loading them into the PyMOL window. cluster_mols also highlights both good and bad polar interactions between the ligands and a user specified receptor. Additionally there are a number of keyboard controls for selecting and extracting compounds, as well as functionality for searching online to see if there are vendors for a selected compound.

== Description ==
The basic work flow of cluster_mols.py can be broken up into three parts.
# Computing a similarity matrix from the input compounds
# Performing hierarchical clustering on the results from 1)
# Cutting the tree at a user-specified height and creating and sorting clusters

The results of 1 and 2 are saved to python pickle files so you do not have to recompute them in subsequent runs.

In addition, it also highlights both good and bad polar contacts between the ligand and a user specified protein using the 'show_contacts' module described below.

This script also integrates keyboard controls which allows for WASD movement through the clusters as well as keyboard shortcuts for pulling out compounds.
See below for usage.

== Download ==
The most up to date version (recommended) of cluster_mols is available through SourceForge at: [https://sourceforge.net/projects/clustermolspy/]

== Installation ==

This plugin has a number of dependencies that are required. And it is currently only supported on Linux and OSX.

Python packages (install using easy_install or pip)
# openbabel
# chemfp
# numpy
# scipy
# Tkinter
# fastcluster
# argparse (optional: for command line only)

Command line tools (These must be accessible through your PATH environment variable):
# babel -- from openbabel.org
# sdsorter -- https://sourceforge.net/projects/sdsorter/

Once you have the required dependencies, install it through PyMOL's Plugin menu.

PyMOL > Plugin > Install Plugin

= Usage =

The GUI is relatively straight forward IMHO, if you follow it from top to bottom, and then then left to right through the tabs.

The program requires that the input be a '.sdf' or '.sdf.gz' file. If your compounds are not in that format, use the 'babel' tool from OpenBabel to convert them.

In the 'Compute Similarities' tab, there are options for selecting a new ligand and for specifying how many CPUs you want to run the similarity calculation on. Clicking the 'Compute Similarity' button will start the similarity calculations. If you check the 'Ignore saved results?' box it will ignore any saved intermediate results files. This could be useful if you change the contents of the original input file while keeping the file name the same.

Depending on how many compounds there are, the similarity calculations may take between 1 and 10 minutes. If you launched PyMOL from the command line, you will be able to see the progress printing out in the console. The similarity results are saved to a file so if you want to re-cluster the same input file, you do not need to wait to recompute the similarities.

== GUI Options ==
[[File:cluster_mols_screen_1_desc.png|200px|thumb]]
[[File:cluster_mols_screen_2_desc.png|200px|thumb]]
The first option on the Cluster Compounds tab defines how the clusters will be sorted. The default is to sort by the 'minimizedAffinity' which is inserted into the output sdf file after minimization with 'smina' (smina.sf.net). You can also sort the clusters by any SD tag that exists in the input file they have including the Title or the size of the cluster.

The second option is the height at which the hierarchical clustering tree is cut. The units are arbitrary, but a higher number leads to a small number of large clusters of less similar compounds, and lower cutoffs lead to more small clusters of more similar compounds. The third option is a check box for whether to group clusters with only one compound in them into one ‘singletons’ cluster. The forth option enables the show_contacts tool that is described in the next section. There is also a field to enter the name of a PyMOL object to compute the hydrogen bonds to, it accepts PyMOL selection strings. Finally, there is a button to create the clusters and load them into PyMOL.

== Keyboard Controls ==
Once you have finished the similarity calculations and clustering mentioned above, you can navigate the Familiar to gamers, you can move through clusters using WASD, (W for up, S for down, A for left, D for right).
The one important caveat is that due to limitations in PyMOL, the WASD movement needs to be used with the Control (or Alt) key. Meaning (Ctrl-W moves up). It seems weird, but you quickly get used to it.

Navigation Controls
Ctrl-W – Move up a cluster

Ctrl-S – Move down a cluster

Ctrl-A – Move to the previous compound in a cluster

Ctrl-D – Move to the next compound in the cluster

Compound selection.
In addition to moving through the clusters, you can also extract compounds that you like for later viewing using the following controls.

F1 – Print title of currently selected molecule

F2 – Remove most recently added compound

'''F3 – Add currently visible compound to list''' (Most commonly used)

F4, F12 – Print List

Ctrl-F -- Check for vendors

[Check for available vendors (ZINC)]
If you acquired your compounds from ZINCPharmer (http://zincpharmer.csb.pitt.edu/) and/or your compounds have title that start with a ZINC ID (docking.zinc.org) or a MolPort ID (www.molport.com), you can hit 'Ctrl-F' to see if there are any vendors listed on the ZINC website.

== show_contacts ==
show_contacts is a tool originally developed by Dr. David Koes for visualizing the hydrogen bond network between ligands and a protein receptor. show_contacts is integrated into cluster_mols as a function and is executed automatically . It can be run by itself, not in the context of cluster_mols. In the standalone case, the usage is as follows:

show_contacts(selection,selection2,result="contacts",cutoff=3.6, bigcutoff = 4.0):

The arguments are as follows:
selection -- pymol selection string for the protein
selection2 -- pymol selection string for the ligands
results -- prefix of the object that the distances should be shown in. (Default "contacts")
cutoff -- Distance cutoff for what is considered an ideal hydrogen bond.
bigcutoff -- Distance cutoff for a non-ideal hydrogen bond.

Output:
The output of show_contacts are a set of pymol distance objects. They are color-coded and size coded to indicate different interactions between the ligand and protein. They are controlled by the parameter indicated.

# thin-purple lines -- all possible polar contacts (acc-acc, don-don, acc-don) -- bigcutoff
# thick-yellow lines -- All ideal hydrogen bonds -- cutoff
# thin-yellow lines -- Non ideal hydrogen bonds -- bigcutoff
# thick-red lines -- Polar clashes, i.e. Donor-Donor, Acceptor-Acceptor -- cutoff

[[Category:Plugins]]

Displaying Biochemical Properties

2014-06-27T17:28:35Z

Mpb21: /* Displaying double bonds */ Added link to the Valence page for more information.

==Selecting secondary structures==
A few examples:
<source lang="python">
select helix, (ss h)
select sheet, (ss s)
select loop, (ss l+'')
</source>

===Manually Assigning Secondary Structure===
You can manually assign secondary stuctures to your protein by
<source lang="python">
alter 96-103/, ss='S'
alter 96-103/, ss='H'
alter 96-103/, ss='L'
</source>

to set residues 96-103 to beta Strand, alpha Helix, and Loop respectively.

===See Also===
[[DSSP]] [[Dss]] [[Caver]]

[[:Category:FAQ|FAQ]] [[:Category:Objects_and_Selections|Displaying Biochemical Properties]]

==Coloring ==
See also [[:Category:Coloring]].

===Color by atom type from a script===
See [[Color]] for this.

===Assign color by B-factor===
See section [[Color]] for this.

===Representation-independent color control===
See section [[Surface#Representation-independent Color Control]].

== Bonds ==
PyMOL can deduce bonds from the PDB structure file, even if the '''CONECT''' records are missing. In fact, PyMOL guesses bonding connectivity based on proximity, based on the empirical observation that two atoms of a given radius will not be generally closer than a certain distance unless they are bonded.

===Displaying double bonds===
<gallery widths="300px" heights="300px">
Image:DoubleBonds.png|Image showing double bonds in PyMOL. Double bonds are supported in [[lines]] and [[sticks]].
</gallery>

You can go into the [[lines]] mode and turning on the valence display:
<source lang="python">
hide
as lines
set valence, 0.1
</source>

A higher value for valence spreads things out more. See the [[Valence]] page for more information on options for changing the appearance of the valence lines.

===Hydrogen bonds and Polar Contacts===

[[Image:Polar_contacts_small.png|thumb|Polar Contacts in PyMol|center|300px]]
Using the actions [A] button for an object or selection you can display Hydrogen bonds and Polar Contacts.
[A]->find->polar contacts-><select from menu>

The command behind the menus is the <b>dist</b>ance command called with the additional argument mode=2.

Parameters that control the the identification of H-bonds are defined as
set h_bond_cutoff_center, 3.6
with ideal geometry and
set h_bond_cutoff_edge, 3.2
with minimally acceptable geometry.

These settings can be changed *before* running the detection process (dist
command mode=2 or via the menus).

Note that the hydrogen bond geometric criteria used in PyMOL was designed to
emulate that used by [http://swift.cmbi.kun.nl/gv/dssp/ DSSP].

==== Hydrogen bonds between specific atoms ====
<source lang="python">
dist name, sele1, sele2, mode=2
</source>

==== Hydrogen bonds where find->polar contacts doesn't do what you need ====
You can show H-bonds between two objects using atom selections so long as hydrogens are present in both molecules. If you don't have hydrogens, you can use [[h_add]] on the proteins, or provide ligands with valence information and then use h_add.

Two examples are below. For clarity, they draw dashes between the heavy atoms and hide the hydrogens.
<source lang="python">
# EXAMPLE 1: Show hydrogen bonds between protein
# and docked ligands (which must have hydrogens)

load target.pdb,prot
load docked_ligs.sdf,lig

# add hydrogens to protein

h_add prot

select don, (elem n,o and (neighbor hydro))
select acc, (elem o or (elem n and not (neighbor hydro)))
dist HBA, (lig and acc),(prot and don), 3.2
dist HBD, (lig and don),(prot and acc), 3.2
delete don
delete acc
hide (hydro)

hide labels,HBA
hide labels,HBD
</source>
<source lang="python">
# EXAMPLE 2
# Show hydrogen bonds between two proteins

load prot1.pdb
load prot2.pdb

h_add prot1
h_add prot2

select don, (elem n,o and (neighbor hydro))
select acc, (elem o or (elem n and not (neighbor hydro)))
dist HBA, (prot1 and acc),(prot2 and don), 3.2
dist HBD, (prot1 and don),(prot2 and acc), 3.2
delete don
delete acc
hide (hydro)

hide labels,HBA
hide labels,HBD

# NOTE: that you could also use this approach between two
# non-overlapping selections within a single object.
</source>
There is also a [http://www.ebi.ac.uk/~gareth/pymol/downloads/scripts/hbond.py script] drawing nice hydrogen bonds from [http://www.ebi.ac.uk/~gareth Gareth Stockwell].

The "polar contacts" mentioned above are probably better at finding hydrogen bonds than these scripts. "Polar contacts" check geometry as well as distance.

==== Details ====
Generally speaking, PyMOL does not have sufficient information to rigorously determine hydrogen bonds, since typical PDB file are ambiguous with respect to charge states, bonds, bond valences, and tautomers. As it stands, all of those things are guessed heuristically. Rigorously determining the location of lone pair electrons and proton coordinates from raw PDB files is a nontrival problem especially when arbitrary small molecule structures are present. In addition, PyMOL would also need to consider the implied coordinate error due to overall structure resolution and local temperature factors before rigorously asserting than any specific hydrogen bond does or does not exist.

Furthermore, our hydrogen bond detection machinery was originally developed for purposes of mimicking Kabsch and Sander's DSSP secondary structure assignment algorithm (Biopolymers 22, 2577, 1983) which is based on a rather generous notion of hydrogen bonding (see Kabsch Figure 1).

Although this approximate capability can be accessed via the distance command using mode=2, the criteria applied by our implementation may be based on heavy-atom coordinates (only) and does not necessarily correspond to anything rigorous or published. So the bottom line is that PyMOL merely offers up putative polar contacts and leaves it to the user to determine whether or not the interactions present are in fact hydrogen bonds, salt bridges, polar interactions, or merely artifacts of incorrect assignments (i.e. two carbonyls hydrogen bonding because they're being treated like hydroxyls).

With respect to the h_bond_* settings, the angle in question for h_bond_cutoff_* and h_bond_max_angle is ADH, assuming H exists. If H does not exist, then PyMOL will guess a hypothetical coordinate which may not actually be valid (in plane, etc.). Tthe hydrogen must also lie within a cone of space with its origin on A (along B->A) and angular width h_bond_cone. Since h_bond_cone in 180 by default, the present behavior is to simply reject any hydrogen bond where the hydrogen would lie behind the plane defined by the acceptor atom (A) in relation to its bonded atom(s) B (if any). In other words, if B is only one atom (e.g. C=O vs. C-O-C), then by default, HAB cannot be less then 90 degrees.

The two h_bond_power_* settings are merely fitting parameters which enable PyMOL to reproduce a curve shape reflecting Kabsch Figure 1. The endpoints of the effective cutoff curve is a function of the two h_bond_cutoff_* setting.

==Calculating dihedral angles==
The get_dihedral function requires four single-atom selections to work:
<source lang="python">
get_dihedral prot1///9/C, prot1///10/N, prot1///10/CA, prot1///10/C
</source>

== Cavities ==
See [[Surfaces_and_Voids]]. Also [[Caver]] and [[CASTp]].

==Surface-Related==

===Surface Area===
To calculate the surface area of a selection, see [[Get_Area]].

===Polar surface area===
For a solvent accessible PSA approximation:
<source lang="python">
set dot_density, 3
remove hydro
remove solvent
show dots
set dot_solvent, on
get_area elem N+O
get_area elem C+S
get_area all
</source>

For molecular PSA approximation
<source lang="python">
set dot_density, 3
remove hydro
remove solvent
set dot_solvent, off
get_area elem N+O
get_area elem C+S
get_area all
</source>

Showing dots isn't mandatory, but it's a good idea to confirm that you're getting the value for the atom dot surface you think you're using.
Please realize that the resulting numbers are only approximate, reflecting the sum of partial surface areas for all the dots you see. To increase accuracy, set dot_density to 4, but be prepared to wait...

===Display solvent accessible surface===
Using the surface display mode, PyMOL doesn't show the solvent accessible surface, rather it shows the solvent/protein contact surface. The solvent accessible surface area is usually defined as the surface traced out by the center of a water sphere, having a radius of about 1.4 angstroms, rolled over the protein atoms. The contact surface is the surface traced out by the vdw surfaces of the water atoms when in contact with the protein.

PyMOL can show solvent accessible surfaces using the dot or sphere representations:

for dots:
<source lang="python">
show dots
set dot_mode,1
set dot_density,3
</source>

for spheres:
<source lang="python">
alter all,vdw=vdw+1.4
show spheres
</source>

Once the Van der Waals radii for the selection have been altered, the surface representation will also be "probe-inflated" to show a pseudo solvent accessible surface, as detailed above.

for surfaces:
<source lang="python">
alter all,vdw=vdw+1.4
show surface
</source>

[[Image:solvent-accessible_surface.jpg|thumb|Solvent-Accessible Surface Example|left]]

Note that to display both the molecular surface and the solvent-accessible surface, the object must be duplicated, as is done for [[Surface#Representation-independent Color Control]]. This also applies if the spheres representation is to be used to display "real" atoms.

===Contact Potential===
See [[Protein_contact_potential]] and [[APBS]].
[[Image:Prot_contact_pot.png|thumb|right|125px]]
<div style="clear:right;"> </div>

=== Electric Field Lines ===
[[Image:Elines.png|center|250px|thumb|PyMOL and APBS used to show electronic field lines.]]

To produce an image with electric field lines, first run APBS. Then, input the following:
<source lang="python">
gradient my_grad, pymol-generated
ramp_new my_grad_ramp, pymol-generated
color my_grad_ramp, my_grad
</source>

===Residues with functional groups===
[[Image:1igt_cys_lys_asp_glu_colored.png|thumb|200px|Whole residues colored (Cys: yellow, Lys: blue, Asp and Glu: red)]]
Poor man's solution: Display protein as surface, colorize all Lys (-NH2), Asp and Glu (-COOH) and Cys (-SH):
<source lang="python">
remove resn hoh # remove water
h_add # add hydrogens

as surface
color grey90

color slate, resn lys # lysines in light blue
color paleyellow, resn cys # cysteines in light yellow
color tv_red, (resn asp or(resn glu)) # aspartic and glutamic acid in light red
</source>

[[Image:1igt_functional_groups_colored.png|thumb|200px|Only central atoms of functional groups colored (Cys: S, Lys: NH2, Asp and Glu: CO2)]]
Not-''so''-poor-man's solution: In order to have the functional groups better localized, only the central atoms can be colored:
* the S atom of cystein,
* the N and H atoms of the free amine of lysine (may be displayed with three H atoms at all three possible positions)
* the C and two O atoms of free carboxylic groups in aspartic and glutamic acid
In this way, they are better visible through the surface compared to only one colored atom, both amines and carboxylic groups consist of three colored atoms each.
<source lang="python">
remove resn hoh # remove water
h_add # add hydrogens

as surface
color grey90

select sulf_cys, (resn cys and (elem S)) # get the sulfur atom of cystein residues
color yellow, sulf_cys

select nitro_lys, (resn lys and name NZ) # get the nitrogens of free amines ("NZ" in PDB file)
select hydro_lys, (elem H and (neighbor nitro_lys)) # get the neighboring H atoms
select amine_lys, (nitro_lys or hydro_lys)
color tv_blue, amine_lys

select oxy_asp, (resn asp and (name OD1 or name OD2)) # get the two oxygens of -COOH ("OD1", "OD2")
select carb_asp, (resn asp and (elem C and (neighbor oxy_asp))) # get the connecting C atom
select oxy_glu, (resn glu and (name OE1 or name OE2)) # oxygens "OE1" and "OE2" in PDB file
select carb_glu, (resn glu and (elem c and (neighbor oxy_glu)))
select carboxy, (carb_asp or oxy_asp or carb_glu or oxy_glu)
color tv_red, carboxy
</source>

By displaying the protein as non-transparent surface, only the functional groups (colored atoms) at the surface are visible. The visualization of those groups can be pronounced by displaying the corresponding atoms as spheres, e.g. "as spheres, carboxy + amine_lys + sulf_cys", in this way it might become more clear how accessible they are.

When displaying the protein as cartoon, the functional groups can be shown as spheres, and the whole residues cys, lys, asp and glu as sticks connected to the backbone, with the atoms of the functional groups again as spheres. However, then also the not accessible residues inside the protein are visible.

== Backbones ==
===Displaying the C-Alpha trace of proteins===
<source lang="python">
hide
show ribbon
set ribbon_sampling,1
</source>

And if your model only contains CA atoms, you'll also need to issue:
<source lang="python">
set ribbon_trace,1
</source>

===Displaying the Amino Acid Backbone===
The easiest way to see the backbone of the protein is to do
<source lang="python">
hide all
show ribbon
</source>

If you don't like the ribbon representation, you can also do something like
<source lang="python">
hide all
show sticks, name C+O+N+CA
</source>
You can replace '''sticks''' in the above by other representations like '''spheres''' or '''lines'''.

===Displaying the Phosphate backbone of nucleic acids===
====Native Nucleic Acid Rendering in PyMol====
PyMol now better supports viewing nucleic acid structure. [[Nuccyl]] still seems to be the reigning champ for image quality, but see PyMol's native [[Cartoon]] command. For more information on representing nucleic acids, please see the [[:Category:Nucleic_Acids|Nucleic Acids]] Category.
[[Image:Cnam_0.png|right|thumb|130px]] <div style="clear:right;"> </div>

Should you ever want to show the phosphate trace of a nucleic acid molecule:
<source lang="python">
def p_trace(selection="(all)"):
s = str(selection)
cmd.hide('lines',"("+s+")")
cmd.hide('spheres',"("+s+")")
cmd.hide('sticks',"("+s+")")
cmd.hide('ribbon',"("+s+")")
cmd.show('cartoon',"("+s+")")
cmd.set('cartoon_sampling',1,"("+s+")")
cmd.set('cartoon_tube_radius',0.5,"("+s+")")
cmd.extend('p_trace',p_trace)
</source>

and then:
<source lang="python">
p_trace (selection)
</source>

==Align proteins with CA fit==
If two proteins have significant homology, you can use the [[Align]] command:
<source lang="python">
align prot1////ca,prot2
</source>

which will perform a sequence alignment of prot1 against prot2, and then an optimizing fit using the CA positions. I'm not sure if the help text for align got into 0.82, but the next version will definitely have it.

[[Category:Objects_and_Selections|Displaying Biochemical Properties]]
[[Category:Nucleic_Acids|Displaying Biochemical Properties]]
[[Category:Biochemical_Properties]]

Create

2014-02-17T16:24:01Z

Mpb21: /* PYMOL API */

'''create''' creates a new molecule object from a selection. It can also be used to create states in an existing object.
'''NOTE''': this command has not yet been throughly tested.

===USAGE===
<source lang="python">
create name, (selection) [,source_state [,target_state ] ]
create name = (selection) [,source_state [,target_state ] ] # (DEPRECATED)
</source>

* name = object to create (or modify)
* selection = atoms to include in the new object
* source_state (default: 0 - copy all states)
* target_state (default: 0)

===PYMOL API===
<source lang="python">
cmd.create(string name, string selection, int source_state, int target_state,int discrete)
</source>

===NOTES===
If the source and target states are zero (default), all states will be copied. Otherwise, only the indicated states will be copied.

===SEE ALSO===
[[Cmd load|load]], [[Cmd copy|copy]], [[Extract]]

=== User Comments/Examples ===

===EXAMPLES===
<source lang="python">
# merging two multi-state objects with the create command
# obj1 has 25 states and obj2 has 40 states

load multi_state_obj1, obj1
load multi_state_obj2, obj2

# merge the two multi-state objects back to back into obj3
# 0 indicates every states from obj1 should be included
# 1 indicates that the first state of obj3 is the first state from obj1 etc.

create obj3, obj1, 0, 1

# as obj1 has 25 states, the first state of obj2 must be state 26 to create a multi-state object of obj1 and obj2 back-to-back
# 26 indicates that the 26th state of obj3 is state nr. 1 of obj2 etc.

create obj3, obj2, 0, 26

# Obj3 now has 65 states (25 from obj1 and 40 from obj2)
# save obj3 as a multi-state pdb file
# use state=0 to get all states into one pdb file

save obj3.pdb, obj3, state=0
</source>

[[Category:Commands|Create]]
[[Category:States|Create]]
[[Category:Editing Module|Create]]