def test_ComplexRandomizer(self):
"""Dock.ComplexRandomizer test"""
from Biskit import Trajectory
if self.local:
print "\nLoading Rec and Lig files ...",
rec_pdb = t.testRoot() + '/rec/1A2P.pdb'
lig_pdb = t.testRoot() + '/lig/1A19.pdb'
rec_psf = t.testRoot() + '/rec/1A2P.psf'
lig_psf = t.testRoot() + '/lig/1A19.psf'
rec = PCRModel( rec_psf, rec_pdb )
lig = PCRModel( lig_psf, lig_pdb )
if self.local:
print "Initializing Randomizer..."
self.cr = ComplexRandomizer( rec, lig, debug=self.DEBUG )
if self.local:
print "Creating 3 random complexes..."
cs = [ self.cr.random_complex() for i in range(3) ]
self.traj = Trajectory( [ c.model() for c in cs ] )
if self.local:
self.display( self.traj )
globals().update( locals() )
self.assertEqual( len(self.traj), 3 )
def prepare(self):
import tempfile
import shutil
## collect the input files needed
self.outfolder = tempfile.mkdtemp('_test_Analyse')
## data from validation sub-projects
dir = '/Mod/project/validation/'
for v in ['1DT7', '1J55']:
os.makedirs(self.outfolder + '/validation/%s/modeller' % v)
shutil.copy(
T.testRoot() + dir + '/%s/modeller/Modeller_Score.out' % v,
self.outfolder + '/validation/%s/modeller' % v)
shutil.copy(T.testRoot() + dir + '/%s/identities_cov.out' % v,
self.outfolder + '/validation/%s' % v)
os.mkdir(self.outfolder + '/validation/%s/benchmark' % v)
for f in ['rmsd_aa.out', 'rmsd_ca.out', 'PDBModels.list']:
shutil.copy(T.testRoot() + dir + '/%s/benchmark/%s' % (v, f),
self.outfolder + '/validation/%s/benchmark' % v)
## data from main project
os.mkdir(self.outfolder + '/modeller')
shutil.copy(T.testRoot() + '/Mod/project/modeller/PDBModels.list',
self.outfolder + '/modeller')
os.mkdir(self.outfolder + '/t_coffee')
shutil.copy(T.testRoot() + '/Mod/project/t_coffee/final.pir_aln',
self.outfolder + '/t_coffee')
def test_StructureMaster(self):
"""StructureMaster test"""
import os
pdbs = {
T.testRoot() + '/lig/1A19.pdb': '',
T.testRoot() + '/rec/1A2P.pdb': '',
T.testRoot() + '/com/1BGS.pdb': ''
}
self.master = StructMaster(pdbs,
2,
hosts=hosts.cpus_all,
outFolder=self.out_folder,
show_output=self.local,
verbose=self.local,
add_hosts=1)
## run and wait for result
self.r = self.master.calculateResult()
if self.local:
print 'The converted pdb files has been written to %s' \
% self.out_folder
self.assert_(os.path.exists(self.out_folder + '/1A19.model'))
def test_reduce(self):
"""Reduce test"""
if self.local: self.log.add('Loading PDB...')
self.m1 = PDBModel(T.testRoot('lig/1A19_dry.model'))
self.m2 = T.load(T.testRoot('com/ref.complex'))
self.m2 = self.m2.model()
if self.local: self.log.add('Starting Reduce')
self.x = Reduce(self.m1, debug=self.DEBUG, verbose=self.local)
if self.local:
self.log.add('Running')
self.r = self.x.run()
if self.local:
self.log.add("Result: ")
self.log.add(self.r.report(prnt=False))
if self.local:
self.log.add('Reduce protein complex')
self.x = Reduce(self.m2,
debug=self.DEBUG,
verbose=self.local,
autocap=True)
self.r2 = self.x.run()
def testOptions():
options = {}
options['q'] = tools.testRoot() + '/Mod/project/target.fasta'
options['o'] = tools.testRoot() + '/Mod/project'
options['log'] = '1'
options['view'] = '1'
return options
def prepare(self):
import tempfile
import shutil
## collect the input files needed
self.outfolder = tempfile.mkdtemp( '_test_Analyse' )
## data from validation sub-projects
dir = '/Mod/project/validation/'
for v in ['1DT7', '1J55']:
os.makedirs( self.outfolder +'/validation/%s/modeller'%v )
shutil.copy( T.testRoot() +dir+'/%s/modeller/Modeller_Score.out'%v,
self.outfolder + '/validation/%s/modeller'%v)
shutil.copy( T.testRoot() + dir + '/%s/identities_cov.out'%v,
self.outfolder + '/validation/%s'%v )
os.mkdir( self.outfolder +'/validation/%s/benchmark'%v )
for f in [ 'rmsd_aa.out', 'rmsd_ca.out', 'PDBModels.list' ]:
shutil.copy( T.testRoot() + dir + '/%s/benchmark/%s'%(v,f),
self.outfolder + '/validation/%s/benchmark'%v )
## data from main project
os.mkdir( self.outfolder +'/modeller' )
shutil.copy( T.testRoot() + '/Mod/project/modeller/PDBModels.list',
self.outfolder + '/modeller' )
os.mkdir( self.outfolder +'/t_coffee' )
shutil.copy( T.testRoot() + '/Mod/project/t_coffee/final.pir_aln',
self.outfolder + '/t_coffee' )
def test_tmalign(self):
"""TMAlign test"""
from Biskit import PDBModel
if self.local: print 'Loading PDB...'
self.m1 = PDBModel(T.testRoot('tmalign/1huy_citrine.model'))
self.m2 = PDBModel(T.testRoot('tmalign/1zgp_dsred_dimer.model'))
if self.local: print 'Starting TMAlign'
self.x = TMAlign(self.m1,
self.m2,
debug=self.DEBUG,
verbose=self.local)
if self.local:
print 'Running'
self.r = self.x.run()
if self.local:
print "Result: "
for key, value in self.r.items():
print '\t', key, ':\t', value
self.assertEqual(self.r['rmsd'], 1.76)
def test_IcmCad(self):
"""IcmCad test"""
from Biskit import PDBModel
if self.local: print 'Loading PDB...'
self.f = T.testRoot() + '/lig/1A19.pdb'
self.m1 = PDBModel(self.f)
self.m1 = self.m1.compress(self.m1.maskProtein())
self.ms = []
self.lig_traj = T.load(T.testRoot() + '/lig_pcr_00/traj.dat')
for m in self.lig_traj[:3]:
m = m.compress(m.maskProtein())
self.ms.append(m)
if self.local: print 'Starting ICM'
self.x = IcmCad(self.m1, self.ms, debug=self.DEBUG, verbose=self.local)
if self.local:
print 'Running'
self.r = self.x.run()
if self.local:
print "Result: ", self.r
self.assertEqual(
self.r,
[8.8603529999999999, 9.0315890000000003, 8.5055429999999994])
def test_ComplexRandomizer(self):
"""Dock.ComplexRandomizer test"""
from Biskit import Trajectory
if self.local:
print "\nLoading Rec and Lig files ...",
rec_pdb = t.testRoot() + '/rec/1A2P.pdb'
lig_pdb = t.testRoot() + '/lig/1A19.pdb'
rec_psf = t.testRoot() + '/rec/1A2P.psf'
lig_psf = t.testRoot() + '/lig/1A19.psf'
rec = PCRModel(rec_psf, rec_pdb)
lig = PCRModel(lig_psf, lig_pdb)
if self.local:
print "Initializing Randomizer..."
self.cr = ComplexRandomizer(rec, lig, debug=self.DEBUG)
if self.local:
print "Creating 3 random complexes..."
cs = [self.cr.random_complex() for i in range(3)]
self.traj = Trajectory([c.model() for c in cs])
if self.local:
self.display(self.traj)
globals().update(locals())
self.assertEqual(len(self.traj), 3)
def test_ModelList(self):
"""ModelList test"""
import random
self.f_lst = [
T.testRoot() + '/rec/1A2P.pdb',
T.testRoot() + '/lig/1A19.pdb',
T.testRoot() + '/com/1BGS.pdb'
]
## Loading PDBs...
self.l = ModelList(self.f_lst)
self.seq = []
for m in self.l:
m.info['score'] = random.random()
self.seq += [m.compress(m.maskProtein()).sequence()]
self.p = self.l.plot('score')
if self.local:
print self.l.valuesOf('score')
self.p.show()
self.assertEqual(self.seq, self.EXPECTED)
def test_tmalign( self ):
"""TMAlign test"""
from Biskit import PDBModel
if self.local: print 'Loading PDB...'
self.m1 = PDBModel( T.testRoot( 'tmalign/1huy_citrine.model' ) )
self.m2 = PDBModel( T.testRoot('tmalign/1zgp_dsred_dimer.model' ) )
if self.local: print 'Starting TMAlign'
self.x = TMAlign( self.m1, self.m2, debug=self.DEBUG,
verbose=self.local )
if self.local:
print 'Running'
self.r = self.x.run()
if self.local:
print "Result: "
for key, value in self.r.items():
print '\t', key, ':\t', value
self.assertEqual( self.r['rmsd'], 1.76 )
def test_Xplorer(self):
"""Xplorer test"""
## input template variables
param = T.dataRoot() + '/xplor/toppar/param19.pro'
pdb_out = self.dir_out + '/lig.pdb'
log_out = self.dir_out + '/test.out'
pdb_in = T.testRoot() + '/lig/1A19.pdb'
psf_in = T.testRoot() + '/lig/1A19.psf'
self.x = Xplorer(self.dir_out + '/test.inp',
xout=log_out,
verbose=self.local,
lig_psf=psf_in,
lig_pdb=pdb_in,
param19=param,
lig_out=pdb_out)
self.x.run()
if self.local:
print """
The minimized structure and the X-Plor log file
have been written to %s and %s, respectively
""" % (pdb_out, log_out)
print """See x.logLines for the complete xplor log file!"""
def test_Analyzer( self):
"""Dock.Analyzer test """
from Biskit import Trajectory
from Biskit.Dock import ComplexList
## create a minimal 1-frame receptor trajectory from a pdb file
self.t_rec = Trajectory( [t.testRoot()+'/rec/1A2P.pdb'],
verbose=self.local)
t.dump( self.t_rec, self.f_out )
## load a complex list
cl = t.load( t.testRoot() + '/dock/hex/complexes.cl')
self.a= Analyzer( rec = self.f_out,
lig = t.testRoot()+'/lig_pcr_00/traj.dat',
ref = t.testRoot()+'/com/ref.complex',
verbose = self.local)
## shuffle this list five times
shuff_lst = self.a.shuffledLists( 5, range(8) )
## create two random contact matrices
rand_mat = self.a.random_contacts( cl[0].atomContacts(), 2 )
self.assertEqual( N0.shape(rand_mat[1]), (1075, 876) )
def test_reduce( self ):
"""Reduce test"""
if self.local: self.log.add('Loading PDB...')
self.m1 = PDBModel( T.testRoot( 'lig/1A19_dry.model' ) )
self.m2 = T.load( T.testRoot( 'com/ref.complex' ) )
self.m2 = self.m2.model()
if self.local: self.log.add('Starting Reduce')
self.x = Reduce( self.m1, debug=self.DEBUG,
verbose=self.local )
if self.local:
self.log.add( 'Running')
self.r = self.x.run()
if self.local:
self.log.add("Result: ")
self.log.add(self.r.report(prnt=False))
if self.local:
self.log.add('Reduce protein complex')
self.x = Reduce( self.m2, debug=self.DEBUG, verbose=self.local,
autocap=True )
self.r2 = self.x.run()
def test_IcmCad( self ):
"""IcmCad test"""
from Biskit import PDBModel
if self.local: print 'Loading PDB...'
self.f = T.testRoot() + '/lig/1A19.pdb'
self.m1 = PDBModel(self.f)
self.m1 = self.m1.compress( self.m1.maskProtein() )
self.ms = []
self.lig_traj = T.load( T.testRoot() + '/lig_pcr_00/traj.dat' )
for m in self.lig_traj[:3]:
m = m.compress( m.maskProtein() )
self.ms.append(m)
if self.local: print 'Starting ICM'
self.x = IcmCad( self.m1, self.ms, debug=self.DEBUG,
verbose=self.local )
if self.local:
print 'Running'
self.r = self.x.run()
if self.local:
print "Result: ", self.r
self.assertEqual( self.r, [8.8603529999999999, 9.0315890000000003,
8.5055429999999994] )
def testOptions():
options = {}
options['q'] = tools.testRoot()+ '/Mod/project/target.fasta'
options['o'] = tools.testRoot()+ '/Mod/project'
options['log'] = '1'
options['view'] = '1'
return options
def prepare(self):
root = T.testRoot() + '/amber/'
self.ref = PDBModel( T.testRoot() + '/amber/1HPT_0.pdb')
self.refdry = root + '1HPT_0dry.pdb'
self.dryparm = tempfile.mktemp('.parm', 'dry_')
self.drycrd = tempfile.mktemp('.crd', 'dry_')
self.drypdb = tempfile.mktemp('.pdb', 'dry_')
self.wetparm = tempfile.mktemp('.parm', 'wet_')
self.wetcrd = tempfile.mktemp('.crd', 'wet_')
self.wetpdb = tempfile.mktemp('.pdb', 'wet_')
self.leapout = tempfile.mktemp('.out', 'leap_')
def prepare(self):
root = T.testRoot() + '/amber/'
self.ref = PDBModel(T.testRoot() + '/amber/1HPT_0.pdb')
self.refdry = root + '1HPT_0dry.pdb'
self.dryparm = tempfile.mktemp('.parm', 'dry_')
self.drycrd = tempfile.mktemp('.crd', 'dry_')
self.drypdb = tempfile.mktemp('.pdb', 'dry_')
self.wetparm = tempfile.mktemp('.parm', 'wet_')
self.wetcrd = tempfile.mktemp('.crd', 'wet_')
self.wetpdb = tempfile.mktemp('.pdb', 'wet_')
self.leapout = tempfile.mktemp('.out', 'leap_')
def prepare(self):
import tempfile
import shutil
## collect the input files needed
self.outfolder = tempfile.mkdtemp( '_test_ValidationSetup' )
os.mkdir( self.outfolder +'/templates' )
shutil.copytree( T.testRoot() + '/Mod/project/templates/nr',
self.outfolder + '/templates/nr' )
shutil.copytree( T.testRoot() + '/Mod/project/templates/modeller',
self.outfolder + '/templates/modeller' )
def prepare(self):
import tempfile
import shutil
from Biskit import PDBModel
## collect the input files needed
self.outfolder = tempfile.mkdtemp('_test_Benchmark')
os.mkdir(self.outfolder + '/modeller')
dir = '/Mod/project/validation/1DT7'
shutil.copy(T.testRoot() + dir + '/modeller/PDBModels.list',
self.outfolder + '/modeller')
shutil.copy(T.testRoot() + dir + '/reference.pdb', self.outfolder)
def prepare(self):
import tempfile
import shutil
## collect the input files needed
self.outfolder = tempfile.mkdtemp( '_test_ValidationSetup' )
os.mkdir( self.outfolder +'/templates' )
shutil.copytree( T.testRoot() + '/Mod/project/templates/nr',
self.outfolder + '/templates/nr' )
shutil.copytree( T.testRoot() + '/Mod/project/templates/modeller',
self.outfolder + '/templates/modeller' )
def test_reduce(self):
"""AtomCharger test"""
if self.local: self.log.add('\nLoading PDB...')
self.m1 = PDBModel(T.testRoot('lig/1A19_dry.model'))
self.m2 = T.load(T.testRoot('com/ref.complex'))
self.m2 = self.m2.model()
if self.local: self.log.add('\nRunning Reduce...')
self.x = Reduce(self.m1,
debug=self.DEBUG,
verbose=self.local,
log=self.log,
autocap=True)
self.m1 = self.x.run()
if self.local:
self.log.add('\nReduce protein complex')
self.x = Reduce(self.m2,
debug=self.DEBUG,
verbose=self.local,
log=self.log,
autocap=True)
self.m2 = self.x.run()
if self.local:
self.log.add('\nSetup Residue Library\n')
ac = AtomCharger(log=self.log, verbose=self.local)
if self.local:
self.log.add('match residues to Amber topology')
ac.charge(self.m1)
ac.charge(self.m2)
self.assertAlmostEqual(N.sum(self.m1['partial_charge']), -6, 2)
self.assertAlmostEqual(N.sum(self.m2['partial_charge']), -4, 2)
self.assert_(N.all(self.m1['partial_charge'] != 0),
'unmatched atoms 1')
self.assert_(N.all(self.m2['partial_charge'] != 0),
'unmatched atoms 2')
if self.local:
self.log.add('\nNow test handling of atom miss-matches:\n')
self.m3 = PDBModel(self.m1.clone())
self.m3.remove([0, 3, 100, 101, 102, 200])
ac.charge(self.m3)
self.assertAlmostEqual(N.sum(self.m3['partial_charge']), -8.21, 2)
def prepare(self):
import tempfile
import shutil
from Biskit import PDBModel
## collect the input files needed
self.outfolder = tempfile.mkdtemp( '_test_Benchmark' )
os.mkdir( self.outfolder +'/modeller' )
dir = '/Mod/project/validation/1DT7'
shutil.copy( T.testRoot() + dir + '/modeller/PDBModels.list',
self.outfolder + '/modeller' )
shutil.copy( T.testRoot() + dir + '/reference.pdb',
self.outfolder )
def test_surfaceRacerBug(self):
"""PDBDope.addSurfaceRacer mask handling bugfix"""
import os
from Biskit import PDBModel
m = PDBModel(os.path.join(T.testRoot(),'lig/1A19.pdb'))
d = PDBDope(m)
d.addSurfaceRacer()
def test_delphiCharges2( self ):
"""
PDB2DelphiCharges test
"""
if self.local:
T.errWrite( 'loading PDB...' )
self.m1 = self.MODEL or PDBModel( T.testRoot( 'lig/1A19_dry.model' ) )
Test.MODEL = self.m1
if self.local:
T.errWriteln( 'Done.' )
if self.local:
T.errWrite( 'Adding hydrogens to model (reduce)...' )
self.rmodel = Reduce( self.m1, verbose=self.local ).run()
self.rmodel.xplor2amber()
if self.local:
T.errWriteln( 'Done.' )
ac = AtomCharger()
ac.charge(self.rmodel)
self.rmodel.addChainFromSegid()
self.dc = PDB2DelphiCharges( self.rmodel )
self.dc.prepare()
self.assertEqual( len(self.dc.resmap['LYS']), 2 ) # normal and N'
self.assertEqual( len(self.dc.resmap['SER']), 2 ) # normal and C'
if self.local:
T.errWriteln( 'writing delphi charge file to %s' % self.fcrg )
self.dc.tofile( self.fcrg )
self.assert_( os.path.exists( self.fcrg ) )
def test_ComplexEvolving(self):
"""Dock.ComplexEvolving test"""
import time
from Biskit.Dock import ComplexEvolving
c = t.load(t.testRoot() + '/com/ref.complex')
self.ce = ComplexEvolving(c.rec_model,
c.lig(),
c,
info={'comment': 'test'})
time.sleep(2)
lig = self.ce.lig().transform(MU.randomRotation(), [0, 0, 0])
self.ce2 = ComplexEvolving(self.ce.rec_model,
lig,
self.ce,
info={'comment': 'test2'})
if self.local:
print '\nGenerations: '
for x in self.ce2:
print x['date']
print 'Comments: ', self.ce2.valuesOf('comment')
self.assertEqual(self.ce2.valuesOf('comment'), [None, 'test', 'test2'])
def test_delphiCharges2(self):
"""
PDB2DelphiCharges test
"""
if self.local:
T.errWrite('loading PDB...')
self.m1 = self.MODEL or PDBModel(T.testRoot('lig/1A19_dry.model'))
Test.MODEL = self.m1
if self.local:
T.errWriteln('Done.')
if self.local:
T.errWrite('Adding hydrogens to model (reduce)...')
self.rmodel = Reduce(self.m1, verbose=self.local).run()
self.rmodel.xplor2amber()
if self.local:
T.errWriteln('Done.')
ac = AtomCharger()
ac.charge(self.rmodel)
self.rmodel.addChainFromSegid()
self.dc = PDB2DelphiCharges(self.rmodel)
self.dc.prepare()
self.assertEqual(len(self.dc.resmap['LYS']), 2) # normal and N'
self.assertEqual(len(self.dc.resmap['SER']), 2) # normal and C'
if self.local:
T.errWriteln('writing delphi charge file to %s' % self.fcrg)
self.dc.tofile(self.fcrg)
self.assert_(os.path.exists(self.fcrg))
def test_msms(self):
"""msms test"""
from Biskit import PDBModel
if self.local: print 'Loading PDB...'
self.m = PDBModel( T.testRoot() + '/lig/1A19.pdb' )
self.m = self.m.compress( self.m.maskProtein() )
if self.local: print 'Getting surfaces via the MSMS executable'
self.ms = MSMS( self.m, debug=self.DEBUG, verbose=self.local )
if self.local: print 'Running'
out, sesList, sasList, atmList = self.ms.run()
if self.local:
print out
print '\nResult from MSMS (first 5 lines): '
print 'SES \tSAS \tAtom name'
for i in range(5):
print '%.2f \t%.2f \t%s'%(sesList[i], sasList[i], atmList[i])
print 'MSMS done'
globals().update( locals() )
self.assertAlmostEqual( out['sas'] + out['ses'],
5085.1580000000004 + 4208.7389999999996, 8 )
def test_surfaceRacerBug(self):
"""PDBDope.addSurfaceRacer mask handling bugfix"""
import os
from Biskit import PDBModel
m = PDBModel(os.path.join(T.testRoot(), 'lig/1A19.pdb'))
d = PDBDope(m)
d.addSurfaceRacer()
def test_ComplexEvolvingList(self):
"""Dock.ComplexEvolvingList test"""
import Biskit.tools as t
from Biskit.Dock import ComplexEvolving
from Biskit.Dock import ComplexEvolvingList
## original complex
cl = t.load( t.testRoot() + "/dock/hex/complexes.cl" )
## first evolution step
c = ComplexEvolving( cl[0].rec(), cl[0].lig(), cl[0],
info={'comment':'test1'})
## second evolution step
c = ComplexEvolving( c.rec(), c.lig(), c,
info={'comment':'test2'})
## create an evolving complex list
cl = ComplexEvolvingList( [c, c] )
if self.local:
## last version of all complexes in list
print cl.valuesOf('comment')
## version 1
print cl.valuesOf('comment', version=1)
## the first complex in the list
print cl[0].valuesOf('comment')
globals().update( locals() )
self.assertEqual( (cl.valuesOf('comment'), cl[0].valuesOf('comment')),
(['test2', 'test2'], [None, 'test1', 'test2']) )
def test_delphi( self ):
"""Delphi test"""
if self.local: print 'Loading PDB...'
self.m1 = self.MODEL or PDBModel( T.testRoot( 'lig/1A19_dry.model' ) )
Test.MODEL = self.m1
self.m1.addChainFromSegid()
if self.local: print 'Starting Delphi'
self.x = Delphi( self.m1, scale=1.2, debug=self.DEBUG,
verbose=self.local, f_map=self.fmap )
if self.local:
print 'Running'
self.r = self.x.run()
if self.local:
print "Result: "
print self.r
expect = {'scharge': 1.427, 'egrid': 9091., 'ecoul': -9870,
'eself': -20420, 'erxn': -666.7}
if self.local:
print "verifying results... "
print "Note: numeric values can differ on different hardware."
for k, v in expect.items():
self.assertAlmostEqual( expect[k], self.r[k], -1 )
self.assert_(os.path.exists( self.fmap ), 'Potential map not found' )
self.assert_(os.path.getsize( self.fmap) > 1000, 'empty potential map')
def test_msms(self):
"""msms test"""
from Biskit import PDBModel
if self.local: print 'Loading PDB...'
self.m = PDBModel( T.testRoot() + '/lig/1A19.pdb' )
self.m = self.m.compress( self.m.maskProtein() )
if self.local: print 'Getting surfaces via the MSMS executable'
self.ms = MSMS( self.m, debug=self.DEBUG, verbose=self.local )
if self.local: print 'Running'
out, sesList, sasList, atmList = self.ms.run()
if self.local:
print out
print '\nResult from MSMS (first 5 lines): '
print 'SES \tSAS \tAtom name'
for i in range(5):
print '%.2f \t%.2f \t%s'%(sesList[i], sasList[i], atmList[i])
print 'MSMS done'
globals().update( locals() )
self.assertAlmostEqual( out['sas'] + out['ses'],
5085.1580000000004 + 4208.7389999999996, 8 )
def test_molTools(self):
"""molTools test"""
from Biskit import PDBModel
## Loading PDB...
self.m = PDBModel( T.testRoot() + '/lig/1A19.pdb' )
self.m = self.m.compress( self.m.maskProtein() )
hb = hbonds( self.m )
xyz = xyzOfNearestCovalentNeighbour( 40, self.m )
if self.local:
print '\nThe nearest covalently attached atom to the'
print ' atom with index 40 has the coordinates:'
print xyz
print 'Potential h-bonds in model:'
print '(donor index, acceptor index, distance and angle)'
for h in hb:
print h
globals().update( locals() )
self.r = N0.sum(N0.ravel(hb[3:5])) + N0.sum(xyz)
self.assertAlmostEqual( self.r, self.EXPECT, 3 )
def test_SurfaceRacer(self):
"""SurfaceRacer test"""
from Biskit import PDBModel
import Biskit.mathUtils as MA
if self.local: print 'Loading PDB...'
f = T.testRoot() + '/lig/1A19.pdb'
m = PDBModel(f)
m = m.compress(m.maskProtein())
if self.local: print 'Starting SurfaceRacer'
self.x = SurfaceRacer(m, 1.4, vdw_set=1, debug=self.DEBUG, verbose=0)
if self.local:
print 'Running ...'
self.r = self.x.run()
c = self.r['curvature']
ms = self.r['MS']
if self.local:
print "Curvature: weighted mean %.6f and standard deviation %.3f"\
%(MA.wMean(c,ms), MA.wSD(c,ms))
print 'Relative MS of atoms 10 to 20:', self.r['relMS'][10:20]
print 'Relative AS of atoms 10 to 20:', self.r['relAS'][10:20]
self.e = (N.sum(self.r['relMS'][10:20]), N.sum(self.r['relAS'][10:20]),
N.sum(self.r['curvature'][10:20]))
self.assertAlmostEqual(self.e, self.EXPECT)
def test():
options = defOptions()
dir = T.testRoot() + '/dock/hex/'
options['i'] = dir + 'complexes_cont.cl'
options['o'] = dir
options['v'] = ['fnac_4.5', 'fnarc_10', 'fnac_10', 'fnrc_4.5']
return options
def test_IntervorDry(self):
self.x = Intervor( self.m, [0], debug=self.DEBUG, verbose=self.local,
catch_err=1, strict=0, validate=0 )
self.x.f_prefix = T.testRoot() + '/intervor/1vfb'
self.x.finish()
def test_SurfaceRacer(self):
"""SurfaceRacer test"""
from Biskit import PDBModel
import Biskit.mathUtils as MA
if self.local: print 'Loading PDB...'
f = T.testRoot()+'/lig/1A19.pdb'
m = PDBModel(f)
m = m.compress( m.maskProtein() )
if self.local: print 'Starting SurfaceRacer'
self.x = SurfaceRacer( m, 1.4, vdw_set=1, debug=self.DEBUG, verbose=0 )
if self.local:
print 'Running ...'
self.r = self.x.run()
c= self.r['curvature']
ms= self.r['MS']
if self.local:
print "Curvature: weighted mean %.6f and standard deviation %.3f"\
%(MA.wMean(c,ms), MA.wSD(c,ms))
print 'Relative MS of atoms 10 to 20:',self.r['relMS'][10:20]
print 'Relative AS of atoms 10 to 20:',self.r['relAS'][10:20]
self.e = ( N.sum(self.r['relMS'][10:20]), N.sum(self.r['relAS'][10:20]),
N.sum(self.r['curvature'][10:20]) )
self.assertAlmostEqual( self.e, self.EXPECT )
def prepare(self):
import tempfile
import shutil
## collect the input files needed
self.outfolder = tempfile.mkdtemp('_test_Modeller')
os.mkdir(self.outfolder + '/templates')
os.mkdir(self.outfolder + '/t_coffee')
shutil.copytree(T.testRoot() + '/Mod/project/templates/modeller',
self.outfolder + '/templates/modeller')
shutil.copy(T.testRoot() + '/Mod/project/t_coffee/final.pir_aln',
self.outfolder + '/t_coffee')
shutil.copy(T.testRoot() + '/Mod/project/target.fasta', self.outfolder)
def test_Capping(self):
"""PDBCleaner.capTerminals test"""
## Loading PDB...
self.model = PDBModel(t.testRoot() + '/rec/1A2P_rec_original.pdb')
self.c = PDBCleaner(self.model, log=self.log, verbose=self.local)
self.m2 = self.c.capTerminals(breaks=True)
self.assert_(self.m2.atomNames() == self.model.atomNames())
self.m3 = self.model.clone()
self.m3.removeRes([10, 11, 12, 13, 14, 15])
self.m4 = self.m3.clone()
self.c = PDBCleaner(self.m3, log=self.log, verbose=self.local)
self.m3 = self.c.capTerminals(breaks=True, capC=[0], capN=[0, 1])
self.assertEqual(
self.m3.takeChains([0]).sequence()[:18], 'XVINTFDGVADXXKLPDN')
if self.local:
self.log.add('\nTesting automatic chain capping...\n')
self.c = PDBCleaner(self.m4, log=self.log, verbose=self.local)
self.m4 = self.c.capTerminals(auto=True)
self.assertEqual(
self.m4.takeChains([0]).sequence()[:18], 'XVINTFDGVADXXKLPDN')
def test_IntervorDry(self):
self.x = Intervor( self.m, [0], debug=self.DEBUG, verbose=self.local,
catch_err=1, strict=0, validate=0 )
self.x.f_prefix = T.testRoot() + '/intervor/1vfb'
self.x.finish()
def test_Capping( self ):
"""PDBCleaner.capTerminals test"""
## Loading PDB...
self.model = PDBModel(t.testRoot() + '/rec/1A2P_rec_original.pdb')
self.c = PDBCleaner( self.model, log=self.log, verbose=self.local )
self.m2 = self.c.capTerminals( breaks=True )
self.assert_( self.m2.atomNames() == self.model.atomNames() )
self.m3 = self.model.clone()
self.m3.removeRes( [10,11,12,13,14,15] )
self.m4 = self.m3.clone()
self.c = PDBCleaner( self.m3, log=self.log, verbose=self.local )
self.m3 = self.c.capTerminals( breaks=True, capC=[0], capN=[0,1])
self.assertEqual( self.m3.takeChains([0]).sequence()[:18],
'XVINTFDGVADXXKLPDN' )
if self.local:
self.log.add( '\nTesting automatic chain capping...\n' )
self.c = PDBCleaner( self.m4, log=self.log, verbose=self.local )
self.m4 = self.c.capTerminals( auto=True )
self.assertEqual( self.m4.takeChains([0]).sequence()[:18],
'XVINTFDGVADXXKLPDN' )
def test_hexTools(self):
"""Dock.hexTools test"""
from Biskit import PDBModel
self.m = PDBModel( t.testRoot() + '/com/1BGS.pdb' )
dist = centerSurfDist( self.m , self.m.maskCA() )
self.assertAlmostEqual( dist[0], 26.880979538, 7)
def test_ComplexEvolving(self):
"""Dock.ComplexEvolving test"""
import time
from Biskit.Dock import ComplexEvolving
c = t.load( t.testRoot() + '/com/ref.complex' )
self.ce= ComplexEvolving( c.rec_model, c.lig(), c,
info={'comment':'test'} )
time.sleep( 2 )
lig = self.ce.lig().transform( MU.randomRotation(), [0,0,0] )
self.ce2 = ComplexEvolving( self.ce.rec_model, lig, self.ce,
info={'comment':'test2'})
if self.local:
print '\nGenerations: '
for x in self.ce2:
print x['date']
print 'Comments: ', self.ce2.valuesOf('comment')
self.assertEqual( self.ce2.valuesOf('comment'),
[None, 'test', 'test2'])
def test_ComplexTraj(self):
"""Dock.ComplexTraj test"""
import Biskit.tools as T
## there is no complex trajectory in the test folder so will have
## to create a fake trajectory with a complex
f = [T.testRoot() + '/com/1BGS.pdb'] * 5
t = Trajectory(f, verbose=self.local)
t = ComplexTraj(t, recChains=[0])
#if self.local:
#print 'plotting contact density...'
#t.plotContactDensity( step=2 )
## create a fake second chain in the ligand
for i in range(1093 + 98, 1968):
t.ref.atoms['chain_id'][i] = 'B'
t.ref.chainIndex(force=1, cache=1)
t.cl = [1, 2]
r = N0.concatenate((range(1093, 1191), range(0,
1093), range(1191, 1968)))
tt = t.takeAtoms(r)
contactMat = tt.atomContacts(1)
if self.local:
print 'Receptor chains: %s Ligand chains: %s' % (t.cr, t.cl)
self.assertEqual(N0.sum(N0.ravel(contactMat)), 308)
def test_molTools(self):
"""molTools test"""
from Biskit import PDBModel
## Loading PDB...
self.m = PDBModel(T.testRoot() + '/lig/1A19.pdb')
self.m = self.m.compress(self.m.maskProtein())
hb = hbonds(self.m)
xyz = xyzOfNearestCovalentNeighbour(40, self.m)
if self.local:
print '\nThe nearest covalently attached atom to the'
print ' atom with index 40 has the coordinates:'
print xyz
print 'Potential h-bonds in model:'
print '(donor index, acceptor index, distance and angle)'
for h in hb:
print h
globals().update(locals())
self.r = N0.sum(N0.ravel(hb[3:5])) + N0.sum(xyz)
self.assertAlmostEqual(self.r, self.EXPECT, 3)
def test_hexTools(self):
"""Dock.hexTools test"""
from Biskit import PDBModel
self.m = PDBModel(t.testRoot() + '/com/1BGS.pdb')
dist = centerSurfDist(self.m, self.m.maskCA())
self.assertAlmostEqual(dist[0], 26.880979538, 7)
def test_ComplexEvolvingList(self):
"""Dock.ComplexEvolvingList test"""
import Biskit.tools as t
from Biskit.Dock import ComplexEvolving
from Biskit.Dock import ComplexEvolvingList
## original complex
cl = t.load( t.testRoot() + "/dock/hex/complexes.cl" )
## first evolution step
c = ComplexEvolving( cl[0].rec(), cl[0].lig(), cl[0],
info={'comment':'test1'})
## second evolution step
c = ComplexEvolving( c.rec(), c.lig(), c,
info={'comment':'test2'})
## create an evolving complex list
cl = ComplexEvolvingList( [c, c] )
if self.local:
## last version of all complexes in list
print cl.valuesOf('comment')
## version 1
print cl.valuesOf('comment', version=1)
## the first complex in the list
print cl[0].valuesOf('comment')
globals().update( locals() )
self.assertEqual( (cl.valuesOf('comment'), cl[0].valuesOf('comment')),
(['test2', 'test2'], [None, 'test1', 'test2']) )
def test():
options = defOptions()
dir = T.testRoot() + '/dock/hex/'
options['i'] = dir + 'complexes_cont.cl'
options['o'] = dir
options['v'] = ['fnac_4.5', 'fnarc_10', 'fnac_10', 'fnrc_4.5']
return options
def prepare(self):
import tempfile
import shutil
## collect the input files needed
self.outfolder = tempfile.mkdtemp( '_test_Modeller' )
os.mkdir( self.outfolder +'/templates' )
os.mkdir( self.outfolder +'/t_coffee' )
shutil.copytree( T.testRoot() + '/Mod/project/templates/modeller',
self.outfolder + '/templates/modeller' )
shutil.copy( T.testRoot() + '/Mod/project/t_coffee/final.pir_aln',
self.outfolder + '/t_coffee' )
shutil.copy( T.testRoot() + '/Mod/project/target.fasta',
self.outfolder )
def prepare(self):
from Biskit import PDBModel
self.f = T.testRoot() + '/com/1BGS.pdb'
self.M = PDBModel(self.f)
self.M = self.M.compress(self.M.maskProtein())
self.d = PDBDope(self.M)
def prepare(self):
from Biskit import PDBModel
self.f = T.testRoot() + '/com/1BGS.pdb'
self.M = PDBModel( self.f )
self.M = self.M.compress( self.M.maskProtein() )
self.d = PDBDope( self.M )
def test_reduce( self ):
"""AtomCharger test"""
if self.local: self.log.add('\nLoading PDB...')
self.m1 = PDBModel( T.testRoot( 'lig/1A19_dry.model' ) )
self.m2 = T.load( T.testRoot( 'com/ref.complex' ) )
self.m2 = self.m2.model()
if self.local: self.log.add('\nRunning Reduce...')
self.x = Reduce( self.m1, debug=self.DEBUG, verbose=self.local,
log=self.log,
autocap=True )
self.m1 = self.x.run()
if self.local:
self.log.add('\nReduce protein complex')
self.x = Reduce( self.m2, debug=self.DEBUG, verbose=self.local,
log=self.log,
autocap=True )
self.m2 = self.x.run()
if self.local:
self.log.add('\nSetup Residue Library\n')
ac = AtomCharger(log=self.log, verbose=self.local)
if self.local:
self.log.add('match residues to Amber topology')
ac.charge( self.m1 )
ac.charge( self.m2 )
self.assertAlmostEqual( N.sum(self.m1['partial_charge']), -6, 2 )
self.assertAlmostEqual( N.sum(self.m2['partial_charge']), -4, 2 )
self.assert_(N.all(self.m1['partial_charge'] != 0),'unmatched atoms 1')
self.assert_(N.all(self.m2['partial_charge'] != 0),'unmatched atoms 2')
if self.local:
self.log.add('\nNow test handling of atom miss-matches:\n')
self.m3 = PDBModel(self.m1.clone())
self.m3.remove( [0,3,100,101,102,200] )
ac.charge( self.m3 )
self.assertAlmostEqual( N.sum(self.m3['partial_charge']),-8.21, 2)
def test_HmmerFasta(self):
"""Hmmer test (search from fasta)"""
h = Hmmer(hmmdb=settings.hmm_db)
h.checkHmmdbIndex()
self.searchMatches, self.searchHits = h.searchHmmdb(
T.testRoot() + '/Mod/project/target.fasta')
self.assertTrue(len(self.searchHits) > 3)
def prepare(self):
from Biskit import PDBModel
import Biskit.tools as T
if not self.M:
if self.local: print "Loading PDB...",
self.M = PDBModel(T.testRoot() + '/lig/1A19.pdb')
self.M = self.M.compress(self.M.maskProtein())
if self.local: print "Done"
def test_DNACleaning( self ):
"""PDBCleaner DNA test"""
## Loading PDB...
self.c = PDBCleaner( t.testRoot() + 'amber/entropy/0_com.pdb',
log=self.log, verbose=self.local )
self.dna = self.c.process(amber=True)
self.assertAlmostEqual( self.dna.mass(), 26953.26, 1 )
def test_capping_extra( self ):
"""PDBCleaner.capTerminals extra challenge"""
self.m2 = PDBModel( t.testRoot() + '/pdbclean/foldx_citche.pdb' )
self.c = PDBCleaner( self.m2, verbose=self.local, log=self.log)
self.assertRaises(CappingError, self.c.capTerminals, auto=True)
if self.local:
self.log.add('OK: CappingError has been raised indicating clash.' )
self.assertEqual( len(self.m2.takeChains([1]).chainBreaks()), 1 )
def prepare( self ):
from Biskit import PDBModel
import Biskit.tools as T
if not self.M:
if self.local: print "Loading PDB...",
self.M = PDBModel( T.testRoot()+'/lig/1A19.pdb')
self.M = self.M.compress( self.M.maskProtein() )
if self.local: print "Done"
def test_HmmerFasta( self ):
"""Hmmer test (search from fasta)"""
h = Hmmer(hmmdb=settings.hmm_db)
h.checkHmmdbIndex()
self.searchMatches, self.searchHits = h.searchHmmdb(
T.testRoot()+'/Mod/project/target.fasta' )
self.assertTrue( len( self.searchHits ) > 3 )
def prepare(self):
import tempfile
import shutil
## collect the input files needed
self.outfolder = tempfile.mkdtemp( '_test_CheckIdentities' )
os.mkdir( self.outfolder +'/t_coffee' )
shutil.copy( T.testRoot() + '/Mod/project/t_coffee/final.pir_aln',
self.outfolder + '/t_coffee' )
