Debian Codegraph @

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

raw
1 import random
2 import csb.test as test
3 import csb.test.cases.bio.hmm
4
5 from csb.bio.fragments import Target, Assignment, TorsionAnglePredictor
6 from csb.bio.fragments import FragmentCluster, ClusterNode, ClusterDivergingError, ClusterExhaustedError
7 from csb.bio.fragments import RosettaFragsetFactory
8 from csb.bio.fragments.rosetta import RosettaFragment, RosettaFragmentMap
9
10 from csb.bio.structure import Atom
11 from csb.bio.sequence import ProteinAlphabet
12
13
14 class SampleTarget(object):
15
16 _instance = None
17
18 def __init__(self):
19 raise NotImplementedError('you are doing it wrong')
20
21 @staticmethod
22 def get(fraglength=10):
23
24 if SampleTarget._instance is None:
25 SampleTarget._instance = SampleTarget.build_target(fraglength)
26
27 return SampleTarget._instance
28
29 @staticmethod
30 def build_target(fraglength=10):
31
32 config = test.Config()
33 chain = config.getPickle('1nz9.model1.pickle').chains['A']
34 chain.compute_torsion()
35 ss = str(chain.secondary_structure) + chain.length * '-'
36
37 target = Target('testA', chain.length, chain.residues)
38
39 for start in range(1, target.length + 1, 5):
40
41 end = min(start + fraglength - 1, target.length)
42 if end - start + 1 < 2:
43 continue
44
45 source = chain.clone()
46 for atom in source.components(klass=Atom):
47 atom.vector[0] += 0.005 * start * atom.vector[0]
48
49 rmsd = chain.subregion(start, end).rmsd(source.subregion(start, end))
50
51 a = Assignment(source, start, end, start, end, id=id, probability=1.0, rmsd=rmsd)
52 a.secondary_structure = ss[start - 1: end]
53 target.assign(a)
54
55 return target
56
57
58 @test.unit
59 class TestTarget(test.Case):
60
61 FRAG_LENGTH = 10
62
63 def setUp(self):
64
65 super(TestTarget, self).setUp()
66 self.target = SampleTarget.get(self.FRAG_LENGTH)
67
68 def testFromSequence(self):
69
70 t = Target.from_sequence('testA', 'ABC')
71
72 self.assertEqual(t.length, 3)
73 self.assertEqual(t.sequence, 'ABC')
74 self.assertEqual(t.accession, 'test')
75 self.assertEqual(t.residues[1].native.type, ProteinAlphabet.ALA)
76
77 def testFromProfile(self):
78
79 hmm = csb.test.cases.bio.hmm.build_hmm()
80 t = Target.from_profile(hmm)
81
82 self.assertEqual(t.length, 2)
83 self.assertEqual(t.sequence, 'AC')
84 self.assertEqual(t.id, 'id')
85 self.assertEqual(t.residues[1].native.type, ProteinAlphabet.ALA)
86
87 def testAccession(self):
88 self.assertEqual(self.target.accession, 'test')
89
90 def testEntryID(self):
91 self.assertEqual(self.target.id, 'testA')
92
93 def testLength(self):
94 self.assertEqual(self.target.length, 58)
95
96 def testSequence(self):
97 self.assertEqual(self.target.sequence, 'AQVAFREGDQVRVVSGPFADFTGTVTEINPERGKVKVMVTIFGRETPVELDFSQVVKA')
98
99 def testResidues(self):
100 self.assertEqual(self.target.residues.length, 58)
101 self.assertEqual(self.target.residues[1].native.type, ProteinAlphabet.ALA)
102 self.assertRaises(IndexError, lambda:self.target.residues[0])
103
104 def testMatches(self):
105 self.assertEqual(self.target.matches.length, 12)
106 self.assertEqual(self.target.matches[0].qstart, 1)
107 self.assertEqual(self.target.matches[-1].qend, 58)
108
109 def testAssign(self):
110
111 a = self.target.matches[0]
112
113 for r in range(a.qstart, a.qend + 1):
114
115 frags = [rai.fragment for rai in self.target.residues[r].assignments]
116 self.assertTrue(a in frags)
117
118 def testFilter(self):
119
120 t = self.target.filter(threshold=1.5, extend=False)
121 self.assertEqual(t.matches.length, self.target.length)
122
123
124 @test.unit
125 class TestTargetResidue(test.Case):
126
127 def setUp(self):
128
129 super(TestTargetResidue, self).setUp()
130
131 self.target = SampleTarget.get()
132 self.residue = self.target.residues[6]
133
134 def testType(self):
135 self.assertEqual(self.residue.type, ProteinAlphabet.ARG)
136
137 def testNative(self):
138 self.assertEqual(self.residue.native.type, ProteinAlphabet.ARG)
139
140 def testAssignments(self):
141
142 self.assertEqual(self.residue.assignments.length, 2)
143 self.assertEqual(self.residue.assignments[0].fragment.qstart, 1)
144 self.assertEqual(self.residue.assignments[0].fragment.qend, 10)
145 self.assertEqual(self.residue.assignments[1].fragment.qstart, 6)
146 self.assertEqual(self.residue.assignments[1].fragment.qend, 15)
147
148 def testAssign(self):
149 pass # implicitly covered
150
151 def testClosest(self):
152 b = self.residue.closest()
153 self.assertEqual(b, self.residue.assignments[0].fragment)
154
155 def testLongest(self):
156 b = self.residue.longest()
157 self.assertEqual(b, self.residue.assignments[0].fragment)
158
159 def testPrecision(self):
160 self.assertEqual(self.residue.precision(), 100.0)
161 self.assertEqual(self.residue.precision(threshold=0.05), 50.0)
162
163 def testFilter(self):
164
165 rep = self.residue.filter()
166 self.assertTrue(rep.centroid in [i.fragment for i in self.residue.assignments])
167
168
169 @test.unit
170 class TestTorsionAnglePredictor(test.Case):
171
172 def setUp(self):
173
174 super(TestTorsionAnglePredictor, self).setUp()
175
176 self.target = SampleTarget.get()
177 self.predictor = TorsionAnglePredictor(self.target)
178
179 def testTarget(self):
180 self.assertEqual(self.predictor.target, self.target)
181
182 def testThreshold(self):
183 self.assertEqual(self.predictor.threshold, 1.5)
184
185 def testComputeSingle(self):
186
187 native = self.target.residues[3].native
188 pred = self.predictor.compute_single(3)
189
190 self.assertEqual(pred.torsion.phi, native.torsion.phi)
191 self.assertEqual(pred.torsion.psi, native.torsion.psi)
192 self.assertEqual(pred.as_tuple(), (0.0, -143.77110677043459, 148.81948663098206, -179.98643191250056))
193
194 self.assertEqual(pred.rank, 3)
195 self.assertEqual(pred.confidence, self.target.residues[3].filter().confidence)
196 self.assertEqual(pred.confidence, 0)
197 self.assertTrue(pred.primary)
198
199 def testCompute(self):
200
201 pred = self.predictor.compute(3)
202 self.assertGreater(len(pred), 1)
203
204 for pi in pred:
205 self.assertEqual(pi.as_tuple()[1:], (-143.77110677043459, 148.81948663098206, -179.98643191250056))
206 self.assertTrue(pi.confidence <= pred[0].confidence)
207
208 def testGetAngles(self):
209
210 pred = self.predictor.get_angles(6)
211 self.assertEqual(len(pred), self.target.residues[6].assignments.length)
212 self.assertEqual(len(pred), 2)
213
214 for pi in pred:
215 ref = self.target.residues[6].assignments[0].fragment.torsion_at(6, 6)[0]
216 self.assertEqual((pi.phi, pi.psi, pi.omega), (-150.51264336633528, 134.10287564490648, 179.98064117348235))
217 self.assertEqual((pi.phi, pi.psi, pi.omega), (ref.phi, ref.psi, ref.omega))
218
219 def testFlatTorsionMap(self):
220
221 source = test.Config().getPickle('1nz9.model1.pickle').chains['A']
222 source.compute_torsion()
223 target = SampleTarget.build_target()
224
225 # add more fragments at location 2..9; this will also alter the confidence
226 for i in range(20):
227 # these fragments come from 12..19
228 target.assign(Assignment(source, 2 + 10, 9 + 10, 2, 9, 't', 1, 1))
229
230 predictor = TorsionAnglePredictor(target)
231 pred = predictor.flat_torsion_map()
232
233 self.assertEqual(len(pred), target.length)
234
235 # outside the 2..9 region
236 self.assertAlmostEqual(pred[18].confidence, 0.301, delta=0.01)
237 self.assertEqual(pred[0].torsion.phi, target.residues[1].native.torsion.phi)
238 self.assertEqual(pred[9].torsion.phi, target.residues[10].native.torsion.phi)
239
240 # intside the 2..9 region
241 for i in range(2, 9 + 1):
242 self.assertEqual(pred[i - 1].rank, i)
243 self.assertAlmostEqual(pred[i - 1].confidence, 1.20, delta=0.01)
244 self.assertEqual(pred[1].torsion.psi, target.residues[2 + 10].native.torsion.psi)
245 self.assertEqual(pred[8].torsion.psi, target.residues[9 + 10].native.torsion.psi)
246
247 self.assertEqual(pred[10].dssp.type, 'E')
248 self.assertEqual(pred[52].dssp.type, 'H')
249
250
251 @test.unit
252 class TestAssignment(test.Case):
253
254 def setUp(self):
255
256 super(TestAssignment, self).setUp()
257
258 self.target = SampleTarget.get()
259 self.a = self.target.matches[0]
260
261 def testBackbone(self):
262
263 self.assertEqual(self.a.backbone.length, 10)
264
265 x = self.target.residues[1].native.atoms['CA'].vector[0]
266 self.assertEqual(self.a.backbone[0][0], x + 0.005 * x)
267 self.assertEqual(list(self.a.backbone[0]), [-0.96882, -17.865, -6.46])
268
269 def testSequence(self):
270 self.assertEqual(self.a.sequence, self.target.sequence[self.a.qstart - 1 : self.a.qend])
271
272 def testTorsion(self):
273 self.assertEqual(self.a.torsion[0].psi, self.target.residues[1].native.torsion.psi)
274
275 def testSourceID(self):
276 self.assertEqual(self.a.source_id, '1nz9A')
277
278 def testStart(self):
279 self.assertEqual(self.a.start, 1)
280
281 def testEnd(self):
282 self.assertEqual(self.a.end, 10)
283
284 def testQStart(self):
285 self.assertEqual(self.a.qstart, 1)
286 self.assertEqual(self.target.residues[7].assignments[1].fragment.qstart, 6)
287
288 def testQEnd(self):
289 self.assertEqual(self.a.qend, 10)
290 self.assertEqual(self.target.residues[7].assignments[1].fragment.qend, 15)
291
292 def testRMSD(self):
293 self.assertAlmostEqual(self.a.rmsd, 0.0128, places=4)
294
295 def testAnchoredAround(self):
296 self.assertTrue(self.a.anchored_around(5))
297 self.assertFalse(self.a.anchored_around(1))
298
299 def testBackboneAt(self):
300 self.assertEqual(list(self.a.backbone_at(1, 1)[0]), [-0.96882, -17.865, -6.46])
301
302 def testTorsionAt(self):
303 self.assertEqual(self.a.torsion_at(1, 1)[0].psi, self.target.residues[1].native.torsion.psi)
304
305 def testOverlap(self):
306 overlap = self.a.overlap(self.target.residues[7].assignments[1].fragment)
307 self.assertEqual(overlap, set([6, 7, 8, 9, 10]))
308
309 def testRMSDTo(self):
310 rmsd = self.a.rmsd_to(self.target.residues[7].assignments[1].fragment)
311 self.assertAlmostEqual(rmsd, 0.038, places=4)
312
313
314 @test.unit
315 class TestFragmentCluster(test.Case):
316
317 class A(object):
318
319 def __init__(self, r):
320 self.r = r
321 self.length = 8
322
323 def rmsd_to(self, other):
324 return abs(self.r - other.r)
325
326 def setUp(self):
327
328 super(TestFragmentCluster, self).setUp()
329 self.target = SampleTarget.get()
330
331 A = TestFragmentCluster.A
332 self.c = FragmentCluster([ ClusterNode(A(0.4)), ClusterNode(A(1.3)), ClusterNode(A(1.2)), ClusterNode(A(1.2)), ClusterNode(A(0.1)), ClusterNode(A(0.09), fixed=False) ], threshold=0.1)
333 self.fc = FragmentCluster([ ClusterNode(A(0.4)), ClusterNode(A(1.3)), ClusterNode(A(1.2)), ClusterNode(A(1.2)), ClusterNode(A(0.1)), ClusterNode(A(0.09), fixed=True) ], threshold=0.1)
334
335 def testCount(self):
336 self.assertEqual(self.c.count, 6)
337
338 def testShrink(self):
339
340 # covers also ClusterRep and ClusterNode; also the methods: mean, reject, shrinkone
341
342 self.assertRaises(ClusterDivergingError, self.fc.shrink)
343 self.assertRaises(ClusterExhaustedError, self.c.shrink, minitems=100)
344
345 rep = self.c.shrink(minitems=1)
346
347 self.assertEqual(rep.centroid.r, 1.2)
348 self.assertEqual(rep.count, 3)
349 self.assertEqual(rep.rejections, 3)
350 self.assertAlmostEqual(rep.mean, 0.0444, places=4)
351 #self.assertAlmostEqual(self.c.mean(), 0.0333, places=4)
352 self.assertAlmostEqual(rep.confidence, 0.2651, places=4)
353 self.assertEqual(rep.centroid, self.c.centroid().centroid)
354
355 for item in self.c.items:
356 self.assertGreater(item.fragment.r, 1.1)
357 for item in self.c.fragments:
358 self.assertGreater(item.r, 1.1)
359
360 def testMean(self):
361 self.assertAlmostEqual(self.c.mean(), 0.4833, places=4)
362
363 def testShrinkOne(self):
364
365 self.assertTrue(self.c.shrinkone())
366 self.assertEqual(self.c.count, 5)
367
368 self.c.shrink()
369 self.assertFalse(self.c.shrinkone())
370
371 @test.unit
372 class TestRosettaFragsetfactory(test.Case):
373
374 def setUp(self):
375
376 super(TestRosettaFragsetfactory, self).setUp()
377
378 self.target = SampleTarget.get()
379 self.factory = RosettaFragsetFactory()
380
381 def testMakeFragset(self):
382
383 fragset = self.factory.make_fragset(self.target)
384
385 self.assertEqual(len(fragset), self.target.matches.length)
386 self.assertEqual(len(fragset.at(3)), 1)
387 self.assertEqual(len(fragset.at(7)), 2)
388
389 def testMakeChopped(self):
390
391 fragset = self.factory.make_fragset(self.target)
392 chopped = self.factory.make_chopped(fragset, window=5)
393
394 for fragment in chopped:
395 self.assertEqual(fragment.length, 5)
396
397 def testMakeCombined(self):
398
399 assert self.target.residues[1].assignments.length == 1
400
401 fragment = RosettaFragment.from_object(self.target.matches[0])
402 filling = RosettaFragmentMap([fragment], self.target.length)
403 combined = self.factory.make_combined(self.target, filling)
404
405 self.assertEqual(len(combined.starting_at(1)), 2)
406 self.assertEqual(len(combined.starting_at(6)), 1)
407
408 def testMakeFiltered(self):
409
410 fragset = self.factory.make_filtered(self.target)
411 self.assertGreater(len(fragset.at(1)), 0)
412
413 def testMix(self):
414
415 fragset = self.factory.make_fragset(self.target)
416 mixed = self.factory.mix(fragset, fragset, fragset)
417
418 self.assertEqual(len(mixed), len(fragset) * 3)
419
420
421 @test.unit
422 class TestRosettaFragment(test.Case):
423
424 def setUp(self):
425
426 super(TestRosettaFragment, self).setUp()
427
428 self.target = SampleTarget.get()
429 self.fragment = RosettaFragment.from_object(self.target.matches[0])
430
431 def testSubregion(self):
432
433 sub = self.fragment.subregion(2, 4)
434 self.assertEqual(sub.length, 3)
435 self.assertEqual(sub.qstart, 2)
436 self.assertEqual(sub.qend, 4)
437 self.assertEqual(sub.residues[0].rank, self.fragment.residues[1].rank)
438 self.assertEqual(sub.residues[-1].rank, self.fragment.residues[3].rank)
439
440 def testLength(self):
441 self.assertEqual(self.fragment.length, 10)
442
443 def testFomObject(self):
444 fragment = RosettaFragment.from_object(self.target.matches[0])
445 self.assertEqual(fragment.length, 10)
446 self.assertEqual(fragment.qstart, 1)
447 self.assertEqual(fragment.qend, 10)
448
449 def testSourceID(self):
450 self.assertEqual(self.fragment.source_id, '1nz9A')
451
452 def testAccession(self):
453 self.assertEqual(self.fragment.accession, '1nz9')
454
455 def testQStart(self):
456 self.assertEqual(self.fragment.qstart, 1)
457 self.assertEqual(self.target.residues[6].assignments[1].fragment.qstart, 6)
458
459 def testStart(self):
460 self.assertEqual(self.fragment.start, 1)
461
462 def testQEnd(self):
463 self.assertEqual(self.fragment.qend, 10)
464 self.assertEqual(self.target.residues[6].assignments[1].fragment.qend, 15)
465
466 def testEnd(self):
467 self.assertEqual(self.fragment.end, 10)
468
469 def testScore(self):
470 self.assertEqual(self.fragment.score, 0.0)
471
472 def testTorsion(self):
473 self.assertAlmostEqual(self.fragment.torsion[0].psi, 112.12957, places=4)
474
475 def testResidues(self):
476 self.assertEqual(len(self.fragment.residues), 10)
477
478 first = self.fragment.residues[0]
479 self.assertEqual(first.aa, self.target.residues[1].type)
480 self.assertEqual(first.rank, 1)
481 self.assertAlmostEqual(first.torsion.psi, 112.12957, places=4)
482
483
484 @test.unit
485 class TestRosettaFragmentMap(test.Case):
486
487 def setUp(self):
488
489 super(TestRosettaFragmentMap, self).setUp()
490
491 self.target = SampleTarget.get()
492 self.map = RosettaFragsetFactory().make_fragset(self.target)
493
494 def testSources(self):
495 self.assertEqual(self.map.sources, tuple(['1nz9']))
496
497 def testSize(self):
498 self.assertEqual(self.map.size, 12)
499
500 def testMarkUnconfident(self):
501
502 self.map.mark_unconfident(5)
503 self.map.mark_unconfident(8)
504
505 self.assertEqual(self.map.unconfident_positions, tuple([5, 8]))
506
507 def testFromSource(self):
508 self.assertEqual(self.map.fromsource('1nz9'), tuple(self.map))
509
510 def testStartingAt(self):
511 self.assertEqual(len(self.map.starting_at(2)), 0)
512 self.assertEqual(len(self.map.starting_at(6)), 1)
513
514 def testAt(self):
515 self.assertEqual(len(self.map.at(2)), 1)
516 self.assertEqual(len(self.map.at(6)), 2)
517
518 def testComplement(self):
519
520 self.map.mark_unconfident(7)
521 for fragment in self.map.at(6):
522 self.map.complement(fragment)
523
524 self.assertEqual(self.map.size, 13)
525
526 def testSort(self):
527
528 fragments = [ RosettaFragment.from_object(f) for f in self.target.matches ]
529 random.shuffle(fragments)
530
531 fragmap = RosettaFragmentMap(fragments)
532 fragmap.sort(field='length')
533
534 for i, fragment in enumerate(fragmap):
535 if i >= 1:
536 self.assertTrue(fragment.length >= fragmap[i-1].length)
537
538 def testIndexer(self):
539
540 self.assertEqual(self.map[0].qstart, 1)
541 self.assertEqual(self.map[0].qend, 10)
542
543 def testRead(self):
544
545 file = self.config.getTestFile('1nz9A.frags')
546 fragmap = RosettaFragmentMap.read(file)
547
548 self.assertEqual(fragmap.size, self.map.size)
549 self.assertEqual(fragmap[1].residues[0].torsion.phi, -150.513)
550 self.assertEqual(fragmap[1].residues[1].torsion.psi, 147.798)
551 self.assertEqual(fragmap[1].residues[1].rank, 7)
552 self.assertEqual(fragmap[1].residues[1].aa, 'E')
553
554 def testDump(self):
555
556 with self.config.getTempStream() as tmp:
557
558 self.map.dump(tmp.name)
559 tmp.flush()
560
561 ref = self.config.getContent('1nz9A.frags').rstrip()
562 new = open(tmp.name).read().rstrip()
563
564 self.assertEqual(ref, new)
565
566
567 if __name__ == '__main__':
568 test.Console()
569