Friday, 8 January 2010

Fragment screening for a new cavity

After about six months or so of having given up on automated docking I have returned with a new biological problem to explore.

I have recently solved the structure of a protein "that shall remain nameless" because I think I have identified a new pocket that no one has targeted before. After asking advice from the ccp4 bulletin board someone suggested using the Uppsalla Software Factories program "Voidoo" for better defining my cavity (http://xray.bmc.uu.se/usf/). As I am quite familiar with USF programs (although have never used Voidoo before) I was quickly able to make a map of all the cavities in my protein using a 1A probe, that I was then able to view in Coot. This gave me an excellent idea of the extent of the pocket along with some ideas of molecules that might fit it.

Before getting out all my Autodock and FlexX scripts again for compound screening I thought I would try out a webservice called "DOCK blaster" based on the docking program DOCK and the ZINC database. It was ridicuously simple to read in my pdb file (with waters and other ligands removed) and equally simple to define the protein site to be docked by simply placing a "fake" phosphate residue into my newly identified cavity and then giving DOCK blaster these coordinates. In a couple of hours I was able to screen three or four sub-sections of the ZINC database and get back fifty or so potential small molecules which, on inspection, seem to fit the site quite well.

I am really impressed with DOCK blaster as it managed to achieve in ten minutes something that took me hours to do last year. Although I have yet to validate the results, it has given me a start. I think the next thing will be to take these fragments and see what Autodock, FlexX and Gold make of them.

Thursday, 23 April 2009

Docking despair

I work on a number of drug design projects where the number of compounds being produced by the chemists is far greater than I could possibly hope to co-crystallise with the protein and solve the subsequent structures. My hope was that I could use a docking program to quickly get an idea of how compounds might bind which could perhaps help me decide which compounds are interesting enough to put into crystal screens. I have three completely separate projects, and libraries of compounds for all three projects where I know both the experimental binding affinity and structure. Thus I figured the best thing to do was to run these libraries through a number of docking programs and see which predicted my binding conformations best. I have no hope of predicting affinity data because docking algorithms are not up to this yet, but a hint at the order of affinities would be an extra bonus. If this all worked successfully I would then try looking at libraries such as ZINC to try and find totally new compounds.

After about a year, and a couple expensive software licenses, I have come to the conclusion that no current docking programs will be able to help me at this point in time. I have evaluated GOLD, FlexX and Autodock 4 with libraries from all three projects, played around with lots of parameters, and it seems none of these programs can accurately predict binding orientations, and certainly cannot rank compounds in any experimentally meaningful way. Meanwhile the couple ZINC sub-libraries I did look at with both Autodock and FlexX did not manage to dock many compounds in a meaningful way.

I think the reason for this failure is down to the protein structures themselves. Looking at the literature and at the situations where docking has worked well for people, it seems that proteins with very well defined binding sites and obvious hydrogen bond donors/acceptors work well with docking prgrams. Although two of my proteins contain strongly charged positive ions, the rest of the binding pockets rely on hydrophobic interactions which seem to be difficult to model (and hence recognise) by the docking programs. Meanwhile my third protein is a promiscuous aromatic binder whose binding site is necessarily quite unspecific, something that again is probably not good for the success of the docking programs. Thus I think at the moment the docking programs are not yet able to model my systems, and cannot really help with quickly screening my compounds.

However I do have some ideas for using the programs to simulate molecular dynamics...

Monday, 13 April 2009

Autodock email list

As a structural biologist I am used to the excellent ccp4 email list populated by the best crystallographers in the world. It is sometimes rather intimidating to post a question, however you always know that you will get an excellent answer...

...and then you have the autodock email list... oh dear...

Although there are one or two people who seem to be genuine scientists, the rest of the posts seem to be written by clueless students just looking to take short-cuts on their projects. I presume that because autodock is free software various teachers around the globe have set assignments using it, however the result seems to be an inundation with stupid questions written in text speak. This is a real shame because molecular docking is a potentially exciting technology which could well benefit from the type of discussions held on the ccp4 email list. I suppose I should just give up on the list, however every now and again something interesting gets written. Perhaps the guys at scripps should think about moderating the list in order to improve the quality?

Monday, 9 March 2009

Have been looking at doing some dockings with a protein containing some calcium atoms. A couple years ago I had problems doing this in Autodock, however after speaking so the guys on the autodocking bulletin board I have found the following:

As far as I can gather the current situation is that ADT now recognises the calcium atom so long as it is labeled in the normal way in the pdb file and automatically assigns Rij and Rii from the AD4_parameters.dat file, HOWEVER does not assign a charge to the atom which you have to do manually by editing the pdbqt file.

This then raises the question what the charge on the calcium atom should be? A couple years ago Garrett suggested using the formal charge of 2+, however I am not certain this is strictly correct. In my case the calcium atom is coordinated by six protein ligands and the small molecule I am trying to dock in the classic calcium pentagonal bipyrimidal geometry. Given the proximity of six oxygens surely the apparent charge on the calcium that the small molecule is seeing will be substantially less than +2? Furthermore surely the presence of such a highly charged atom will affect the charge on these residues and thus alter the electrostatics of the binding site? Wouldn't it be far more accurate for the charge calculation to take into account the presence of the calcium atom (and presumably also the pH)? It feels like a bit of a fudge to manually edit the pdbqt file to the approximate value.

Incidentally I have compared dockings with the calcium charge set to +2 and 2/7. At +2 the electrostatics completely dominate the binding whilst at 2/7 the ligand is never in the correct orientation (as compared to my 1.8A X-ray structure).

Wednesday, 15 October 2008

Convert pdb to sdf or mol2

Found the excellent set of utilities yesterday called Open Babel.

The utility babel is a command line program that allows you to easily switch between chemical file formats. There is a GUI which I tried on my mac but couldn't get to work. However, the command line program is so easy to use that I don't really care!

Wednesday, 1 October 2008

Autodock - virtual screening

As I was on a role from my attempts described below I decided to try some virtual screening:

1. I went to the free ZINC database and downloaded a couple thousand molecules.

2. The molecules were downloaded as a single huge .mol2 file which I split using:

split_multi_mol2_file.py -i filename

getting split_multi_mol2_file.py from the AutoDock Virtual Screening Tutorial.

3. Next I converted the mol2 files into pdbqt's using:

foreach f (`ls *`)
echo $f
/home/progs/MGLTools-1.5.1/MGLToolsPckgs/AutoDockTools/Utilities24/prepare_ligand4.py -l $f -d ligand_dict.py
end

4. I divided the pdbqt files into separate directories (of about 1000 compounds) and then carried out the multiple ligand docking pocedure outlined in my posts below. I ran about eight jobs in total on different processors (sort of manual parallel processing!) which took about 24 hours in total processing time.

5. To evaluate the thousands of dockings I ran the script:

#!/bin/csh
cd ./Dockings
foreach d (`/bin/ls`)
echo $d
/home/progs/MGLTools-1.5.1/MGLToolsPckgs/AutoDockTools/Utilities24/summarize_results4.py -d $d -t 2. -L -a -o ../summary_run1.txt
end

This gave me the list:

largestCl_dlgfn #runs #cl #LC LE_LC rmsd_LC #ats #tors
ZINC00000077_rigid/ZINC00000077_rigid, 20, 14, 3, -6.0700, 56.6501, 25, 6
ZINC00000123_rigid/ZINC00000123_rigid, 20, 4, 8, -5.7200, 51.5977, 25, 1
ZINC00000154_rigid/ZINC00000154_rigid, 20, 3, 11, -6.4300, 52.8504, 23, 4
ZINC00000169_rigid/ZINC00000169_rigid, 20, 8, 7, -6.6700, 56.0226, 23, 4

where:

largestCl_dlgfn: filename of the dlg file which contains the result with
the lowest energy in the largest cluster.

#runs: total number of runs found in all the dlg files in the specified
directory

#cl: number of distinct clusters formed in the clustering done on all the
dlg files in the specified directory

LE_LC: the energy of the lowest energy conformation in the largest cluster

rmsd_LC: the rmsd difference between the lowest energy conformation in the
largest cluster and the reference ligand conformation. This is the input
ligand conformation unless a different reference is specified with the
'-f' flag

#ats: number of atoms in the ligand

#tors: number of active torsions in the ligand

Autodock - evaluating dockings

To evaluate my dockings I did it the hard way with a graphics program, however first needed to split the docking log files into multiple pdb files that could be read by the graphics programs. To do this I invoked the following script in each of my /Dockings/ligands directories:

#!
grep '^DOCKED' T000015_rigid.dlg | cut -c9- > my_docking.pdbqt
cut -c-66 my_docking.pdbqt > my_docking.pdb
# csh to split pdb files from autodock output.
# edit outputname.
#
set outputname=T000015
set a=`grep ENDMDL my_docking.pdb | wc -l`
set b=`expr $a - 2`
csplit -k -s -n 3 -f $outputname. my_docking.pdb '/^ENDMDL/+1' '{'$b'}'
foreach f ( $outputname.[0-9][0-9][0-9] )
mv $f $f.pdb
end

This gave me a whole bunch of pdb files which I loaded into PyMOL to examine using the PyMOL script:

load T000015.000.pdb, conf0
load T000015.001.pdb, conf1
load T000015.002.pdb, conf2
load T000015.003.pdb, conf3
etc...

Autodock 4 - making gpf & dpf files

I made my grid parameter files using Autodock tools, with the atom types found in the top of summary.txt from my ligands directories (simply add the atom types to the pop-up box in ADT) as per the tutorial. I ran AutoGrid and then checked to make sure I had all the .map files I was expecting.

Next I copied all of my ligand pdbq files into the same directory as my grid files. I then ran the following script, adapted from the virtual screening tutorial:

#!/bin/csh
mkdir Dockings
cd Dockings
foreach f (`ls ../*.pdbqt`)
set name = `basename $f .pdbqt`
echo $name
mkdir "$name"_rigid
cd "$name"_rigid
cp ../"$f" .
ln -s ../../protein.pdbqt .
ln -s ../../protein*map* .
/home/progs/MGLTools-1.5.1/MGLToolsPckgs/AutoDockTools/Utilities24/prepare_dpf4.py -l `basename $f` -r protein.pdbqt \
-p ga_num_evals=1750000 \
-p ga_pop_size=150 \
-p ga_run=20 \
-p rmstol=2.0
mv "$name"_protein.dpf "$name"_rigid.dpf
cd ..
end

This made a new directory called "Dockings", within this a directory for each of my ligands, and within each ligand directory a link to the appropriate map files and a docking parameter file for the AutoDock run for each ligand.

To run the multiple autodockings I made a file called ligands.list containing the name of all my ligand directories (ls > ligands.list then delete the file names) and invoked multiple autodock runs with:

#!/bin/csh
foreach d (`cat docking.list`)
echo $d
cd $d
/home/progs/AutoDock/autodocksuite/bin/i8664Linux2/autodock4 -p $d.dpf -l $d.dlg
cd ..
end

Autodock 4 - overview & preparing ligand & protein

I need to try some dockings of ligands to a protein that will remain nameless until we publish the paper fairly shortly. Essentially I have solved a number of crystal structures and want to design some new compounds but would like an idea of how they bind before the chemists go ahead and make them. I could dock them by eye using a program like COOT or PyMOL, but find it very difficult trying to get all the distances and angles correct. I am not really interested in the calculated delta G's as AutoDock is notoriously bad at estimating these. If I can get a rough ranking that would be great, but otherwise it is the structural detail I am more interested in.

The first thing I did was get my IT manager to install Autodock 4, AutoGrid and AutoDockTools (ADT).

I then performed five steps (I'll talk about 1 & 2 in this post and 3-5 in later posts):

1. Prepare the protein both as a rigid docking receptor and using the new "flexible residues" feature to see if that makes a difference.
2. Prepare the ligands for auto-docking.
3. Make the grid parameter file (.gpf) based on the atoms in the ligands and run AutoGrid.
4. Make the docking parameter file (.dpf) and run AutoDock for each of my ligands.
5. Analyse the results.

For step 1 I used the tutorial: "Using AutoDock 4 with AutoDockTools: A Tutorial" by Ruth Huey and Garrett Morris.

However for step 2 I borrowed some ideas from the virtual screening tutorial as I had twelve ligands to prepare:

1. Firstly I made pdb files of all my ligands using the PRODRG2 server.

2. Next I invoked the file "prepare_ligand4.py" from the ADT utilities24 directory using a c-shell script adapted from the virtual screening tutorial called make_pdbqt.csh and chmod +x'ed:

#!/bin/csh
foreach f (`ls *`)
echo $f
/home/progs/MGLTools-1.5.1/MGLToolsPckgs/AutoDockTools/Utilities24/prepare_ligand4.py -l $f -d ligand_dict.py
end

This produced a bunch of pdbqt files (pdb + partial charges + AutoDock atom types) for each of my ligands.

3. I then "examined" the pdbqt files to get a list of atoms in all the ligands using examine_ligand_dict.py again from the ADT utilities directory, which I copied into my working directory and invoked with the command:

./examine_ligand_dict.py > summary.txt

Saturday, 2 August 2008

Autodock..ing

My very first experience with automated docking came about four years ago when my boss decided to find out whether docking algorithms could be helpful in our search for drugs that bound to the pentraxin proteins serum amyloid P component (SAP) and C-reactive protein (CRP). As we had a number of crystal structures, and I had spent the first year of my PhD experimentally measuring Kd's, enthalpy and entropy of binding using Isothermal titration calorimetry, my boss figured it would make a nice chapter in my thesis if I evaluated automated docking. I chose to use AUTODOCK (then ver.2.4) because it was free and the developers seemed quite keen to help.

I have posted a snippet of my methods and results from the chapter of my thesis relating to this work here. Essentially I found that AUTODOCK was unable to deal with calcium atoms. After a bit of to-ing and fro-ing with the developers I was able to come up with some parameters that seemed to allow the ligands to dock in a semi-satisfactory manner, and although the actual orientations seemed correct (and the program was mostly able to order the ligands in order of affinity) the calculated delta-G's bared little resemblance to the experimentally measured parameters. There was also evidence that the electrostatics of the interaction completely dominated the calculations whilst the critically important hydrophobic interactions and hydrogen bonding were less important for the docking.

In retrospect i should have written up and published these results at the time, however the experiments were done prior to some big publications and we did not want to risk the chances of our Nature papers!

Friday, 25 July 2008

Agenda

I am starting this blog pretty much as a reminder to myself of what I have tried, and what is available for ligand design and optimisation based upon structural data.