Debian Codegraph @

csb/test/cases/bio/nmr/__init__.py

raw
1 import csb.test as test
2
3 from csb.bio.nmr import RandomCoil, AtomConnectivity, ContactMap, Filters, Label
4 from csb.bio.nmr import ChemShiftInfo, ChemShiftScoringModel, NOESpectrum, NOEPeak
5 from csb.bio.nmr import InvalidResidueError, EntityNotSupportedError
6 from csb.bio.sequence import ProteinAlphabet
7 from csb.bio.structure import ChemElements, Atom
8
9
10 def get_chain():
11 s = test.Config().getPickle('1nz9.model1.pickle')
12 return s.first_chain.subregion(1, 5, clone=True)
13
14
15 @test.unit
16 class TestRandomCoil(test.Case):
17
18 def setUp(self):
19
20 super(TestRandomCoil, self).setUp()
21
22 self.rc = RandomCoil.get()
23 self.chain = get_chain()
24 self.residue = self.chain.residues[2]
25
26 def testFactory(self):
27 self.assertTrue(RandomCoil.get() is RandomCoil.get())
28
29 def testSimpleSecondaryShift(self):
30
31 raw = 200.0
32
33 for r in ['A', 'ALA', ProteinAlphabet.ALA]:
34 self.assertEqual(
35 self.rc.simple_secondary_shift(r, 'N', raw),
36 raw - 125)
37
38 self.assertRaises(
39 InvalidResidueError,
40 lambda:self.rc.simple_secondary_shift('$', 'N', 0))
41 self.assertRaises(
42 EntityNotSupportedError,
43 lambda:self.rc.simple_secondary_shift('A', '$', 0))
44
45 def testSecondaryShift(self):
46
47 raw = 200.0
48
49 for r in [self.residue, self.residue.rank, self.residue.id]:
50 self.assertEqual(
51 self.rc.secondary_shift(self.chain, r, 'H', raw),
52 raw - (8.44 + 0.07 - 0.05 - 0.01))
53
54
55 @test.unit
56 class TestAtomConnectivity(test.Case):
57
58 def setUp(self):
59 super(TestAtomConnectivity, self).setUp()
60 self.ac = AtomConnectivity.get()
61
62 def testFactory(self):
63 self.assertTrue(AtomConnectivity.get() is AtomConnectivity.get())
64
65 def testConnected(self):
66
67 self.assertTrue(self.ac.connected(ProteinAlphabet.CYS, "SG", "HG"))
68 self.assertTrue(self.ac.connected(ProteinAlphabet.CYS, "SG", "CB"))
69 self.assertFalse(self.ac.connected(ProteinAlphabet.CYS, "SG", "H"))
70
71 self.assertTrue(self.ac.connected(ProteinAlphabet.CYS, "CA", "C"))
72 self.assertTrue(self.ac.connected(ProteinAlphabet.CYS, "CA", "HA"))
73 self.assertTrue(self.ac.connected(ProteinAlphabet.CYS, "CA", "CB"))
74 self.assertFalse(self.ac.connected(ProteinAlphabet.CYS, "CA", "HB"))
75
76 def testConnectedAtoms(self):
77
78 partners = self.ac.connected_atoms(ProteinAlphabet.CYS, "CA")
79 self.assertTrue(partners, ("N", "C", "CB", "HA"))
80
81 partners = self.ac.connected_atoms(ProteinAlphabet.CYS, "SG")
82 self.assertTrue(partners, ("CB"))
83
84 def testContains(self):
85
86 self.assertTrue(self.ac.contains(ProteinAlphabet.CYS, "SG"))
87 self.assertTrue(self.ac.contains(ProteinAlphabet.ASP, "CG"))
88 self.assertFalse(self.ac.contains(ProteinAlphabet.ALA, "CG"))
89
90 def testGetAtoms(self):
91
92 atoms = frozenset(['C', 'HD2', 'CB', 'CA', 'CG', 'O', 'N',
93 'H', 'OD1', 'HA', 'OD2', 'HB3', 'HB2'])
94 self.assertEqual(self.ac.get_atoms(ProteinAlphabet.ASP), atoms)
95
96
97 @test.unit
98 class TestContactMap(test.Case):
99
100 @classmethod
101 def setUpClass(cls):
102 cls.CHAIN = get_chain()
103 cls.MAP = ContactMap(cls.CHAIN, cutoff=1.75, filter=Filters.HYDROGENS)
104 cls.MAP.build()
105
106 def setUp(self):
107 super(TestContactMap, self).setUp()
108 self.chain = TestContactMap.CHAIN
109 self.cm = TestContactMap.MAP
110
111 def testBuild(self):
112 self.assertEqual(len(self.cm.atoms), 38)
113
114 def testContains(self):
115 self.assertFalse(self.chain[0]['C'] in self.cm)
116 self.assertTrue(self.chain[0]['HA'] in self.cm)
117
118 def testIterator(self):
119 self.assertEqual(list(self.cm), list(self.cm.contacts))
120
121 def testCutoff(self):
122 self.assertEqual(self.cm.cutoff, 1.75)
123
124 def testChain(self):
125 self.assertTrue(self.cm.chain is self.chain)
126
127 def testAtoms(self):
128 self.assertTrue(self.cm.atoms[0] is self.chain[0]['H1'])
129 self.assertTrue(self.cm.atoms[-1] is self.chain[-1]['HZ'])
130
131 def testContacts(self):
132
133 c = self.chain
134 contacts = set([
135 (c[0]['H2'], c[0]['H3']),
136 (c[0]['H2'], c[0]['H1']),
137 (c[0]['H1'], c[0]['H3']),
138 (c[1]['HE22'], c[1]['HE21']) ])
139
140 self.assertEqual(len(contacts), len(set(self.cm.contacts)))
141 for a1, a2 in contacts:
142 self.assertTrue((a1, a2) in contacts or (a2, a1) in contacts)
143
144 def testConnect(self):
145 # covers also cm.connected()
146
147 c = self.chain
148 cm = ContactMap(TestContactMap.CHAIN, cutoff=1.75, filter=Filters.CALPHAS)
149
150 self.assertFalse(cm.connected(c[0]['CA'], c[1]['CA']))
151 cm.connect(c[0]['CA'], c[1]['CA'])
152 self.assertTrue(cm.connected(c[0]['CA'], c[1]['CA']))
153 self.assertTrue(cm.connected(c[1]['CA'], c[0]['CA']))
154
155 def testConnected(self):
156 c = self.chain
157 self.assertTrue(self.cm.connected(c[0]['H3'], c[0]['H2']))
158 self.assertTrue(self.cm.connected(c[0]['H2'], c[0]['H3']))
159
160 def testAtomContacts(self):
161 atoms = set([self.chain[0]['H2'], self.chain[0]['H3']])
162 self.assertEqual(self.cm.atom_contacts(self.chain[0]['H1']), atoms)
163
164 def testResidueContacts(self):
165 residues = set([self.chain[0]])
166 self.assertEqual(self.cm.residue_contacts(self.chain[0]), residues)
167
168 def testPosition(self):
169 self.assertEqual(self.cm.position(1, 'H1'), 1.0)
170 self.assertEqual(self.cm.position(2, 'HA'), 2.125)
171
172 def testCompare(self):
173
174 ci = ContactMap.compare(self.cm, self.cm, 0)
175 self.assertEqual(ci.precision, 1)
176 self.assertEqual(ci.coverage, 1)
177
178 ci = ContactMap.compare(self.cm, self.cm, 1)
179 self.assertEqual(ci.precision, 0)
180 self.assertEqual(ci.coverage, 0)
181
182
183 @test.unit
184 class TestLabel(test.Case):
185
186 def testBuild(self):
187 self.assertEqual(Label.build(ProteinAlphabet.ALA, 2, 'CA'), "A#2:CA")
188
189 def testFromShift(self):
190 shift = ChemShiftInfo(2, ProteinAlphabet.ALA, 'CA', ChemElements.C, 12)
191 self.assertEqual(Label.from_shift(shift), "A#2:CA")
192
193 def testFromAtom(self):
194 atom = get_chain()[1]['CA']
195 self.assertEqual(Label.from_atom(atom), "Q#2:CA")
196
197 def testGetAtom(self):
198 chain = get_chain()
199 self.assertEqual(Label.get_atom(chain, "Q#2:CA"), chain[1]['CA'])
200
201 def testMatch(self):
202 atom = get_chain()[1]['CA']
203 shift = ChemShiftInfo(2, ProteinAlphabet.GLN, 'CA', ChemElements.C, 12)
204 self.assertTrue(Label.match(shift, atom))
205
206 def testParse(self):
207 self.assertEqual(Label.parse("Q#2:CA"), ("Q", 2, 'CA'))
208
209 def testFromString(self):
210
211 label = Label.from_string("Q#2:CA")
212
213 self.assertEqual(label.residue, ProteinAlphabet.GLN)
214 self.assertEqual(label.rank, 2)
215 self.assertEqual(label.atom_name, 'CA')
216
217
218 @test.unit
219 class TestChemShiftInfo(test.Case):
220
221 def testConstructor(self):
222
223 shift = ChemShiftInfo(2, 'ALA', 'CA', 'C', 12)
224
225 self.assertEqual(shift.element, ChemElements.C)
226 self.assertEqual(shift.residue, ProteinAlphabet.ALA)
227 self.assertEqual(shift.position, 2)
228 self.assertEqual(shift.shift, 12)
229
230 def testLabel(self):
231
232 shift = ChemShiftInfo(2, 'ALA', 'CA', 'C', 12)
233 self.assertEqual(shift.label, Label.from_shift(shift))
234
235
236 @test.unit
237 class TestChemShiftScoringModel(test.Case):
238
239 def setUp(self):
240 super(TestChemShiftScoringModel, self).setUp()
241 self.model = ChemShiftScoringModel()
242
243 def testPositive(self):
244 self.assertAlmostEqual(self.model.positive('CA', 1), 0.191, places=3)
245 self.assertAlmostEqual(self.model.positive('CA', [1, 1])[1], 0.191, places=3)
246
247 def testNegative(self):
248 self.assertAlmostEqual(self.model.negative('CA', 1), 0.127, places=3)
249 self.assertAlmostEqual(self.model.negative('CA', [1, 1])[1], 0.127, places=3)
250
251 def testScore(self):
252 self.assertAlmostEqual(self.model.score('CA', 1), 0.588, places=3)
253 self.assertAlmostEqual(self.model.score('CA', [1, 1])[1], 0.588, places=3)
254
255
256 @test.unit
257 class TestNOESpectrum(test.Case):
258
259 def setUp(self):
260 super(TestNOESpectrum, self).setUp()
261
262 self.elements = (ChemElements.H, ChemElements.C, ChemElements.H)
263 self.spectrum = NOESpectrum(self.elements)
264 self.spectrum.connect(1, 2)
265 self.spectrum.add(11, [1, 2, 3])
266 self.spectrum.add(12, [11, 22, 33])
267
268 def testGetitem(self):
269 self.assertEqual(self.spectrum[0].intensity, 11)
270 self.assertRaises(IndexError, lambda i: self.spectrum[i], 3)
271
272 def testLen(self):
273 self.assertEqual(len(self.spectrum), 2)
274
275 def testMinIntensity(self):
276 self.assertEqual(self.spectrum.min_intensity, 11)
277
278 def testMaxIntensity(self):
279 self.assertEqual(self.spectrum.max_intensity, 12)
280
281 def testElement(self):
282 self.assertEqual(self.spectrum.element(0), self.elements[0])
283 self.assertEqual(self.spectrum.element(1), self.elements[1])
284 self.assertRaises(IndexError, self.spectrum.element, 3)
285
286 def testDimensions(self):
287 self.assertEqual(self.spectrum.dimensions, self.elements)
288
289 def testProtonDimensions(self):
290 self.assertEqual(self.spectrum.proton_dimensions, (0, 2))
291
292 def testNumDimensions(self):
293 self.assertEqual(self.spectrum.num_dimensions, 3)
294
295 def testNumProtonDimensions(self):
296 self.assertEqual(self.spectrum.num_proton_dimensions, 2)
297
298 def testHasElement(self):
299 self.assertFalse(self.spectrum.has_element(ChemElements.Ca))
300 self.assertTrue(self.spectrum.has_element(ChemElements.C))
301
302 def testHasConnectedDimensions(self):
303 self.assertFalse(self.spectrum.has_connected_dimensions(0))
304 self.assertTrue(self.spectrum.has_connected_dimensions(1))
305 self.assertTrue(self.spectrum.has_connected_dimensions(2))
306
307 def testConnectedDimensions(self):
308 self.assertEqual(self.spectrum.connected_dimensions(0), ())
309 self.assertEqual(self.spectrum.connected_dimensions(1), (2,))
310 self.assertEqual(self.spectrum.connected_dimensions(2), (1,))
311
312 def testConnect(self):
313 self.assertRaises(ValueError, self.spectrum.connect, 0, 2) # H-H
314 self.assertRaises(IndexError, self.spectrum.connect, 0, 3)
315
316 def testIterator(self):
317
318 peaks = list(self.spectrum)
319
320 self.assertEqual(peaks[0].intensity, 11)
321 self.assertEqual(peaks[0].get(0), 1)
322 self.assertEqual(peaks[0].get(1), 2)
323 self.assertEqual(peaks[0].get(2), 3)
324
325
326 @test.unit
327 class TestNOEPeak(test.Case):
328
329 def setUp(self):
330 super(TestNOEPeak, self).setUp()
331
332 self.elements = (ChemElements.H, ChemElements.C, ChemElements.H)
333 self.spectrum = NOESpectrum(self.elements)
334 self.spectrum.connect(1, 2)
335 self.spectrum.add(11, [1, 2, 3])
336 self.spectrum.add(12, [11, 22, 33])
337
338 self.peaks = list(self.spectrum)
339
340 def testIntensity(self):
341 self.assertEqual(self.peaks[0].intensity, 11)
342 self.assertEqual(self.peaks[1].intensity, 12)
343
344 def testNumDimensions(self):
345 self.assertEqual(self.peaks[0].num_dimensions, 3)
346
347 def testHasConnectedDimensions(self):
348 self.assertFalse(self.peaks[0].has_connected_dimensions(0))
349 self.assertTrue(self.peaks[0].has_connected_dimensions(1))
350 self.assertTrue(self.peaks[0].has_connected_dimensions(2))
351
352 def testConnectedDimensions(self):
353 self.assertEqual(self.peaks[0].connected_dimensions(0), ())
354 self.assertEqual(self.peaks[0].connected_dimensions(1), (2,))
355 self.assertEqual(self.peaks[0].connected_dimensions(2), (1,))
356
357 def testElement(self):
358 self.assertEqual(self.peaks[0].element(0), self.elements[0])
359 self.assertEqual(self.peaks[0].element(1), self.elements[1])
360
361 def testHasElement(self):
362 self.assertTrue(self.peaks[0].has_element(self.elements[0]))
363 self.assertTrue(self.peaks[0].has_element(self.elements[1]))
364
365 def testGet(self):
366 self.assertEqual(self.peaks[0].get(0), 1)
367 self.assertEqual(self.peaks[0][0], 1)
368 self.assertEqual(self.peaks[1].get(1), 22)
369 self.assertEqual(self.peaks[1][1], 22)
370
371 self.assertRaises(IndexError, lambda i: self.peaks[0][i], 4)
372 self.assertRaises(IndexError, self.peaks[0].get, -1)
373
374
375 if __name__ == '__main__':
376
377 test.Console()