コード例 #1
0
ファイル: Processing.py プロジェクト: stufisher/Proton8
    def __init__(self, nb):
        Tab.__init__(self, nb)
        
        Holder.set_finished_callback(self._job_finished)
                
        self._tabs = wx.aui.AuiNotebook(self, -1, size=(700,750))
        
        self.main = wx.BoxSizer(wx.HORIZONTAL)
        self.main.Add(self._tabs, 1 , wx.EXPAND)
        self.SetSizer(self.main)

        self._auto_manager = AutoProcessManager()
        AutoProcess.set_start_refinement(self.start_new_refinement)
        
        self._running = 0
コード例 #2
0
ファイル: Processing.py プロジェクト: stufisher/Proton8
class ProcessManager(Tab):

    def __init__(self, nb):
        Tab.__init__(self, nb)
        
        Holder.set_finished_callback(self._job_finished)
                
        self._tabs = wx.aui.AuiNotebook(self, -1, size=(700,750))
        
        self.main = wx.BoxSizer(wx.HORIZONTAL)
        self.main.Add(self._tabs, 1 , wx.EXPAND)
        self.SetSizer(self.main)

        self._auto_manager = AutoProcessManager()
        AutoProcess.set_start_refinement(self.start_new_refinement)
        
        self._running = 0

    def _r_act(self, event):
        id = event.GetId()
        fns = ['abort', 'view_log', 'load_coot']
        
        if id < len(fns):
            pid = self._tabs.GetSelection()
            
            if pid > -1:
                page = self._tabs.GetPage(pid)
                getattr(page, fns[id])()

        
    def _job_finished(self, id, status):
        self._auto_manager.refinement_finished(id, status)
        self.refresh_tabs()
                  
        self._running -= 1
        
        if self._running == 0:
            self.set_status('All Jobs Finished')
        else:
            self.set_status(str(self._running) + ' Job(s) Running')
        
        
    def _load_refinement(self, event):
        inputs, files = self._get_inputs('dat')
        dlg = wx.SingleChoiceDialog(self, 'Select a refinement to load:', 'Load Refinement', inputs, wx.CHOICEDLG_STYLE)
        if dlg.ShowModal() == wx.ID_OK:
            file = files[dlg.GetSelection()]
            
            tab = Holder(self._tabs)
            tab.load_refinement(file)
            self._tabs.AddPage(tab, inputs[dlg.GetSelection()], True)
            tab.SetFocus()
            
        dlg.Destroy() 

    
    def load_refinement(self, file, title):
        tab = Holder(self._tabs)
        tab.load_refinement(file)
        self._tabs.AddPage(tab, title, True)
        tab.SetFocus()
        self.GetParent().SetSelection(1)
    
    def new_refinement(self, **kwargs):
        self._new_refinement(**kwargs)
    
    def auto_refinement(self):
        pass
    
    def _new_refinement(self, **kwargs):
        inputs, files = self._get_inputs()
        inputs2, files2 = self._get_root_files('ins')
        reflns, files3 = self._get_root_files()
        
        inputs = inputs2 + inputs
        files  = files2 + files
        
        sel_hkl = kwargs['hkl'] if 'hkl' in kwargs else None
        sel_ins = kwargs['ins'] if 'ins' in kwargs else None
        resh = kwargs['resh'] if 'resh' in kwargs else None
        
        dlg = NewRefinement(self, -1, 'New Refinement', inputs, reflns, files, files3, sel_hkl, sel_ins, resh)
        val = dlg.ShowModal()
        
        if val == 1:
            title, refln, input, type, cycles, res, resl, options = dlg.get_values()
            
            if options['auto']:
                self._auto_manager.new(title, files3[refln], files[input], type, cycles, res, resl, options)
            else:
                self.start_new_refinement(title, files3[refln], files[input], type, cycles, res, resl, options)

        dlg.Destroy()
            
            
    def start_new_refinement(self, title, refln, input, type, cycles, res, resl, options):
        id = self._get_next_jobid()
        
        os.mkdir(self._project.root() + '/' + str(id) + '_' + REFINEMENT_TYPES[type])
        #root = self._project.root() + '/' + str(id) + '_' + REFINEMENT_TYPES[type] + '/'+ str(id) + '_' + REFINEMENT_TYPES[type].lower()
        root = './' + str(id) + '_' + REFINEMENT_TYPES[type] + '/'+ str(id) + '_' + REFINEMENT_TYPES[type].lower()
        file = root + '.ins'
        
        print os.getcwd()
        
        shutil.copy2(input, file)
        shutil.copy2(refln, root + '.hkl')
        
        if type == FULL_MATRIX:
            shutil.copy2(input.replace('.res', '.pdb'), root + '_start.pdb')
        
        print input, file
        ins = Shelx(file)
        ins.set_type(type, cycles, options)
        ins.set_res(res, resl)
        ins.set_hklf(refln.find('_F.hkl') > -1)
        ins.write()
        
        self._running += 1
        self.set_status(str(self._running) + ' Job(s) Running')
        
        self._project.action(REFINEMENT_TYPES[type])
        
        tab = Holder(self._tabs)
        tab.start_refinement(type, root, title, res, resl, cycles, input, refln, id, options)
        
        self._tabs.AddPage(tab, str(id) + '_' + REFINEMENT_TYPES[type], True)
        tab.SetFocus()
        self.GetParent().SetSelection(1)
            
        return id, root
    
    def _get_next_jobid(self):
        last = 0
        for f in os.listdir(self._project.root()):
            m = re.match('(\d+)_', f)
            if m:
                if int(m.group(1)) > last:
                    last = int(m.group(1))
                
        return last + 1
            
    
    def _get_inputs(self, type='res'):
        inputs = []
        files = []
    
        for f in sorted(os.listdir(self._project.root()), key=self.sort_dirs):
            m = re.match('(\d+)_', f)
            if m:
                types = ['res', 'ins'] if type == 'res' else [type]
                for t in types:
                    res = glob.glob(self._project.root() + os.sep + f + os.sep + '*.' + t)
                    for fl in res:
                        if os.path.basename(fl) == (f.lower() + '.ins'):
                            inputs.append(f+'/Input')
                        elif os.path.basename(fl) == (f.lower() + '.res'):
                            inputs.append(f+'/Output')
                        else:
                            inputs.append(fl.replace(self._project.root() + os.sep, ''))
                    
                        files.append(fl)
                
        return inputs, files
    
    def sort_dirs(self, item):
        l = item.split('_')
        if l[0].isdigit():
            i = int(l[0])
        else:
            i = item
        return i
    
    def _get_root_files(self, type='hkl'):
        res = glob.glob(self._project.root() + '/*.' + type)
        names = [ os.path.basename(r) for r in res]
        
        return names, res