Difference between revisions of "Autodock plugin"

From PyMOLWiki
Jump to: navigation, search
(Autodock Plugin)
 
Line 17: Line 17:
  
 
[[Category:Plugins]]
 
[[Category:Plugins]]
 
<source lang="python">#!/usr/bin/env python
 
 
from __future__ import division
 
from __future__ import generators
 
 
import os,math,re
 
import Tkinter
 
from Tkinter import *
 
import tkMessageBox
 
import Pmw
 
from pymol import cmd,selector
 
import sys
 
from pymol.cmd import _feedback,fb_module,fb_mask,is_list,_cmd
 
from pymol.cgo import *
 
from pymol import stored
 
from Numeric import *
 
import tkColorChooser
 
from pymol.vfont import plain
 
 
# Python backward-compatibility...
 
try:
 
    True
 
except:
 
    True = 1
 
try:
 
    False
 
except:
 
    False = 0
 
#
 
# Cheap hack for testing purposes
 
#
 
try:
 
    import pymol
 
    REAL_PYMOL = True
 
except ImportError:
 
    REAL_PYMOL = False
 
    class pymol:
 
        class cmd:
 
            def load(self,name,sel=''):
 
                pass
 
            def get_names(self):
 
                return ['mol1','mol2','map1','map2']
 
            def get_type(self,thing):
 
                if thing.startswith('mol'):
 
                    return 'object:molecule'
 
                else:
 
                    return 'object:map'
 
                f.close()
 
        cmd = cmd()
 
    pymol = pymol()
 
 
def __init__(self):
 
        self.menuBar.addmenuitem('Plugin', 'command',
 
                                'Launch Autodock',
 
                                label='Autodock...',
 
                                command = lambda s=self: Autodock(s))
 
       
 
 
 
 
 
# set the defaults
 
 
defaults = {
 
    "spacing" : '0.375',
 
    "xpst":'100',
 
    "ypst":'100',
 
    "zpts":'100',
 
    "sel":'(all)',
 
    "X":'0',
 
    "Y":'0',
 
    "Z":'0',
 
    "dx":'1.0',
 
    "dy":'1.0',
 
    "dz":'1.0',
 
    "csize":'0.2',
 
    "lwidth":'1',
 
    "grid":'1',
 
    "output":'grid.gpf',
 
    "dlgfile":'dock.dlg'
 
    }
 
     
 
 
 
 
class FileDialogButtonClassFactory:
 
    def get(fn,filter='*'):
 
        """This returns a FileDialogButton class that will
 
        call the specified function with the resulting file.
 
        """
 
        class FileDialogButton(Tkinter.Button):
 
            # This is just an ordinary button with special colors.
 
 
            def __init__(self, master=None, cnf={}, **kw):
 
                '''when we get a file, we call fn(filename)'''
 
                self.fn = fn
 
                self.__toggle = 0
 
                apply(Tkinter.Button.__init__, (self, master, cnf), kw)
 
                self.configure(command=self.set)
 
            def set(self):
 
                fd = PmwFileDialog(self.master,filter=filter)
 
                fd.title('Please choose a file')
 
                n=fd.askfilename()
 
                if n is not None:
 
                    self.fn(n)
 
        return FileDialogButton
 
    get = staticmethod(get)
 
 
 
 
 
 
       
 
class Autodock:
 
 
    def __init__(self,app):
 
        parent = app.root
 
        self.parent = parent
 
        self.on_screen = IntVar()
 
        self.on_screen.set(0) # 0 box | 1 wire
 
        self.center = []
 
        self.have_box = 0
 
        self.colorRGB = [1,1,1]
 
        self.dialog = Pmw.Dialog(parent,
 
                                buttons = ('Exit',),
 
                                title = 'PyMOL Autodock Tools',
 
                                command = self.buttonPressed)
 
        self.dialog.withdraw()
 
        Pmw.setbusycursorattributes(self.dialog.component('hull'))
 
 
        # the title
 
 
        w = Tkinter.Label(self.dialog.interior(),
 
                                text = 'PyMOL Autodock Tools\nDaniel Seeliger\n<http://www.mpibpc.mpg.de/groups/grubmueller/start/people/dseelig/index.html>',
 
                                background = 'navy',
 
                                foreground = 'white',
 
                                #pady = 20,
 
                                )
 
        w.pack(expand = 1, fill = 'both', padx = 4, pady = 4)
 
 
        # the basic notebook
 
 
        self.notebook = Pmw.NoteBook(self.dialog.interior())
 
        self.notebook.pack(fill='both',expand=0,padx=3,pady=3)
 
       
 
        # the grid page
 
       
 
        page = self.notebook.add('Grid')
 
 
        # grid definiton page
 
        group = Pmw.Group(page,tag_text='Grid Definition')
 
        group.pack(fill = 'both', expand = 0, padx = 10, pady = 5)
 
        self.dialog.bind('<Return>',self.buttonPressed)
 
 
        # we put the parametes on the left side
 
       
 
        lgroup = Pmw.Group(group.interior(),tag_text = "Parameters")
 
        lgroup.pack(side='left',fill = 'both', expand = 0, padx = 10, pady = 3)
 
 
        # ... and the display stuff on the right side
 
       
 
        rgroup = Pmw.Group(group.interior(),tag_text = "Display Options")
 
        rgroup.pack(side='right',fill = 'both', expand = 0, padx = 10, pady = 3)
 
 
        # the left side ...
 
 
        self.space=DoubleVar()
 
        self.space.set(defaults['spacing'])
 
        self.spacefr = Tkinter.Frame(lgroup.interior())
 
        labSP = Label(self.spacefr,text="Grid:");
 
        self.splocation = Entry(self.spacefr,textvariable=self.space,bg='black',fg='green');
 
        self.scrSP=Scrollbar(self.spacefr,orient="horizontal",command=self.changeValueSpacing)
 
        labSP.pack(side=LEFT)
 
        self.splocation.pack(side=LEFT)
 
        self.scrSP.pack(side=LEFT)
 
        self.spacefr.pack(fill='x',padx=4,pady=1) # vertical
 
 
        self.xpts=IntVar()
 
        self.xpts.set(100)
 
        self.xptsfr = Tkinter.Frame(lgroup.interior())
 
        labXP = Label(self.xptsfr,text="xpts:");
 
        self.xptslocation = Entry(self.xptsfr,textvariable=self.xpts,bg='black',fg='green');
 
        self.xptsSP=Scrollbar(self.xptsfr,orient="horizontal",command=self.changeValueXpts)
 
        labXP.pack(side=LEFT)
 
        self.xptslocation.pack(side=LEFT)
 
        self.xptsSP.pack(side=LEFT)
 
        self.xptsfr.pack(fill='x',padx=4,pady=1) # vertical
 
 
        self.ypts=IntVar()
 
        self.ypts.set(100)
 
        self.yptsfr = Tkinter.Frame(lgroup.interior())
 
        labYP = Label(self.yptsfr,text="ypts:");
 
        self.yptslocation = Entry(self.yptsfr,textvariable=self.ypts,bg='black',fg='green');
 
        self.yptsSP=Scrollbar(self.yptsfr,orient="horizontal",command=self.changeValueYpts)
 
        labYP.pack(side=LEFT)
 
        self.yptslocation.pack(side=LEFT)
 
        self.yptsSP.pack(side=LEFT)
 
        self.yptsfr.pack(fill='x',padx=4,pady=1) # vertical
 
 
        self.zpts=IntVar()
 
        self.zpts.set(100)
 
        self.zptsfr = Tkinter.Frame(lgroup.interior())
 
        labZP = Label(self.zptsfr,text="zpts:");
 
        self.zptslocation = Entry(self.zptsfr,textvariable=self.zpts,bg='black',fg='green');
 
        self.zptsSP=Scrollbar(self.zptsfr,orient="horizontal",command=self.changeValueZpts)
 
        labZP.pack(side=LEFT)
 
        self.zptslocation.pack(side=LEFT)
 
        self.zptsSP.pack(side=LEFT)
 
        self.zptsfr.pack(fill='x',padx=4,pady=1) # vertical
 
 
 
        # put a dummy frame
 
        dumframe = Tkinter.Frame(page)
 
        dumframe.pack(fill='x',padx=4,pady=2)
 
       
 
        dum1 = Tkinter.Label(dumframe,
 
                              justify=LEFT,
 
                              text = "",
 
                              )
 
        dum1.pack(side='left')
 
 
 
        # the center definition
 
       
 
        radiogroups = []
 
        self.selmode = Tkinter.IntVar()
 
        self.selmode.set(0)
 
        radioframe = Tkinter.Frame(page)
 
       
 
        w = Pmw.Group(radioframe,
 
                      tag_pyclass = Tkinter.Radiobutton,
 
                      tag_text='Use average coordinates \nof a given selection',
 
                      tag_value = 0,
 
                      tag_variable = self.selmode)
 
        w.pack(fill = 'x', expand = 1, side='top')
 
        cw = Tkinter.Frame(w.interior())
 
        cw.pack(padx = 2, pady = 2, expand='yes', fill='both')
 
        radiogroups.append(w)
 
        self.selectionlist = Pmw.EntryField(w.interior(),
 
                                            labelpos='w',
 
                                            label_text='Selection: ',
 
                                            value=defaults['sel'],
 
                                            command = self.changed,
 
                                            )
 
        self.selectionlist.pack(fill='x',padx=4,pady=1,expand=0) # vertical
 
 
       
 
        w = Pmw.Group(radioframe,
 
                      tag_pyclass = Tkinter.Radiobutton,
 
                      tag_text='Use coordinates',
 
                      tag_value = 1,
 
                      tag_variable = self.selmode)
 
        w.pack(fill = 'x', expand = 1, side='top')
 
        cw = Tkinter.Frame(w.interior())
 
        cw.pack(padx = 2, pady = 2, expand='yes', fill='both')
 
        radiogroups.append(w)
 
 
        radioframe.pack(padx = 6, pady = 6, expand='yes', fill='both')
 
        Pmw.aligngrouptags(radiogroups)
 
 
       
 
        self.x=DoubleVar()
 
        self.x.set(float(defaults["X"]))
 
        self.y=DoubleVar()
 
        self.y.set(float(defaults["Y"]))
 
        self.z=DoubleVar()
 
        self.z.set(float(defaults["Z"]))
 
       
 
        self.xfr = Tkinter.Frame(w.interior())
 
        labX = Label(self.xfr,text="X:");
 
        self.xloc = Entry(self.xfr,textvariable=self.x,bg='black',fg='green');
 
        self.scrX=Scrollbar(self.xfr,orient="horizontal",command=self.changeValueX)
 
       
 
       
 
        self.yfr = Tkinter.Frame(w.interior())
 
        labY = Label(self.yfr,text="Y:");
 
        self.yloc = Entry(self.yfr,textvariable=self.y,bg='black',fg='green');
 
        self.scrY=Scrollbar(self.yfr,orient="horizontal",command=self.changeValueY)
 
       
 
        self.zfr = Tkinter.Frame(w.interior())
 
        labZ = Label(self.zfr,text="Z:");
 
        self.zloc = Entry(self.zfr,textvariable=self.z,bg='black',fg='green');
 
        self.scrZ=Scrollbar(self.zfr,orient="horizontal",command=self.changeValueZ)
 
       
 
        labX.pack(side=LEFT)
 
        self.xloc.pack(side=LEFT)
 
        self.scrX.pack(side=LEFT)
 
        self.xfr.pack(fill='x',padx=4,pady=1) # vertical
 
        labY.pack(side=LEFT)
 
        self.yloc.pack(side=LEFT)
 
        self.scrY.pack(side=LEFT)
 
        self.yfr.pack(fill='x',padx=4,pady=1) # vertical
 
        labZ.pack(side=LEFT)
 
        self.zloc.pack(side=LEFT)
 
        self.scrZ.pack(side=LEFT)
 
        self.zfr.pack(fill='x',padx=4,pady=1) # vertical
 
 
        self.butt1 = Pmw.ButtonBox(radioframe, padx=0)
 
        self.butt1.pack(side=TOP)
 
        self.butt1.add('Show Box',command = self.calc_box)
 
        self.butt1.add('Hide Box',command = self.hideBox)
 
        self.butt1.add('Write gpf',command = self.write_gpf)
 
        self.butt1.add('Write Box',command = self.write_box)
 
        self.butt1.add('Change Color',command=self.tk_color_dialog)
 
       
 
 
        # the display options
 
       
 
        radiogroups = []
 
        radioframe = Tkinter.Frame(rgroup.interior())
 
 
        w = Pmw.Group(radioframe,
 
                      tag_pyclass = Tkinter.Radiobutton,
 
                      tag_text='Cylindric Box',
 
                      tag_value = 0,
 
                      tag_variable = self.on_screen)
 
        w.pack(fill = 'x', expand = 1, side='top')
 
        cw = Tkinter.Frame(w.interior())
 
        cw.pack(padx = 2, pady = 2, expand='yes', fill='both')
 
        radiogroups.append(w)
 
       
 
        self.csize=DoubleVar()
 
        self.csize.set(float(defaults["csize"]))
 
 
        self.csizefr = Tkinter.Frame(w.interior())
 
        labcsize = Label(self.csizefr,text="size:");
 
        self.csizeloc = Entry(self.csizefr,textvariable=self.csize,bg='black',fg='green',width=15);
 
        self.scrcsize=Scrollbar(self.csizefr,orient="horizontal",command=self.changeValueCsize)
 
 
        labcsize.pack(side=LEFT)
 
        self.csizeloc.pack(side=LEFT)
 
        self.scrcsize.pack(side=LEFT)
 
        self.csizefr.pack(fill='x',padx=4,pady=1) # vertical
 
 
        w = Pmw.Group(radioframe,
 
                      tag_pyclass = Tkinter.Radiobutton,
 
                      tag_text='Wired Box',
 
                      tag_value = 1,
 
                      tag_variable = self.on_screen)
 
        w.pack(fill = 'x', expand = 1, side='top')
 
        cw = Tkinter.Frame(w.interior())
 
        cw.pack(padx = 2, pady = 2, expand='yes', fill='both')
 
        radiogroups.append(w)
 
       
 
        self.lwidth=DoubleVar()
 
        self.lwidth.set(float(defaults["lwidth"]))
 
 
        self.lwidthfr = Tkinter.Frame(w.interior())
 
        lablwidth = Label(self.lwidthfr,text="line:");
 
        self.lwidthloc = Entry(self.lwidthfr,textvariable=self.lwidth,bg='black',fg='green',width=15);
 
        self.scrlwidth=Scrollbar(self.lwidthfr,orient="horizontal",command=self.changeValueLwidth)
 
 
        lablwidth.pack(side=LEFT)
 
        self.lwidthloc.pack(side=LEFT)
 
        self.scrlwidth.pack(side=LEFT)
 
        self.lwidthfr.pack(fill='x',padx=4,pady=1) # vertical
 
 
        self.grid=DoubleVar()
 
        self.grid.set(float(defaults["grid"]))
 
 
        self.gridfr = Tkinter.Frame(w.interior())
 
        labgrid = Label(self.gridfr,text="grid:");
 
        self.gridloc = Entry(self.gridfr,textvariable=self.grid,bg='black',fg='green',width=15);
 
        self.scrgrid=Scrollbar(self.gridfr,orient="horizontal",command=self.changeValueGrid)
 
 
        labgrid.pack(side=LEFT)
 
        self.gridloc.pack(side=LEFT)
 
        self.scrgrid.pack(side=LEFT)
 
        self.gridfr.pack(fill='x',padx=4,pady=1) # vertical
 
 
        radioframe.pack(padx = 6, pady = 6, expand='yes', fill='both')
 
        Pmw.aligngrouptags(radiogroups)
 
 
 
        # the output file stuff
 
 
        self.outfile = StringVar()
 
        self.outfile.set(defaults['output'])
 
        self.outlocation = Pmw.EntryField(page,
 
                                          labelpos='w',
 
                                          label_pyclass = FileDialogButtonClassFactory.get(self.set_outfilename,filter=("*.gpf")),
 
                                          validate = {'validator':self.quickFileValidation,},
 
                                          value = defaults['output'],
 
                                          label_text = 'Browse:')
 
 
        self.outlocation.pack(fill = 'both', expand = 1, padx = 10, pady = 5)
 
 
       
 
        # Docking Results Card
 
       
 
        page = self.notebook.add('View Docked')
 
 
        # the input file
 
       
 
        group = Pmw.Group(page,tag_text='File')
 
        group.pack(fill = 'both', expand = 0, padx = 10, pady = 5)
 
 
        # the structure card
 
       
 
        rgroup = Pmw.Group(page,tag_text='Structures')
 
        rgroup.pack(fill = 'both', expand = 1, padx = 10, pady = 5)
 
        self.rgroup = Pmw.NoteBook(rgroup.interior())
 
        self.rgroup.pack(fill='both',expand=1,padx=3,pady=3)
 
        self.pages = {}
 
        self.struct_dic = {}       
 
        self.dlgfile = StringVar()
 
        self.dlgfile.set(defaults['dlgfile'])
 
        self.dlglocation = Pmw.EntryField(group.interior(),
 
                                          labelpos='w',
 
                                          label_pyclass = FileDialogButtonClassFactory.get(self.set_dlgfilename,filter="*.dlg"),
 
                                          validate = {'validator':self.quickFileValidation,},
 
                                          value = defaults['dlgfile'],
 
                                          label_text = 'Browse:')
 
 
        self.dlglocation.pack(fill = 'both', expand = 1, padx = 10, pady = 5)
 
 
        self.load_buttonbox = Pmw.ButtonBox(group.interior(), padx=0)
 
        self.load_buttonbox.pack(side=LEFT,expand = 1, padx = 10, pady = 5)
 
        self.load_buttonbox.add('Load',command=self.load_dlg)
 
 
        self.mlist = []
 
        self.namelist = []
 
 
        self.radiobuttons = Pmw.RadioSelect(rgroup.interior(),
 
                                            buttontype = 'radiobutton',
 
                                            orient = 'horizontal',
 
                                            labelpos = 'w',
 
                                            )
 
        for text in ('Show Selected',
 
                    'Delete Selected'):
 
            self.radiobuttons.add(text)
 
            self.radiobuttons.setvalue('Show Selected')
 
        self.radiobuttons.pack(padx=4,pady=1,side='top')
 
 
        self.status_line = Label(rgroup.interior(), #relief='groove',
 
                                relief='sunken',
 
                                font='helvetica 12', anchor='w',fg='yellow',bg='black')
 
 
        self.status_line.pack(side='left', fill='x', expand=True)
 
 
 
        # the about card
 
       
 
        page = self.notebook.add('About')
 
        group = Pmw.Group(page, tag_text='About PyMOL Autodock Tools')
 
        group.pack(fill = 'both', expand = 1, padx = 10, pady = 5)
 
text = """
 
  This plugin should help to set up docking runs and view docking results.
 
 
  To set up a docking grid,
 
 
  1) Load a protein structure.
 
  2) Select the center of the box either by giving a selection or
 
    the coordinates directly.
 
  3) Adjust the box as needed and save the *.gpf file.
 
 
  To view docking results,
 
 
 
  1) Load the protein structure.
 
  2) Load the *.dlg file (or multiple *dlg files).
 
 
 
  For any bug, please send a mail with description to the author.
 
 
  Many thanks to
 
  - Warren DeLano for everything involving PyMOL
 
  - The PyMOL plugin writers for providing templates
 
 
 
  Created by Daniel Seeliger (dseelig@gwdg.de)
 
  <http://www.mpibpc.mpg.de/groups/grubmueller/start/people/dseelig/index.html>
 
  Computational Biomolecular Dynamics Group
 
  <http://www.mpibpc.gwdg.de/abteilungen/073/>
 
"""
 
 
lfre=Frame(group.interior())
 
bar=Scrollbar(lfre,)
 
ll=Text(lfre,yscrollcommand=bar.set,background="#ddddff",font="Times 14")
 
bar.config(command=ll.yview)
 
 
ll.insert(END,text)
 
ll.pack(side=LEFT,expand="yes",fill="both")
 
bar.pack(side=LEFT,expand="yes",fill="y")
 
lfre.pack(expand="yes",fill="both")
 
 
        self.notebook.setnaturalsize()
 
 
        self.showAppModal()
 
 
 
    # functions
 
 
    def tk_color_dialog(self):
 
        color = tkColorChooser.Chooser(
 
            initialcolor='white',title='Choose box color').show()
 
        if color[0] is not None:
 
            self.colorRGB = [color[0][0]/100.,
 
                            color[0][1]/100.,
 
                            color[0][2]/100.]
 
                           
 
 
       
 
    def status_combobox(self, value):
 
        name = value.split('_')[0]
 
        if self.radiobuttons.getvalue()=='Show Selected':
 
            view = cmd.get_view()
 
            cmd.read_pdbstr(self.struct_dic[str(value)].as_string,str(value))
 
            cmd.set_view(view)
 
            text = 'Docked Energy: %8.2f kcal/mol' % self.struct_dic[str(value)].energy
 
            self.status_line.configure(text=text)
 
            usr = self.struct_dic[str(value)].info_as_string.split('\n')
 
            u = ''
 
            for l in usr:
 
                u+=l[8:]+'\n'
 
            atoms = self.struct_dic[str(value)].as_string.split('\n')
 
            at = ''
 
            for a in atoms:
 
                at+=a[8:]+'\n'
 
               
 
            self.pages[name]['text'].clear()
 
            self.pages[name]['text'].insert('end',u)
 
            self.pages[name]['text'].insert('end',at)
 
        else:
 
            cmd.delete(str(value))
 
            self.pages[name]['text'].clear()
 
            self.status_line.configure(text='')
 
           
 
    def set_outfilename(self,filename):
 
        self.outlocation.setvalue(filename)
 
 
    def set_dlgfilename(self,filename):
 
        self.dlglocation.setvalue(filename)
 
 
    def buttonPressed(self,result):
 
        if hasattr(result,'keycode'):
 
            if result.keycode == 36:
 
                if self.notebook.getcurselection()=='Grid':
 
                    self.calc_box()
 
                elif self.notebook.getcurselection()=='View Docked':
 
                    self.load_dlg()
 
        if result == 'Show Box':
 
            self.calc_box()
 
        elif result == 'Write gpf':
 
            self.write_gpf()
 
        elif result == 'Exit' or result == None:
 
            self.dialog.withdraw()
 
 
    def write_gpf(self):
 
        fname = self.outlocation.getvalue()
 
        if os.path.isfile(fname):
 
            print "backing up %s to ~%s" % (fname,fname)
 
            os.rename(fname,'~'+fname)
 
        print 'writing file %s' % fname
 
        fp = self.fileopen(fname,'w')
 
        if fp:
 
            print >>fp,"receptor protein.pdbqs          #macromolecule"
 
            print >>fp,"gridfld  protein.maps.fld      #grid_data_file"
 
            print >>fp,"npts  %5d %5d %5d        #num.grid points in xyz" % \
 
                  (self.xpts.get(),self.ypts.get(),self.zpts.get())
 
            print >>fp,"spacing %7.3f                #spacing (Angstroms)" % self.space.get()
 
            print >>fp,"gridcenter %6.3f %6.3f %6.3f #xyz-coordinates or \"auto\" "%\
 
                  (self.center[0],self.center[1],self.center[2])
 
            self.print_stuff(fp)
 
            fp.close()
 
       
 
    def write_box(self):
 
        self.calc_box()
 
        fname = self.outlocation.getvalue()
 
        if os.path.isfile(fname):
 
            print "backing up %s to ~%s" % (fname,fname)
 
            os.rename(fname,'~'+fname)
 
        print 'writing file %s' % fname
 
        fp = self.fileopen(fname,'w')
 
        print >>fp, 'xmin = %8.3f' % self.dbox[0][0]
 
        print >>fp, 'xmax = %8.3f' % self.dbox[0][1]
 
        print >>fp, 'ymin = %8.3f' % self.dbox[1][0]
 
        print >>fp, 'ymax = %8.3f' % self.dbox[1][1]
 
        print >>fp, 'zmin = %8.3f' % self.dbox[2][0]
 
        print >>fp, 'zmax = %8.3f' % self.dbox[2][1]
 
        fp.close()
 
   
 
    def print_stuff(self,fp):
 
       
 
        print >>fp, """types CANOSH                    #atom type names
 
smooth 0.500                    #store minimum energy within radius (Ang)
 
map protein.C.map              #filename of grid map
 
nbp_r_eps  4.00 0.0222750 12  6 #C-C lj
 
nbp_r_eps  3.75 0.0230026 12  6 #C-N lj
 
nbp_r_eps  3.60 0.0257202 12  6 #C-O lj
 
nbp_r_eps  4.00 0.0257202 12  6 #C-S lj
 
nbp_r_eps  3.00 0.0081378 12  6 #C-H lj
 
nbp_r_eps  4.10 0.0257202 12  6 #C-X lj (X: Phosphorus in protein-cofactor)
 
nbp_r_eps  3.70 0.0181874 12  6 #C-M lj (Met: Mg)
 
sol_par 12.77 0.6844            #C atomic fragmental volume, solv. param.
 
constant 0.000                  #C grid map constant energy
 
map protein.A.map              #filename of grid map
 
nbp_r_eps  4.00 0.0222750 12  6 #A-C lj
 
nbp_r_eps  3.75 0.0230026 12  6 #A-N lj
 
nbp_r_eps  3.60 0.0257202 12  6 #A-O lj
 
nbp_r_eps  4.00 0.0257202 12  6 #A-S lj
 
nbp_r_eps  3.00 0.0081378 12  6 #A-H lj
 
nbp_r_eps  4.10 0.0257202 12  6 #A-X lj (X: Phosphorus in protein-cofactor)
 
nbp_r_eps  3.70 0.0181874 12  6 #A-M lj (Met: Mg)
 
sol_par 10.80 0.1027            #A atomic fragmental volume, solv. param.
 
constant 0.000                  #A grid map constant energy
 
map protein.N.map              #filename of grid map
 
nbp_r_eps  3.75 0.0230026 12  6 #N-C lj
 
nbp_r_eps  3.50 0.0237600 12  6 #N-N lj
 
nbp_r_eps  3.35 0.0265667 12  6 #N-O lj
 
nbp_r_eps  3.75 0.0265667 12  6 #N-S lj
 
nbp_r_eps  2.75 0.0084051 12  6 #N-H lj
 
nbp_r_eps  3.85 0.0265667 12  6 #N-X lj (X: Phosphorus in protein-cofactor)
 
nbp_r_eps  3.45 0.0187839 12  6 #N-M lj (Met: Mg)
 
sol_par  0.00 0.0000            #N atomic fragmental volume, solv. param.
 
constant 0.000                  #N grid map constant energy
 
map protein.O.map              #filename of grid map
 
nbp_r_eps  3.60 0.0257202 12  6 #O-C lj
 
nbp_r_eps  3.35 0.0265667 12  6 #O-N lj
 
nbp_r_eps  3.20 0.0297000 12  6 #O-O lj
 
nbp_r_eps  3.60 0.0297000 12  6 #O-S lj
 
nbp_r_eps  1.90 0.3280000 12 10 #O-H hb
 
nbp_r_eps  3.70 0.0297000 12  6 #O-X lj (X: Phosphorus in protein-cofactor)
 
nbp_r_eps  3.30 0.0210010 12  6 #O-M lj (Met: Mg)
 
sol_par  0.00 0.0000            #O atomic fragmental volume, solv. param.
 
constant 0.236                  #O grid map constant energy
 
map protein.S.map              #filename of grid map
 
nbp_r_eps  4.00 0.0257202 12  6 #S-C lj
 
nbp_r_eps  3.75 0.0265667 12  6 #S-N lj
 
nbp_r_eps  3.60 0.0297000 12  6 #S-O lj
 
nbp_r_eps  4.00 0.0297000 12  6 #S-S lj
 
nbp_r_eps  2.50 0.0656000 12 10 #S-H hb
 
nbp_r_eps  4.10 0.0297000 12  6 #S-X lj (X: Phosphorus in protein-cofactor)
 
nbp_r_eps  3.70 0.0210010 12  6 #S-M lj (Met: Mg)
 
sol_par  0.00 0.0000            #S atomic fragmental volume, solv. param.
 
constant 0.000                  #S grid map constant energy
 
map protein.H.map              #filename of grid map
 
nbp_r_eps  3.00 0.0081378 12  6 #H-C lj
 
nbp_r_eps  2.75 0.0084051 12  6 #H-N lj
 
nbp_r_eps  1.90 0.3280000 12 10 #H-O hb
 
nbp_r_eps  2.50 0.0656000 12 10 #H-S hb
 
nbp_r_eps  2.00 0.0029700 12  6 #H-H lj
 
nbp_r_eps  3.10 0.0093920 12  6 #H-X lj (X: Phosphorus in protein-cofactor)
 
nbp_r_eps  2.70 0.0066411 12  6 #H-M lj (Met: Mg)
 
sol_par  0.00 0.0000            #H atomic fragmental volume, solv. param.
 
constant 0.118                  #H grid map constant energy
 
elecmap protein.e.map          #electrostatic potential map
 
dielectric -0.1146              #<0,distance-dep.diel; >0,constant
 
#fmap ... .f.map                #floating grid
 
"""
 
       
 
    def quickFileValidation(self,s):
 
        if s == '': return Pmw.PARTIAL
 
        elif os.path.isfile(s): return Pmw.OK
 
        elif os.path.exists(s): return Pmw.PARTIAL
 
        else: return Pmw.PARTIAL
 
 
    def changed(self):
 
        self.selmode.set(0)
 
        self.calc_box()
 
        self.showCrisscross()
 
        self.selectionlist.clear()
 
       
 
    def calc_center(self):
 
        self.center = []
 
        if self.selmode.get() == 0:
 
            sel = self.selectionlist.getvalue()
 
            if sel:
 
                stored.xyz  = []
 
                cmd.iterate_state(1,sel,"stored.xyz.append([x,y,z])")
 
                self.center = average(stored.xyz)
 
            else:
 
                self.selmode.set(1)
 
                self.calc_center()
 
 
        elif self.selmode.get() == 1:
 
            self.center.append(float(self.x.get()))
 
            self.center.append(float(self.y.get()))
 
            self.center.append(float(self.z.get()))
 
        self.x.set(self.center[0])
 
        self.y.set(self.center[1])
 
        self.z.set(self.center[2])
 
       
 
 
    def showCrisscross(self):
 
        startpoint = (self.center[0],self.center[1],self.center[2])
 
        cmd.delete("crisscross")
 
        self.crisscross(startpoint[0],startpoint[1],startpoint[2],0.5,"crisscross")
 
       
 
    def changeValueSpacing(self,a):
 
        val = float(self.space.get())+float(a)*0.005
 
        self.space.set(val)
 
        if self.have_box:
 
            self.selmode.set(1)
 
            self.calc_center()
 
            self.showCrisscross()
 
            self.calc_box()
 
       
 
       
 
    def changeValueXpts(self,a):
 
        val = int(self.xpts.get())+int(a)
 
        self.xpts.set(val)
 
        if self.have_box:
 
            self.selmode.set(1)
 
            self.calc_center()
 
            self.showCrisscross()
 
            self.calc_box()
 
 
    def changeValueYpts(self,a):
 
        val = int(self.ypts.get())+int(a)
 
        self.ypts.set(val)
 
        if self.have_box:
 
            self.selmode.set(1)
 
            self.calc_center()
 
            self.showCrisscross()
 
            self.calc_box()
 
 
    def changeValueZpts(self,a):
 
        val = int(self.zpts.get())+int(a)
 
        self.zpts.set(val)
 
        if self.have_box:
 
            self.selmode.set(1)
 
            self.calc_center()
 
            self.showCrisscross()
 
            self.calc_box()
 
 
 
    def changeValueX(self,a):
 
        self.selmode.set(1)
 
        val=float(self.x.get())+float(a)*1.0
 
        self.x.set(val)
 
        self.calc_center()
 
        self.showCrisscross()
 
        self.calc_box()
 
       
 
    def changeValueY(self,a):
 
        self.selmode.set(1)
 
        val=float(self.y.get())+float(a)*1.0
 
        self.y.set(val)
 
        self.calc_center()
 
        self.showCrisscross()
 
        self.calc_box()
 
       
 
    def changeValueZ(self,a):
 
        self.selmode.set(1)
 
        val=float(self.z.get())+float(a)*1.0
 
        self.z.set(val)
 
        self.calc_center()
 
        self.showCrisscross()
 
        self.calc_box()
 
       
 
    def changeValueCsize(self,a):
 
        val=float(self.csize.get())+float(a)*0.1
 
        self.csize.set(val)
 
        self.selmode.set(1)
 
        self.calc_center()
 
        self.showCrisscross()
 
        self.calc_box()
 
 
       
 
    def changeValueLwidth(self,a):
 
        val=float(self.lwidth.get())+float(a)*1.0
 
        self.lwidth.set(val)
 
        self.selmode.set(1)
 
        self.calc_center()
 
        self.showCrisscross()
 
        self.calc_box()
 
       
 
    def changeValueGrid(self,a):
 
        val=float(self.grid.get())+float(a)*1.0
 
        self.grid.set(val)
 
        self.selmode.set(1)
 
        self.calc_center()
 
        self.showCrisscross()
 
        self.calc_box()
 
 
 
    def calc_box(self):
 
        self.calc_center()
 
        xpts = int(self.xpts.get())
 
        ypts = int(self.ypts.get())
 
        zpts = int(self.zpts.get())
 
        csize = float(self.csize.get())
 
        spacing = float(self.space.get())
 
        size = [xpts*spacing,ypts*spacing,zpts*spacing]
 
        xmax = xmin = ymax = ymin = zmax =zmin = 0
 
        xmax = self.center[0] + size[0]/2.
 
        xmin = self.center[0] - size[0]/2.
 
        ymax = self.center[1] + size[1]/2.
 
        ymin = self.center[1] - size[1]/2.
 
        zmax = self.center[2] + size[2]/2.
 
        zmin = self.center[2] - size[2]/2.
 
        x = [xmin,xmax]
 
        y = [ymin,ymax]
 
        z = [zmin,zmax]
 
        self.dbox = [x,y,z]
 
        if self.on_screen.get()==0:
 
            self.showBox(self.dbox,csize)
 
        elif self.on_screen.get()==1:
 
            self.showWireBox(self.dbox)
 
        self.have_box = 1
 
       
 
    def showBox(self,box,size):
 
        view = cmd.get_view()
 
        name =" box"
 
        obj = []
 
        # do the box
 
        for i in range(2):
 
            for k in range (2):
 
                for j in range(2):
 
                    if i != 1:
 
                        obj.append(CYLINDER)
 
                        obj.extend([box[0][i],box[1][j],box[2][k]])
 
                        obj.extend([box[0][i+1],box[1][j],box[2][k]])
 
                        obj.append(size)
 
                        obj.extend(self.colorRGB)
 
                        obj.extend(self.colorRGB)
 
                        obj.append(COLOR)
 
                        obj.extend(self.colorRGB)
 
                        obj.append(SPHERE)
 
                        obj.extend([box[0][i],box[1][j],box[2][k],size])
 
                       
 
                    if j != 1:
 
                        obj.append(CYLINDER)
 
                        obj.extend([box[0][i],box[1][j],box[2][k]])
 
                        obj.extend([box[0][i],box[1][j+1],box[2][k]])
 
                        obj.append(size)
 
                        obj.extend(self.colorRGB)
 
                        obj.extend(self.colorRGB)
 
                        obj.append(COLOR)
 
                        obj.extend(self.colorRGB)
 
                        obj.append(SPHERE)
 
                        obj.extend([box[0][i],box[1][j+1],box[2][k],size])
 
                    if k != 1:
 
                        obj.append(CYLINDER)
 
                        obj.extend([box[0][i],box[1][j],box[2][k]])
 
                        obj.extend([box[0][i],box[1][j],box[2][k+1]])
 
                        obj.append(size)
 
                        obj.extend(self.colorRGB)
 
                        obj.extend(self.colorRGB)
 
                        obj.append(COLOR)
 
                        obj.extend(self.colorRGB)
 
                        obj.append(SPHERE)
 
                        obj.extend([box[0][i],box[1][j],box[2][k+1],size])
 
 
        axes = [[2.0,0.0,0.0],[0.0,2.0,0.0],[0.0,0.0,2.0]]
 
        xpos = [box[0][1]+(box[0][1]-box[0][0])/5.,box[1][0],box[2][0]]
 
        cyl_text(obj,plain,xpos,'X',0.10,axes=axes)
 
        ypos = [box[0][0],box[1][1]+(box[1][1]-box[1][0])/5,box[2][0]]
 
        cyl_text(obj,plain,ypos,'Y',0.10,axes=axes)
 
        zpos = [box[0][0],box[1][0],box[2][1]+(box[2][1]-box[2][0])/5]
 
        cyl_text(obj,plain,zpos,'Z',0.10,axes=axes)
 
        cmd.load_cgo(obj,name)
 
        cmd.set_view(view)
 
       
 
    def hideBox(self):
 
        cmd.delete("box")
 
        cmd.delete("wirebox")
 
       
 
    def showWireBox(self,box):
 
        cmd.delete("wirebox")
 
        view = cmd.get_view()
 
        spacing = float(self.grid.get())
 
        lwidth = float(self.lwidth.get())
 
        xpts = int(round((box[0][1]-box[0][0])/spacing))+1
 
        ypts = int(round((box[1][1]-box[1][0])/spacing))+1
 
        zpts = int(round((box[2][1]-box[2][0])/spacing))+1
 
        obj = []
 
        for i in range(xpts):
 
            for k in range (ypts):
 
                obj.append(BEGIN)
 
                obj.append(LINE_STRIP)
 
                obj.append(COLOR)
 
                obj.extend(self.colorRGB)
 
               
 
                for j in range(zpts):
 
                   
 
                    obj.append(VERTEX)
 
                    obj.extend([box[0][0]+spacing*i,box[1][0]+spacing*k,\
 
                                box[2][0]+spacing*j])
 
 
                obj.append(END)
 
        for i in range(xpts):
 
            for j in range (zpts):
 
                obj.append(BEGIN)
 
                obj.append(LINE_STRIP)
 
                obj.append(COLOR)
 
                obj.extend(self.colorRGB)
 
                for k in range(ypts):
 
                    obj.append(VERTEX)
 
                    obj.extend([box[0][0]+spacing*i,box[1][0]+spacing*k,\
 
                                box[2][0]+spacing*j])
 
                obj.append(END)
 
        for j in range(zpts):
 
            for i in range (xpts):
 
                obj.append(BEGIN)
 
                obj.append(LINE_STRIP)
 
                obj.append(COLOR)
 
                obj.extend(self.colorRGB)
 
                for k in range(ypts):
 
                    obj.append(VERTEX)
 
                    obj.extend([box[0][0]+spacing*i,box[1][0]+spacing*k,\
 
                                box[2][0]+spacing*j])
 
                obj.append(END)
 
        for j in range(zpts):
 
            for k in range (ypts):
 
                obj.append(BEGIN)
 
                obj.append(LINE_STRIP)
 
                obj.append(COLOR)
 
                obj.extend(self.colorRGB)
 
                for i in range(xpts):
 
                    obj.append(VERTEX)
 
                    obj.extend([box[0][0]+spacing*i,box[1][0]+spacing*k,\
 
                                box[2][0]+spacing*j])
 
                obj.append(END)
 
        cmd.load_cgo(obj,"wirebox")
 
        cmd.set("cgo_line_width",lwidth)
 
        cmd.set_view(view)
 
       
 
    def crisscross(self,x,y,z,d,name="crisscross"):
 
       
 
        obj = [
 
            LINEWIDTH, 3,
 
           
 
            BEGIN, LINE_STRIP,
 
            VERTEX, float(x-d), float(y), float(z),
 
            VERTEX, float(x+d), float(y), float(z),
 
            END,
 
           
 
            BEGIN, LINE_STRIP,
 
            VERTEX, float(x), float(y-d), float(z),
 
            VERTEX, float(x), float(y+d), float(z),
 
            END,
 
           
 
            BEGIN, LINE_STRIP,
 
            VERTEX, float(x), float(y), float(z-d),
 
            VERTEX, float(x), float(y), float(z+d),
 
            END
 
           
 
            ]
 
        view = cmd.get_view()
 
        cmd.load_cgo(obj,name)
 
        cmd.set_view(view)
 
 
 
 
    def load_dlg(self):
 
        filename = self.dlglocation.get()
 
        self.namelist = []
 
        name = filename.split('/')[-1].split('.')[0]
 
        fp=self.fileopen(filename,'r')
 
        if fp:
 
            string = fp.read()
 
            newl = []
 
            modlist = []
 
            ex = re.compile('DOCKED:.*')
 
            l = ex.findall(string)
 
            str = ''
 
            mod = []
 
            for i in range(len(l)):
 
                if 'MODEL' in l[i]:
 
                    str+=l[i]+'\n'
 
                    for k in range(i+1,len(l)):
 
                        if 'TER' in l[k]:
 
                            str+=l[k]+'\n'
 
                            mod.append(str)
 
                            str=''
 
                            break
 
                        else:
 
                            str+=l[k]+'\n'
 
                            mlist= []
 
            for x in mod:
 
                m = Model()
 
                m.str2mod(x)
 
                mlist.append(m)
 
            self.mlist = sortByEnergy(mlist)
 
            for i in range(len(self.mlist)):
 
                self.namelist.append(name+'_%d'%(i+1))
 
                self.struct_dic[name+'_%d'%(i+1)] = self.mlist[i]
 
            self.update_combo(name)
 
       
 
    def update_combo(self,name):
 
        try:
 
            self.rgroup.delete(name)
 
        except:
 
            pass
 
        self.pages[name] = {'name':self.rgroup.add(name)}
 
        self.pages[name].update({'structs':self.namelist})
 
        self.del_buttonbox = Pmw.ButtonBox(self.pages[name]['name'], padx=3)
 
        self.del_buttonbox.pack(fill='x',side=TOP)
 
        self.del_buttonbox.add('Show best 10 %s' % name,command=self.show_best_lig)
 
        self.del_buttonbox.add('Show all %s' % name,command=self.show_all_lig)
 
        self.del_buttonbox.add('Hide all %s' % name,command=self.hide_all_lig)
 
        self.del_buttonbox.add('Delete %s' % name,command=self.del_lig)       
 
 
        self.pages[name]['combo'] = Pmw.ComboBox(self.pages[name]['name'],
 
                                                label_text='Docked',
 
                                                labelpos='nw',
 
                                                scrolledlist_items= self.namelist,
 
                                                selectioncommand=self.status_combobox,
 
                                                listbox_height=10,
 
                                                listbox_width=1,
 
                                               
 
                                                dropdown=False)
 
        self.pages[name]['combo'].pack(side='left', padx=3, anchor='n')
 
 
        self.pages[name]['text'] = Pmw.ScrolledText(self.pages[name]['name'],
 
                                                    borderframe=5,
 
                                                    vscrollmode='dynamic',
 
                                                    hscrollmode='dynamic',
 
                                                    labelpos='n',
 
                                                    label_text=name,
 
                                                    text_width=150, text_height=15,
 
                                                    text_wrap='none',
 
                                                    text_background='#000000',
 
                                                    text_foreground='green'
 
                                                    )
 
        self.pages[name]['text'].pack()
 
        self.rgroup.selectpage(name)
 
        self.status_line.configure(text ='Loading %s' % name)
 
       
 
    def show_all_lig(self):
 
        name = self.rgroup.getcurselection()
 
        for s in self.pages[name]['structs']:
 
            self.status_combobox(s)
 
        self.status_line.configure(text = 'Showing all %s' % name)
 
 
    def show_best_lig(self):
 
        name = self.rgroup.getcurselection()
 
        for s in self.pages[name]['structs'][:10]:
 
            self.status_combobox(s)
 
        self.status_line.configure(text = 'Showing best 10 %s' % name)
 
 
       
 
    def hide_all_lig(self):
 
        name = self.rgroup.getcurselection()
 
        cmd.delete(name+'*')
 
        self.status_line.configure(text = 'Deleted all %s' % name)
 
       
 
    def del_lig(self):
 
        name = self.rgroup.getcurselection()
 
        cmd.delete(name+'*')
 
        self.rgroup.delete(self.rgroup.getcurselection())
 
        self.status_line.configure(text = 'Deleted %s' % name)
 
 
    def fileopen(self, filename, mode):
 
        try:
 
            fp = open(filename,mode)
 
            return fp
 
        except:
 
            tkMessageBox.showerror('Error','Could not open file %s' % filename)
 
            return None
 
               
 
    def showAppModal(self):
 
        #self.dialog.activate(geometry = 'centerscreenalways', globalMode = 'nograb')
 
        self.dialog.show()
 
        #self.dialog.activate(geometry = 'centerscreenalways')
 
 
 
#
 
# The classes PmwFileDialog and PmwExistingFileDialog and the _errorpop function
 
# are taken from the Pmw contrib directory.  The attribution given in that file
 
# is:
 
################################################################################
 
# Filename dialogs using Pmw
 
#
 
# (C) Rob W.W. Hooft, Nonius BV, 1998
 
#
 
# Modifications:
 
#
 
# J. Willem M. Nissink, Cambridge Crystallographic Data Centre, 8/2002
 
#    Added optional information pane at top of dialog; if option
 
#    'info' is specified, the text given will be shown (in blue).
 
#    Modified example to show both file and directory-type dialog
 
#
 
# No Guarantees. Distribute Freely.
 
# Please send bug-fixes/patches/features to <r.hooft@euromail.com>
 
#
 
################################################################################
 
import os,fnmatch,time
 
import Tkinter,Pmw
 
#Pmw.setversion("0.8.5")
 
 
def _errorpop(master,text):
 
    d=Pmw.MessageDialog(master,
 
                        title="Error",
 
                        message_text=text,
 
                        buttons=("OK",))
 
    d.component('message').pack(ipadx=15,ipady=15)
 
    d.activate()
 
    d.destroy()
 
   
 
class PmwFileDialog(Pmw.Dialog):
 
    """File Dialog using Pmw"""
 
    def __init__(self, parent = None, **kw):
 
# Define the megawidget options.
 
optiondefs = (
 
    ('filter',    '*',              self.newfilter),
 
    ('directory', os.getcwd(),      self.newdir),
 
    ('filename',  '',              self.newfilename),
 
    ('historylen',10,              None),
 
    ('command',  None,            None),
 
            ('info',      None,            None),
 
    )
 
self.defineoptions(kw, optiondefs)
 
        # Initialise base class (after defining options).
 
Pmw.Dialog.__init__(self, parent)
 
 
self.withdraw()
 
 
        # Create the components.
 
interior = self.interior()
 
 
        if self['info'] is not None:
 
            rowoffset=1
 
            dn = self.infotxt()
 
            dn.grid(row=0,column=0,columnspan=2,padx=3,pady=3)
 
        else:
 
            rowoffset=0
 
 
dn = self.mkdn()
 
dn.grid(row=0+rowoffset,column=0,columnspan=2,padx=3,pady=3)
 
del dn
 
 
# Create the directory list component.
 
dnb = self.mkdnb()
 
dnb.grid(row=1+rowoffset,column=0,sticky='news',padx=3,pady=3)
 
del dnb
 
 
# Create the filename list component.
 
fnb = self.mkfnb()
 
fnb.grid(row=1+rowoffset,column=1,sticky='news',padx=3,pady=3)
 
del fnb
 
 
# Create the filter entry
 
ft = self.mkft()
 
ft.grid(row=2+rowoffset,column=0,columnspan=2,padx=3,pady=3)
 
del ft
 
 
# Create the filename entry
 
fn = self.mkfn()
 
fn.grid(row=3+rowoffset,column=0,columnspan=2,padx=3,pady=3)
 
fn.bind('<Return>',self.okbutton)
 
del fn
 
 
# Buttonbox already exists
 
bb=self.component('buttonbox')
 
bb.add('OK',command=self.okbutton)
 
bb.add('Cancel',command=self.cancelbutton)
 
del bb
 
 
Pmw.alignlabels([self.component('filename'),
 
self.component('filter'),
 
self.component('dirname')])
 
 
    def infotxt(self):
 
        """ Make information block component at the top """
 
        return self.createcomponent(
 
                'infobox',
 
                (), None,
 
                Tkinter.Label, (self.interior(),),
 
                width=51,
 
                relief='groove',
 
                foreground='darkblue',
 
                justify='left',
 
                text=self['info']
 
            )
 
 
    def mkdn(self):
 
        """Make directory name component"""
 
        return self.createcomponent(
 
    'dirname',
 
    (), None,
 
    Pmw.ComboBox, (self.interior(),),
 
    entryfield_value=self['directory'],
 
    entryfield_entry_width=40,
 
            entryfield_validate=self.dirvalidate,
 
    selectioncommand=self.setdir,
 
    labelpos='w',
 
    label_text='Directory:')
 
 
    def mkdnb(self):
 
        """Make directory name box"""
 
        return self.createcomponent(
 
    'dirnamebox',
 
    (), None,
 
    Pmw.ScrolledListBox, (self.interior(),),
 
    label_text='directories',
 
    labelpos='n',
 
    hscrollmode='none',
 
    dblclickcommand=self.selectdir)
 
 
    def mkft(self):
 
        """Make filter"""
 
        return self.createcomponent(
 
    'filter',
 
    (), None,
 
    Pmw.ComboBox, (self.interior(),),
 
    entryfield_value=self['filter'],
 
    entryfield_entry_width=40,
 
    selectioncommand=self.setfilter,
 
    labelpos='w',
 
    label_text='Filter:')
 
 
    def mkfnb(self):
 
        """Make filename list box"""
 
        return self.createcomponent(
 
    'filenamebox',
 
    (), None,
 
    Pmw.ScrolledListBox, (self.interior(),),
 
    label_text='files',
 
    labelpos='n',
 
    hscrollmode='none',
 
    selectioncommand=self.singleselectfile,
 
    dblclickcommand=self.selectfile)
 
 
    def mkfn(self):
 
        """Make file name entry"""
 
        return self.createcomponent(
 
    'filename',
 
    (), None,
 
    Pmw.ComboBox, (self.interior(),),
 
    entryfield_value=self['filename'],
 
    entryfield_entry_width=40,
 
            entryfield_validate=self.filevalidate,
 
    selectioncommand=self.setfilename,
 
    labelpos='w',
 
    label_text='Filename:')
 
   
 
    def dirvalidate(self,string):
 
        if os.path.isdir(string):
 
            return Pmw.OK
 
        else:
 
            return Pmw.PARTIAL
 
       
 
    def filevalidate(self,string):
 
        if string=='':
 
            return Pmw.PARTIAL
 
        elif os.path.isfile(string):
 
            return Pmw.OK
 
        elif os.path.exists(string):
 
            return Pmw.PARTIAL
 
        else:
 
            return Pmw.OK
 
       
 
    def okbutton(self):
 
"""OK action: user thinks he has input valid data and wants to
 
          proceed. This is also called by <Return> in the filename entry"""
 
fn=self.component('filename').get()
 
self.setfilename(fn)
 
if self.validate(fn):
 
    self.canceled=0
 
    self.deactivate()
 
 
    def cancelbutton(self):
 
"""Cancel the operation"""
 
self.canceled=1
 
self.deactivate()
 
 
    def tidy(self,w,v):
 
"""Insert text v into the entry and at the top of the list of
 
          the combobox w, remove duplicates"""
 
if not v:
 
    return
 
entry=w.component('entry')
 
entry.delete(0,'end')
 
entry.insert(0,v)
 
list=w.component('scrolledlist')
 
list.insert(0,v)
 
index=1
 
while index<list.index('end'):
 
    k=list.get(index)
 
    if k==v or index>self['historylen']:
 
list.delete(index)
 
    else:
 
index=index+1
 
        w.checkentry()
 
 
    def setfilename(self,value):
 
if not value:
 
    return
 
value=os.path.join(self['directory'],value)
 
dir,fil=os.path.split(value)
 
self.configure(directory=dir,filename=value)
 
       
 
c=self['command']
 
if callable(c):
 
    c()
 
 
    def newfilename(self):
 
"""Make sure a newly set filename makes it into the combobox list"""
 
self.tidy(self.component('filename'),self['filename'])
 
 
    def setfilter(self,value):
 
self.configure(filter=value)
 
 
    def newfilter(self):
 
"""Make sure a newly set filter makes it into the combobox list"""
 
self.tidy(self.component('filter'),self['filter'])
 
self.fillit()
 
 
    def setdir(self,value):
 
self.configure(directory=value)
 
 
    def newdir(self):
 
"""Make sure a newly set dirname makes it into the combobox list"""
 
self.tidy(self.component('dirname'),self['directory'])
 
self.fillit()
 
 
    def singleselectfile(self):
 
"""Single click in file listbox. Move file to "filename" combobox"""
 
cs=self.component('filenamebox').curselection()
 
if cs!=():
 
    value=self.component('filenamebox').get(cs)
 
            self.setfilename(value)
 
 
    def selectfile(self):
 
"""Take the selected file from the filename, normalize it, and OK"""
 
        self.singleselectfile()
 
value=self.component('filename').get()
 
        self.setfilename(value)
 
        if value:
 
    self.okbutton()
 
 
    def selectdir(self):
 
"""Take selected directory from the dirnamebox into the dirname"""
 
cs=self.component('dirnamebox').curselection()
 
if cs!=():
 
    value=self.component('dirnamebox').get(cs)
 
    dir=self['directory']
 
    if not dir:
 
dir=os.getcwd()
 
    if value:
 
if value=='..':
 
    dir=os.path.split(dir)[0]
 
else:
 
    dir=os.path.join(dir,value)
 
    self.configure(directory=dir)
 
    self.fillit()
 
 
    def askfilename(self,directory=None,filter=None):
 
"""The actual client function. Activates the dialog, and
 
  returns only after a valid filename has been entered
 
          (return value is that filename) or when canceled (return
 
          value is None)"""
 
if directory!=None:
 
    self.configure(directory=directory)
 
if filter!=None:
 
    self.configure(filter=filter)
 
self.fillit()
 
        self.canceled=1 # Needed for when user kills dialog window
 
self.activate()
 
if self.canceled:
 
    return None
 
else:
 
    return self.component('filename').get()
 
 
    lastdir=""
 
    lastfilter=None
 
    lasttime=0
 
    def fillit(self):
 
"""Get the directory list and show it in the two listboxes"""
 
        # Do not run unnecesarily
 
        if self.lastdir==self['directory'] and self.lastfilter==self['filter'] and self.lasttime>os.stat(self.lastdir)[8]:
 
            return
 
        self.lastdir=self['directory']
 
        self.lastfilter=self['filter']
 
        self.lasttime=time.time()
 
dir=self['directory']
 
if not dir:
 
    dir=os.getcwd()
 
dirs=['..']
 
files=[]
 
        try:
 
            fl=os.listdir(dir)
 
            fl.sort()
 
        except os.error,arg:
 
            if arg[0] in (2,20):
 
                return
 
            raise
 
for f in fl:
 
    if os.path.isdir(os.path.join(dir,f)):
 
dirs.append(f)
 
    else:
 
filter=self['filter']
 
if not filter:
 
    filter='*'
 
if fnmatch.fnmatch(f,filter):
 
    files.append(f)
 
self.component('filenamebox').setlist(files)
 
self.component('dirnamebox').setlist(dirs)
 
   
 
    def validate(self,filename):
 
"""Validation function. Should return 1 if the filename is valid,
 
          0 if invalid. May pop up dialogs to tell user why. Especially
 
          suited to subclasses: i.e. only return 1 if the file does/doesn't
 
          exist"""
 
return 1
 
 
class PmwExistingFileDialog(PmwFileDialog):
 
    def filevalidate(self,string):
 
        if os.path.isfile(string):
 
            return Pmw.OK
 
        else:
 
            return Pmw.PARTIAL
 
       
 
    def validate(self,filename):
 
        if os.path.isfile(filename):
 
            return 1
 
        elif os.path.exists(filename):
 
            _errorpop(self.interior(),"This is not a plain file")
 
            return 0
 
        else:
 
            _errorpop(self.interior(),"Please select an existing file")
 
            return 0
 
 
 
#===============================================================
 
#
 
# stuff to deal with dlg files
 
 
class Model:
 
    def __init__(self):
 
        self.atoms = []
 
        self.energy = 0.
 
        self.info = []
 
        self.num = 0
 
        self.as_string = ''
 
        self.info_as_string = ''
 
    def str2mod(self,string):
 
        list = string.split('\n')
 
        for line in list:
 
            if 'ATOM' in line:
 
                self.atoms.append(line.split(':')[1].strip())
 
                self.as_string+=line.split(':')[1].strip()+'\n'
 
            elif 'USER' in line:
 
                self.info.append(line.split(':')[1].strip())
 
                self.info_as_string+=line.split(':')[1].strip()+'\n'
 
            elif 'MODEL' in line:
 
                self.num = int(line.split()[2])
 
        for line in self.info:
 
            if 'Docked Energy' in line:
 
                x = line.split('=')[1]
 
                self.energy = float(x.split()[0])
 
 
    def writeMod(self,fp):
 
        print >>fp,'MODEL%8d' % self.num
 
        for at in self.atoms:
 
            print >>fp, at
 
        print >>fp,'ENDMDL'
 
 
 
def sortByEnergy(mlist):
 
    en = []
 
    idx = []
 
    for m in mlist:
 
        en.append(m.energy)
 
        idx.append(mlist.index(m))
 
    changed = True
 
    while changed:
 
        changed = False
 
        for i in range(len(en)-1):
 
            if en[i] > en[i+1]:
 
                dum = en[i+1]
 
                en[i+1] = en[i]
 
                en[i] = dum
 
                dum = idx[i+1]
 
                idx[i+1] = idx[i]
 
                idx[i] = dum
 
                changed = True
 
    new = []
 
    for i in range(len(idx)):
 
        new.append(mlist[idx[i]])
 
        new[i].num=i+1
 
    return new
 
 
 
# Create demo in root window for testing.
 
if __name__ == '__main__':
 
    class App:
 
        def my_show(self,*args,**kwargs):
 
            pass
 
    app = App()
 
    app.root = Tkinter.Tk()
 
    Pmw.initialise(app.root)
 
    app.root.title('Some Title')
 
   
 
    widget = Autodock(app)
 
    exitButton = Tkinter.Button(app.root, text = 'Exit', command = app.root.destroy)
 
    exitButton.pack()
 
    app.root.mainloop()
 
</source>
 

Revision as of 09:52, 10 August 2006

Description

This plugin should help to set up docking runs with Autodock and view docking results. It has two features:

1) Setup of a docking grid for Autodock with PyMOL.

2) View the docking results.

Installation

1)Download plugin

2) PyMOL -> Plugin -> Install Plugin

Author

Daniel Seeliger