def test_Benchmark(self):
"""Mod.Benchmark test"""
from Biskit import Pymoler
self.b = Benchmark(self.outfolder)
self.b.go()
pdb = T.load(self.outfolder + "/modeller/PDBModels.list")[0]
reference = PDBModel(self.outfolder + "/reference.pdb")
tmp_model = pdb.clone()
reference = reference.compress(reference.maskCA())
pdb = pdb.compress(pdb.maskCA())
tmp_model = tmp_model.compress(tmp_model.maskCA())
tm = tmp_model.transformation(reference,
n_it=0,
profname="rms_outliers")
pdb = pdb.transform(tm)
if self.local:
pm = Pymoler()
pm.addPdb(pdb, "m")
pm.addPdb(reference, "r")
pm.colorAtoms("m", tmp_model.profile("rms_outliers"))
pm.add('set ribbon_trace,1')
pm.add('show ribbon')
pm.show()
if self.DEBUG:
self.log.add(
'The result from the benchmarking is in %s/benchmark'%\
self.outfolder)
globals().update(locals())
def test_Benchmark(self):
"""Mod.Benchmark test"""
from Biskit import Pymoler
self.b = Benchmark( self.outfolder )
self.b.go()
pdb = T.load( self.outfolder + "/modeller/PDBModels.list" )[0]
reference = PDBModel(self.outfolder + "/reference.pdb" )
tmp_model = pdb.clone()
reference = reference.compress( reference.maskCA() )
pdb = pdb.compress( pdb.maskCA() )
tmp_model = tmp_model.compress(tmp_model.maskCA())
tm = tmp_model.transformation( reference, n_it=0,
profname="rms_outliers")
pdb = pdb.transform( tm )
if self.local:
pm = Pymoler()
pm.addPdb( pdb, "m" )
pm.addPdb( reference, "r" )
pm.colorAtoms( "m", tmp_model.profile("rms_outliers") )
pm.add('set ribbon_trace,1')
pm.add('show ribbon')
pm.show()
if self.DEBUG:
self.log.add(
'The result from the benchmarking is in %s/benchmark'%\
self.outfolder)
globals().update( locals() )
def go(self, model_list = None, reference = None):
"""
Run benchmarking.
@param model_list: list of models
(default: None S{->} outFolder/L{F_PDBModels})
@type model_list: ModelList
@param reference: reference model
(default: None S{->} outFolder/L{F_INPUT_REFERENCE})
@type reference: PDBModel
"""
model_list = model_list or self.outFolder + self.F_PDBModels
reference = reference or self.outFolder + self.F_INPUT_REFERENCE
pdb_list = T.load('%s'%model_list)
reference = PDBModel(reference)
# check with python 2.4
iref, imodel = reference.compareAtoms(pdb_list[0])
mask_casting = N.zeros(len(pdb_list[0]))
N.put(mask_casting, imodel, 1)
reference = reference.take(iref)
#reference_mask_CA = reference_rmsd.maskCA()
atom_mask = N.zeros(len(pdb_list[0]))
N.put(atom_mask,imodel,1)
rmask = pdb_list[0].profile2mask("n_templates", 1,1000)
amask = pdb_list[0].res2atomMask(rmask)
mask_final_ref = N.compress(mask_casting, amask)
mask_final = mask_casting * amask
reference = reference.compress(mask_final_ref)
for i in range(len(pdb_list)):
#self.cad(reference, pdb_list[i])
pdb_list[i], pdb_wo_if = self.output_fittedStructures(\
pdb_list[i], reference, i, mask_final)
fitted_model_if = pdb_list[i].compress(mask_final)
fitted_model_wo_if = pdb_wo_if.compress(mask_final)
coord1 = reference.getXyz()
coord2 = fitted_model_if.getXyz()
aprofile = self.rmsd_res(coord1,coord2)
self.calc_rmsd(fitted_model_if, fitted_model_wo_if,
reference, pdb_list[i])
pdb_list[i].atoms.set('rmsd2ref_if', aprofile,
mask=mask_final, default = -1,
comment="rmsd to known reference structure")
self.output_rmsd_aa(pdb_list)
self.output_rmsd_ca(pdb_list)
self.output_rmsd_res(pdb_list)
self.write_PDBModels(pdb_list)
def go(self, model_list=None, reference=None):
"""
Run benchmarking.
@param model_list: list of models
(default: None S{->} outFolder/L{F_PDBModels})
@type model_list: ModelList
@param reference: reference model
(default: None S{->} outFolder/L{F_INPUT_REFERENCE})
@type reference: PDBModel
"""
model_list = model_list or self.outFolder + self.F_PDBModels
reference = reference or self.outFolder + self.F_INPUT_REFERENCE
pdb_list = T.load('%s' % model_list)
reference = PDBModel(reference)
# check with python 2.4
iref, imodel = reference.compareAtoms(pdb_list[0])
mask_casting = N0.zeros(len(pdb_list[0]))
N0.put(mask_casting, imodel, 1)
reference = reference.take(iref)
#reference_mask_CA = reference_rmsd.maskCA()
atom_mask = N0.zeros(len(pdb_list[0]))
N0.put(atom_mask, imodel, 1)
rmask = pdb_list[0].profile2mask("n_templates", 1, 1000)
amask = pdb_list[0].res2atomMask(rmask)
mask_final_ref = N0.compress(mask_casting, amask)
mask_final = mask_casting * amask
reference = reference.compress(mask_final_ref)
for i in range(len(pdb_list)):
#self.cad(reference, pdb_list[i])
pdb_list[i], pdb_wo_if = self.output_fittedStructures(\
pdb_list[i], reference, i, mask_final)
fitted_model_if = pdb_list[i].compress(mask_final)
fitted_model_wo_if = pdb_wo_if.compress(mask_final)
coord1 = reference.getXyz()
coord2 = fitted_model_if.getXyz()
aprofile = self.rmsd_res(coord1, coord2)
self.calc_rmsd(fitted_model_if, fitted_model_wo_if, reference,
pdb_list[i])
pdb_list[i].atoms.set('rmsd2ref_if',
aprofile,
mask=mask_final,
default=-1,
comment="rmsd to known reference structure")
self.output_rmsd_aa(pdb_list)
self.output_rmsd_ca(pdb_list)
self.output_rmsd_res(pdb_list)
self.write_PDBModels(pdb_list)
def randomSurfaces( base_folder, label, mask ):
"""
calculate surfaces for all peptides and return the
average and SD
"""
## container for results and standard deviations
MS, AS = {}, {}
MS_sd, AS_sd = {}, {}
## loop over peptide directories
for k in MOU.aaAtoms.keys():
dir = base_folder + 'GLY-%s-GLY_pcr/pcr_00'%(k)
fLst = glob.glob( dir + '/*.pdb')
msLst = []
asLst = []
## loop over pdb files for each peptide
T.flushPrint( '\nNow collecting data in %s'%dir )
for f in fLst:
## load peptide and remove waters and hydrogens
m = PDBModel( f )
m = m.compress( m.maskProtein() * m.maskHeavy() )
T.flushPrint( '.')
## add surface data
try:
d = PDBDope( m )
d.addSurfaceRacer( probe=1.4 )
## remove tailing GLY
m = m.compress( m.res2atomMask(mask) )
## collect surface data for each peptide
msLst += [ m.profile('MS') ]
asLst += [ m.profile('AS') ]
except:
print 'Failed calculating exposure for GLY-%s-GLY'%(k)
print '\t and file %s'%f
## get result dictionary for peptide
T.flushPrint('\nCollecting data ...\n')
msDic = {}
asDic = {}
msDic_sd = {}
asDic_sd = {}
j = 0
#atoms = [ a['name'] for a in m.atoms ]
for n in m['name']:
msDic[n] = N0.average(msLst)[j]
asDic[n] = N0.average(asLst)[j]
msDic_sd[n] = MAU.SD( msLst )[j]
asDic_sd[n] = MAU.SD( asLst )[j]
j += 1
MS[ k ] = msDic
AS[ k ] = asDic
MS_sd[ k ] = msDic_sd
AS_sd[ k ] = asDic_sd
return MS, AS, MS_sd, AS_sd
def randomSurfaces( base_folder, label, mask ):
"""
calculate surfaces for all peptides and return the
average and SD
"""
## container for results and standard deviations
MS, AS = {}, {}
MS_sd, AS_sd = {}, {}
## loop over peptide directories
for k in MOU.aaAtoms.keys():
dir = base_folder + 'GLY-%s-GLY_pcr/pcr_00'%(k)
fLst = glob.glob( dir + '/*.pdb')
msLst = []
asLst = []
## loop over pdb files for each peptide
T.flushPrint( '\nNow collecting data in %s'%dir )
for f in fLst:
## load peptide and remove waters and hydrogens
m = PDBModel( f )
m = m.compress( m.maskProtein() * m.maskHeavy() )
T.flushPrint( '.')
## add surface data
try:
d = PDBDope( m )
d.addSurfaceRacer( probe=1.4 )
## remove tailing GLY
m = m.compress( m.res2atomMask(mask) )
## collect surface data for each peptide
msLst += [ m.profile('MS') ]
asLst += [ m.profile('AS') ]
except:
print 'Failed calculating exposure for GLY-%s-GLY'%(k)
print '\t and file %s'%f
## get result dictionary for peptide
T.flushPrint('\nCollecting data ...\n')
msDic = {}
asDic = {}
msDic_sd = {}
asDic_sd = {}
j = 0
#atoms = [ a['name'] for a in m.atoms ]
for n in m['name']:
msDic[n] = N.average(msLst)[j]
asDic[n] = N.average(asLst)[j]
msDic_sd[n] = MAU.SD( msLst )[j]
asDic_sd[n] = MAU.SD( asLst )[j]
j += 1
MS[ k ] = msDic
AS[ k ] = asDic
MS_sd[ k ] = msDic_sd
AS_sd[ k ] = asDic_sd
return MS, AS, MS_sd, AS_sd
class Test( BT.BiskitTest ):
"""Test AmberParmBuilder"""
TAGS = [ BT.EXE ]
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 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 test_AmberParmMirror(self):
"""AmberParmBuilder.parmMirror test"""
ref = self.ref
mask = N.logical_not( ref.maskH2O() ) ## keep protein and Na+ ion
self.mdry = ref.compress( mask )
self.a = AmberParmBuilder( self.mdry, verbose=self.local,
leap_out=self.leapout,
debug=self.DEBUG )
self.a.parmMirror(f_out=self.dryparm,
f_out_crd=self.drycrd )
self.a.parm2pdb( self.dryparm, self.drycrd, self.drypdb )
self.m1 = PDBModel(self.drypdb)
self.m2 = PDBModel(self.refdry)
eq = N.array( self.m1.xyz == self.m2.xyz )
self.assert_( eq.all() )
def test_AmberParmSolvated( self ):
"""AmberParmBuilder.parmSolvated test"""
## remove waters and hydrogens
self.mdry = self.ref.compress( self.ref.maskProtein() )
self.mdry = self.mdry.compress( self.mdry.maskHeavy() )
self.a = AmberParmBuilder( self.mdry,
leap_out=self.leapout,
verbose=self.local, debug=self.DEBUG)
self.a.parmSolvated( self.wetparm, f_out_crd=self.wetcrd,
f_out_pdb=self.wetpdb,
box=2.5 )
self.m3 = PDBModel( self.wetpdb )
m3prot = self.m3.compress( self.m3.maskProtein() )
refprot= self.ref.compress( self.ref.maskProtein() )
refprot.xplor2amber()
self.assertEqual( self.ref.lenChains(), self.m3.lenChains() )
self.assertEqual( refprot.atomNames(), m3prot.atomNames() )
def test_capIrregular( self ):
"""AmberParmBuilder.capNME & capACE test"""
gfp = PDBModel('1GFL')
normal = gfp.takeResidues([10,11])
chromo = gfp.takeResidues([64,65])
self.a = AmberParmBuilder( normal )
self.m4 = self.a.capACE( normal, 0 )
self.assertEqual( len(self.m4), 17 )
## del chromo.residues['biomol']
self.m5 = self.a.capACE( chromo, 0 )
self.m5 = self.a.capNME( self.m5, 0 )
self.assertEqual( self.m5.sequence(), 'XSYX' )
class Test(BT.BiskitTest):
"""Test AmberParmBuilder"""
TAGS = [BT.EXE]
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 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 test_AmberParmMirror(self):
"""AmberParmBuilder.parmMirror test"""
ref = self.ref
mask = N.logical_not(ref.maskH2O()) ## keep protein and Na+ ion
self.mdry = ref.compress(mask)
self.a = AmberParmBuilder(self.mdry,
verbose=self.local,
leap_out=self.leapout,
debug=self.DEBUG)
self.a.parmMirror(f_out=self.dryparm, f_out_crd=self.drycrd)
self.a.parm2pdb(self.dryparm, self.drycrd, self.drypdb)
self.m1 = PDBModel(self.drypdb)
self.m2 = PDBModel(self.refdry)
eq = N.array(self.m1.xyz == self.m2.xyz)
self.assert_(eq.all())
def test_AmberParmSolvated(self):
"""AmberParmBuilder.parmSolvated test"""
## remove waters and hydrogens
self.mdry = self.ref.compress(self.ref.maskProtein())
self.mdry = self.mdry.compress(self.mdry.maskHeavy())
self.a = AmberParmBuilder(self.mdry,
leap_out=self.leapout,
verbose=self.local,
debug=self.DEBUG)
self.a.parmSolvated(self.wetparm,
f_out_crd=self.wetcrd,
f_out_pdb=self.wetpdb,
box=2.5)
self.m3 = PDBModel(self.wetpdb)
m3prot = self.m3.compress(self.m3.maskProtein())
refprot = self.ref.compress(self.ref.maskProtein())
refprot.xplor2amber()
self.assertEqual(self.ref.lenChains(), self.m3.lenChains())
self.assertEqual(refprot.atomNames(), m3prot.atomNames())
def test_capIrregular(self):
"""AmberParmBuilder.capNME & capACE test"""
gfp = PDBModel('1GFL')
normal = gfp.takeResidues([10, 11])
chromo = gfp.takeResidues([64, 65])
self.a = AmberParmBuilder(normal)
self.m4 = self.a.capACE(normal, 0)
self.assertEqual(len(self.m4), 17)
## del chromo.residues['biomol']
self.m5 = self.a.capACE(chromo, 0)
self.m5 = self.a.capNME(self.m5, 0)
self.assertEqual(self.m5.sequence(), 'XSYX')
class Test(BT.BiskitTest):
"""Test AmberParmBuilder"""
TAGS = [BT.EXE]
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 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 test_AmberParmMirror(self):
"""AmberParmBuilder.parmMirror test"""
ref = self.ref
mask = N0.logical_not(ref.maskH2O()) ## keep protein and Na+ ion
self.mdry = ref.compress(mask)
self.a = AmberParmBuilder(self.mdry,
verbose=self.local,
leap_out=self.leapout,
debug=self.DEBUG)
self.a.parmMirror(f_out=self.dryparm, f_out_crd=self.drycrd)
self.a.parm2pdb(self.dryparm, self.drycrd, self.drypdb)
self.m1 = PDBModel(self.drypdb)
self.m2 = PDBModel(self.refdry)
eq = N0.array(self.m1.xyz == self.m2.xyz)
self.assert_(eq.all())
def test_AmberParmSolvated(self):
"""AmberParmBuilder.parmSolvated test"""
## remove waters and hydrogens
self.mdry = self.ref.compress(self.ref.maskProtein())
self.mdry = self.mdry.compress(self.mdry.maskHeavy())
self.a = AmberParmBuilder(self.mdry,
leap_out=self.leapout,
verbose=self.local,
debug=self.DEBUG)
self.a.parmSolvated(self.wetparm,
f_out_crd=self.wetcrd,
f_out_pdb=self.wetpdb,
box=2.5)
self.m3 = PDBModel(self.wetpdb)
m3prot = self.m3.compress(self.m3.maskProtein())
refprot = self.ref.compress(self.ref.maskProtein())
refprot.xplor2amber()
self.assertEqual(self.ref.lenChains(), self.m3.lenChains())
self.assertEqual(refprot.atomNames(), m3prot.atomNames())
