def __init__( self, ref_model, models, **kw ): """ @param ref_model: reference @type ref_model: PDBModel @param models: structures to be compared with reference @type models: [PDBModel] @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ Executor.__init__( self, 'icmbrowser', template=self.inp_head, **kw ) self.f_ref = tempfile.mktemp('_icmcad_ref.pdb') self.f_pdb = tempfile.mktemp('_icmcad_%i.pdb') self.ref_model = ref_model self.models = models if not isinstance( self.models, list ): self.models = [ self.models ]
def __init__(self, model, **kw): """ @param model: model analyze @type model: PDBModel @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.model = model # self.model = model.clone( deepcopy=1 ) ## temporary pdb-file self.f_pdb = tempfile.mktemp('_dssp.pdb') self.f_out = tempfile.mktemp('_dssp.out') Executor.__init__(self, 'dsspcmbi', args='-i %s' % self.f_pdb, catch_err=1, **kw)
def __init__(self, full=0, mode='w', verbose=1, **kw ): """ @param mode: open file with this mode, w=override, a=append @type mode: str @param full: dispaly pymol structures in fill screen mode:: 0 - normal mode 1 - full screen mode 2 - full screen and no menues @type full: 0|1|2 """ self.verbose = verbose # name of .pml file self.foutName = tempfile.mktemp() + '.pml' # open for <appending|writing|reading> self.fgenerate = open(self.foutName, mode) # will contain PymolModels or lists of PymolModels self.dic = {} ## add startup commands self.initPymol() ## set arguments for display options (normal, full, all) arg = '-q %s'%self.foutName if full == 1: arg = '-qe %s'%self.foutName if full == 2: arg = '-qei %s'%self.foutName Executor.__init__( self, 'pymol', args=arg, catch_err=1, catch_out=1, **kw )
def __init__(self, target, hmmdb=settings.hmm_db, noSearch=None, **kw): """ @param target: fasta sequence, fasta file, or PDBModel @type target: PDBModel or str (fasta file) or [ str ] (fasta lines) @param hmmdb: Pfam hmm database @type hmmdb: str @param noSearch: don't perform a seach @type noSearch: 1 OR None """ self.hmmdb = hmmdb Executor.__init__(self, 'hmmpfam', f_in=tempfile.mktemp('.fasta'), catch_out=1, **kw) self.target = target self.fastaID = '' if noSearch: if self.verbose: self.log.writeln( 'Profiles provided - No search will be performed.')
def __init__(self, model, **kw ): """ @param model: reference PDBModel @type model: PDBModel @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.temp_pdb = tempfile.mktemp('_foldx_.pdb') self.temp_command = tempfile.mktemp('_foldx_.command') self.temp_option = tempfile.mktemp('_foldx_.option') self.temp_result = tempfile.mktemp('_foldx_.result') self.temp_runlog = tempfile.mktemp('_foldx_.log') self.temp_errlog = tempfile.mktemp('_foldx_.err') Executor.__init__( self, 'fold_X', args='-manual %s %s %s'\ %(self.temp_pdb, self.temp_option, self.temp_command), **kw ) self.model = model.clone() ## fold-X-allowed atoms for each res in standard order self.aminoAcidDict = molUtils.aaAtoms for k in self.aminoAcidDict: if 'HN' not in self.aminoAcidDict[ k ]: self.aminoAcidDict[ k ] += ['HN']
def prepare( self ): """ Overrides Executor method. """ Executor.prepare( self ) self.__prepareFolder() ## if setGrid hasn't been called yet, create automatic grid if not self.gsize: self.setGrid() if self.protonate: reducer = Reduce( self.model, verbose=self.verbose, autocap=self.autocap, tempdir=self.tempdir, cwd=self.cwd, log=self.log, debug=self.debug ) if self.verbose: self.log.add('adding hydrogen atoms to input structure\n') self.delphimodel = reducer.run() else: self.delphimodel = self.model.clone() self.delphimodel.xplor2amber() if not os.path.exists( self.f_charges ): self.__prepareCharges( self.f_charges ) self.delphimodel.writePdb( self.f_pdb )
def finish( self ): """ Overrides Executor method """ Executor.finish( self ) self.result = self.parse_result() ## if probe radius other than 1.4 A the relative surface exposure ## cannot be calculated, but allow this check to be a little flexible ## if we ate forced to slightly increase the radii to excape round off ## SurfaceRacer errors try: if round(self.probe, 1) == 1.4 and self.vdw_set == 1: self.__relExposure('MS') self.__relExposure('AS') else: EHandler.warning("No relative accessabilities calculated "+\ "when using a prob radius other than 1.4 A"+\ " or not using the Richards vdw radii set.") except KeyError, what: EHandler.warning("Missing standard accessibilities for some "+\ "atoms. No relative accesibilities calculated.") if 'relMS' in self.result: del self.result['relMS'] if 'relAS' in self.result: del self.result['relAS']
def cleanup( self ): Executor.cleanup( self ) if not self.debug: T.tryRemove( self.prosaPdbFile ) T.tryRemove( self.f_in) T.tryRemove( self.prosaOutput + '.ana' )
def finish( self ): """ Overrides Executor method """ Executor.finish( self ) self.result = self.parse_result() ## if probe radius other than 1.4 A the relative surface exposure ## cannot be calculated, but allow this check to be a little flexible ## if we ate forced to slightly increase the radii to excape round off ## SurfaceRacer errors try: if round(self.probe, 1) == 1.4 and self.vdw_set == 1: self.__relExposure('MS') self.__relExposure('AS') else: EHandler.warning("No relative accessabilities calculated "+\ "when using a prob radius other than 1.4 A"+\ " or not using the Richards vdw radii set.") except KeyError, what: EHandler.warning("Missing standard accessibilities for some "+\ "atoms. No relative accesibilities calculated.") if 'relMS' in self.result: del self.result['relMS'] if 'relAS' in self.result: del self.result['relAS']
def parm2pdb(self, f_parm, f_crd, f_out, aatm=0): """ Use ambpdb to build PDB from parm and crd. @param f_parm: existing parm file @type f_parm: str @param f_crd: existing crd file @type f_crd: str @param f_out: target file name for PDB @type f_out: str @return: f_out, target file name for PDB @rtype: str @raise AmberError: if ambpdb fail """ ## cmd = '%s -p %s -aatm < %s > %s' % \ args = '-p %s %s' % (f_parm, '-aatm' * aatm) x = Executor('ambpdb', args, f_in=f_crd, f_out=f_out, log=self.log, verbose=1, catch_err=1) output, error, status = x.run() if not os.path.exists(f_out): raise AmberError, 'ambpdb failed.' return f_out
def __init__( self, model, **kw ): """ @param model: model analyze @type model: PDBModel @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.model = model # self.model = model.clone( deepcopy=1 ) ## temporary pdb-file self.f_pdb = tempfile.mktemp( '_dssp.pdb') self.f_out = tempfile.mktemp( '_dssp.out') Executor.__init__( self, 'dsspcmbi', args='-na %s'%self.f_pdb, catch_err=1, **kw )
def __init__( self, model, refmodel, **kw ): """ @param model: structure to be aligned to reference @type model: PDBModel @param refmodel: reference structure @type refmodel: PDBModel @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.f_pdbin = tempfile.mktemp( '_tmalign_in.pdb' ) self.f_pdbref= tempfile.mktemp( '_tmalign_ref.pdb' ) self.f_matrix= tempfile.mktemp( '_tmalign_matrix.out' ) Executor.__init__( self, 'tmalign', args= '%s %s -m %s' % (self.f_pdbin, self.f_pdbref, self.f_matrix), **kw ) self.refmodel = refmodel self.model = model
def __init__( self, model, **kw ): """ @param model: PDBModel @type model: @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.f_xyzrn = tempfile.mktemp('_msms.xyzrn') ## output file from MSMS, will add .area exiension to file self.f_surf = tempfile.mktemp( ) arg =' -surface ases -if %s -af %s'%( self.f_xyzrn, self.f_surf ) Executor.__init__( self, 'msms', args=arg, **kw ) self.model = model.clone()
def __init__(self, ref_model, models, **kw): """ @param ref_model: reference @type ref_model: PDBModel @param models: structures to be compared with reference @type models: [PDBModel] @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ Executor.__init__(self, 'icmbrowser', template=self.inp_head, **kw) self.f_ref = tempfile.mktemp('_icmcad_ref.pdb') self.f_pdb = tempfile.mktemp('_icmcad_%i.pdb') self.ref_model = ref_model self.models = models if not isinstance(self.models, list): self.models = [self.models]
def cleanup(self): Executor.cleanup(self) if not self.debug: T.tryRemove(self.prosaPdbFile) T.tryRemove(self.f_in) T.tryRemove(self.prosaOutput + '.ana')
def prepare(self): """ Overrides Executor method. """ Executor.prepare(self) self.__prepareFolder() ## if setGrid hasn't been called yet, create automatic grid if not self.gsize: self.setGrid() if self.protonate: reducer = Reduce(self.model, verbose=self.verbose, autocap=self.autocap, tempdir=self.tempdir, cwd=self.cwd, log=self.log, debug=self.debug) if self.verbose: self.log.add('adding hydrogen atoms to input structure\n') self.delphimodel = reducer.run() else: self.delphimodel = self.model.clone() self.delphimodel.xplor2amber() if not os.path.exists(self.f_charges): self.__prepareCharges(self.f_charges) self.delphimodel.writePdb(self.f_pdb)
def __init__( self, model, **kw ): """ @param model: PDBModel @type model: @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.f_xyzrn = tempfile.mktemp('_msms.xyzrn') ## output file from MSMS, will add .area exiension to file self.f_surf = tempfile.mktemp( ) arg =' -surface ases -if %s -af %s'%( self.f_xyzrn, self.f_surf ) Executor.__init__( self, 'msms', args=arg, **kw ) self.model = model.clone()
def __init__(self, model, **kw): """ @param model: PDBModel @type model: @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ Executor.__init__(self, 'whatif', template=self.whatif_script, f_out='/dev/null', **kw) self.f_pdb = tempfile.mktemp('_whatif.pdb') self.f_relativeASA = tempfile.mktemp('_whatif_relative.log') self.f_residueASA = tempfile.mktemp('_whatif_residue.log') self.model = model.clone()
def parm2pdb( self, f_parm, f_crd, f_out, aatm=0 ): """ Use ambpdb to build PDB from parm and crd. @param f_parm: existing parm file @type f_parm: str @param f_crd: existing crd file @type f_crd: str @param f_out: target file name for PDB @type f_out: str @return: f_out, target file name for PDB @rtype: str @raise AmberError: if ambpdb fail """ ## cmd = '%s -p %s -aatm < %s > %s' % \ args = '-p %s %s' % (f_parm, '-aatm'*aatm ) x = Executor('ambpdb', args, f_in=f_crd, f_out=f_out, log=self.log, verbose=1, catch_err=1) output,error,status = x.run() if not os.path.exists( f_out ): raise AmberError, 'ambpdb failed.' return f_out
def __init__(self, model, refmodel, **kw): """ @param model: structure to be aligned to reference @type model: PDBModel @param refmodel: reference structure @type refmodel: PDBModel @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.f_pdbin = tempfile.mktemp('_tmalign_in.pdb') self.f_pdbref = tempfile.mktemp('_tmalign_ref.pdb') self.f_matrix = tempfile.mktemp('_tmalign_matrix.out') Executor.__init__(self, 'tmalign', args='%s %s -m %s' % (self.f_pdbin, self.f_pdbref, self.f_matrix), **kw) self.refmodel = refmodel self.model = model
def cleanup( self ): """ Tidy up the mess you created. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_pdb )
def finish( self ): """ Overrides Executor method """ Executor.finish( self ) self.raw_result = self.parse_file() self.parse_lines( self.raw_result ) self.result = self.model
def cleanup(self): """ Tidy up the mess you created. """ Executor.cleanup(self) if not self.debug: T.tryRemove(self.f_pdb)
def __init__(self, model, tempdir=None, args='', autocap=False, capN=[], capC=[], **kw): """ @param model: structure to be aligned to reference @type model: PDBModel @param tempdir: create dedicated temporary folder (default: None) see Executor @param tempdir: str | 0|1 @param args: additional command line arguments for reduce (default:'') example: '-OLDpdb' @type args: str @param autocap: add capping NME and ACE residues to any (auto-detected) false N- or C-terminal (default: False) @type autocap: bool @param capN: cap N-terminal of these chains (indices) with ACE ([]) @type capN: [ int ] @param capC: cap C-terminal of these chains (indices) with NME ([]) @type capN: [ int ] @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ tempdir = self.newtempfolder(tempdir) self.f_pdbin = tempfile.mktemp('_in.pdb', 'reduce_', dir=tempdir) f_out = tempfile.mktemp('_out.pdb', 'reduce_', dir=tempdir) self.f_db = T.dataRoot() + '/reduce/reduce_wwPDB_het_dict.txt' self.autocap = autocap self.capN = capN self.capC = capC lenchains = model.lenChains() Executor.__init__( self, 'reduce', args= '%s -BUILD -Nterm%i -DB %s %s' %\ (args, lenchains, self.f_db, self.f_pdbin), f_out=f_out, catch_err=True, tempdir=tempdir, **kw ) self.model = model
def cleanup(self): """ remove temporary files """ Executor.cleanup(self) if not self.debug: T.tryRemove(self.inp1) T.tryRemove(self.inp2)
def cleanup(self): """ Tidy up the mess you created. Does nothing. No temporary files are created. """ Executor.cleanup(self) if not self.debug: T.tryRemove(self.f_pdbin) T.tryRemove(self.f_out)
def cleanup( self ): """ Remove temp files. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_xyzrn ) T.tryRemove( self.f_surf + '.area' )
def cleanup(self): """ remove temporary files """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.inp1 ) T.tryRemove( self.inp2 )
def cleanup( self ): """ Remove temp files. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_xyzrn ) T.tryRemove( self.f_surf + '.area' )
def cleanup( self ): """ Tidy up the mess you created. Does nothing. No temporary files are created. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_pdbin ) T.tryRemove( self.f_out)
def cleanup( self ): """ Tidy up the mess we created. Called after program execution. """ Executor.cleanup( self ) if not self.debug: ## remove all files created by intervor for f in glob.glob( self.f_prefix + '*' ): T.tryRemove( f )
def cleanup(self): """ Tidy up the mess we created. Called after program execution. """ Executor.cleanup(self) if not self.debug: ## remove all files created by intervor for f in glob.glob(self.f_prefix + '*'): T.tryRemove(f)
def prepare(self, cleanUp=1): """ Overrides Executor method. """ Executor.prepare(self) self.flush() ## important to avoid empty input file ## Write PDB's to disc if needed self.writeStructures()
def cleanup( self ): """ Tidy up the mess you created. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_ref ) for i in range( len(self.models)): T.tryRemove( self.f_pdb % i )
def cleanup(self): """ Tidy up the mess you created. """ Executor.cleanup(self) if not self.debug: T.tryRemove(self.f_ref) for i in range(len(self.models)): T.tryRemove(self.f_pdb % i)
def cleanup( self ): """ Tidy up the mess you created. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_pdb, verbose=self.verbose ) T.tryRemove( self.f_out_name, verbose=self.verbose ) T.tryRemove( os.path.join(self.cwd, 'result.txt'), verbose=self.verbose ) T.tryRemove( self.f_pdb[:-4]+'_residue.txt', verbose=self.verbose)
def __init__( self, model, tempdir=None, args='', autocap=False, capN=[], capC=[], **kw ): """ @param model: structure to be aligned to reference @type model: PDBModel @param tempdir: create dedicated temporary folder (default: None) see Executor @param tempdir: str | 0|1 @param args: additional command line arguments for reduce (default:'') example: '-OLDpdb' @type args: str @param autocap: add capping NME and ACE residues to any (auto-detected) false N- or C-terminal (default: False) @type autocap: bool @param capN: cap N-terminal of these chains (indices) with ACE ([]) @type capN: [ int ] @param capC: cap C-terminal of these chains (indices) with NME ([]) @type capN: [ int ] @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ tempdir = self.newtempfolder( tempdir ) self.f_pdbin = tempfile.mktemp( '_in.pdb', 'reduce_', dir=tempdir ) f_out= tempfile.mktemp( '_out.pdb', 'reduce_', dir=tempdir) self.f_db = T.dataRoot() + '/reduce/reduce_wwPDB_het_dict.txt' self.autocap = autocap self.capN = capN self.capC = capC lenchains = model.lenChains() Executor.__init__( self, 'reduce', args= '%s -BUILD -Nterm%i -DB %s %s' %\ (args, lenchains, self.f_db, self.f_pdbin), f_out=f_out, catch_err=True, tempdir=tempdir, **kw ) self.model = model
def cleanup( self ): """ Tidy up the mess you created. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_pdb, verbose=self.verbose ) T.tryRemove( self.f_out_name, verbose=self.verbose ) T.tryRemove( os.path.join(self.cwd, 'result.txt'), verbose=self.verbose ) T.tryRemove( self.f_pdb[:-4]+'_residue.txt', verbose=self.verbose)
def __init__( self, hmmFile, fastaFile, fastaID, **kw ): """ @param hmmFile: path to hmm file (profile) @type hmmFile: str @param fastaFile: path to fasta search sequence @type fastaFile: str @param fastaID: fasta id of search sequence @type fastaID: str """ self.fastaID = fastaID Executor.__init__( self, 'hmmalign', args=' -q %s %s'%(hmmFile, fastaFile), **kw )
def __init__(self, hmmdb, **kw): """ @param hmmdb: Pfam hmm database @type hmmdb: str """ Executor.__init__(self, 'hmmindex', args='%s' % hmmdb, **kw) if not os.path.exists(hmmdb + '.ssi'): if self.verbose: self.log.writeln( 'HMMINDEX: Indexing hmm database. This will take a while') self.run()
def __init__( self, hmmName, hmmdb, **kw ): """ @param hmmName: hmm profile name @type hmmName: str @param hmmdb: Pfam hmm database @type hmmdb: str """ self.hmmName = hmmName Executor.__init__( self, 'hmmfetch', args=' %s %s'%(hmmdb, hmmName), **kw ) self.f_out = tempfile.mktemp('.hmm')
def __init__( self, hmmdb, **kw ): """ @param hmmdb: Pfam hmm database @type hmmdb: str """ Executor.__init__( self, 'hmmindex', args='%s'%hmmdb, **kw ) if not os.path.exists(hmmdb+'.ssi'): if self.verbose: self.log.writeln( 'HMMINDEX: Indexing hmm database. This will take a while') self.run()
def __init__(self, model, cr=[0], cl=None, mode=2, breaks=0, catch_err=1, **kw): """ Create a new Intervor instance for a given protein-protein complex. @param model: Structure of receptor, ligand and water @type model: Biskit.PDBModel @param cr: receptor chains (default: [0] = first chain) @type cr: [ int ] @param cl: ligand chains (default: None = all remaining protein chains) @type cl: [ int ] @param breaks: consider chain breaks (backbone gaps) (default: 0) @type breaks: bool or 1|0 @param mode: what to calculate (default 2, = all with shelling order) @type mode: int @param catch_err: deviate STDERR to temporary file (default 1) @type catch_err: bool or 0|1 @param **kw: any other keyword=value pair recognized by Executor """ Executor.__init__(self, 'intervor', catch_err=catch_err, **kw) assert isinstance( model, B.PDBModel ), \ 'requires PDBModel instance' assert model is not None, 'requires PDBModel instance' self.model = model self.breaks = breaks self.chains_rec = cr self.chains_lig = cl or self.__getLigandChains(model, cr) self.local_model = None #: will hold modified copy of model self.mode = mode ## intervor puts several output files into current working directory ## but respect cwd from Executor.__init__ or ExeConfig/exe_intervor.dat self.cwd = self.cwd or tempfile.gettempdir() #: will be used by intervor for different output files self.f_prefix = tempfile.mktemp(dir=self.exe.cwd) self.f_pdb = self.f_prefix + '_intervor.pdb' self.result = {}
def fail( self ): """ Called if external program failed, Overrides Executor method. In some very rare cases SurfaceRacer round off error cause the program to terminate. The simplest remedy to this problem is to increase the probe radii with a very small number and rerun the calculation. """ self.i_failed += 1 if self.i_failed < 2: self.probe = self.probe + 0.001 self.run() Executor.fail( self )
def fail( self ): """ Called if external program failed, Overrides Executor method. In some very rare cases SurfaceRacer round off error cause the program to terminate. The simplest remedy to this problem is to increase the probe radii with a very small number and rerun the calculation. """ self.i_failed += 1 if self.i_failed < 2: self.probe = self.probe + 0.001 self.run() Executor.fail( self )
def finish(self): """ Overrides Executor method """ Executor.finish(self) self.result = PDBModel(self.f_out) ## renumber atoms self.result['serial_number'] = N.arange(len(self.result)) ## rescue non-atom informations self.result.pdbCode = self.model.pdbCode self.result.info.update(self.model.info) self.result.residues.update(self.model.residues) self.result.info['reduce'] = 'hydrogens added/replaced by '\ + self.version()
def finish( self ): """ Overrides Executor method """ Executor.finish( self ) self.result = PDBModel( self.f_out ) ## renumber atoms self.result['serial_number'] = N.arange( len( self.result ) ) ## rescue non-atom informations self.result.pdbCode = self.model.pdbCode self.result.info.update( self.model.info ) self.result.residues.update( self.model.residues ) self.result.info['reduce'] = 'hydrogens added/replaced by '\ + self.version()
def cleanup(self): """ Tidy up the mess you created. """ Executor.cleanup(self) if not self.debug: T.tryRemove(self.f_pdb) T.tryRemove(self.f_relativeASA) T.tryRemove(self.f_residueASA) T.tryRemove('FOR???.DAT', wildcard=1) T.tryRemove('pdbout.tex') T.tryRemove('pdbout.txt') T.tryRemove('TEXSTORE.DAT') T.tryRemove('TEXTABLE.DAT')
def cleanup( self ): """ Tidy up the mess you created. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.f_pdb ) T.tryRemove( self.f_relativeASA ) T.tryRemove( self.f_residueASA ) T.tryRemove('FOR???.DAT', wildcard=1) T.tryRemove('pdbout.tex') T.tryRemove('pdbout.txt') T.tryRemove('TEXSTORE.DAT') T.tryRemove('TEXTABLE.DAT')
def __init__(self, models, **kw): """ @param models: if more than one model is given they are concatenated and the energy is calculated for the two together. @type models: PDBModels @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.models = models ## Potentials to use, pII3.0 is the default setting self.pairPot = 'prosa2003.pair-cb' # default: pII3.0.pair-cb self.surfPot = 'prosa2003.surf-cb' # default: pII3.0.surf-cb ## temp files for prosa pdb file and prosa output file self.prosaPdbFile = tempfile.mktemp('_prosa2003.pdb') self.prosaOutput = tempfile.mktemp('_prosa2003.out') self.temp_dir = T.tempDir() prosaInput = tempfile.mktemp('_prosa2003.inp') ## set default values self.objectName = 'obj1' self.lower_k = 1 self.upper_k = 600 self.pot_lb = 0. self.pot_ub = 15. Executor.__init__(self, 'prosa2003', template=self.inp, f_in=prosaInput, **kw) ## check the path to the potential files self.checkPotentials()
def __init__( self, template, leaprc=None, **kw ): """ @param template: template for leap input file (file or string) @type template: str @param leaprc: forcefield code (leaprc file ending, e.g. 'ff99') OR leaprc file name (e.g, 'leaprc.f99') OR leaprc path witin $AMBERHOME OR leaprc path default: take value from exe_tleap.dat @type leaprc: str @param f_in: complete leap input file -- existing or not, to be kept (default: create from template and then discard) @type f_in: str @param f_out: file for leap log output (default: discard) @type f_out: str @param out_parm: parm output file name (default: 'top.parm') @type out_parm: str @param out_crd : coordinate output file name (default '0.crd' ) @type out_crd : str @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ # override some Executor defaults unless they are freshly given kw['catchout'] = kw.get('catchout',0) Executor.__init__( self, 'tleap', template=template, **kw ) self.args = '-f %s' % self.f_in self.leaprc = self.findLeaprc( leaprc or self.exe.leaprc ) ## set some defaults that may or may not have been specified self.out_parm = kw.get('out_parm', 'top.parm' ) self.out_crd = kw.get('out_crd', '0.crd')
def __init__( self, hmmName, hmmdb=settings.hmm_db, **kw ): """ @param hmmName: hmm profile name @type hmmName: str @param hmmdb: Pfam hmm database @type hmmdb: str **kw - all Executor parameters, in particular: @param f_out: target file name for profile.hmm, prevents its deletion @type f_out: str @param debug: @param log: @param ... """ self.hmmName = hmmName Executor.__init__( self, 'hmmfetch', args=' %s %s'%(hmmdb, hmmName), **kw )
def __init__( self, hmmFile, fastaFile, fastaID, **kw ): """ @param hmmFile: path to hmm file (profile) @type hmmFile: str @param fastaFile: path to fasta search sequence @type fastaFile: str @param fastaID: fasta id of search sequence @type fastaID: str """ self.fastaID = fastaID self.hmmFile = hmmFile self.fastaFile = fastaFile assert T.fileLength( self.hmmFile ) > 10, \ 'input HMM file missing or empty' Executor.__init__( self, 'hmmalign', args=' -q %s %s'%(hmmFile, fastaFile), **kw )
def __init__(self, models, **kw ): """ @param models: if more than one model is given they are concatenated and the energy is calculated for the two together. @type models: PDBModels @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ self.models = models ## Potentials to use, pII3.0 is the default setting self.pairPot = 'prosa2003.pair-cb' # default: pII3.0.pair-cb self.surfPot = 'prosa2003.surf-cb' # default: pII3.0.surf-cb ## temp files for prosa pdb file and prosa output file self.prosaPdbFile = tempfile.mktemp('_prosa2003.pdb') self.prosaOutput = tempfile.mktemp('_prosa2003.out') self.temp_dir = T.tempDir() prosaInput = tempfile.mktemp('_prosa2003.inp') ## set default values self.objectName = 'obj1' self.lower_k = 1 self.upper_k = 600 self.pot_lb = 0. self.pot_ub = 15. Executor.__init__( self, 'prosa2003', template=self.inp, f_in=prosaInput, **kw ) ## check the path to the potential files self.checkPotentials()
def __init__( self, model, cr=[0], cl=None, mode=2, breaks=0, catch_err=1, **kw ): """ Create a new Intervor instance for a given protein-protein complex. @param model: Structure of receptor, ligand and water @type model: Biskit.PDBModel @param cr: receptor chains (default: [0] = first chain) @type cr: [ int ] @param cl: ligand chains (default: None = all remaining protein chains) @type cl: [ int ] @param breaks: consider chain breaks (backbone gaps) (default: 0) @type breaks: bool or 1|0 @param mode: what to calculate (default 2, = all with shelling order) @type mode: int @param catch_err: deviate STDERR to temporary file (default 1) @type catch_err: bool or 0|1 @param **kw: any other keyword=value pair recognized by Executor """ Executor.__init__( self, 'intervor', catch_err=catch_err, **kw ) assert isinstance( model, B.PDBModel ), \ 'requires PDBModel instance' assert model is not None, 'requires PDBModel instance' self.model = model self.breaks= breaks self.chains_rec = cr self.chains_lig = cl or self.__getLigandChains( model, cr ) self.local_model = None #: will hold modified copy of model self.mode = mode ## intervor puts several output files into current working directory ## but respect cwd from Executor.__init__ or ExeConfig/exe_intervor.dat self.cwd = self.cwd or tempfile.gettempdir() #: will be used by intervor for different output files self.f_prefix = tempfile.mktemp( dir=self.exe.cwd ) self.f_pdb = self.f_prefix + '_intervor.pdb' self.result = {}
def __init__(self, template, leaprc=None, **kw): """ @param template: template for leap input file (file or string) @type template: str @param leaprc: forcefield code (leaprc file ending, e.g. 'ff99') OR leaprc file name (e.g, 'leaprc.f99') OR leaprc path witin $AMBERHOME OR leaprc path default: take value from exe_tleap.dat @type leaprc: str @param f_in: complete leap input file -- existing or not, to be kept (default: create from template and then discard) @type f_in: str @param f_out: file for leap log output (default: discard) @type f_out: str @param out_parm: parm output file name (default: 'top.parm') @type out_parm: str @param out_crd : coordinate output file name (default '0.crd' ) @type out_crd : str @param kw: additional key=value parameters for Executor: @type kw: key=value pairs :: debug - 0|1, keep all temporary files (default: 0) verbose - 0|1, print progress messages to log (log != STDOUT) node - str, host for calculation (None->local) NOT TESTED (default: None) nice - int, nice level (default: 0) log - Biskit.LogFile, program log (None->STOUT) (default: None) """ # override some Executor defaults unless they are freshly given kw['catchout'] = kw.get('catchout', 0) Executor.__init__(self, 'tleap', template=template, **kw) self.args = '-f %s' % self.f_in self.leaprc = self.findLeaprc(leaprc or self.exe.leaprc) ## set some defaults that may or may not have been specified self.out_parm = kw.get('out_parm', 'top.parm') self.out_crd = kw.get('out_crd', '0.crd')
def __init__(self, hmmName, hmmdb=settings.hmm_db, **kw): """ @param hmmName: hmm profile name @type hmmName: str @param hmmdb: Pfam hmm database @type hmmdb: str **kw - all Executor parameters, in particular: @param f_out: target file name for profile.hmm, prevents its deletion @type f_out: str @param debug: @param log: @param ... """ self.hmmName = hmmName Executor.__init__(self, 'hmmfetch', args=' %s %s' % (hmmdb, hmmName), **kw)
def __init__(self, hmmFile, fastaFile, fastaID, **kw): """ @param hmmFile: path to hmm file (profile) @type hmmFile: str @param fastaFile: path to fasta search sequence @type fastaFile: str @param fastaID: fasta id of search sequence @type fastaID: str """ self.fastaID = fastaID self.hmmFile = hmmFile self.fastaFile = fastaFile assert T.fileLength( self.hmmFile ) > 10, \ 'input HMM file missing or empty' Executor.__init__(self, 'hmmalign', args=' -q %s %s' % (hmmFile, fastaFile), **kw)
def cleanup( self ): """ Remove files created for and by the calculation. """ Executor.cleanup( self ) if not self.debug: T.tryRemove( self.temp_pdb ) T.tryRemove( self.temp_command ) T.tryRemove( self.temp_option ) T.tryRemove( self.temp_result ) T.tryRemove( self.temp_runlog ) T.tryRemove( self.temp_errlog ) ## Fold-X writes a file called "runlog.txt" ## to local directory. Try to remove it. T.tryRemove( 'runlog.txt' ) ## and even though the error log is supposed ## to be written to self.temp_errlog, I get a ## 'errorfile.txt' in the local directory. Remove. T.tryRemove( 'errorfile.txt' )