def fetchPDB( self, id ):
try:
h = self.getLocalPDBHandle( id )
except:
h = self.getRemotePDBHandle( id )
fname = tempfile.mktemp( '.pdb', 'ncbiparser_' )
lines, infos = self.parsePdbFromHandle( h, first_model_only=1 )
## close if it is a handle
try: h.close()
except:
pass
f = open( fname, 'w', 1 )
f.writelines( lines )
f.close()
m = B.PDBModel( fname )
m.disconnect()
m.pdbCode = id
m.info.update( infos )
T.tryRemove( fname )
return m
def load_locked(self, fname):
"""
wait with unpickling until another Entropist has finished.
@param fname: file name
@type fname: str
@return: trajectroy
@rtype: Trajectroy
"""
flock = fname + '__locked'
while os.path.exists(flock):
if self.verbose: self.log.write('~')
time.sleep(random.random() * 10)
if self.verbose: self.log.add('')
try:
f = open(flock, 'w')
f.write('1')
f.close()
r = t.load(fname)
finally:
t.tryRemove(flock)
return r
def fetchPDB(self, id):
try:
h = self.getLocalPDBHandle(id)
except:
h = self.getRemotePDBHandle(id)
fname = tempfile.mktemp('.pdb', 'ncbiparser_')
lines, infos = self.parsePdbFromHandle(h, first_model_only=1)
## close if it is a handle
try:
h.close()
except:
pass
f = open(fname, 'w', 1)
f.writelines(lines)
f.close()
m = B.PDBModel(fname)
m.disconnect()
m.pdbCode = id
m.info.update(infos)
T.tryRemove(fname)
return m
def load_locked( self, fname ):
"""
wait with unpickling until another Entropist has finished.
@param fname: file name
@type fname: str
@return: trajectroy
@rtype: Trajectroy
"""
flock = fname + '__locked'
while os.path.exists( flock ):
if self.verbose: self.log.write('~')
time.sleep( random.random() * 10 )
if self.verbose: self.log.add('')
try:
f = open( flock, 'w' )
f.write('1')
f.close()
r = t.load(fname)
finally:
t.tryRemove( flock )
return r
def testCleanup( self, tree=True ):
"""
Remove files marked as 'cleanup' by setTest().
@param tree: try also removing directories
@type tree: bool
"""
for f in self.test_cleanup:
T.tryRemove( f, tree=tree )
def cleanup(self):
"""
remove temp files
"""
if not self.debug:
del_lst = [self.sub_fastaFile, self.hmmFile, self.fastaFile]
for d in del_lst:
T.tryRemove(d)
def cleanup( self ):
"""
Tidy up the mess you created.
"""
Executor.cleanup( self )
if not self.debug:
T.tryRemove( self.f_pdb )
def testCleanup(self, tree=True):
"""
Remove files marked as 'cleanup' by setTest().
@param tree: try also removing directories
@type tree: bool
"""
for f in self.test_cleanup:
T.tryRemove(f, tree=tree)
def cleanup( self ):
"""
remove temp files
"""
if not self.debug:
del_lst = [ self.sub_fastaFile, self.hmmFile, self.fastaFile ]
for d in del_lst:
T.tryRemove( d )
def cleanup(self):
"""
Tidy up the mess you created.
"""
Executor.cleanup(self)
if not self.debug:
T.tryRemove(self.f_pdb)
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 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 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 ):
"""
Clean up after external program has finished (failed or not).
Override, but call in child method!
"""
if not self.keep_inp and not self.debug:
T.tryRemove( self.f_in )
if self.f_err and not self.debug:
T.tryRemove( self.f_err )
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 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):
"""
Clean up after external program has finished (failed or not).
Note: a temporary folder, if it has been created, is only deleted if
it empty.
Override, but call in (preferably at the end of) child method!
"""
if not self.keep_out and not self.debug and self.f_out:
t.tryRemove(self.f_out)
if not self.keep_inp and not self.debug:
t.tryRemove(self.f_in)
if self.f_err and not self.debug:
t.tryRemove(self.f_err)
if not self.keep_tempdir and not self.debug:
if self.verbose:
if os.listdir(self.tempdir):
self.log.writeln('Removing non-empty temporary folder %s'\
% self.tempdir )
else:
self.log.writeln( 'Removing temporary folder %s'\
% self.tempdir )
t.tryRemove(self.tempdir, tree=True)
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 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 cleanup( self ):
"""
Remove temporary files.
"""
Xplorer.cleanup( self )
if not self.debug:
t.tryRemove( self.rec_in )
t.tryRemove( self.lig_in )
t.tryRemove( self.rec_out )
t.tryRemove( self.lig_out )
def cleanup(self):
"""
Remove temporary files.
"""
Xplorer.cleanup(self)
if not self.debug:
t.tryRemove(self.rec_in)
t.tryRemove(self.lig_in)
t.tryRemove(self.rec_out)
t.tryRemove(self.lig_out)
def cleanCache( self ):
"""
Remove left-over cache files
"""
fs = [ self.ref_frec, self.ref_flig, self.ref_com, self.ref_brec,
self.ref_blig ]
fs.extend( self.members_frec + self.members_flig )
fs.extend( self.members_brec + self.members_blig )
fs.extend( self.members_com )
for f in fs:
self.log.add('removing %s: %i' % (f, T.tryRemove(f)) )
def cleanCache( self ):
"""
Remove left-over cache files
"""
fs = [ self.ref_frec, self.ref_flig, self.ref_com, self.ref_brec,
self.ref_blig ]
fs.extend( self.members_frec + self.members_flig )
fs.extend( self.members_brec + self.members_blig )
fs.extend( self.members_com )
for f in fs:
self.log.add('removing %s: %i' % (f, T.tryRemove(f)) )
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 cleanup( self ):
Executor.cleanup( self )
if not self.debug:
T.tryRemove( self.prosaPdbFile )
T.tryRemove( self.f_in)
T.tryRemove( self.prosaOutput + '.ana' )
def cleanup(self):
"""
Remove temporary files.
"""
AmberCrdEntropist.cleanup(self)
if not self.debug:
t.tryRemove(self.parmcrd)
if not self.keep_crd:
t.tryRemove(self.f_crd)
if not self.keep_parm:
t.tryRemove(self.f_parm)
def cleanup( self ):
"""
Remove temporary files.
"""
AmberCrdEntropist.cleanup( self )
if not self.debug:
t.tryRemove( self.parmcrd )
if not self.keep_crd:
t.tryRemove( self.f_crd )
if not self.keep_parm:
t.tryRemove( self.f_parm )
def cleanup( self ):
"""
Clean up after external program has finished (failed or not).
Note: a temporary folder, if it has been created, is only deleted if
it empty.
Override, but call in (preferably at the end of) child method!
"""
if not self.keep_out and not self.debug and self.f_out:
t.tryRemove( self.f_out )
if not self.keep_inp and not self.debug:
t.tryRemove( self.f_in )
if self.f_err and not self.debug:
t.tryRemove( self.f_err )
if not self.keep_tempdir and not self.debug and self.verbose:
if os.listdir( self.tempdir ):
self.log.add('Warning: Removing non-empty temporary folder %s'%\
self.tempdir )
self.log.writeln( 'Removing temporary folder %s' % self.tempdir )
t.tryRemove( self.tempdir, tree=True )
def cleanUp(self):
import Biskit.tools as T
T.tryRemove( self.fout )
def cleanUp(self):
T.tryRemove( self.out_folder, tree=1 )
def cleanUp(self):
t.tryRemove( self.f_pfb )
t.tryRemove( self.f_crd )
def cleanUp(self):
t.tryRemove(self.fout)
def cleanUp(self):
if T.tryRemove(self.f_out) and self.local:
print 'log file removed.'
def parmSolvated( self, f_out, f_out_crd=None, f_out_pdb=None,
hetatm=0, norun=0,
cap=0, capN=[], capC=[],
fmod=['frcmod.ionsjc_tip3p'], fprep=[],
box=10.0, center=True, **kw ):
"""
@param f_out: target file for parm (topology)
@type f_out: str
@param f_out_crd: target file for crd (coordinates)
(default:|f_out_base|.crd)
@type f_out_crd: str
@param f_out_pdb: target file for pdb (default:|f_out_base|.pdb)
@type f_out_pdb: str
@param hetatm: keep hetero atoms (default: 0)
@type hetatm: 1|0
@param cap: put ACE and NME capping residue on chain breaks
(default: 0)
@type cap: 1|0
@param capN: indices of chains that should get ACE cap (default: [])
@type capN: [int]
@param capC: indices of chains that should get NME cap (default: [])
@type capC: [int]
@param box: minimal distance of solute from box edge (default: 10.0)
@type box: float
@param center: re-center coordinates (default: True)
@type center: bool
@param fmod: list of files with amber parameter modifications
to be loaded into leap with loadAmberParams
(default:['frcmod.ionsjc_tip3p'] ... mod file needed for
default Amber ff10 ions -- topology saving will fail if this
one is missing)
@type fmod: [str]
@param fprep: list of files with amber residue definitions
(to be loaded into leap with loadAmberPrep) (default: [])
@type fprep: [str]
@param kw: additional key=value pairs for leap input template
@type kw: key=value
@raise IOError:
"""
f_out = t.absfile( f_out )
f_out_crd = t.absfile( f_out_crd ) or t.stripSuffix( f_out ) + '.crd'
f_out_pdb = t.absfile( f_out_pdb ) or t.stripSuffix( f_out ) +\
'_leap.pdb'
## removed: (bugfix 3434136)
#fmod = [ t.absfile( f ) for f in t.toList( fmod ) ]
#fprep = [ t.absfile( f ) for f in t.toList( fprep ) ]
try:
if self.verbose: self.log.add( '\nCleaning PDB file for Amber:' )
m = self.leapModel( hetatm=hetatm, center=center )
if cap:
end_broken = m.atom2chainIndices( m.chainBreaks() )
capC = MU.union( capC, end_broken )
capN = MU.union( capN, N.array( end_broken ) + 1 )
for i in capN:
if self.verbose:
self.log.add( 'Adding ACE cap to chain %i' % i )
m = self.capACE( m, i )
for i in capC:
if self.verbose:
self.log.add( 'Adding NME cap to chain %i' % i )
m = self.capNME( m, i )
m.renumberResidues( addChainId=1 ) ## again, to accomodate capping
template = open( self.leap_template ).read()
leap_mod = self.__fLines( 'm = loadAmberParams %s\n', fmod )
leap_prep= self.__fLines( 'loadAmberPrep %s\n', fprep )
ss = self.__ssBonds( m, cutoff=4. )
self.__cys2cyx( m, ss )
leap_ss = self.__fLines( self.ss_bond, ss )
if self.verbose:
self.log.add('Found %i disulfide bonds: %s' % (len(ss),str(ss)))
if self.verbose:
self.log.add( 'writing cleaned PDB to %s' % self.leap_pdb )
m.writePdb( self.leap_pdb, ter=3 )
self.__runLeap( template, in_pdb=self.leap_pdb,
out_parm=f_out, out_crd=f_out_crd,
ss_bonds=leap_ss, fmod=leap_mod,
fprep=leap_prep, norun=norun,
box=box, **kw )
if not norun:
parm_pdb = self.parm2pdb( f_out, f_out_crd, f_out_pdb )
if not self.keep_leap_pdb and not self.debug:
t.tryRemove( self.leap_pdb )
except IOError, why:
raise IOError, why
def cleanUp(self):
T.tryRemove( self.fparm )
T.tryRemove( self.flog )
def cleanUp(self):
T.tryRemove( self.sep.log.fname )
def cleanUp(self):
import Biskit.tools as T
T.tryRemove(self.fout)
def cleanUp(self):
t.tryRemove(self.f_pfb)
t.tryRemove(self.f_crd)
def cleanUp(self):
T.tryRemove( self.cl_out )
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 parmMirror( self, f_out, f_out_crd=None, fmod=['frcmod.ionsjc_tip3p'],
fprep=[], **kw ):
"""
Create a parm7 file whose atom content (and order) exactly mirrors
the given PDBModel. This requires two leap runs. First we get a
temporary topology, then we identify all atoms added by leap and
build a final topology where these atoms are deleted.
This parm is hence NOT suited for simulations but can be used to parse
e.g. a trajectory or PDB into ptraj.
@param f_out: target parm file
@type f_out: str
@param f_out_crd: target crd file (default: f_out but ending .crd)
@type f_out_crd: str
@param fmod : list of amber Mod files (loaded with loadAmberParams)
@type fmod : [str]
@param fmod : list of amber Prep files (loaded with loadAmberPrep)
@type fmod : [str]
"""
f_out = t.absfile( f_out )
f_out_crd = t.absfile( f_out_crd ) or t.stripSuffix( f_out ) + '.crd'
## if there are hydrogens, recast them to standard amber names
aatm = 'HA' in self.m.atomNames() ## 'HB2' in self.m.atomNames()
## First leap round ##
m_ref = self.m.clone()
m_ref.xplor2amber( aatm=aatm, parm10=True )
tmp_in = tempfile.mktemp( 'leap_in0.pdb' )
m_ref.writePdb( tmp_in, ter=3 )
tmp_parm = tempfile.mktemp( '_parm0' )
tmp_crd = tempfile.mktemp( '_crd0' )
leap_mod = self.__fLines( 'm = loadAmberParams %s\n', fmod )
leap_prep= self.__fLines( 'loadAmberPrep %s\n', fprep )
self.__runLeap( self.script_mirror_pdb,
leaprc=self.leaprc, fmod=leap_mod, fprep=leap_prep,
in_pdb=tmp_in, out_parm=tmp_parm, out_crd=tmp_crd,
delete_atoms='' )
tmp_pdb = self.parm2pdb( tmp_parm, tmp_crd,
tempfile.mktemp( 'leap_out.pdb' ), aatm=aatm )
if not self.debug:
t.tryRemove( tmp_parm )
t.tryRemove( tmp_crd )
t.tryRemove( tmp_in )
## load model with missing atoms added by leap
m_leap = PDBModel( tmp_pdb )
## compare atom content
iLeap, iRef = m_leap.compareAtoms( m_ref )
## check that ref model doesn't need any change
if iRef != range( len( m_ref ) ):
uLeap, uRef = m_leap.unequalAtoms( m_ref, iLeap, iRef )
atms = m_ref.reportAtoms( uRef, n=6 )
raise AmberError, "Cannot create exact mirror of %s.\n" % tmp_in +\
"Leap has renamed/deleted original atoms in %s:\n"% tmp_pdb+\
atms
## indices of atoms that were added by leap
delStr = self.__deleteAtoms( m_leap,
self.__inverseIndices( m_leap, iLeap ) )
## Second leap round ##
self.__runLeap( self.script_mirror_pdb, leaprc=self.leaprc,
in_pdb=tmp_pdb, fmod=leap_mod, fprep=leap_prep,
out_parm=f_out, out_crd=f_out_crd,
delete_atoms=delStr )
if not self.debug:
t.tryRemove( tmp_pdb )
def parmSolvated(self,
f_out,
f_out_crd=None,
f_out_pdb=None,
hetatm=0,
norun=0,
cap=0,
capN=[],
capC=[],
fmod=['frcmod.ionsjc_tip3p'],
fprep=[],
box=10.0,
center=True,
**kw):
"""
@param f_out: target file for parm (topology)
@type f_out: str
@param f_out_crd: target file for crd (coordinates)
(default:|f_out_base|.crd)
@type f_out_crd: str
@param f_out_pdb: target file for pdb (default:|f_out_base|.pdb)
@type f_out_pdb: str
@param hetatm: keep hetero atoms (default: 0)
@type hetatm: 1|0
@param cap: put ACE and NME capping residue on chain breaks
(default: 0)
@type cap: 1|0
@param capN: indices of chains that should get ACE cap (default: [])
@type capN: [int]
@param capC: indices of chains that should get NME cap (default: [])
@type capC: [int]
@param box: minimal distance of solute from box edge (default: 10.0)
@type box: float
@param center: re-center coordinates (default: True)
@type center: bool
@param fmod: list of files with amber parameter modifications
to be loaded into leap with loadAmberParams
(default:['frcmod.ionsjc_tip3p'] ... mod file needed for
default Amber ff10 ions -- topology saving will fail if this
one is missing)
@type fmod: [str]
@param fprep: list of files with amber residue definitions
(to be loaded into leap with loadAmberPrep) (default: [])
@type fprep: [str]
@param kw: additional key=value pairs for leap input template
@type kw: key=value
@raise IOError:
"""
f_out = t.absfile(f_out)
f_out_crd = t.absfile(f_out_crd) or t.stripSuffix(f_out) + '.crd'
f_out_pdb = t.absfile( f_out_pdb ) or t.stripSuffix( f_out ) +\
'_leap.pdb'
## removed: (bugfix 3434136)
#fmod = [ t.absfile( f ) for f in t.toList( fmod ) ]
#fprep = [ t.absfile( f ) for f in t.toList( fprep ) ]
try:
if self.verbose: self.log.add('\nCleaning PDB file for Amber:')
m = self.leapModel(hetatm=hetatm, center=center)
if cap:
end_broken = m.atom2chainIndices(m.chainBreaks())
capC = MU.union(capC, end_broken)
capN = MU.union(capN, N.array(end_broken) + 1)
for i in capN:
if self.verbose:
self.log.add('Adding ACE cap to chain %i' % i)
m = self.capACE(m, i)
for i in capC:
if self.verbose:
self.log.add('Adding NME cap to chain %i' % i)
m = self.capNME(m, i)
m.renumberResidues(addChainId=1) ## again, to accomodate capping
template = open(self.leap_template).read()
leap_mod = self.__fLines('m = loadAmberParams %s\n', fmod)
leap_prep = self.__fLines('loadAmberPrep %s\n', fprep)
ss = self.__ssBonds(m, cutoff=4.)
self.__cys2cyx(m, ss)
leap_ss = self.__fLines(self.ss_bond, ss)
if self.verbose:
self.log.add('Found %i disulfide bonds: %s' %
(len(ss), str(ss)))
if self.verbose:
self.log.add('writing cleaned PDB to %s' % self.leap_pdb)
m.writePdb(self.leap_pdb, ter=3)
self.__runLeap(template,
in_pdb=self.leap_pdb,
out_parm=f_out,
out_crd=f_out_crd,
ss_bonds=leap_ss,
fmod=leap_mod,
fprep=leap_prep,
norun=norun,
box=box,
**kw)
if not norun:
parm_pdb = self.parm2pdb(f_out, f_out_crd, f_out_pdb)
if not self.keep_leap_pdb and not self.debug:
t.tryRemove(self.leap_pdb)
except IOError, why:
raise IOError, why
def cleanUp(self):
if not self.DEBUG:
T.tryRemove( self.dryparm )
T.tryRemove( self.drycrd )
T.tryRemove( self.drypdb )
T.tryRemove( self.wetparm )
T.tryRemove( self.wetcrd )
T.tryRemove( self.wetpdb )
T.tryRemove( self.leapout )
def cleanUp(self):
try:
T.tryRemove( self.f_plot )
except:
pass
def cleanUp(self):
T.tryRemove(self.dir_out, tree=1)
def cleanup(self):
"""
Tidy up.
"""
T.tryRemove(self.outFolder, verbose=self.verbose, tree=1)
def cleanUp(self):
t.tryRemove( self.f_out )
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' )
def cleanUp(self):
if not self.DEBUG:
T.tryRemove(self.dryparm)
T.tryRemove(self.drycrd)
T.tryRemove(self.drypdb)
T.tryRemove(self.wetparm)
T.tryRemove(self.wetcrd)
T.tryRemove(self.wetpdb)
T.tryRemove(self.leapout)
def cleanUp(self):
T.tryRemove(self.fparm)
T.tryRemove(self.flog)
def parmMirror(self,
f_out,
f_out_crd=None,
fmod=['frcmod.ionsjc_tip3p'],
fprep=[],
**kw):
"""
Create a parm7 file whose atom content (and order) exactly mirrors
the given PDBModel. This requires two leap runs. First we get a
temporary topology, then we identify all atoms added by leap and
build a final topology where these atoms are deleted.
This parm is hence NOT suited for simulations but can be used to parse
e.g. a trajectory or PDB into ptraj.
@param f_out: target parm file
@type f_out: str
@param f_out_crd: target crd file (default: f_out but ending .crd)
@type f_out_crd: str
@param fmod : list of amber Mod files (loaded with loadAmberParams)
@type fmod : [str]
@param fmod : list of amber Prep files (loaded with loadAmberPrep)
@type fmod : [str]
"""
f_out = t.absfile(f_out)
f_out_crd = t.absfile(f_out_crd) or t.stripSuffix(f_out) + '.crd'
## if there are hydrogens, recast them to standard amber names
aatm = 'HA' in self.m.atomNames() ## 'HB2' in self.m.atomNames()
## First leap round ##
m_ref = self.m.clone()
m_ref.xplor2amber(aatm=aatm, parm10=True)
tmp_in = tempfile.mktemp('leap_in0.pdb')
m_ref.writePdb(tmp_in, ter=3)
tmp_parm = tempfile.mktemp('_parm0')
tmp_crd = tempfile.mktemp('_crd0')
leap_mod = self.__fLines('m = loadAmberParams %s\n', fmod)
leap_prep = self.__fLines('loadAmberPrep %s\n', fprep)
self.__runLeap(self.script_mirror_pdb,
leaprc=self.leaprc,
fmod=leap_mod,
fprep=leap_prep,
in_pdb=tmp_in,
out_parm=tmp_parm,
out_crd=tmp_crd,
delete_atoms='')
tmp_pdb = self.parm2pdb(tmp_parm,
tmp_crd,
tempfile.mktemp('leap_out.pdb'),
aatm=aatm)
if not self.debug:
t.tryRemove(tmp_parm)
t.tryRemove(tmp_crd)
t.tryRemove(tmp_in)
## load model with missing atoms added by leap
m_leap = PDBModel(tmp_pdb)
## compare atom content
iLeap, iRef = m_leap.compareAtoms(m_ref)
## check that ref model doesn't need any change
if iRef != range(len(m_ref)):
uLeap, uRef = m_leap.unequalAtoms(m_ref, iLeap, iRef)
atms = m_ref.reportAtoms(uRef, n=6)
raise AmberError, "Cannot create exact mirror of %s.\n" % tmp_in +\
"Leap has renamed/deleted original atoms in %s:\n"% tmp_pdb+\
atms
## indices of atoms that were added by leap
delStr = self.__deleteAtoms(m_leap,
self.__inverseIndices(m_leap, iLeap))
## Second leap round ##
self.__runLeap(self.script_mirror_pdb,
leaprc=self.leaprc,
in_pdb=tmp_pdb,
fmod=leap_mod,
fprep=leap_prep,
out_parm=f_out,
out_crd=f_out_crd,
delete_atoms=delStr)
if not self.debug:
t.tryRemove(tmp_pdb)
def cleanUp(self):
T.tryRemove(self.f_inp)
T.tryRemove(self.f_out_inp)
def cleanUp(self):
try:
T.tryRemove(self.f_plot)
except:
pass
def cleanUp(self):
T.tryRemove(self.cl_out)
def cleanUp(self):
T.tryRemove( self.f_inp )
T.tryRemove( self.f_out_inp )
