示例#1
0
    def __init__(self, top, queue, UseOldTypes):
        
        #print "New instance of Wizard SetAtomType"

        Wizard.__init__(self)
        
        self.top = top
        self.FlexAID = self.top.top
        self.queue = queue
        # Save view
        self.View = cmd.get_view()
        self.State = cmd.get_state()
                
        #self.pdbPath = self.FlexAID.SimPath + 'tmp.pdb'
        self.pdbPath = self.FlexAID.IOFile.ProcessedLigandPath.get()
        
        self.ErrorCode = 1

        self.SelAtomName = '...'   
        self.SelAtomType = '...'

        self.Set_DDL_Colors(UseOldTypes)       

        smm = []
        smm.append([ 2, 'Type Selection', '' ])
        for a in self.types:
            smm.append([ 1, self.type_name[a], 'cmd.get_wizard().set_AtomType("' + a + '")'])
        self.menu['type']=smm
       
        self.atom = list()
        self.ID = ''
示例#2
0
文件: Sphere.py 项目: NRGlab/NRGsuite
    def __init__(self, top, queue, Sphere, SphereDisplay, SphereSize, ExtraPrompt):

        #print "New instance of flexsphere Wizard"

        Wizard.__init__(self)

        self.top = top
        self.queue = queue
        self.App = self.top.top

        self.App.WizardError = False
        self.App.WizardResult = 0

        self.Sphere = Sphere
        self.SphereView = self.Sphere.Copy()

        self.SphereSize = SphereSize
        self.SphereDisplay = SphereDisplay
        self.View = cmd.get_view()

        self.ErrorCode = 0

        self.Prompt = [ "Press Shift + Mouse3 (Wheel Click) to move the sphere.",
                        "Use the scaler in the " + self.App.Name + " interface to edit its radius." ]
                        
        if ExtraPrompt:
            self.Prompt.append( ExtraPrompt )
示例#3
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)
        
        self.editing_name = 0
        self.copying = 0
        
        self.points_name = ''
        self.set_name(default_name)
    
        self.mode = default_mode
        self.modes = [
            'box',
            'walls', 
            'plane',
	    'quad',
            ]

        self.mode_name = {
            'box':'Box',
            'walls':'Walls',
            'plane':'Plane',
	    'quad':'Quad',
            }

        smm = []
        smm.append([ 2, 'Box Mode', '' ])
        for a in self.modes:
            smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
        self.menu['mode']=smm

        self.update_box()
示例#4
0
    def __init__(self, app, _self=cmd):
        Wizard.__init__(self, _self)

        # Clean the slate
        self.cmd.unpick()
        self.app = app

        # Default values
        self.rmsd_cutoff = 1.0
        self.number_of_structures = 25
        self.full_match = False
        self.url = URL
        self.LOGOurl = LOGOURL

        self.ref = Wizard

        # default values for sequence logo UI
        self.operations = []
        self.searches = []
        self.database = DATABASE_FULL
        self.database_name = "Full"
        self.search = None # current search action
        self.operation = None # current operation

        self.dictionary = {}

        self.searchThread = None
        self.logoThread = None

        self.status = 'waiting for selection'
        self.searchProgress = 0.0
        self.errorMessage = ''
        self.makeLogo = 0
        self.update()
示例#5
0
 def __init__(self,old_name,mode='object',_self=cmd):
     Wizard.__init__(self,_self)
     
     self.prefix = 'Renaming \\999%s\\--- to: \\999'%old_name
     self.old_name = old_name
     self.new_name = old_name
     self.mode = mode
示例#6
0
    def __init__(self, _self=cmd):
        Wizard.__init__(self, _self)

        self.modes = ["labchg", "addchg", "cpychg", "zrochg", "mzochg", "cbachg", "movchg", "rbachg", "sumchg"]

        self.mode = default_mode
        self.status = 0

        self.mode_name = {
            "labchg": "Show",
            "cpychg": "Copy",
            "addchg": "Add",
            "zrochg": "Zero",
            "mzochg": "Move & Zero (atom)",
            "cbachg": "Move & Zero (resi)",
            "movchg": "Move & Remove (atom)",
            "rbachg": "Move & Remove (resi)",
            "sumchg": "Get Total Charge",
        }

        # initialize mode menu

        smm = []
        smm.append([2, "Atom Charge Mode", ""])
        for a in self.modes:
            smm.append([1, self.mode_name[a], 'cmd.get_wizard().set_mode("' + a + '")'])

        self.menu["mode"] = smm

        self.memory = 0

        _self.edit_mode()
示例#7
0
 def __init__(self,mode='label',pos='[0.0,0.0,0.0]',_self=cmd):
     Wizard.__init__(self,_self)
     self.mode = mode
     if mode == 'label':
         self.prefix = 'Label text: \888'
     self.text = ''
     self.pos = pos
示例#8
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)

        self.cmd.unpick()
        
        self.status = 0 # 0 no atoms selections, 1 atom selected, 2 atoms selected, 3 atoms selected
        self.error = None
        self.object_name = None

        # mode selection subsystem

        self.mode = self.session.get('default_mode','pairs')
        self.modes = [
            'pairs',
            'angle',
            'dihed', 
            'polar',
            'heavy',
            'neigh',
            ]
        
        self.mode_name = {
            'polar':'Polar Neighbors',
            'heavy':'Heavy Neighbors',
            'neigh':'Neighbors',
            'pairs':'Distances',
            'angle':'Angles',
            'dihed':'Dihedrals',
            }

        smm = []
        smm.append([ 2, 'Measurement Mode', '' ])
        for a in self.modes:
            smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
        self.menu['mode']=smm

        # overwrite mode selection subsystem
        
        self.object_mode = self.session.get('default_object_mode','append')
        self.object_modes = [
            'merge', 
            'overwr',
            'append',
            ]
        self.object_mode_name = {
            'merge':'Merge With Previous',
            'overwr':'Replace Previous',
            'append':'Create New Object',         
            }

        smm = []
        smm.append([ 2, 'New Measurements?', '' ])
        for a in self.object_modes:
            smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")'])
        self.menu['object_mode']=smm
        self.selection_mode = self.cmd.get_setting_legacy("mouse_selection_mode")
        self.cmd.set("mouse_selection_mode",0) # set selection mode to atomic
        self.cmd.deselect() # disable the active selection (if any)
示例#9
0
 def __init__(self,*arg,**kw):
     _self = kw.get('_self',cmd)
     self.valid = 1
     Wizard.__init__(self,_self)
     if len(arg):
         self.old_button_mode = int(arg[0])
     self.check_valid()
     if self.valid:
         self.recount()
示例#10
0
 def __init__(self,arg0=None,_self=cmd):
     Wizard.__init__(self,_self)        
     self.gl = 5.0
     self.short_cpu = 8.0
     self.long_cpu = 16.0
     self.message = []
     if arg0!=None:
         if hasattr(self,arg0):
             getattr(self,arg0)()
示例#11
0
文件: density.py 项目: Almad/pymol
    def __init__(self,_self=cmd):

        self.cmd = _self
        self.cmd.unpick()
        
        Wizard.__init__(self,_self)
        
        # mode selection subsystem
        
        self.radius = default_radius
        self.map = copy.deepcopy(default_map)
        self.level = copy.deepcopy(default_level)
        self.track = copy.deepcopy(default_track)
        self.avail_maps = []
        
        self.menu['radius'] = [
                                      [1, '4.0 A Radius','cmd.get_wizard().set_radius(4)'],
                                      [1, '5.0 A Radius','cmd.get_wizard().set_radius(5)'],
                                      [1, '6.0 A Radius','cmd.get_wizard().set_radius(6)'],
                                      [1, '8.0 A Radius','cmd.get_wizard().set_radius(8)'],
                                      [1, '10.0 A Radius','cmd.get_wizard().set_radius(10)'],
                                      [1, '15.0 A Radius','cmd.get_wizard().set_radius(15)'],
                                      [1, '20.0 A Radius','cmd.get_wizard().set_radius(20)'],
                                      [1, '50.0 A Radius','cmd.get_wizard().set_radius(50)'],
                                      ]
                                        
        self.menu['map0'] = []
        self.menu['map1'] = []
        self.menu['map2'] = []

        level_menu = lambda x:[ [1, '1.0 sigma','cmd.get_wizard().set_level(%d,1.0)'%x],
                                        [1, '1.5 sigma','cmd.get_wizard().set_level(%d,1.5)'%x],
                                        [1, '2.0 sigma','cmd.get_wizard().set_level(%d,2.0)'%x],
                                        [1, '3.0 sigma','cmd.get_wizard().set_level(%d,3.0)'%x],
                                        [1, '5.0 sigma','cmd.get_wizard().set_level(%d,5.0)'%x],
                                        [1, '-3.0 sigma','cmd.get_wizard().set_level(%d,-3.0)'%x]]
        
        self.menu['level0'] = level_menu(0)
        self.menu['level1'] = level_menu(1)
        self.menu['level2'] = level_menu(2)
        
        self.menu['track'] = [
        [ 1, "Track & Zoom", 'cmd.get_wizard().set_track(0)'],
        [ 1, "Track & Center", 'cmd.get_wizard().set_track(1)'],
        [ 1, "Track & Set Origin", 'cmd.get_wizard().set_track(2)'],
        [ 1, "Track Off", 'cmd.get_wizard().set_track(3)'],
        ]

        if (self.map[0] == '') and (self.map[1] == '') and (self.map[2]==''):
            for a in self.cmd.get_names(): # automatically load first map we find
                if self.cmd.get_type(a)=='object:map':
                    self.map[0]=a
                    break
        self.update_map_menus()

        self.cmd.set_key('pgup',lambda c=cmd:c.get_wizard().next_res(d=-1))
        self.cmd.set_key('pgdn',lambda c=cmd:c.get_wizard().next_res())      
示例#12
0
 def __init__(self,*arg,**kw):
     _self = kw.get('_self',cmd)
     Wizard.__init__(self,_self)
     self.message = []
     for a in arg:
         if not isinstance(a,list):
             self.message.append(a)
         else:
             self.message.extend(a)
示例#13
0
    def __init__(self,_self=cmd):

        Wizard.__init__(self,_self)
        
        self.memory = 0
        self.n_pair = 0
        self.status = 0 # 0 no atoms selections, 1 atom selected
        self.message = None

        self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
        cmd.set("mouse_selection_mode",0) # set selection mode to atomic
        cmd.deselect() # disable the active selection (if any)
示例#14
0
 def __init__(self,*arg,**kw):
     _self = kw.get('_self',cmd)
     Wizard.__init__(self,_self)        
     self.message = []
     for a in arg:
         if not isinstance(a,list):
             self.message.append(a)
         else:
             self.message.extend(a)
     for a in self.message:
         print(" " + _nuke_color_re.sub('',a))
     self.dismiss = int(kw.get("dismiss",1))
示例#15
0
    def __init__(self,_self=cmd):

        cmd.unpick();
        Wizard.__init__(self,_self)
        
        self.status = 0 # 0 no atoms selections, 1 atom selected
        self.error = None
        self.object_name = None

        # mode selection subsystem
        
        self.mode = default_mode
        self.modes = [
            'polar',
            'heavy',
            'neigh',
            'pairs',
            ]
        
        self.mode_name = {
            'polar':'Polar Neighbors',
            'heavy':'Heavy Neighbors',
            'neigh':'Neighbors',
            'pairs':'Pairwise Distances',
            }

        smm = []
        smm.append([ 2, 'Measurement Mode', '' ])
        for a in self.modes:
            smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
        self.menu['mode']=smm

        # overwrite mode selection subsystem
        
        self.object_mode=default_object_mode
        self.object_modes = [
            'overwr',
            'append',
            ]
        self.object_mode_name = {
            'overwr':'Replace Previous',
            'append':'Create New',         
            }

        smm = []
        smm.append([ 2, 'New Distances?', '' ])
        for a in self.object_modes:
            smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")'])
        self.menu['object_mode']=smm
        self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
        cmd.set("mouse_selection_mode",0) # set selection mode to atomic
        cmd.deselect() # disable the active selection (if any)
示例#16
0
文件: cleanup.py 项目: Almad/pymol
 def __init__(self,_self=cmd):
     Wizard.__init__(self,_self)
     
     self.ligand = ""
     for a in self.cmd.get_names("public_objects",1):
         if self.cmd.count_atoms(a) < 1000:
             self.ligand = a
             break
     self.target = "(none)"
     self.message = []
     self.menu = {}
     self.update_menus()
     self.cmd.edit_mode()
示例#17
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)
        self.cmd.unpick()
        self.cmd.deselect()
        self.cmd.set('mouse_selection_mode', 0)

        self.menu = {
            'mode': [
                [2, 'Mode', ''],
            ] + [
                [1, name, 'cmd.get_wizard().set_mode(%d)' % i]
                for (i, name) in enumerate(self.mode_names)
            ]
        }
    def __init__(self):
        Wizard.__init__(self)
 
        # some attributes to do with picking
        self.pick_count = 0
        self.object_count = 0
        self.object_prefix = "pw"
 
        # the plane facet size (the 'radius' of the section of plane we show)
        self.facetSize = 5
 
        self.selection_mode = cmd.get_setting_legacy("mouse_selection_mode")
        cmd.set("mouse_selection_mode",0) # set selection mode to atomic
        cmd.deselect()
示例#19
0
 def __init__(self,*arg,**kw):
     _self=kw.get('_self',cmd)
     Wizard.__init__(self,_self)        
     self.message = []
     self.last = None
     cmd.full_screen("off")
     if not  ("mono" in list(kw.keys())):
         cmd.stereo("on")
     cmd.set("sphere_mode","5")
     if 'last' in saved:
         self.last = saved['last']
     if len(arg):
         self.launch(arg[0])
     else:
         self.launch("cartoon")
示例#20
0
 def __init__(self, app, _self = cmd):
     Wizard.__init__(self, _self)
     
     # Clean the slate
     self.cmd.unpick()        
     self.do_select(SELECTION_NAME, 'none')
     self.prompt = ['Select motifs using left click']
     self.app = app
     
     # type Key = (Object, Model, Segi, Chain, Resn, Resi, Name)
     # type Val = Selection corresponding to the key
     # word_list :: Dict Key Val
     self.word_list = {}
     
     # Default values
     self.rmsd_cutoff = 1.0
     self.random_seed = 0
     self.number_of_structures = 100
     self.suns_server_address = SUNS_SERVER_ADDRESS
     self.group_name = SUNS_DEFAULT_GROUP_NAME
     
     self.searchThread = None
     
     # Rebind left click to select bonds.  I choose left click since it is
     # the most portable input method across devices, especially laptops, and
     # also because the user definitely does not need the old left click
     # function for the duration of the wizard.
     self.cmd.button('single_left', 'None', 'PkTB')
     
     # PyMOL has this really obscure and undocumented 'auto_hide_selections'
     # setting that auto hides selections when using editing commands.  This
     # wizard overrides "PkTB", which is one of those editing commands, but
     # we still want to display selections to the user, so we must disable
     # this setting.
     self.prev_auto_hide_setting = self.cmd.get('auto_hide_selections')
     self.cmd.set('auto_hide_selections',0)
     self.prev_auto_zoom_setting = self.cmd.get('auto_zoom')
     self.cmd.set('auto_zoom', 0)
     
     # There are a few functions which would like to use a Tcl window
     # to communicate with the user.  This can cause some unsafe threading
     # issues with the global PyMol Tcl window.  Thus, we will instead
     # store the function calls in the pymol module itself, and when 
     # the time comes, just ask the PyMol module to execute it for us.
     pymol.stored.aacycler = lambda: AACycler(self.app, self.cmd)
     pymol.stored.fetch_full_context = lambda: self.fetch_full_context()
     pymol.stored.ask_group_name = lambda: self.ask_group_name()
     pymol.stored.ask_server_address = lambda: self.ask_server_address()
示例#21
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)

        if auto_configure() < 1:
            raise pymol.CmdException('cannot find "szybki" executable, please '
                    'set OE_DIR environment variable')
        
        self.ligand = ""
        for a in self.cmd.get_names("public_objects",1):
            if self.cmd.count_atoms(a) < 1000:
                self.ligand = a
                break
        self.target = "(none)"
        self.message = []
        self.menu = {}
        self.update_menus()
        self.cmd.edit_mode()
示例#22
0
文件: filter.py 项目: evonove/pymol
    def __init__(self,_self=cmd):

        # initialize parent class
        
        Wizard.__init__(self,_self)

        self.update_object_menu()
        
        # restore previous state from global storage

        self.dict = static_dict
        self.object = default_object if default_object in self.avail_objects else None
        self.browse = default_browse
        self.state_dict = {}
        
        # if we don't have a current object, choose the first multi-state object
        
        if not self.object and self.avail_objects:
            self.object = self.avail_objects[0]

        # menu for
        
        self.menu['browse'] = [
            [2, 'Browse Mode',''],
            [1, 'Browse All','cmd.get_wizard().set_browse(1)'],
            [1, 'Browse Accepted','cmd.get_wizard().set_browse(2)'],
            [1, 'Browse Rejected','cmd.get_wizard().set_browse(3)'],
            [1, 'Browse Deferred','cmd.get_wizard().set_browse(4)'],
            [1, 'Browse Remaining','cmd.get_wizard().set_browse(5)'],         
            ]

        self.menu['create'] = [
            [2, 'Create Filtered Object', ''],
            [1, 'Accepted','cmd.get_wizard().create_object("Accept")'],
            [1, 'Rejected','cmd.get_wizard().create_object("Reject")'],
            [1, 'Deferred','cmd.get_wizard().create_object("Defer")'],
            ]

        self.count_object()
        self.load_state_dict()
        self.update_object_menu()
        cmd.set_key('F1',lambda s=self:s.accept())
        cmd.set_key('F2',lambda s=self:s.reject())
        cmd.set_key('F3',lambda s=self:s.defer())
        cmd.set_key('right',lambda s=self:s.forward())
        cmd.set_key('left',lambda s=self:s.backward())
示例#23
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)

        self.cmd.unpick()

        self.cutoff = self.cmd.get_setting_float("neighbor_cutoff")
        self.heavy_neighbor_cutoff = self.cmd.get_setting_float("heavy_neighbor_cutoff")
        self.polar_neighbor_cutoff = self.cmd.get_setting_float("polar_neighbor_cutoff")
        self.hbond_cutoff = self.cmd.get_setting_float("h_bond_cutoff_center")

        self.status = 0 # 0 no atoms selections, 1 atom selected, 2 atoms selected, 3 atoms selected
        self.error = None
        self.object_name = None

        # mode selection subsystem
        self.mode = self.session.get('default_mode','pairs')
        
        self.neighbor_target = ""

        # TODO: 
        # make this a function, and call it when we call refresh wizard
        # to update the object/selection list
        smm = []
        smm.append([ 2, 'Measurement Mode', '' ])
        for a in self.modes:
            if a in ("neigh", "polar", "heavy"):
                smm.append([ 1, self.mode_name[a], self.neighbor_submenu(a)])
            else:
                smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
        self.menu['mode']=smm

        # overwrite mode selection subsystem
        self.object_mode = self.session.get('default_object_mode','append')

        smm = []
        smm.append([ 2, 'New Measurements?', '' ])
        for a in self.object_modes:
            smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")'])

        self.menu['object_mode']=smm
        # initially select atoms, but now users can change this
        self.selection_mode = self.cmd.get_setting_legacy("mouse_selection_mode")
        self.cmd.set("mouse_selection_mode",0) # set selection mode to atomic
        self.cmd.deselect() # disable the active selection (if any)
        self.mouse_mode = 0
示例#24
0
    def __init__(self, app, _self=cmd):
        Wizard.__init__(self, _self)

        # Clean the slate
        self.cmd.unpick()
        self.app = app

        # Default values
        self.rmsd_cutoff = 1.0
        self.number_of_structures = 25
        self.full_match = False
        self.url = URL
        self.LOGOurl = LOGOURL

        self.ref = Wizard

        # default values for sequence logo UI
        self.operations = []
        self.searches = []
        self.database = DATABASE_TEST
        self.database_name = "Test"
        self.search = None # current search action
        self.operation = None # current operation

        self.jobIDs = {}
        self.qSeqs = {}

        self.searchThread = None
        self.logoThread = None

        self.status = 'waiting for selection'
        self.searchProgress = 0.0
        self.errorMessage = ''
        self.makeLogo = 0
        
        self.popup_app = None
        self.done_adding = False
        self.live_app = False
        self.logo_flag = None
        self.filename = None
        self.res_info = None
        
        
        self.update()
示例#25
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)
        
        self.modes = [
            'labchg',
            'addchg',
            'cpychg',
            'zrochg',
            'mzochg',
            'cbachg',
            'movchg',
            'rbachg',
            'sumchg',
            ]

        self.mode = default_mode
        self.status = 0
        
        self.mode_name = {
            'labchg':'Show',
            'cpychg':'Copy',
            'addchg':'Add',
            'zrochg':'Zero',
            'mzochg':'Move & Zero (atom)',
            'cbachg':'Move & Zero (resi)',
            'movchg':'Move & Remove (atom)',
            'rbachg':'Move & Remove (resi)',
            'sumchg':'Get Total Charge'
            }
        
        # initialize mode menu
        
        smm = []
        smm.append([ 2, 'Atom Charge Mode', '' ])
        for a in self.modes:
            smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])

        self.menu['mode']=smm
        
        self.memory = 0

        _self.edit_mode()
示例#26
0
文件: filter.py 项目: Almad/pymol
    def __init__(self, _self=cmd):

        # initialize parent class

        Wizard.__init__(self, _self)

        # restore previous state from global storage

        self.dict = static_dict
        self.object = default_object
        self.browse = default_browse
        self.avail_objects = []
        self.state_dict = {}

        # if we don't have a current object, choose the first multi-state object

        if self.object == None:
            for a in cmd.get_names("objects"):
                if cmd.get_type(a) == "object:molecule":
                    if cmd.count_states(a) > 1:
                        self.object = a
                        break

        # menu for

        self.menu["browse"] = [
            [2, "Browse Mode", ""],
            [1, "Browse All", "cmd.get_wizard().set_browse(1)"],
            [1, "Browse Accepted", "cmd.get_wizard().set_browse(2)"],
            [1, "Browse Rejected", "cmd.get_wizard().set_browse(3)"],
            [1, "Browse Deferred", "cmd.get_wizard().set_browse(4)"],
            [1, "Browse Remaining", "cmd.get_wizard().set_browse(5)"],
        ]

        self.count_object()
        self.load_state_dict()
        self.update_object_menu()
        cmd.set_key("F1", lambda s=self: s.accept())
        cmd.set_key("F2", lambda s=self: s.reject())
        cmd.set_key("F3", lambda s=self: s.defer())
        cmd.set_key("right", lambda s=self: s.forward())
        cmd.set_key("left", lambda s=self: s.backward())
示例#27
0
文件: Anchor.py 项目: NRGlab/NRGsuite
    def __init__(self, top, queue, LigandPath, AnchorAtom):
        
        #print("New instance of anchor Class.\n")

        Wizard.__init__(self)

        self.top = top
        self.queue = queue
        self.FlexAID = self.top.top
        self.FlexAID.WizardError = False
        
        self.LigandPath = LigandPath
        
        self.PrevAnchorAtom = AnchorAtom
        self.AnchorAtom = self.PrevAnchorAtom
        
        self.View = cmd.get_view()
        self.State = cmd.get_state()
        self.auto_zoom = cmd.get("auto_zoom")

        self.ErrorStatus =  []
示例#28
0
文件: demo.py 项目: Almad/pymol
 def __init__(self,name=None,_self=cmd):
     Wizard.__init__(self,_self)
     self.message = []
     self.last = None
     if saved.has_key('last'):
         self.last = saved['last']
     if name!=None:
         demo = DemoInfo(_self=_self)
         if self.last:
             if hasattr(demo,self.last):
                 getattr(demo,self.last)(cleanup=1)
         if hasattr(demo,name):
             self.last = name
             demo_fn = getattr(demo,name)
             t = threading.Thread(target=demo_fn)
             t.setDaemon(1)
             t.start()
             self.message = demo.message_dict.get(name,None)
         else:
             self.last = None
         saved['last']=self.last
示例#29
0
    def __init__(self, _self=pymol.cmd):  #PyMOL pattern
        Wizard.__init__(self, _self)  #PyMOL pattern
        if self.cmd.get_movie_length() > 0:
            raise pymol.wizarding.WizardError(
                'Mutagenesis Wizard cannot be used with Movie')

        self.cmd.unpick()

        self._stored = pymol.Scratch_Storage()
        self._space = {'stored': self._stored}

        self._status = Status.NO_SELECTION
        self._auto_center = "ON"
        self.mode = DEFAULT_MODE
        self.rep = DEFAULT_REP

        self.selection_mode = self.cmd.get_setting_int("mouse_selection_mode")
        self.cmd.set("mouse_selection_mode", 1)

        tmp_menu = [[2, 'Mutant', '']]
        for mode in self._mode_labels:
            tmp_menu.append(
                [1, mode, 'cmd.get_wizard().set_mode("' + mode + '")'])

        self.menu['mode'] = tmp_menu

        tmp_menu2 = [[2, 'Representation', '']]
        for rep in self._reps:
            tmp_menu2.append([
                1, self._rep_name[rep],
                'cmd.get_wizard().set_rep("' + rep + '")'
            ])
        self.menu['rep'] = tmp_menu2

        tmp_menu = [[2, 'Auto Center',
                     ''], [1, "ON", 'cmd.get_wizard().set_auto_center("ON")'],
                    [1, "OFF", 'cmd.get_wizard().set_auto_center("OFF")']]
        self.menu['auto_center'] = tmp_menu
示例#30
0
    def __init__(self, _self=cmd):

        cmd.unpick();
        Wizard.__init__(self, _self)

        self.mouse_selection_mode = cmd.get_setting_int('mouse_selection_mode')
        cmd.set('mouse_selection_mode',0) # set selection mode to atomic
        cmd.deselect() # disable the active selection (if any)

        self.error = None
        self.selection_mode = 1 if self.mouse_selection_mode == 6 else 0
        self.selection_modes = [
            'Residues',
            'C-alphas',
        ]

        smm = []
        smm.append([ 2, 'Selection Mode', '' ])
        for i, label in enumerate(self.selection_modes):
            smm.append([1, label, 'cmd.get_wizard().set_mode(%d)' % i])
        self.menu['selection_mode'] = smm

        self.name = None
示例#31
0
 def cleanup(self):
     self.cmd.delete(display_sele)
     Wizard.cleanup(self)
示例#32
0
    def __init__(self, _self=cmd):

        self.cmd = _self
        self.cmd.unpick()

        Wizard.__init__(self, _self)

        # mode selection subsystem

        self.radius = default_radius
        self.map = copy.deepcopy(default_map)
        self.level = copy.deepcopy(default_level)
        self.track = copy.deepcopy(default_track)
        self.avail_maps = []

        self.menu['radius'] = [
            [1, '4.0 A Radius', 'cmd.get_wizard().set_radius(4)'],
            [1, '5.0 A Radius', 'cmd.get_wizard().set_radius(5)'],
            [1, '6.0 A Radius', 'cmd.get_wizard().set_radius(6)'],
            [1, '8.0 A Radius', 'cmd.get_wizard().set_radius(8)'],
            [1, '10.0 A Radius', 'cmd.get_wizard().set_radius(10)'],
            [1, '15.0 A Radius', 'cmd.get_wizard().set_radius(15)'],
            [1, '20.0 A Radius', 'cmd.get_wizard().set_radius(20)'],
            [1, '50.0 A Radius', 'cmd.get_wizard().set_radius(50)'],
        ]

        self.menu['map0'] = []
        self.menu['map1'] = []
        self.menu['map2'] = []

        level_menu = lambda x: [
            [1, '1.0 sigma',
             'cmd.get_wizard().set_level(%d,1.0)' % x],
            [1, '1.5 sigma',
             'cmd.get_wizard().set_level(%d,1.5)' % x],
            [1, '2.0 sigma',
             'cmd.get_wizard().set_level(%d,2.0)' % x],
            [1, '3.0 sigma',
             'cmd.get_wizard().set_level(%d,3.0)' % x],
            [1, '5.0 sigma',
             'cmd.get_wizard().set_level(%d,5.0)' % x],
            [1, '-3.0 sigma',
             'cmd.get_wizard().set_level(%d,-3.0)' % x]
        ]

        self.menu['level0'] = level_menu(0)
        self.menu['level1'] = level_menu(1)
        self.menu['level2'] = level_menu(2)

        self.menu['track'] = [
            [1, "Track & Zoom", 'cmd.get_wizard().set_track(0)'],
            [1, "Track & Center", 'cmd.get_wizard().set_track(1)'],
            [1, "Track & Set Origin", 'cmd.get_wizard().set_track(2)'],
            [1, "Track Off", 'cmd.get_wizard().set_track(3)'],
        ]

        if (self.map[0] == '') and (self.map[1] == '') and (self.map[2] == ''):
            for a in self.cmd.get_names(
            ):  # automatically load first map we find
                if self.cmd.get_type(a) == 'object:map':
                    self.map[0] = a
                    break
        self.update_map_menus()

        self.cmd.set_key('pgup', lambda c=cmd: c.get_wizard().next_res(d=-1))
        self.cmd.set_key('pgdn', lambda c=cmd: c.get_wizard().next_res())
示例#33
0
 def __init__(self, _self=cmd):
     Wizard.__init__(self, _self)
     self.cmd.unpick()
示例#34
0
 def _validate_instance(self):
     Wizard._validate_instance(self)
     if not hasattr(self, 'meas_count'):
         self.meas_count = self.session.get('meas_count', 0)
 def __init__(self, _self=cmd):
     Wizard.__init__(self, _self)
     self.cmd.unpick()
     self.click_list = []
     cmd.select(click_sele, "none", enable=0)
     cmd.select(disp_sele, "none", enable=1)
示例#36
0
 def __init__(self, _self=cmd):
     Wizard.__init__(self, _self)
     for a in self.get_prompt():
         print a
示例#37
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)
        self.cmd.deselect()
        self.cmd.unpick()
        self.selection_mode = self.cmd.get_setting_legacy("mouse_selection_mode")
        self.cmd.set("mouse_selection_mode",0) # set selection mode to atomic      
        self.current_mode = saved_mode
        self.current_what = saved_what
        self.current_scope = saved_scope
        self.current_color = saved_color
        self.menu['mode'] = [
            [2, 'Mode', '' ],
            [1, self.mode_dict[0][0], 'cmd.get_wizard().set_mode(0)' ],
            [1, self.mode_dict[1][0], 'cmd.get_wizard().set_mode(1)' ],
            [ 0, ''           , '' ],         
            [1, self.mode_dict[2][0], 'cmd.get_wizard().set_mode(2)' ],
            [1, self.mode_dict[3][0], 'cmd.get_wizard().set_mode(3)' ],
            [1, self.mode_dict[4][0], 'cmd.get_wizard().set_mode(4)' ],
#         [1, self.mode_dict[5][0], 'cmd.get_wizard().set_mode(4)' ],         
            ]

        self.menu['what'] = [
            [2, 'What', '' ],
            [1, self.what_dict[1][0], 'cmd.get_wizard().set_what(1)' ],
            [1, self.what_dict[2][0], 'cmd.get_wizard().set_what(2)' ],
            [1, self.what_dict[3][0], 'cmd.get_wizard().set_what(3)' ],
            [1, self.what_dict[4][0], 'cmd.get_wizard().set_what(4)' ],
            [1, self.what_dict[5][0], 'cmd.get_wizard().set_what(5)' ],
            [0, '', '' ],
            [1, self.what_dict[6][0], 'cmd.get_wizard().set_what(6)' ],
            [0, '', '' ],         
            [1, self.what_dict[7][0], 'cmd.get_wizard().set_what(7)' ],
            [1, self.what_dict[8][0], 'cmd.get_wizard().set_what(8)' ],
            [1, self.what_dict[9][0], 'cmd.get_wizard().set_what(9)' ],
            [0, '', '' ],
            [1, self.what_dict[10][0], 'cmd.get_wizard().set_what(10)' ],
            [1, self.what_dict[11][0], 'cmd.get_wizard().set_what(11)' ],
            ]

        self.menu['color'] = [
            [2, 'Color', '' ],
            [1, self.color_dict[1][0], 'cmd.get_wizard().set_color(1)' ],
            [1, self.color_dict[2][0], 'cmd.get_wizard().set_color(2)' ],
            [1, self.color_dict[3][0], 'cmd.get_wizard().set_color(3)' ],
            [1, self.color_dict[4][0], 'cmd.get_wizard().set_color(4)' ],
            [1, self.color_dict[5][0], 'cmd.get_wizard().set_color(5)' ],
            [1, self.color_dict[6][0], 'cmd.get_wizard().set_color(6)' ],
            [1, self.color_dict[7][0], 'cmd.get_wizard().set_color(7)' ],
            [1, self.color_dict[8][0], 'cmd.get_wizard().set_color(8)' ],
            [1, self.color_dict[9][0], 'cmd.get_wizard().set_color(9)' ],
            [1, self.color_dict[10][0], 'cmd.get_wizard().set_color(10)' ],
            [1, self.color_dict[11][0], 'cmd.get_wizard().set_color(11)' ],
            [1, self.color_dict[12][0], 'cmd.get_wizard().set_color(12)' ],
            [1, self.color_dict[13][0], 'cmd.get_wizard().set_color(13)' ],
            [1, self.color_dict[14][0], 'cmd.get_wizard().set_color(14)' ],         
            ]

        self.menu['scope'] = [
            [ 2, 'Scope', ''],
            [ 1, self.scope_dict[0][0], 'cmd.get_wizard().set_scope(0)' ],
            [ 1, self.scope_dict[1][0], 'cmd.get_wizard().set_scope(1)' ],
            [ 1, self.scope_dict[2][0], 'cmd.get_wizard().set_scope(2)' ],
            [ 1, self.scope_dict[3][0], 'cmd.get_wizard().set_scope(3)' ],
            [ 1, self.scope_dict[4][0], 'cmd.get_wizard().set_scope(4)' ],        
            [ 0, ''           , '' ],
            [ 1, self.scope_dict[5][0], 'cmd.get_wizard().set_scope(5)' ],                 
            ]
示例#38
0
    def __init__(self,_self=cmd):
        Wizard.__init__(self,_self)
        cmd=self.cmd

        if self.cmd.get_movie_length() > 0:
            raise pymol.wizarding.WizardError('Mutagenesis Wizard cannot be used with Movie')

        cmd.unpick()

        self.stored = pymol.Scratch_Storage()
        self.space = {'stored': self.stored}

        self.bump_scores = []
        self.dep = default_dep

        self.ind_library = io.pkl.fromFile(os.environ['PYMOL_DATA']+
                                           "/chempy/sidechains/sc_bb_ind.pkl")
        self.load_library()
        self.status = 0 # 0 no selection, 1 mutagenizing
        self.bump_check = 1
        self.auto_center = 1
        self.error = None
        self.object_name = None
        self.modes = [
            'current'
            ]
        self.mode = default_mode
        self.rep = default_rep
        self.hyd = default_hyd
        self.n_cap = default_n_cap
        self.c_cap = default_c_cap
        residues = list(self.ind_library.keys())
        # could extent with additional fragments manually as below
        residues.extend(['GLY','ALA'])
        residues.extend(['HID','HIE','HIP'])
        residues.extend(['ARGN','LYSN','ASPH','GLUH'])
        residues.sort()
        res_copy = deepcopy(residues)
        for a in res_copy:
            residues.append('NT_'+a)
            residues.append('CT_'+a)
        self.modes.extend(residues)
        self.mode_label={}
        for a in self.modes:
            self.mode_label[a] = ""+a
        self.mode_label['current']="No Mutant"

        self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
        cmd.set("mouse_selection_mode",1)

        smm = []
        smm.append([ 2, 'Mutant', '' ])
        smm.append([ 1, 'No change', 'cmd.get_wizard().set_mode("current")' ])
#        smm.append([ 1, 'N-Term', [] ])
#        smm.append([ 1, 'C-Term', [] ])
        smm.append([ 0, '', '' ])
        for a in self.modes:
            if a == 'current':
                pass
            elif a[0:3]=='NT_':
                pass
#                smm[2][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
            elif a[0:3]=='CT_':
                pass
#                smm[3][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
            else:
                smm.append([ 1, self.mode_label[a], 'cmd.get_wizard().set_mode("'+a+'")'])

        # group arg, lys, his, glu, asp

        for lst in [ smm ]: # [ smm, smm[2][2], smm[3][2] ]:
            for a in 'ARG','LYS','HID','GLU','ASP':
                ix = 0
                start = 0
                stop = 0
                for b in lst:
                    if start==0:
                        if b[1][0:]==a:
                            start = ix
                            stop = ix + 1
                    elif b[1][0:3]==a[0:3] or ( b[1][0:2]==a[0:2] and a[0:2]=='HI' ):
                        stop = ix + 1
                    ix = ix + 1
                if start!=0 and stop!=0:
                    slice = lst[start:stop]
                    if a != 'HID':
                        slice2 = [slice[0] ] + [ [0,'',''] ] + slice[1:]
                        lst[start:stop] = [ [1, self.mode_label[a] + "... " , slice2 ] ]
                    else:
                        slice2 = [ slice[3] ] + [ [0,'',''] ] + slice[0:3]
                        lst[start:stop] = [ [1, self.mode_label['HIS']+ "... ", slice2 ] ]

        self.menu['mode']=smm


        self.reps = [
            'lines',
            'sticks',
            'spheres',
            'dots'
            ]

        self.rep_name = {
            'lines' : "Show Lines",
            'sticks' : "Show Sticks",
            'spheres' : "Show Spheres",
            'dots' : "Show Dots",
            }

        self.dep_name = {
            'dep' : "Backbone Depen. Rotamers",
            'ind' : "Backbone Indep. Rotamers"
            }

        self.hyd_name = {
            'auto' : "Hydrogens: Current",
            'keep' : "Hydrogens: Add & Retain",
#            'polar' : "Polar Hydrogens",
            'none'  : "Hydrogens: Remove",
            }
        self.hyds = [ 'auto', 'keep', 'none' ]

        self.n_cap_name = {
            'none' : 'Open',
            'posi' : 'NH3+',
            'acet' : 'Acetyl',
            }
        self.n_caps = [ 'none', 'posi', 'acet' ]

        self.c_cap_name = {
           'none' : 'Open',
           'nega' : 'COO-',
           'amin' : 'Amine',
           'nmet' : 'N-methyl',
            }
        self.c_caps = [ 'none', 'nega', 'amin', 'nmet' ]

        smm = []
        smm.append([ 2, 'N-Cap', '' ])
        for a in self.n_caps:
            smm.append([ 1, self.n_cap_name[a], 'cmd.get_wizard().set_n_cap("'+a+'")'])
        self.menu['n_cap']=smm

        smm = []
        smm.append([ 2, 'C-Cap', '' ])
        for a in self.c_caps:
            smm.append([ 1, self.c_cap_name[a], 'cmd.get_wizard().set_c_cap("'+a+'")'])
        self.menu['c_cap']=smm

        smm = []
        smm.append([ 2, 'Hydrogens', '' ])
        for a in self.hyds:
            smm.append([ 1, self.hyd_name[a], 'cmd.get_wizard().set_hyd("'+a+'")'])
        self.menu['hyd']=smm

        smm = []
        smm.append([ 2, 'Representation', '' ])
        for a in self.reps:
            smm.append([ 1, self.rep_name[a], 'cmd.get_wizard().set_rep("'+a+'")'])
        self.menu['rep']=smm

        self.deps = [ 'dep', 'ind' ]
        smm = []
        smm.append([ 2, 'Rotamers', '' ])
        for a in self.deps:
            smm.append([ 1, self.dep_name[a], 'cmd.get_wizard().set_dep("'+a+'")'])
        self.menu['dep']=smm

        if 'pk1' in cmd.get_names('selections'):
            cmd.select(src_sele,"(byres pk1)")
            cmd.unpick()
            cmd.enable(src_sele)
            self.status = 1
            self.error = None
            self.do_library()
            cmd.refresh_wizard()
示例#39
0
 def __init__(self):
     Wizard.__init__(self)
     self.reset()
示例#40
0
 def __init__(self,_self):
     Wizard.__init__(self,_self)
     self.actionHash = str(self.__class__)
示例#41
0
    def __init__(self,_self=cmd):

        Wizard.__init__(self,_self)

        self.status = NO_SELECTIONS
        self.error = None
        self.object_name = None
        self.radius = default_radius
        self.cushion = default_cushion

        # activate editing mode if not already active

        if "Editing" not in self.cmd.get("button_mode_name"):
            self.cmd.edit_mode(1)
            self.restore_edit_mode = 0
        else:
            self.restore_edit_mode = None

        # activate bumps

        self.restore_sculpt_vdw_vis_mode = self.cmd.get('sculpt_vdw_vis_mode')
        self.cmd.set("sculpt_vdw_vis_mode")

        # deactivate all objects

        self.cmd.sculpt_deactivate("all")

        # turn on sculpting

        self.cmd.set("sculpting")

        # unmask all atoms so that they can be picked

        self.cmd.unmask("all")

        # mode selection subsystem

        self.mode = default_mode
        self.modes = [
            'ligand_rx',
#         'ligand_re',
#         'by_atom',
            'by_resi',
            ]

        self.mode_name = {
            'by_atom':'Atom Shells',
            'by_resi':'Residue Shells',
            'ligand_rx' :'One Residue',
            'ligand_re' :'Residue v. Free',
            'ligand_cx' :'Chain v. Fixed',
            'ligand_ce' :'Chain v. Free',
            }

        smm = []
        smm.append([ 2, 'Selection Mode', '' ])
        for a in self.modes:
            smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
        self.menu['mode']=smm

        self.menu['radius'] = [[ 2, 'Mobile Atom Sphere', '' ],
                                      [1, '4.0 A Radius','cmd.get_wizard().set_radius(4)'],
                                      [1, '5.0 A Radius','cmd.get_wizard().set_radius(5)'],
                                      [1, '6.0 A Radius','cmd.get_wizard().set_radius(6)'],
                                      [1, '8.0 A Radius','cmd.get_wizard().set_radius(8)'],
                                      [1, '10.0 A Radius','cmd.get_wizard().set_radius(10)'],
                                      [1, '15.0 A Radius','cmd.get_wizard().set_radius(15)'],
                                      [1, '20.0 A Radius','cmd.get_wizard().set_radius(20)'],
                                      ]

        self.menu['cushion'] = [[ 2, 'Fixed Atom Cushion', '' ],
            [1, '2.0 A Cushion','cmd.get_wizard().set_cushion(2)'],
            [1, '3.0 A Cushion','cmd.get_wizard().set_cushion(3)'],
            [1, '4.0 A Cushion','cmd.get_wizard().set_cushion(4)'],
            [1, '6.0 A Cushion','cmd.get_wizard().set_cushion(6)'],
            [1, '8.0 A Cushion','cmd.get_wizard().set_cushion(8)'],
            [1, '10.0 A Cushion','cmd.get_wizard().set_cushion(10)'],
            [1, '12.0 A Cushion','cmd.get_wizard().set_cushion(12)'],
            ]
示例#42
0
    def __init__(self, _self=cmd):
        Wizard.__init__(self, _self)

        self.cmd.unpick()

        self.cutoff = self.cmd.get_setting_float("neighbor_cutoff")
        self.heavy_neighbor_cutoff = self.cmd.get_setting_float(
            "heavy_neighbor_cutoff")
        self.polar_neighbor_cutoff = self.cmd.get_setting_float(
            "polar_neighbor_cutoff")
        self.hbond_cutoff = self.cmd.get_setting_float("h_bond_cutoff_center")

        self.status = 0  # 0 no atoms selections, 1 atom selected, 2 atoms selected, 3 atoms selected
        self.error = None
        self.object_name = None

        # mode selection subsystem
        self.mode = self.session.get('default_mode', 'pairs')

        self.modes = [
            'pairs',
            'angle',
            'dihed',
            'polar',
            'heavy',
            'neigh',
            'hbond',
        ]

        self.mode_name = {
            'polar': 'Polar Neighbors',
            'heavy': 'Heavy Neighbors',
            'neigh': 'Neighbors',
            'pairs': 'Distances',
            'angle': 'Angles',
            'dihed': 'Dihedrals',
            'hbond': 'Polar Contacts',
        }
        # users can now specify how they're finding neighbors
        self.neighbor_modes = [
            'same', 'other', 'enabled', 'all', 'in_object', 'in_selection'
        ]

        self.neighbor_target = ""

        # TODO:
        # make this a function, and call it when we call refresh wizard
        # to update the object/selection list
        smm = []
        smm.append([2, 'Measurement Mode', ''])
        for a in self.modes:
            if a in ("neigh", "polar", "heavy"):
                smm.append([1, self.mode_name[a], self.neighbor_submenu(a)])
            else:
                smm.append([
                    1, self.mode_name[a],
                    'cmd.get_wizard().set_mode("' + a + '")'
                ])
        self.menu['mode'] = smm

        # overwrite mode selection subsystem
        self.object_mode = self.session.get('default_object_mode', 'append')
        self.object_modes = [
            'merge',
            'overwr',
            'append',
        ]
        self.object_mode_name = {
            'merge': 'Merge With Previous',
            'overwr': 'Replace Previous',
            'append': 'Create New Object',
        }

        smm = []
        smm.append([2, 'New Measurements?', ''])
        for a in self.object_modes:
            smm.append([
                1, self.object_mode_name[a],
                'cmd.get_wizard().set_object_mode("' + a + '")'
            ])

        self.menu['object_mode'] = smm
        # initially select atoms, but now users can change this
        self.selection_mode = self.cmd.get_setting_legacy(
            "mouse_selection_mode")
        self.cmd.set("mouse_selection_mode", 0)  # set selection mode to atomic
        self.cmd.deselect()  # disable the active selection (if any)
        self.mouse_mode = 0