def test_feature_hbond(self):
"""Check hydrogen bond features"""
env = self.get_environ()
mlib = self.get_mdt_library()
mlib.hbond_classes.read("data/atmcls-hbda.lib")
donor = mdt.features.HydrogenBondDonor(mlib, mdt.uniform_bins(7, 1.0, 1.0))
accep = mdt.features.HydrogenBondAcceptor(mlib, mdt.uniform_bins(7, 1.0, 1.0))
totchg = mdt.features.HydrogenBondCharge(mlib, mdt.uniform_bins(9, 1.0, 1.0))
satisf = mdt.features.HydrogenBondSatisfaction(mlib, mdt.uniform_bins(100, 0.0, 10.0))
self.assertRaises(mdt.MDTError, mlib.hbond_classes.read, "data/atmcls-hbda.lib")
m = mdt.Table(mlib, features=donor)
m2 = mdt.Table(mlib, features=accep)
m3 = mdt.Table(mlib, features=satisf)
m4 = mdt.Table(mlib, features=totchg)
aln = modeller.alignment(env, file="test/data/alignment.ali")
m.add_alignment(aln)
m2.add_alignment(aln)
m3.add_alignment(aln)
m4.add_alignment(aln)
self.assertInTolerance(m[0], 295.0, 0.0005)
self.assertInTolerance(m[1], 139.0, 0.0005)
self.assertEqual(m[-1], 349.0)
self.assertInTolerance(m2[0], 236.0, 0.0005)
self.assertInTolerance(m2[1], 223.0, 0.0005)
self.assertEqual(m2[-1], 168.0)
self.assertInTolerance(m3[0], 1.0, 0.0005)
self.assertInTolerance(m3[1], 0.0, 0.0005)
self.assertEqual(m3[-1], 0.0)
self.assertInTolerance(m4[0], 78.0, 0.0005)
self.assertInTolerance(m4[1], 24.0, 0.0005)
self.assertEqual(m4[-1], 739.0)
# Exercise writing of hbond information to HDF5 files:
for t in (m, m2, m3, m4):
t.write_hdf5("test.hdf5")
os.unlink("test.hdf5")
def test_feature_sidechain_biso(self):
"""Check average sidechain Biso feature"""
env = self.get_environ()
mlib = self.get_mdt_library()
self.assertRaises(ValueError, mdt.features.SidechainBiso, mlib, bins=mdt.uniform_bins(5, 0, 10), protein=3)
sidechain_biso = mdt.features.SidechainBiso(mlib, bins=mdt.uniform_bins(5, 0, 10))
mdl = modeller.model(env)
mdl.build_sequence("A")
aln = modeller.alignment(env)
aln.append_model(mdl, align_codes="test")
s = aln[0]
# Mainchain atom Biso should be ignored:
for mainchain in ("N:1", "C:1", "O:1", "OXT:1", "CA:1"):
s.atoms[mainchain].biso = 1000
for (biso, bin) in (
(22, 2),
(32, 3), # Map regular values to bins
(0, -1), # Zero Biso should be "undefined"
(1, 3),
): # Biso < 2 is multiplied by 4pi^2
s.atoms["CB:1"].biso = biso
m = mdt.Table(mlib, features=sidechain_biso)
m.add_alignment(aln)
self.assertEqual(m.shape, (6,))
self.assertEqual(m.sum(), 1)
self.assertEqual(m[bin], 1)
def test_feature_resind_diff(self):
"""Test the residue index difference feature"""
env = self.get_environ()
mlib = self.get_mdt_library()
diff = mdt.features.ResidueIndexDifference(mlib, bins=mdt.uniform_bins(21, -10, 1))
absdiff = mdt.features.ResidueIndexDifference(mlib, absolute=True, bins=mdt.uniform_bins(21, -10, 1))
aln = modeller.alignment(env, file="test/data/alignment.ali", align_codes="5fd1")
m1 = mdt.Table(mlib, features=diff)
m2 = mdt.Table(mlib, features=absdiff)
self.assertEqual(m1.symmetric, False)
self.assertEqual(m2.symmetric, True)
m1.add_alignment(aln, residue_span_range=(-999, -2, 2, 999))
m2.add_alignment(aln, residue_span_range=(-999, -2, 2, 999))
self.assertEqual(m1.sum(), 10920)
self.assertEqual(m2.sum(), 5460)
# span range should result in 0, +/- 1 bins being zero:
for m in (m1, m2):
self.assertEqual(m[9], 0.0)
self.assertEqual(m[10], 0.0)
self.assertEqual(m[11], 0.0)
# Non-absolute feature should have other bins symmetrically distributed:
for i in range(9):
self.assertEqual(m1[i], m[-2 - i])
# Absolute feature should have no negative values:
for i in range(9):
self.assertEqual(m2[i], 0.0)
def test_disulfide(self):
"""Test handling of disulfide bonds"""
mlib = self.get_all_libraries()
bsep = mdt.features.AtomBondSeparation(mlib,
bins=mdt.uniform_bins(20, 0, 1.0))
bsep_ss = mdt.features.AtomBondSeparation(mlib,
bins=mdt.uniform_bins(20, 0, 1.0),
disulfide=True)
env = self.get_environ()
mdl = modeller.model(env)
mdl.build_sequence('CC')
# When SG-SG distance is small enough, an extra bond
# (separation feature = 1) should be detected, but only with
# disulfide=True
for (dist, num) in [(2.6, 11.0), (2.4, 12.0)]:
sg1 = mdl.residues[0].atoms['SG']
sg2 = mdl.residues[1].atoms['SG']
sg1.x = sg1.y = sg1.z = 0.
sg2.x = sg2.y = 0.
sg2.z = dist
a = modeller.alignment(env)
a.append_model(mdl, atom_files='test', align_codes='test')
m = mdt.Table(mlib, features=bsep)
m.add_alignment(a, residue_span_range=(-999,0,0,999))
self.assertEqual(m[1], 11.0)
m2 = mdt.Table(mlib, features=bsep_ss)
m2.add_alignment(a, residue_span_range=(-999,0,0,999))
self.assertEqual(m2[1], num)
def test_feature_triplet_type(self):
"""Check triplet type features"""
env = self.get_environ()
mlib = self.get_mdt_library()
mlib.tuple_classes.read("data/trpcls.lib")
tuple_type = mdt.features.TupleType(mlib)
tuple_type2 = mdt.features.TupleType(mlib, pos2=True)
tuple_dist = mdt.features.TupleDistance(mlib, bins=mdt.uniform_bins(9, 2.0, 0.2))
tuple_angle1 = mdt.features.TupleAngle1(mlib, bins=mdt.uniform_bins(6, 0, 30.0))
tuple_dihed1 = mdt.features.TupleDihedral1(mlib, bins=mdt.uniform_bins(6, -180, 60.0))
tuple_dihed2 = mdt.features.TupleDihedral2(mlib, bins=mdt.uniform_bins(6, -180, 60.0))
tuple_dihed3 = mdt.features.TupleDihedral3(mlib, bins=mdt.uniform_bins(6, -180, 60.0))
self.assertRaises(mdt.MDTError, mlib.tuple_classes.read, "data/trpcls.lib")
m1 = mdt.Table(mlib, features=tuple_type)
m2 = mdt.Table(mlib, features=tuple_type2)
m3 = mdt.Table(mlib, features=tuple_dist)
m4 = mdt.Table(mlib, features=tuple_angle1)
m5 = mdt.Table(mlib, features=tuple_dihed1)
m6 = mdt.Table(mlib, features=tuple_dihed2)
m7 = mdt.Table(mlib, features=tuple_dihed3)
aln = modeller.alignment(env, file="test/data/tiny.ali")
for m in (m1, m2, m3, m4, m5, m6, m7):
m.add_alignment(aln, residue_span_range=(-9999, 0, 0, 9999))
self.assertInTolerance(m1[0], 1.0, 0.0005)
self.assertInTolerance(m1[1], 0.0, 0.0005)
self.assertInTolerance(m1[2], 1.0, 0.0005)
self.assertEqual(m1.shape, (236,))
self.assertEqual(m1[-1], 0.0)
self.assertInTolerance(m2[0], 60.0, 0.0005)
self.assertInTolerance(m2[1], 0.0, 0.0005)
self.assertInTolerance(m2[2], 60.0, 0.0005)
self.assertEqual(m2.shape, (236,))
self.assertEqual(m2[-1], 0.0)
self.assertInTolerance(m3[0], 0.0, 0.0005)
self.assertInTolerance(m3[1], 82.0, 0.0005)
self.assertInTolerance(m3[2], 226.0, 0.0005)
self.assertEqual(m3.shape, (10,))
self.assertInTolerance(m3[-1], 3018.0, 0.0005)
self.assertInTolerance(m4[0], 479.0, 0.0005)
self.assertInTolerance(m4[1], 806.0, 0.0005)
self.assertInTolerance(m4[2], 471.0, 0.0005)
self.assertEqual(m4.shape, (7,))
self.assertEqual(m4[-1], 0.0)
self.assertInTolerance(m5[0], 556.0, 0.0005)
self.assertInTolerance(m5[1], 642.0, 0.0005)
self.assertInTolerance(m5[2], 470.0, 6.0005)
self.assertEqual(m5.shape, (7,))
self.assertInTolerance(m5[-1], 180.0, 0.0005)
self.assertInTolerance(m6[0], 661.0, 0.0005)
self.assertInTolerance(m6[1], 520.0, 0.0005)
self.assertInTolerance(m6[2], 545.0, 6.0005)
self.assertEqual(m6.shape, (7,))
self.assertInTolerance(m6[-1], 112.0, 0.0005)
self.assertInTolerance(m7[0], 661.0, 0.0005)
self.assertInTolerance(m7[1], 520.0, 0.0005)
self.assertInTolerance(m7[2], 545.0, 6.0005)
self.assertEqual(m7.shape, (7,))
self.assertInTolerance(m7[-1], 112.0, 0.0005)
def test_feature_combination(self):
"""Check that invalid feature combinations are rejected"""
mlib = self.get_mdt_library()
atmdist = mdt.features.AtomDistance(mlib,
bins=mdt.uniform_bins(60, 0, 0.5))
resdist = mdt.features.ResidueDistance(mlib, protein=1,
bins=mdt.uniform_bins(7, 0, 2.0))
self.assertRaises(ValueError, self.get_test_mdt, mlib,
features=(resdist,atmdist))
def test_bond_span_range(self):
"""Test bond_span_range argument"""
env = self.get_environ()
mdl = model(env)
mdl.build_sequence('A')
aln = alignment(env)
aln.append_model(mdl, align_codes='test')
mlib = self.get_mdt_library()
mlib.bond_classes.read('data/bndgrp.lib')
dist = mdt.features.AtomDistance(mlib,
bins=mdt.uniform_bins(60, 0, 0.5))
# Only 4 direct chemical bonds (N-CA, CA-CB, CA-C, C-O) in ALA; note
# that bond library does not include OXT so C-OXT interaction is
# excluded
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, bond_span_range=(1,1),
residue_span_range=(0,0,0,0))
self.assertEqual(m.sample_size, 4.0)
# Only 2 dihedrals (N-CA-C-O, O-C-CA-CB)
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, bond_span_range=(3,3),
residue_span_range=(0,0,0,0))
self.assertEqual(m.sample_size, 2.0)
# 4 bonds, 4 angles and 2 dihedrals: 10 in total
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, bond_span_range=(1,3),
residue_span_range=(0,0,0,0))
self.assertEqual(m.sample_size, 10.0)
# Check for bonds between residues (just the N-C bond here)
mdl = model(env)
mdl.build_sequence('AA')
aln = alignment(env)
aln.append_model(mdl, align_codes='test')
# Force a non-symmetric scan (to check handling of bond separation
# regardless of which order atom indices are in)
diff = mdt.features.ResidueIndexDifference(mlib,
bins=mdt.uniform_bins(21, -10, 1))
m = mdt.Table(mlib, features=(dist,diff))
m.add_alignment(aln, bond_span_range=(0,1),
residue_span_range=(-10,-1,1,10))
self.assertEqual(m.sample_size, 2.0)
# Bonds never span chains
mdl = model(env)
mdl.build_sequence('A/A')
aln = alignment(env)
aln.append_model(mdl, align_codes='test')
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, bond_span_range=(0,99999),
residue_span_range=(-10,-1,1,10))
self.assertEqual(m.sample_size, 0.0)
def test_feature_alpha_content(self):
"""Check alpha content feature"""
env = self.get_environ()
mlib = self.get_mdt_library()
self.assertRaises(ValueError, mdt.features.AlphaContent, mlib, bins=mdt.uniform_bins(10, 0, 0.1), protein=3)
alpha = mdt.features.AlphaContent(mlib, bins=mdt.uniform_bins(10, 0, 0.1))
for (alnfile, bin) in (("tiny.ali", 0), ("alignment.ali", 5)):
m = mdt.Table(mlib, features=alpha)
a = modeller.alignment(env, file=os.path.join("test", "data", alnfile))
m.add_alignment(a)
self.assertEqual(m.shape, (11,))
self.assertEqual(m.sum(), 1)
self.assertEqual(m[bin], 1)
def test_write_2dsplinelib(self):
"""Test the write_2dsplinelib function"""
mlib = self.get_mdt_library()
restype = mdt.features.ResidueType(mlib)
phi = mdt.features.PhiDihedral(mlib,
bins=mdt.uniform_bins(18, -180.0, 40.0))
psi = mdt.features.PsiDihedral(mlib,
bins=mdt.uniform_bins(18, -180.0, 40.0))
m = self.get_test_mdt(mlib, [restype, phi, psi])
mdt.write_2dsplinelib(open('test.out', 'w'), m)
# Make sure that valid Python code was produced
code = compile(open('test.out').read(), 'test.out', 'exec')
os.unlink('test.out')
def test_feature_dihedral_type(self):
"""Check dihedral type features"""
env = self.get_environ()
mlib = self.get_mdt_library()
mlib.dihedral_classes.read("data/impgrp.lib")
dihedtype = mdt.features.DihedralType(mlib)
dihedral = mdt.features.Dihedral(mlib, bins=mdt.uniform_bins(288, -180, 1.25))
self.assertRaises(mdt.MDTError, mlib.dihedral_classes.read, "data/impgrp.lib")
m = mdt.Table(mlib, features=dihedtype)
m2 = mdt.Table(mlib, features=dihedral)
aln = modeller.alignment(env, file="test/data/alignment.ali")
m.add_alignment(aln)
m2.add_alignment(aln)
self.assertInTolerance(m[0], 7.0, 0.0005)
self.assertInTolerance(m[2], 9.0, 0.0005)
self.assertInTolerance(m[4], 11.0, 0.0005)
self.assertEqual(m.shape, (79,))
self.assertEqual(m[-1], 0.0)
self.assertInTolerance(m2[143], 60.0, 1.0005)
self.assertInTolerance(m2[144], 53.0, 1.0005)
self.assertInTolerance(m2[145], 24.0, 0.0005)
self.assertEqual(m2.shape, (289,))
self.assertEqual(m2[-1], 0.0)
# Exercise writing of dihedral class information to HDF5 files:
m.write_hdf5("test.hdf5")
os.unlink("test.hdf5")
def test_tuple_pair_bond_span_range(self):
"""Test bond_span_range with tuple pair scan"""
env = self.get_environ()
mdl = model(env)
mdl.build_sequence('A')
aln = alignment(env)
aln.append_model(mdl, align_codes='test')
mlib = self.get_mdt_library()
mlib.bond_classes.read('data/bndgrp.lib')
mlib.tuple_classes.read('data/trpcls.lib')
typ = mdt.features.TupleType(mlib)
typ2 = mdt.features.TupleType(mlib, pos2=True)
dist = mdt.features.TupleDistance(mlib,
bins=mdt.uniform_bins(9, 2.0, 0.2))
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, residue_span_range=(0,0,0,0))
self.assertEqual(m.sample_size, 10.0)
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, bond_span_range=(1,1),
residue_span_range=(0,0,0,0))
# Bond span should restrict interactions to 6
# (C:CA:CB-CA:C:O, CA:C:O-N:CA:C, CA:C:O-N:CA:CB, and the reverse)
self.assertEqual(m.sample_size, 6.0)
def test_chain_span_range(self):
"""Test chain_span_range argument"""
env = self.get_environ()
mdl = model(env)
mdl.build_sequence('G/G')
aln = alignment(env)
aln.append_model(mdl, align_codes='test')
mlib = self.get_mdt_library()
mlib.tuple_classes.read('data/dblcls.lib')
tuple_dist = mdt.features.TupleDistance(mlib,
bins=mdt.uniform_bins(49, 2.0, 0.2))
# All chain differences should be out of range, so this MDT should
# end up empty:
m = mdt.Table(mlib, features=tuple_dist)
m.add_alignment(aln, chain_span_range=(-999, -999, 999, 999),
residue_span_range=(-999, 0, 0, 999))
self.assertEqual(m.sum(), 0.0)
# Default chain separation should allow intra-chain interactions, so
# should yield more (56) than only allowing inter-chain
# interactions (32)
m = mdt.Table(mlib, features=tuple_dist)
m.add_alignment(aln, residue_span_range=(-999, 0, 0, 999))
self.assertEqual(m.sum(), 56.0)
m = mdt.Table(mlib, features=tuple_dist)
m.add_alignment(aln, chain_span_range=(-999, -1, 1, 999),
residue_span_range=(-999, 0, 0, 999))
self.assertEqual(m.sum(), 32.0)
def test_bond_span_range_disulfide(self):
"""Test bond_span_range argument with disulfides"""
env = self.get_environ()
mdl = model(env)
mdl.read('1HEL.pdb')
aln = alignment(env)
aln.append_model(mdl, align_codes='test')
mlib = self.get_mdt_library()
mlib.bond_classes.read('data/bndgrp.lib')
dist = mdt.features.AtomDistance(mlib,
bins=mdt.uniform_bins(60, 0, 0.5))
# Four disulfide bond in this structure
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, bond_span_range=(1,1),
residue_span_range=(-9999,0,0,9999))
m2 = mdt.Table(mlib, features=dist)
m2.add_alignment(aln, bond_span_range=(1,1),
residue_span_range=(-9999,0,0,9999), disulfide=True)
self.assertEqual(m2.sample_size-m.sample_size, 4.0)
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln, bond_span_range=(3,3),
residue_span_range=(-9999,0,0,9999))
m2 = mdt.Table(mlib, features=dist)
m2.add_alignment(aln, bond_span_range=(3,3),
residue_span_range=(-9999,0,0,9999), disulfide=True)
self.assertEqual(m2.sample_size-m.sample_size, 12.0)
def test_symmetric(self):
"""Test symmetric/asymmetric residue pair features"""
env = self.get_environ()
mlib = self.get_mdt_library()
bins = mdt.uniform_bins(10, 0, 1.0)
dist = mdt.features.ResidueDistance(mlib, bins)
avresacc = mdt.features.AverageResidueAccessibility(mlib, bins)
avndif = mdt.features.AverageNeighborhoodDifference(mlib, bins)
diff = mdt.features.ResidueIndexDifference(mlib, bins)
ddist = mdt.features.ResidueDistanceDifference(mlib, bins)
avgapdist = mdt.features.AverageGapDistance(mlib, bins)
sym_features = (avndif, avresacc, avgapdist)
asym_features = (dist, ddist, diff)
for a in sym_features:
m = mdt.Table(mlib, features=a)
self.assertEqual(m.symmetric, True)
for a in asym_features:
m = mdt.Table(mlib, features=a)
self.assertEqual(m.symmetric, False)
# Combinations are only symmetric if all features are symmetric:
for (a, b, symm) in (
(sym_features[0], sym_features[1], True),
(asym_features[0], asym_features[1], False),
(sym_features[0], asym_features[0], False),
):
m = mdt.Table(mlib, features=(a, b))
self.assertEqual(m.symmetric, symm)
def test_feature_iresol(self):
"""Check resolution features"""
env = self.get_environ()
mlib = self.get_mdt_library()
bins = mdt.uniform_bins(3, -1.0, 1.5)
xray0 = mdt.features.XRayResolution(mlib, bins, protein=0)
xray0_nmr = mdt.features.XRayResolution(mlib, bins, protein=0, nmr=1.0)
xray1 = mdt.features.XRayResolution(mlib, bins, protein=1)
xray2 = mdt.features.XRayResolution(mlib, bins, protein=2)
# Check valid range for protein argument
for p in (-1, 3):
self.assertRaises(ValueError, mdt.features.XRayResolution, mlib, bins, protein=p)
m = self.get_test_mdt(mlib, features=xray0)
m2 = self.get_test_mdt(mlib, features=xray1)
self.assertEqual(m.shape, (4,))
self.assertEqual([b for b in m], [0.0, 1.0, 1.0, 0.0])
self.assertMDTDataEqual(m, m2)
for (code, feat, bin) in (
("bin0", xray0, 0),
("bin0", xray0_nmr, 1),
("bin1", xray0, 1),
("bin2", xray0, 2),
("undef1", xray0, 3),
("undef2", xray0, 3),
):
m = mdt.Table(mlib, features=feat)
aln = modeller.alignment(env, file="test/data/resol.ali", align_codes=code)
m.add_alignment(aln)
self.assertEqual(m[bin], 1.0)
def test_external(self):
"""Check bond separation feature between residues"""
mlib = self.get_all_libraries()
attyp1 = mdt.features.AtomType(mlib)
attyp2 = mdt.features.AtomType(mlib, pos2=True)
bsep = mdt.features.AtomBondSeparation(mlib,
bins=mdt.uniform_bins(20, 0, 1.0))
m = self.build_mdt_from_sequence(mlib, [attyp1, attyp2, bsep],
'ARN', residue_span_range=(-999,-1,1,999))
atom_types = {}
for n, b in enumerate(m.features[0].bins):
atom_types[b.symbol] = n
def assertBondSep(at1, at2, numbond, sep):
bins = [b for b in m[atom_types[at1]][atom_types[at2]]]
self.assertEqual(sum(bins), numbond)
self.assertEqual(bins[sep], numbond)
# Check known bond separations between adjacent residues
assertBondSep('AN', 'RN', numbond=1, sep=3)
assertBondSep('AC', 'RN', numbond=1, sep=1)
# Check known bond separations between non-adjacent residues
assertBondSep('AN', 'NN', numbond=1, sep=6)
assertBondSep('AN', 'NC', numbond=1, sep=8)
assertBondSep('ACB', 'NCG', numbond=1, sep=9)
def test_add(self):
"""Check adding MDTs"""
mlib = self.get_mdt_library()
bins = mdt.uniform_bins(3, -1.0, 1.5)
xray0 = mdt.features.XRayResolution(mlib, bins, protein=0)
xray1 = mdt.features.XRayResolution(mlib, bins, protein=1)
m1 = mdt.Table(mlib, features=xray0)
for (n, val) in enumerate((1,2,3,4)):
m1[n] = val
m2 = mdt.Table(mlib, features=xray0)
for (n, val) in enumerate((10,20,30,40)):
m2[n] = val
m3 = m1 + m2
m1 += m2
self.assertMDTsEqual(m1, m3)
for (n, val) in enumerate((11,22,33,44)):
self.assertEqual(m3[n], val)
# Cannot add if numbers of features are different
badmdt = mdt.Table(mlib, features=(xray0, xray1))
self.assertRaises(ValueError, m1.__add__, badmdt)
# Cannot add if feature types are different
badmdt = mdt.Table(mlib, features=xray1)
self.assertRaises(ValueError, m1.__add__, badmdt)
# Cannot add if starts are different
badmdt = m2.reshape(features=xray0, offset=1, shape=0)
self.assertRaises(ValueError, m1.__add__, badmdt)
# Cannot add if nbins are different
badmdt = m2.reshape(features=xray0, offset=0, shape=-1)
self.assertRaises(ValueError, m1.__add__, badmdt)
def test_integrate(self):
"""Make sure MDT integration works"""
env = self.get_environ()
mlib = self.get_mdt_library()
restyp0 = mdt.features.ResidueType(mlib, protein=0)
restyp1 = mdt.features.ResidueType(mlib, protein=1)
chi1 = mdt.features.Chi1Dihedral(mlib,
mdt.uniform_bins(36, -180, 10))
m1 = mdt.Table(mlib, features=restyp0)
m2 = mdt.Table(mlib, features=restyp1)
mboth = mdt.Table(mlib, features=(restyp0,restyp1))
seq1 = "AFVVTDNCIK"
seq2 = "DCVEVCPVDC"
aln = alignment(env)
aln.append_sequence(seq1)
aln.append_sequence(seq2)
for m in (m1, m2, mboth):
m.add_alignment(aln)
# Number of features must be correct:
for features in ((), (restyp0,restyp1), (restyp0,restyp1,chi1)):
self.assertRaises(ValueError, mboth.integrate, features=features)
# Features must exist in input MDT:
self.assertRaises(ValueError, mboth.integrate, features=chi1)
m1int = mboth.integrate(features=restyp0)
self.assertMDTsEqual(m1, m1int)
m2int = mboth.integrate(features=restyp1)
self.assertMDTsEqual(m2, m2int)
def test_feature_residue_distance_difference(self):
"""Check residue-residue distance difference feature"""
env = self.get_environ()
mlib = self.get_mdt_library()
ddist = mdt.features.ResidueDistanceDifference(mlib, bins=mdt.uniform_bins(20, -10, 1))
aln = modeller.alignment(env, file="test/data/struc-struc.ali")
m = mdt.Table(mlib, features=ddist)
m.add_alignment(aln)
self.assertEqual(m[9], 20)
self.assertEqual(m[10], 20)
self.assertEqual(sum([b for b in m]), 40)
self.assertEqual(m[-1], 0)
# Undefined (-999) coordinates in either structure should put
# features in the undefined bin
oldx = aln[0].residues[0].atoms["CA"].x
aln[0].residues[0].atoms["CA"].x = -999
m = mdt.Table(mlib, features=ddist)
m.add_alignment(aln)
self.assertEqual(m[-1], 16)
aln[0].residues[0].atoms["CA"].x = oldx
aln[1].residues[0].atoms["CA"].x = -999
m = mdt.Table(mlib, features=ddist)
m.add_alignment(aln)
self.assertEqual(m[-1], 16)
def test_feature_angle_type(self):
"""Check angle type features"""
env = self.get_environ()
mlib = self.get_mdt_library()
mlib.angle_classes.read("data/anggrp.lib")
angletype = mdt.features.AngleType(mlib)
angle = mdt.features.Angle(mlib, bins=mdt.uniform_bins(288, 0.0, 0.625))
self.assertRaises(mdt.MDTError, mlib.angle_classes.read, "data/anggrp.lib")
m = mdt.Table(mlib, features=angletype)
m2 = mdt.Table(mlib, features=angle)
aln = modeller.alignment(env, file="test/data/alignment.ali")
m.add_alignment(aln)
m2.add_alignment(aln)
self.assertInTolerance(m[0], 7.0, 0.0005)
self.assertInTolerance(m[7], 9.0, 0.0005)
self.assertInTolerance(m[15], 11.0, 0.0005)
self.assertEqual(m.shape, (236,))
self.assertEqual(m[-1], 0.0)
self.assertInTolerance(m2[176], 48.0, 1.0005)
self.assertInTolerance(m2[177], 42.0, 0.0005)
self.assertInTolerance(m2[178], 38.0, 0.0005)
self.assertEqual(m2.shape, (289,))
self.assertEqual(m2[-1], 0.0)
# Exercise writing of angle class information to HDF5 files:
m.write_hdf5("test.hdf5")
os.unlink("test.hdf5")
def test_abstract(self):
"""Should not be able to instantiate abstract features"""
env = self.get_environ()
mlib = self.get_mdt_library()
bins = mdt.uniform_bins(10, 0, 1.0)
for feat in [
mdt.features.Protein,
mdt.features.ProteinPair,
mdt.features.Residue,
mdt.features.ResiduePair,
mdt.features.AlignedResidue,
mdt.features.AlignedResiduePair,
mdt.features.Atom,
mdt.features.AtomPair,
mdt.features.Tuple,
mdt.features.TuplePair,
mdt.features.ChemicalBond,
]:
self.assertRaises(TypeError, feat, mlib, bins)
for feat in [
mdt.features.ResidueFixedBins,
mdt.features.AtomFixedBins,
mdt.features.TupleFixedBins,
mdt.features.ChemicalBondFixedBins,
]:
self.assertRaises(TypeError, feat, mlib)
def test_feature_resacc(self):
"""Check residue accessibility features"""
mlib = self.get_mdt_library()
bins = mdt.uniform_bins(30, 0.0, 5.0)
resacc = mdt.features.ResidueAccessibility(mlib, bins)
avresacc = mdt.features.AverageResidueAccessibility(mlib, bins=mdt.uniform_bins(10, 0, 15))
m = self.get_test_mdt(mlib, features=resacc)
self.assertEqual(m.shape, (31,))
self.assertInTolerance(m[0], 24.0, 1.0005)
self.assertInTolerance(m[1], 10.0, 2.0005)
self.assertInTolerance(m[2], 4.0, 1.0005)
self.assertEqual(m[-1], 0.0)
m = self.get_test_mdt(mlib, features=avresacc)
self.assertEqual(m.shape, (11,))
self.assertInTolerance(m[0], 988.0, 10.0005)
self.assertInTolerance(m[1], 1379.0, 10.0005)
self.assertInTolerance(m[2], 1317.0, 10.0005)
def test_feature_residue_distance(self):
"""Check residue-residue distance feature"""
env = self.get_environ()
mlib = self.get_mdt_library()
dist = mdt.features.ResidueDistance(mlib, bins=mdt.uniform_bins(7, 0, 2.0))
aln = modeller.alignment(env, file="test/data/tiny.ali")
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln)
self.assertEqual([b for b in m], [0, 0, 0, 8, 2, 4, 4, 2])
def test_feature_radius_gyration(self):
"""Check radius of gyration feature"""
mlib = self.get_mdt_library()
rgyr = mdt.features.RadiusOfGyration(mlib, mdt.uniform_bins(45, 5.0, 1.0))
m = self.get_test_mdt(mlib, features=rgyr)
self.assertEqual(m[7], 1.0)
for (n, bin) in enumerate(m):
if n != 7:
self.assertEqual(bin, 0.0)
def test_feature_alpha_dihedral(self):
"""Check alpha dihedral feature"""
mlib = self.get_mdt_library()
alpha = mdt.features.AlphaDihedral(mlib, mdt.uniform_bins(36, -180, 10))
m = self.get_test_mdt(mlib, features=alpha)
self.assertEqual(m.shape, (37,))
self.assertInTolerance(m[30], 3.0, 0.0005)
self.assertInTolerance(m[31], 4.0, 0.0005)
self.assertInTolerance(m[32], 2.0, 0.0005)
def test_feature_check(self):
"""When rereading MDTs, features should be the same"""
mlib = self.get_mdt_library()
feat = mdt.features.AtomDistance(mlib, mdt.uniform_bins(10, 0, 1))
m = mdt.Table(mlib, features=feat)
m.write(file='test.mdt')
m.write_hdf5(file='test.hdf5')
# Different feature type, same bins should fail:
mlib = self.get_mdt_library()
feat = mdt.features.ResidueDistance(mlib, mdt.uniform_bins(10, 0, 1))
for f in ('test.mdt', 'test.hdf5'):
self.assertRaises(mdt.MDTError, mdt.Table, mlib, file=f)
# Same feature type, different number of bins should fail:
mlib = self.get_mdt_library()
feat = mdt.features.AtomDistance(mlib, mdt.uniform_bins(20, 0, 1))
for f in ('test.mdt', 'test.hdf5'):
self.assertRaises(mdt.MDTError, mdt.Table, mlib, file=f)
os.unlink('test.mdt')
os.unlink('test.hdf5')
def test_feature_distance(self):
"""Check atom-atom distance feature"""
mlib = self.get_mdt_library()
dist = mdt.features.AtomDistance(mlib, bins=mdt.uniform_bins(60, 0, 0.5))
m = self.get_test_mdt(mlib, features=dist)
self.assertEqual(m.shape, (61,))
self.assertInTolerance(m[30], 10057.0, 0.0005)
self.assertInTolerance(m[31], 10214.0, 0.0005)
self.assertInTolerance(m[32], 10095.0, 0.0005)
self.assertInTolerance(m[-1], 4892.0, 0.0005)
def test_feature_seqlen(self):
"""Check sequence length feature"""
env = self.get_environ()
mlib = self.get_mdt_library()
seqlen = mdt.features.SequenceLength(mlib, bins=mdt.uniform_bins(49, 0, 5))
m = self.get_test_mdt(mlib, features=seqlen)
self.assertEqual(m.shape, (50,))
self.assertEqual(m[10], 1.0)
self.assertEqual(m[21], 1.0)
self.assertEqual(sum([b for b in m]), 2.0)
def test_feature_atmacc(self):
"""Check atom accessibility features"""
mlib = self.get_mdt_library()
bins = mdt.uniform_bins(120, 0.0, 0.20)
atmacc = mdt.features.AtomAccessibility(mlib, bins)
bins = mdt.uniform_bins(60, 0.0, 0.01)
fatmacc = mdt.features.FractionalAtomAccessibility(mlib, bins)
m = self.get_test_mdt(mlib, features=atmacc)
self.assertEqual(m.shape, (121,))
self.assertInTolerance(m[0], 425.0, 1.0005)
self.assertInTolerance(m[1], 35.0, 2.0005)
self.assertInTolerance(m[2], 17.0, 0.0005)
self.assertEqual(m[-1], 0.0)
m = self.get_test_mdt(mlib, features=fatmacc)
self.assertEqual(m.shape, (61,))
self.assertInTolerance(m[0], 457.0, 1.0005)
self.assertInTolerance(m[1], 39.0, 1.0005)
self.assertInTolerance(m[2], 35.0, 2.0005)
self.assertEqual(m[-1], 0.0)
def test_bad_bin_name_write_bondlib(self):
"""Test the write_bondlib function handling of bad bin names"""
mlib = self.get_mdt_library()
f1 = mdt.features.XRayResolution(mlib, mdt.uniform_bins(3, -1.0, 1.5))
f2 = mdt.features.ResidueType(mlib)
m = self.get_test_mdt(mlib, [f1, f2])
for func in (mdt.write_bondlib, mdt.write_anglelib,
mdt.write_improperlib):
self.assertRaises(ValueError, func, sys.stdout, m)
def test_triple_protein_scan(self):
"""Test scan of triples of proteins"""
env = self.get_environ()
mlib = self.get_mdt_library()
a = Alignment(env,
file='test/data/resol.ali',
align_codes=('bin1', 'bin2', 'undef2'))
f1 = mdt.features.XRayResolution(mlib,
mdt.uniform_bins(5, 0, 1.0),
protein=0)
f2 = mdt.features.XRayResolution(mlib,
mdt.uniform_bins(5, 0, 1.0),
protein=1)
f3 = mdt.features.XRayResolution(mlib,
mdt.uniform_bins(5, 0, 1.0),
protein=2)
# When we have features that cover proteins 0,1,2, triple scan should
# be forced; different number of samples for symmetric/non-symmetric
for (sym, size) in ((False, 6.0), (True, 3.0)):
t = mdt.Table(mlib, features=(f1, f2, f3))
t.add_alignment(a, symtriples=sym)
self.assertAlmostEqual(t.sample_size, size, delta=1e-6)
# When feature only covers some of the proteins, triplet scan does
# not occur.
for sym in (True, False):
t = mdt.Table(mlib, features=f3)
t.add_alignment(a, symtriples=sym)
self.assertAlmostEqual(t.sample_size, 3.0, delta=1e-6)
# Exercise residue pair features in combination with triplet scans
ri = mdt.features.ResidueIndexDifference(mlib,
mdt.uniform_bins(5, 0, 1.0),
protein=2)
t = mdt.Table(mlib, features=(f1, f2, ri))
t.add_alignment(a, symtriples=sym)
self.assertAlmostEqual(t.sample_size, 12, delta=1e-6)
def test_chain_span(self):
"""Atom pairs spanning chains should not be connected"""
mlib = self.get_all_libraries()
bsep = mdt.features.AtomBondSeparation(mlib,
bins=mdt.uniform_bins(
20, 0, 1.0))
m = self.build_mdt_from_sequence(mlib,
bsep,
'C/C',
residue_span_range=(-999, -1, 1, 999))
# All atom pairs should be undefined, since chains are not connected
self.assertEqual(m.sample_size, 49.0)
self.assertEqual(m[-1], 49.0)
def test_linear_transform(self):
"""Check for correctness of linear transform"""
mlib = self.get_mdt_library()
restyp = mdt.features.ResidueType(mlib)
chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10))
m = self.get_test_mdt(mlib, features=(restyp, chi1))
offset = -1.3
multiplier = 0.8
m2 = m.linear_transform(offset, multiplier)
inds = []
while self.roll_inds(inds, m.shape, m.offset):
y = offset + multiplier * m[inds]
self.assertAlmostEqual(y, m2[inds], places=3)
def test_section_bins(self):
"""Test checks of section bin indices"""
import _mdt
mlib = self.get_mdt_library()
restyp = mdt.features.ResidueType(mlib)
chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10))
m = mdt.Table(mlib, features=(restyp, chi1))
self.assertRaises(ValueError, _mdt.mdt_section_sum, m._basept,
[0, 0, 0])
self.assertRaises(IndexError, _mdt.mdt_section_sum, m._basept, [22])
self.assertRaises(IndexError, _mdt.mdt_section_entropy, m._basept,
[22])
self.assertRaises(IndexError, _mdt.mdt_section_meanstdev, m._basept,
mlib._modpt, [22])
def test_reshape_distancemdt(self):
"""Check that reshaping distance mdt produces the table correctly"""
env = self.get_environ()
mlib = self.get_mdt_library()
dist = mdt.features.AtomDistance(mlib,
bins=mdt.uniform_bins(30, 0, 0.5))
aln = Alignment(env,
file='test/data/alignment.ali',
align_codes='5fd1')
m1 = mdt.Table(mlib, features=dist)
m1.reshape(dist, [0], [-1])
m1.add_alignment(aln, residue_span_range=(-999, -1, 1, 999))
self.assertEqual(m1[29], 10014.0)
self.assertAlmostEqual(m1[28], 9758.5, delta=0.6)
def test_write_splinelib(self):
"""Test the write_splinelib function"""
mlib = self.get_mdt_library()
restype = mdt.features.ResidueType(mlib)
ang = mdt.features.Chi1Dihedral(
mlib, bins=mdt.uniform_bins(180, -180.0, 4.0))
m = self.get_test_mdt(mlib, [restype, ang])
with open('test.out', 'w') as fh:
mdt.write_splinelib(fh, m, 'chi1')
# Make sure that valid Python code was produced
with open('test.out') as fh:
_ = compile(fh.read(), 'test.out', 'exec')
os.unlink('test.out')
def test_write_improperlib(self):
"""Test the write_improperlib function"""
mlib = self.get_mdt_library()
mlib.dihedral_classes.read('data/impgrp.lib')
angtype = mdt.features.DihedralType(mlib)
ang = mdt.features.Dihedral(mlib, bins=mdt.uniform_bins(180, 0.0, 2.0))
m = self.get_test_mdt(mlib, [angtype, ang])
with open('test.out', 'w') as fh:
mdt.write_improperlib(fh, m)
# Make sure that valid Python code was produced
with open('test.out') as fh:
_ = compile(fh.read(), 'test.out', 'exec')
os.unlink('test.out')
def test_unknown_atom_type(self):
"""Atoms of unknown type should count as undefined"""
mlib = self.get_all_libraries()
bsep = mdt.features.AtomBondSeparation(mlib,
bins=mdt.uniform_bins(
10, -1000, 1000.0))
m = self.build_mdt_from_sequence(mlib,
bsep,
'C',
residue_span_range=(0, 0, 0, 0))
# The OXT atom is not referenced in the bond library, so bond
# separation to any of the other 6 atoms should count as undefined
# (even though the raw "distance" of -1 would otherwise fall in the
# first bin)
self.assertEqual(m[-1], 6.0)
def test_exp_transform(self):
"""Check for correctness of exp transform"""
mlib = self.get_mdt_library()
restyp = mdt.features.ResidueType(mlib)
phi = mdt.features.PhiDihedral(mlib, mdt.uniform_bins(36, -180, 10))
m = self.get_test_mdt(mlib, features=(restyp, phi))
offset = 1.
expoffset = 0.1
multiplier = 0.8
power = 0.7
m2 = m.exp_transform(offset, expoffset, multiplier, power)
inds = []
while self.roll_inds(inds, m.shape, m.offset):
y = offset + math.exp(expoffset + multiplier * m[inds]**power)
self.assertAlmostEqual(y, m2[inds], places=3)
def test_3d(self):
"""Super-smoothed 3D MDT should not crash"""
mlib = self.get_mdt_library()
restyp = mdt.features.ResidueType(mlib)
chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10))
chi1class = mdt.features.Chi1Class(mlib)
m = self.get_test_mdt(mlib, features=(restyp, chi1, chi1class))
m1 = m.super_smooth(1, 0.5, False)
# Every 1D section should be normalized:
for sec in m1:
for sec2 in sec:
self.assertSectionNormalized(sec2)
m1 = m.super_smooth(2, 0.5, False)
# Every 2D section should be normalized:
for sec in m1:
self.assertSectionNormalized(sec)
def test_write_bondlib(self):
"""Test the write_bondlib function"""
mlib = self.get_mdt_library()
mlib.bond_classes.read('data/bndgrp.lib')
bondtype = mdt.features.BondType(mlib)
bondlen = mdt.features.BondLength(
mlib, bins=mdt.uniform_bins(200, 1.0, 0.005))
m = self.get_test_mdt(mlib, [bondtype, bondlen])
with open('test.out', 'w') as fh:
mdt.write_bondlib(fh, m)
# Make sure that valid Python code was produced
with open('test.out') as fh:
_ = compile(fh.read(), 'test.out', 'exec')
os.unlink('test.out')
def test_mdt_witherr(self):
"""Test the calculation of mdt with error"""
env = self.get_environ()
mlib = self.get_mdt_library()
mlib.tuple_classes.read('data/dblcls.lib')
dbldist = mdt.features.TupleDistance(mlib,
bins=mdt.uniform_bins(30, 0, 0.5))
aln = Alignment(env, file='test/data/tiny.ali', align_codes='5fd1')
m1 = mdt.Table(mlib, features=dbldist)
m1.add_alignment_witherr(aln,
residue_span_range=(-999, -1, 1, 999),
errorscale=0.1)
self.assertAlmostEqual(m1.sum(), 1475.91, delta=0.01)
self.assertAlmostEqual(m1[29], 22.00, delta=0.5)
self.assertAlmostEqual(m1[25], 38.00, delta=0.5)
self.assertAlmostEqual(m1[0], 0.00, delta=1.0)
def test_sources(self):
"""Make sure that alignments and models both work as sources"""
env = self.get_environ()
mlib = self.get_mdt_library()
dist = mdt.features.AtomDistance(mlib,
bins=mdt.uniform_bins(60, 0, 0.5))
m1 = mdt.Table(mlib, features=dist)
m2 = mdt.Table(mlib, features=dist)
a1 = Alignment(env, file='test/data/tiny.ali', align_codes='5fd1')
m1.add_alignment(a1)
mdl = Model(env, file='test/data/5fd1.atm', model_segment=('1:', '6:'))
a2 = Alignment(env)
# Atom file 'foo' does not exist; all data should be taken from mdl
a2.append_model(mdl, align_codes='foo', atom_files='foo')
m2.add_alignment(a2)
self.assertMDTsEqual(m1, m2)
def test_internal(self):
"""Check bond separation feature within residues"""
mlib = self.get_all_libraries()
attyp1 = mdt.features.AtomType(mlib)
attyp2 = mdt.features.AtomType(mlib, pos2=True)
bsep = mdt.features.AtomBondSeparation(mlib,
bins=mdt.uniform_bins(
20, 0, 1.0))
m = self.build_mdt_from_sequence(mlib, [attyp1, attyp2, bsep],
'ARNDCQEHFWY',
residue_span_range=(0, 0, 0, 0))
atom_types = {}
for n, b in enumerate(m.features[0].bins):
atom_types[b.symbol] = n
def assertBondSep(at1, at2, numbond, sep):
bins = [b for b in m[atom_types[at1]][atom_types[at2]]]
self.assertEqual(sum(bins), numbond)
self.assertEqual(bins[sep], numbond)
# Check known ALA bond separations
assertBondSep('AN', 'ACA', numbond=1, sep=1)
assertBondSep('AN', 'AC', numbond=1, sep=2)
assertBondSep('AN', 'AO', numbond=1, sep=3)
assertBondSep('AN', 'ACB', numbond=1, sep=2)
# Check known ARG bond separations
assertBondSep('RCA', 'RCZ', numbond=1, sep=5)
assertBondSep('RCA', 'RNH', numbond=2, sep=6)
# Check known HIS bond separations
assertBondSep('HCD2', 'HC', numbond=1, sep=4)
assertBondSep('HNE2', 'HC', numbond=1, sep=5)
assertBondSep('HCE1', 'HC', numbond=1, sep=5)
assertBondSep('HND1', 'HC', numbond=1, sep=4)
# Check known PHE bond separations
assertBondSep('FN', 'FCZ', numbond=1, sep=6)
# Check known TRP bond separations
assertBondSep('WN', 'WCE3', numbond=1, sep=5)
assertBondSep('WN', 'WNE1', numbond=1, sep=5)
assertBondSep('WN', 'WCZ2', numbond=1, sep=6)
assertBondSep('WN', 'WCZ3', numbond=1, sep=6)
# Check known TYR bond separations
assertBondSep('YN', 'YOH', numbond=1, sep=7)
def test_inverse_transform(self):
"""Check for correctness of inverse transform"""
mlib = self.get_mdt_library()
restyp = mdt.features.ResidueType(mlib)
phi = mdt.features.PhiDihedral(mlib, mdt.uniform_bins(36, -180, 10))
m = self.get_test_mdt(mlib, features=(restyp, phi))
offset = 0.0
multiplier = 0.8
undefined = 300.0
m2 = m.inverse_transform(offset, multiplier, undefined)
inds = []
while self.roll_inds(inds, m.shape, m.offset):
if abs(m[inds]) < 1e-15:
y = undefined
else:
y = offset + multiplier / m[inds]
self.assertAlmostEqual(y, m2[inds], places=3)
def test_log_transform(self):
"""Check for correctness of log transform"""
mlib = self.get_mdt_library()
restyp = mdt.features.ResidueType(mlib)
phi = mdt.features.PhiDihedral(mlib, mdt.uniform_bins(36, -180, 10))
m = self.get_test_mdt(mlib, features=(restyp, phi))
offset = 0.0
multiplier = 0.7
undefined = 500.0
m2 = m.log_transform(offset, multiplier, undefined)
inds = []
while self.roll_inds(inds, m.shape, m.offset):
y = offset + multiplier * m[inds]
if y < 1e-10:
y = undefined
else:
y = math.log(y)
self.assertAlmostEqual(y, m2[inds], places=3)
def test_unconnected_external(self):
"""Separation between unconnected external atoms is undefined"""
mlib = self.get_mdt_library()
mlib.atom_classes.read('${LIB}/atmcls-mf.lib')
# Make dummy bond class library that does not connect C and CA atoms
with open('dummy.lib', 'w') as fh:
fh.write("""
BNDGRP 'ALA:CB:CA'
BOND 'ALA' 'CB' 'CA'
BNDGRP 'ALA:N:CA'
BOND 'ALA' 'N' 'CA'
BNDGRP 'ALA:O:C'
BOND 'ALA' 'O' 'C'
""")
mlib.bond_classes.read('dummy.lib')
attyp1 = mdt.features.AtomType(mlib)
attyp2 = mdt.features.AtomType(mlib, pos2=True)
bsep = mdt.features.AtomBondSeparation(mlib,
bins=mdt.uniform_bins(
20, 0, 1.0))
m = self.build_mdt_from_sequence(mlib, [attyp1, attyp2, bsep],
'AA',
residue_span_range=(-1, -1, 1, 1))
atom_types = {}
for n, b in enumerate(m.features[0].bins):
atom_types[b.symbol] = n
def assertBondSep(at1, at2, numbond, sep):
bins = [b for b in m[atom_types[at1]][atom_types[at2]]]
self.assertEqual(sum(bins), numbond)
self.assertEqual(bins[sep], numbond)
# All bonds that pass through C-CA should be undefined, others are OK
assertBondSep('AN', 'ACA', numbond=1, sep=-1)
assertBondSep('AN', 'AC', numbond=1, sep=-1)
assertBondSep('AN', 'AO', numbond=1, sep=-1)
assertBondSep('AN', 'ACB', numbond=1, sep=-1)
assertBondSep('AC', 'AN', numbond=1, sep=1)
assertBondSep('AO', 'ACB', numbond=1, sep=4)
os.unlink('dummy.lib')
def test_section(self):
"""Test access to sections of MDTs"""
mlib = self.get_mdt_library()
restyp = mdt.features.ResidueType(mlib)
chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10))
chi1class = mdt.features.Chi1Class(mlib)
m = mdt.Table(mlib, features=(restyp, chi1, chi1class))
m[0, 1, 2] = 1.0
self.assertEqual(m[0][1][2], 1.0)
m[1][-2][3] = 4.0
self.assertEqual(m[1, -2, 3], 4.0)
sec = m[1]
self.assertEqual([f.ifeat for f in sec.features],
[f.ifeat for f in m.features[1:]])
self.assertEqual(sec.shape, m.shape[1:])
self.assertEqual(sec.offset, m.offset[1:])
sec = m[2][4]
self.assertEqual([f.ifeat for f in sec.features],
[f.ifeat for f in m.features[2:]])
self.assertEqual(sec.shape, m.shape[2:])
self.assertEqual(sec.offset, m.offset[2:])
def test_write_statpot(self):
"""Test the write_statpot function"""
env = self.get_environ()
mlib = self.get_mdt_library()
mlib.atom_classes.read('test/data/atmcls-tiny.lib')
d = mdt.features.AtomDistance(mlib, bins=mdt.uniform_bins(5, 0, 0.5))
a1 = mdt.features.AtomType(mlib)
a2 = mdt.features.AtomType(mlib, pos2=True)
m = mdt.Table(mlib, features=(d, a1, a2))
# Remove undefined bin
m = m.reshape((d, a1, a2), m.offset, (-1, -1, -1))
with open('test.out', 'w') as fh:
mdt.write_statpot(fh, m)
# Check size of file
with open('test.out') as fh:
lines = fh.readlines()
self.assertEqual(len(lines), 7)
self.assertEqual(len(lines[-1].split()), 21)
# Make sure Modeller can read the file
_ = modeller.GroupRestraints(env, 'test/data/atmcls-tiny.lib',
'test.out')
os.unlink('test.out')
from modeller import *
import mdt
import mdt.features
env = Environ()
log.minimal()
env.io.atom_files_directory = ['/salilab/park2/database/pdb/divided/']
mlib = mdt.Library(env)
# read the bond definitions in terms of the constituting atom type pairs:
mlib.bond_classes.read('${LIB}/bndgrp.lib')
# define the features:
xray = mdt.features.XRayResolution(mlib, bins=[(0.51, 2.001, 'High res(2.0A)')])
bond_type = mdt.features.BondType(mlib)
bond_length = mdt.features.BondLength(mlib,
bins=mdt.uniform_bins(400, 1.0, 0.0025))
m = mdt.Table(mlib, features=(xray, bond_type, bond_length))
# make the MDT table using the pdb_60 sample chains:
a = Alignment(env)
f = modfile.File('../cluster-PDB/pdb_60.pir', 'r')
while a.read_one(f):
m.add_alignment(a)
# write out the MDT table:
m.write('mdt.mdt')
from modeller import *
import os
import mdt
import mdt.features
env = Environ()
mlib = mdt.Library(env)
xray = mdt.features.XRayResolution(mlib,
bins=[(0.51, 2.001, 'High res(2.0A)')])
restyp = mdt.features.ResidueType(mlib)
chi1 = mdt.features.Chi1Dihedral(mlib, bins=mdt.uniform_bins(144, -180, 2.5))
m = mdt.Table(mlib, file='mdt.mdt')
m = m.reshape(features=(xray, restyp, chi1),
offset=(0, 0, 0),
shape=(1, -2, -1))
text = """
SET X_LABEL_STYLE = 2, X_TICK_LABEL = -999 -999
SET X_TICK = -999 -999 -999
SET TICK_FONT = 5, CAPTION_FONT = 5
SET Y_TICK = -999 -999 -999
SET WORLD_WINDOW = -999 -999 -999 -999
SET NO_XY_SCOLUMNS = 1 1, XY_SCOLUMNS = 2 1
FILL_COLUMN COLUMN = 2, COLUMN_PARAMETERS = -180. 2.5
SET BAR_XSHIFT = 1.25
"""
m.write_asgl(asglroot='asgl1-a',
plots_per_page=8,
dimensions=1,
plot_position=1,
from modeller import *
import os
import mdt
import mdt.features
env = Environ()
mlib = mdt.Library(env)
xray = mdt.features.XRayResolution(mlib,
bins=[(0.51, 2.001, 'High res(2.0A)')])
restyp_1 = mdt.features.ResidueType(mlib, delta=1)
omega = mdt.features.OmegaDihedral(mlib, bins=mdt.uniform_bins(720, -180, 0.5))
m = mdt.Table(mlib, file='mdt.mdt')
m = m.reshape(features=(xray, restyp_1, omega),
offset=(0, 0, 0),
shape=(1, -2, -1))
text = """
SET X_LABEL_STYLE = 2, X_TICK_LABEL = -999 -999
SET X_TICK = -999 -999 -999
SET TICK_FONT = 5, CAPTION_FONT = 5
SET Y_TICK = -999 -999 -999
SET WORLD_WINDOW = -999 -999 -999 -999
SET NO_XY_SCOLUMNS = 1 1, XY_SCOLUMNS = 2 1
FILL_COLUMN COLUMN = 2, COLUMN_PARAMETERS = -180. 0.5
SET BAR_XSHIFT = 0.25
TRANSFORM TRF_TYPE = LOGARITHMIC4, ;
TRF_PARAMETERS = 1 1, NO_XY_SCOLUMNS = 0 1, XY_SCOLUMNS = 1
"""
m.write_asgl(asglroot='asgl2-a',
plots_per_page=8,
import mdt.features
import os
import sys
import pdb
fl = os.listdir(sys.argv[1])
pfl = [f for f in fl if f.endswith('.pdb')]
scriptpath = os.path.dirname(os.path.abspath(__file__))
env = environ()
env.io.atom_files_directory = [sys.argv[1]]
mlib = mdt.Library(env)
#mlib.atom_classes.read('$(LIB)/atmcls-mf.lib')
mlib.bond_classes.read('${LIB}/bndgrp.lib')
mlib.tuple_classes.read(os.path.join(scriptpath, 'dicls-all.lib'))
d = mdt.features.TupleDistance(mlib, bins=mdt.uniform_bins(35, 0, 0.2))
a1 = mdt.features.TupleAngle1(mlib, bins=mdt.uniform_bins(6, 0, 30))
a2 = mdt.features.TupleAngle2(mlib, bins=mdt.uniform_bins(6, 0, 30))
h = mdt.features.TupleDihedral1(mlib, bins=mdt.uniform_bins(12, -180, 30))
t1 = mdt.features.TupleType(mlib)
t2 = mdt.features.TupleType(mlib, pos2=True)
m = mdt.Table(mlib,
features=(d, a1, a2, h, t1, t2),
bin_type=mdt.Float,
shape=[-1] * 6)
m.read_hdf5(os.path.join(scriptpath, os.path.join(scriptpath, 'mdt1.hdf5')))
scorelist = []
for pf in pfl:
mdl = model(env)
mdl.read(file=pf)
def test_bond_span_range(self):
"""Test bond_span_range argument"""
env = self.get_environ()
mdl = Model(env)
mdl.build_sequence('A')
aln = Alignment(env)
aln.append_model(mdl, align_codes='test')
mlib = self.get_mdt_library()
mlib.bond_classes.read('data/bndgrp.lib')
dist = mdt.features.AtomDistance(mlib,
bins=mdt.uniform_bins(60, 0, 0.5))
# Only 4 direct chemical bonds (N-CA, CA-CB, CA-C, C-O) in ALA; note
# that bond library does not include OXT so C-OXT interaction is
# excluded
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln,
bond_span_range=(1, 1),
residue_span_range=(0, 0, 0, 0))
self.assertEqual(m.sample_size, 4.0)
# Only 2 dihedrals (N-CA-C-O, O-C-CA-CB)
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln,
bond_span_range=(3, 3),
residue_span_range=(0, 0, 0, 0))
self.assertEqual(m.sample_size, 2.0)
# 4 bonds, 4 angles and 2 dihedrals: 10 in total
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln,
bond_span_range=(1, 3),
residue_span_range=(0, 0, 0, 0))
self.assertEqual(m.sample_size, 10.0)
# Check for bonds between residues (just the N-C bond here)
mdl = Model(env)
mdl.build_sequence('AA')
aln = Alignment(env)
aln.append_model(mdl, align_codes='test')
# Force a non-symmetric scan (to check handling of bond separation
# regardless of which order atom indices are in)
diff = mdt.features.ResidueIndexDifference(mlib,
bins=mdt.uniform_bins(
21, -10, 1))
m = mdt.Table(mlib, features=(dist, diff))
m.add_alignment(aln,
bond_span_range=(0, 1),
residue_span_range=(-10, -1, 1, 10))
self.assertEqual(m.sample_size, 2.0)
# Bonds never span chains
mdl = Model(env)
mdl.build_sequence('A/A')
aln = Alignment(env)
aln.append_model(mdl, align_codes='test')
m = mdt.Table(mlib, features=dist)
m.add_alignment(aln,
bond_span_range=(0, 99999),
residue_span_range=(-10, -1, 1, 10))
self.assertEqual(m.sample_size, 0.0)
from modeller import *
import mdt
import mdt.features
# See ../bonds/make_mdt.py for additional comments
env = Environ()
log.minimal()
env.io.atom_files_directory = ['/salilab/park2/database/pdb/divided/']
mlib = mdt.Library(env)
mlib.dihedral_classes.read('${LIB}/impgrp.lib')
xray = mdt.features.XRayResolution(mlib,
bins=[(0.51, 2.001, 'High res(2.0A)')])
impr_type = mdt.features.DihedralType(mlib)
improper = mdt.features.Dihedral(mlib, bins=mdt.uniform_bins(400, 1.0, 0.0025))
m = mdt.Table(mlib, features=(xray, impr_type, improper))
a = Alignment(env)
f = modfile.File('../cluster-PDB/pdb_60.pir', 'r')
while a.read_one(f):
m.add_alignment(a)
m.write('mdt.mdt')
from modeller import *
import mdt
import mdt.features
env = Environ()
log.minimal()
env.io.atom_files_directory = ['/salilab/park2/database/pdb/divided/']
mlib = mdt.Library(env)
xray = mdt.features.XRayResolution(mlib, bins=mdt.uniform_bins(20, 0, 0.2))
m = mdt.Table(mlib, features=xray)
a = Alignment(env)
f = modfile.File('../cluster-PDB/pdb_60.pir', 'r')
while a.read_one(f):
m.add_alignment(a)
m.write('mdt2.mdt')
from modeller import *
import mdt
import mdt.features
# See ../bonds/make_mdt.py for additional comments
env = Environ()
log.minimal()
env.io.atom_files_directory = ['/salilab/park2/database/pdb/divided/']
mlib = mdt.Library(env)
mlib.angle_classes.read('${LIB}/anggrp.lib')
xray = mdt.features.XRayResolution(mlib,
bins=[(0.51, 2.001, 'High res(2.0A)')])
angle_type = mdt.features.AngleType(mlib)
angle = mdt.features.Angle(mlib, bins=mdt.uniform_bins(720, 0, 0.25))
m = mdt.Table(mlib, features=(xray, angle_type, angle))
a = Alignment(env)
f = modfile.File('../cluster-PDB/pdb_60.pir', 'r')
while a.read_one(f):
m.add_alignment(a)
m.write('mdt.mdt')
from modeller import *
import os
import mdt
import mdt.features
env = Environ()
mlib = mdt.Library(env)
xray = mdt.features.XRayResolution(mlib,
bins=[(0.51, 2.001, 'High res(2.0A)')])
restyp = mdt.features.ResidueType(mlib)
phi = mdt.features.PhiDihedral(mlib, bins=mdt.uniform_bins(72, -180, 5.0))
m = mdt.Table(mlib, file='mdt.mdt')
# remove the bins corresponding to undefined values for each of the 3 variables:
m = m.reshape(features=(xray, restyp, phi),
offset=(0, 0, 0),
shape=(-1, -2, -1))
# Let's get rid of the resolution variable from the output MDT table:
m = m.integrate(features=(restyp, phi))
# Process the raw histograms to get appropriate pdf 1D splines for restraints:
# Start by smoothing with a uniform prior (equal weight when 10 points per bin),
# producing a normalized distribution that sums to 1 (not a pdf when dx != 1):
m = m.smooth(dimensions=1, weight=10)
# Normalize it to get the true pdf (Integral p(x) dx = 1):
# (the scaling actually does not matter, because I am eventually taking the
# log and subtracting the smallest element of the final pdf, so this command
def _gen_single_feature(self,sfc,end,numofbin,start):
mlib=self.mlib
if end > 0:
ub=mdt.uniform_bins(numofbin, start, (float(end)-float(start))/numofbin)
if sfc[0:2]=='as':
return mdt.features.AtomType(mlib, pos2=True)
elif sfc=='b2':
return mdt.features.FractionalAtomAccessibility(mlib,bins=mdt.uniform_bins(1, 0,0.1)+mdt.uniform_bins(1, 0.1,0.9))
elif sfc=='bs2':
return mdt.features.FractionalAtomAccessibility(mlib,pos2=True, bins=mdt.uniform_bins(1, 0,0.1)+mdt.uniform_bins(1, 0.1,0.9))
elif sfc[0:1]=='a':
return mdt.features.AtomType(mlib)
elif sfc[0:2]=='rs':
return mdt.features.ResidueType(mlib,delta=numofbin, pos2=True)
elif sfc[0:1]=='r':
return mdt.features.ResidueType(mlib,delta=numofbin)
elif sfc in ['dr']:
return mdt.features.ResidueDistance(mlib, bins=ub)
elif sfc[0:1]=='m':
return mdt.features.MainchainConformation(mlib)
elif sfc[0:2]=='ms':
return mdt.features.MainchainConformation(mlib,pos2=True)
elif sfc[0:2]=='ca':
return mdt.features.AngleType(mlib)
elif sfc[0:2]=='cb':
return mdt.features.BondType(mlib)
elif sfc[0:2]=='cd':
return mdt.features.DihedralType(lib)
elif sfc[0:2]=='co':
return mdt.features.BondLength(mlib,bins=ub)
elif sfc[0:2]=='cn':
return mdt.features.Angle(mlib,bins=ub)
elif sfc[0:2]=='ci':
return mdt.features.Dihedral(mlib,bins=ub)
elif sfc[0:2]=='ps':
return mdt.features.PsiDihedral(mlib,bins=ub)
elif sfc[0:2]=='ph':
return mdt.features.PhiDihedral(mlib,bins=ub)
elif sfc in ['d','dca','dmc','dsc','dl']:
return mdt.features.AtomDistance(mlib,bins=ub)
elif sfc=='l':
return mdt.features.ResidueAccessibility(mlib,bins=ub)
elif sfc=='b':
return mdt.features.FractionalAtomAccessibility(mlib,bins=ub)
elif sfc=='bs':
return mdt.features.FractionalAtomAccessibility(mlib,bins=ub,pos2=True)
elif sfc=='ba30':
return mdt.features.AtomAccessibility(mlib,bins=mdt.uniform_bins(30, 0, 0.5))
elif sfc=='bas30':
return mdt.features.AtomAccessibility(mlib,bins=mdt.uniform_bins(30, 0, 0.5),pos2=True)
elif sfc=='s2':
return mdt.features.ResidueIndexDifference(mlib, bins=mdt.uniform_bins(1, -1,1)+mdt.uniform_bins(1, 1,1), absolute=False)
elif sfc=='s33':
return mdt.features.ResidueIndexDifference(mlib, bins=mdt.uniform_bins(1, -10015,10000)+mdt.uniform_bins(31, -15,1)+mdt.uniform_bins(1, 16,100000), absolute=False)
elif sfc in ['dt','dtl']:
return mdt.features.TupleDistance(mlib,bins=ub)
elif sfc=='g':
return mdt.features.TupleAngle1(mlib,bins=ub)
elif sfc=='gs':
return mdt.features.TupleAngle2(mlib,bins=ub)
elif sfc=='h':
return mdt.features.TupleDihedral1(mlib,bins=ub)
elif sfc[0]=='t':
return mdt.features.TupleType(mlib)
elif sfc[:2]=='ts':
return mdt.features.TupleType(mlib, pos2=True)
else:
raise Exception('can not find feature '+sfc+' in module feature._gen_single_feature()')
