Debian Codegraph @

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

raw
1 import numpy
2
3 import csb.test as test
4 import csb.bio.structure as structure
5 import csb.core
6
7 import csb.bio.sequence as sequence
8
9
10 @test.regression
11 class ChainRegressions(test.Case):
12
13 def setUp(self):
14
15 super(ChainRegressions, self).setUp()
16
17 self.structure = self.config.getPickle('1nz9.model1.pickle')
18 self.chain = self.structure['A']
19
20 def testClone(self):
21 """
22 @see: [CSB 0000029]
23 """
24 self.assertEqual(self.chain.residues[1].clone()._container, None)
25
26 def testApplyTransformation(self):
27 """
28 @see: [CSB 0000030]
29 """
30 r = numpy.eye(3)
31 t = numpy.array([1, 1, 1])
32
33 residue = self.chain.residues[1]
34
35 atom1 = structure.Atom(99999, 'Cx', structure.ChemElements.C, numpy.array([2, 2, 2]), alternate=True)
36 atom1.occupancy = 0.2
37 atom2 = structure.Atom(99999, 'Cx', structure.ChemElements.C, numpy.array([2, 2, 2]), alternate=True)
38 atom2.occupancy = 0.8
39
40 residue.atoms.append(atom1)
41 residue.atoms.append(atom2)
42
43 self.chain.transform(r, t)
44
45 disatom = residue.atoms['Cx']
46 self.assertTrue(isinstance(disatom, structure.DisorderedAtom))
47 self.assertEqual(disatom.vector.tolist(), [3, 3, 3])
48
49 # now the regression itself
50 for altatom in disatom:
51 self.assertEqual(altatom.vector.tolist(), [3, 3, 3])
52
53 @test.skip("may fail on slower machines")
54 def testListCoordinates(self):
55 """
56 Performance tweaks in AbstractEntity.get_coordinates()
57 """
58
59 def test():
60 for dummy in range(1000):
61 self.structure.get_coordinates(what=['CA'])
62
63 self.assertFasterThan(0.50, test)
64
65 def testAppendAtom(self):
66 """
67 @see: [CSB 0000122]
68 """
69 r = structure.ProteinResidue(1, sequence.ProteinAlphabet.ALA)
70
71 a1 = structure.Atom(1, 'CA', structure.ChemElements.C, [1, 1, 1], alternate='A')
72 a2 = structure.Atom(1, 'CA', structure.ChemElements.C, [1, 1, 1], alternate='B')
73
74 r.atoms.append(a1)
75 r.atoms.append(a2)
76
77 self.assertEqual(a1.residue, r)
78 self.assertEqual(a2.residue, r)
79
80
81 @test.unit
82 class TestAbstractEntity(test.Case):
83
84 def setUp(self):
85
86 super(TestAbstractEntity, self).setUp()
87
88 self.e = self.config.getPickle('1nz9.full.pickle')
89 self.s = self.e.models[1]
90 self.c = self.s.chains['A']
91 self.r = self.c.residues[1]
92 self.a = self.r.atoms['CA']
93
94 def testItems(self):
95
96 self.assertEqual(list(self.e.items), list(self.e.models))
97 self.assertEqual(list(self.s.items), list(self.s.chains[c] for c in self.s.chains))
98 self.assertEqual(list(self.c.items), list(self.c.residues))
99 self.assertEqual(list(self.r.items), list(self.r.atoms[a] for a in self.r.atoms))
100 self.assertEqual(list(self.a.items), list([]))
101
102 def testComponents(self):
103
104 # also covers the composite iterators
105
106 items = list(structure.CompositeEntityIterator.create(self.e, leaf=structure.Chain))
107 self.assertEqual(items, [self.e[0], self.e[0]['A'], self.e[1], self.e[1]['A']])
108
109 self.assertEqual(list(self.e.components())[:4], [self.s, self.c, self.r, list(self.r.items)[0]])
110 self.assertEqual(list(self.e.components(structure.Structure)), list(self.e.models))
111 self.assertEqual(list(self.e.components(structure.Chain)), [self.e[0]['A'], self.e[1]['A']])
112
113 self.assertEqual(list(self.r.components()), [self.r[a] for a in self.r.atoms])
114 self.assertEqual(list(self.r.components(structure.Atom)), [self.r[a] for a in self.r.atoms])
115 self.assertEqual(list(self.r.components(structure.Residue)), [])
116
117 self.assertEqual(list(self.a.components()), [])
118 self.assertEqual(list(self.a.components(structure.Atom)), [])
119
120 def testApplyTransformation(self):
121
122 R = numpy.eye(3)
123 t = numpy.array([1, 2, 3])
124
125 original = self.s['A'].get_coordinates(('CA',))
126 assert len(original) > 0
127
128 self.e.transform(R, t)
129 translated = self.s['A'].get_coordinates(('CA',))
130
131 self.e.transform(R, -t)
132 restored = self.s['A'].get_coordinates(('CA',))
133
134 self.assertTrue(len(original) == len(translated) == len(restored))
135
136 for i in range(len(original)):
137 for j in range(3):
138 self.assertEqual((original[i] + t)[j], translated[i][j])
139 self.assertAlmostEqual(original[i][j], restored[i][j], places=13)
140
141 def testListCoordinates(self):
142
143 # all atoms
144 original, listed = [], []
145
146 for s in self.e.items:
147 for c in s.items:
148 for r in c.items:
149 for a in r.items:
150 original.append(list(a.vector))
151
152 for i in self.e.get_coordinates(what=None):
153 listed.append(list(i))
154
155 self.assertEqual(original, listed)
156 self.assertEqual([list(i) for i in self.r.get_coordinates()], [list(a.vector) for a in self.r.items])
157 self.assertEqual(list(self.a.get_coordinates()[0]), list(self.a.vector))
158
159 # specific atoms
160 original, listed = [], []
161
162 for s in self.e.items:
163 for c in s.items:
164 for r in c.items:
165 original.append(list(r.atoms['CA'].vector))
166
167 for i in self.e.get_coordinates(what=['CA']):
168 listed.append(list(i))
169
170 self.assertEqual(original, listed)
171 self.assertEqual([list(i) for i in self.r.get_coordinates(['CA'])], [list(self.r.atoms['CA'].vector)])
172 self.assertEqual(list(self.a.get_coordinates(['CA'])[0]), list(self.a.vector))
173
174 # other stuff
175 self.assertRaises(structure.Broken3DStructureError, lambda: self.c.get_coordinates(what=['BUG']))
176 self.assertRaises(structure.Broken3DStructureError, lambda: self.r.get_coordinates(what=['BUG']))
177 self.assertRaises(structure.Broken3DStructureError, lambda: self.a.get_coordinates(what=['BUG']))
178
179 @test.unit
180 class TestEnsemble(test.Case):
181
182 def setUp(self):
183
184 super(TestEnsemble, self).setUp()
185 self.ensemble = self.config.getPickle('1nz9.full.pickle')
186
187 def testItems(self):
188
189 models = list(self.ensemble.items)
190 self.assertEqual(len(models), self.ensemble.models.length)
191
192 def testComponents(self):
193
194 models = list(self.ensemble.components(klass=structure.Structure))
195 self.assertEqual(len(models), self.ensemble.models.length)
196
197 def testGetitem(self):
198
199 self.assertEqual(self.ensemble.models.length, 2)
200 self.assertEqual(self.ensemble.models[1].model_id, 1)
201 self.assertEqual(self.ensemble[1].model_id, 2)
202
203 def testFirstModel(self):
204
205 self.assertEqual(self.ensemble.models[1], self.ensemble.first_model)
206 self.assertEqual(self.ensemble[0], self.ensemble.first_model)
207
208 def testAppend(self):
209
210 testModel = structure.Structure('test')
211 testModel.model_id = 3
212 rank = self.ensemble.models.append(testModel)
213
214 self.assertEqual(rank, 3)
215 self.assertEqual(self.ensemble.models[3], testModel)
216 self.assertEqual(self.ensemble.models[3].model_id, 3)
217
218 self.assertRaises(Exception, self.ensemble.models.append, 1)
219
220 def testToPDB(self):
221
222 pdbraw = self.ensemble.to_pdb()
223 pdb = pdbraw.splitlines()
224
225 model = 0
226 endmdl = 0
227
228 for line in pdb:
229 if line.startswith('MODEL '):
230 model += 1
231 if line.startswith('ENDMDL '):
232 endmdl += 1
233
234 self.assertEqual(model, self.ensemble.models.length)
235 self.assertEqual(endmdl, self.ensemble.models.length)
236
237 self.assertTrue(pdb[0].startswith, 'HEADER')
238 self.assertTrue(pdb[0].endswith('1NZ9 '))
239 self.assertEqual(pdb[-3].rstrip(), 'TER')
240 self.assertEqual(pdb[-2].rstrip(), 'ENDMDL')
241 self.assertEqual(pdb[-1].rstrip(), 'END')
242
243 @test.unit
244 class TestStructure(test.Case):
245
246 def setUp(self):
247
248 super(TestStructure, self).setUp()
249 self.structure = self.config.getPickle('1nz9.model1.pickle')
250 self.structure2 = self.config.getPickle('1nz9.model1.pickle')
251
252 def testGetitem(self):
253
254 self.assertEqual(self.structure.chains.length, 1)
255 self.assertTrue('A' in self.structure.chains)
256 self.assertTrue('A' in self.structure)
257 self.assertEqual(self.structure.chains['A'], self.structure['A'])
258 self.assertEqual(self.structure.chains['A'].id, 'A')
259
260 def testFirstChain(self):
261
262 self.assertEqual(self.structure.chains['A'], self.structure.first_chain)
263 self.assertEqual(self.structure['A'], self.structure.first_chain)
264
265 def testItems(self):
266
267 self.assertEqual(self.structure['A'], tuple(self.structure.items)[0])
268
269 def testAppend(self):
270
271 testChain = structure.Chain('$', accession='____')
272 self.structure2.chains.append(testChain)
273
274 self.assertTrue('$' in self.structure2.chains)
275 self.assertEqual(self.structure2.chains['$'], testChain)
276 self.assertEqual(self.structure2.chains['$'].accession, self.structure2.accession)
277
278 self.assertRaises(structure.DuplicateChainIDError, self.structure2.chains.append, testChain)
279 self.assertRaises(structure.InvalidOperation, self.structure2.chains.append, self.structure.first_chain)
280
281 def testRemove(self):
282
283 self.assertTrue('A' in self.structure2.chains)
284 self.structure2.chains.remove('A')
285 self.assertFalse('A' in self.structure2.chains)
286
287 for c in ['.', 'A']:
288 self.assertRaises(structure.ChainNotFoundError, self.structure2.chains.remove, c)
289
290 def testAccession(self):
291
292 self.assertEqual(self.structure.accession, '1nz9')
293
294 self.structure.accession = ' TeST '
295 self.assertEqual(self.structure.accession, 'test')
296
297 for chain in self.structure.items:
298 self.assertEqual(chain.accession, self.structure.accession)
299
300 self.structure.accession = '1nz9'
301
302 def testToFASTA(self):
303
304 fasta = self.structure.to_fasta().splitlines()
305 self.assertTrue(fasta[0].startswith('>1nz9_A'))
306 self.assertEqual(fasta[1], 'AQVAFREGDQVRVVSGPFADFTGTVTEINPERGKVKVMVTIFGRETPVELDFSQVVKA')
307
308 def testToPDB(self):
309
310 pdbraw = self.structure.to_pdb()
311 pdb = pdbraw.splitlines()
312
313 self.assertTrue(pdb[0].startswith, 'HEADER')
314 self.assertTrue(pdb[0].endswith('1NZ9 '))
315 self.assertEqual(pdb[-2].rstrip(), 'TER')
316 self.assertEqual(pdb[-1].rstrip(), 'END')
317
318 for line in pdb:
319 self.assertTrue(not line.startswith('MODEL '))
320 self.assertTrue(not line.startswith('ENDMDL '))
321
322 has_seqres = False
323 has_atom = False
324 # check first SEQRES line
325 for l in pdb:
326 if l.startswith('SEQRES') and not has_seqres:
327 has_seqres = True
328 self.assertEqual(l, 'SEQRES 1 A 58 ALA GLN VAL ALA PHE ARG GLU GLY ASP GLN VAL ARG VAL ')
329
330 if l.startswith('SEQRES 3 A 58'):
331 self.assertEqual(l, 'SEQRES 3 A 58 GLU ILE ASN PRO GLU ARG GLY LYS VAL LYS VAL MSE VAL ')
332 break
333
334 # check first ATOM line
335 for l in pdb:
336 if l.startswith('ATOM') and not has_atom:
337 has_atom = True
338 self.assertEqual(l, 'ATOM 1 N ALA A 127 -0.977 -18.702 -7.689 1.00 0.00 N ')
339
340 if l.startswith('ATOM 572'):
341 self.assertEqual(l, 'ATOM 572 SE MSE A 164 8.107 5.802 4.753 1.00 0.00 Se ')
342 break
343
344 self.assertTrue(has_seqres)
345 self.assertTrue(has_atom)
346
347 # test also the content written to a file stream
348 with self.config.getTempStream() as tmp:
349
350 self.structure.to_pdb(tmp)
351 tmp.flush()
352
353 self.assertEqual(pdbraw, open(tmp.name).read())
354
355 # and to a file
356 with self.config.getTempStream() as tmp:
357 self.structure.to_pdb(tmp.name)
358 self.assertEqual(pdbraw, open(tmp.name).read())
359
360 def testFromChain(self):
361 new_structure = structure.Structure.from_chain(self.structure.first_chain)
362
363 self.assertEqual(new_structure.chains.length,1)
364 self.assertEqual(new_structure.first_chain.get_coordinates(('CA',)).tolist(),
365 self.structure.first_chain.get_coordinates(('CA',)).tolist(),)
366
367 self.assertEqual(new_structure.first_chain.sequence,
368 self.structure.first_chain.sequence)
369
370
371
372
373 @test.unit
374 class TestChain(test.Case):
375
376 def setUp(self):
377
378 super(TestChain, self).setUp()
379
380 self.structure = self.config.getPickle('1nz9.model1.pickle')
381 self.chain = self.structure['A']
382
383 def testFromSequence(self):
384
385 seq = sequence.Sequence('testA', 'test seq', 'ABCDE', type=sequence.SequenceTypes.Protein)
386 chain = structure.Chain.from_sequence(seq, 'Z')
387
388 self.assertEqual(chain.sequence, 'ABCDE')
389 self.assertEqual(chain.id, 'Z')
390 self.assertEqual(chain.residues[2].sequence_number, 2)
391 self.assertEqual(chain.residues[2].rank, 2)
392 self.assertEqual(chain.residues[2].type, sequence.ProteinAlphabet.ASX)
393
394 def testId(self):
395
396 self.assertEqual(self.chain.id, 'A')
397 self.chain.id = '$'
398 self.assertEqual(self.chain.id, '$')
399 self.assertEqual(tuple(self.structure.items)[0].id, '$')
400 self.assertTrue('$' in self.structure)
401 self.chain.id = 'A'
402
403 def testAccession(self):
404
405 def assign(chain, value):
406 chain.accession = value
407
408 self.assertRaises(structure.InvalidOperation, assign, self.chain, 'xxxx')
409 chain = self.chain.clone()
410 chain.accession = 'xxxx'
411 self.assertEqual(chain.accession, 'xxxx')
412
413 def testType(self):
414 self.assertEqual(self.chain.type, structure.SequenceTypes.Protein)
415
416 def testEntryID(self):
417 self.assertEqual(self.chain.entry_id, '1nz9A')
418
419 def testSequence(self):
420 self.assertEqual(self.chain.sequence, 'AQVAFREGDQVRVVSGPFADFTGTVTEINPERGKVKVMVTIFGRETPVELDFSQVVKA')
421
422 def testHeader(self):
423 self.assertTrue(self.chain.header.startswith('1nz9_A'))
424
425 def testLength(self):
426 self.assertEqual(self.chain.length, 58)
427 self.assertEqual(self.chain.length, len(self.chain))
428
429 def testAlphabet(self):
430
431 self.assertEqual(self.chain.alphabet, structure.SequenceAlphabets.Protein)
432
433 chain = self.chain.clone()
434 chain.type = structure.SequenceTypes.DNA
435 self.assertEqual(chain.alphabet, structure.SequenceAlphabets.Nucleic)
436
437 def testSecStructure(self):
438
439 self.assertEqual(self.chain.secondary_structure.length, 6)
440 self.assertEqual(self.chain.secondary_structure[1].type, structure.SecStructures.Strand)
441 self.assertEqual(self.chain.secondary_structure[5].type, structure.SecStructures.Helix)
442 self.assertEqual(self.chain.secondary_structure.to_string(), '---------EEEE--------EEEEEEEE----EEEEEEE----EEEEEE-HHHEEE')
443
444 def testClone(self):
445
446 chain = self.chain
447 clone = chain.clone()
448
449 self.assertEqual(chain.id, clone.id)
450 self.assertEqual(chain.length, clone.length)
451 self.assertNotEqual(id(chain), id(clone))
452
453 # residues
454 self.assertEqual(chain[0].type, clone[0].type)
455 self.assertNotEqual(id(chain[0]), id(clone[0]))
456 # atoms
457 self.assertEqual(set(chain[0].atoms), set(clone[0].atoms))
458 self.assertNotEqual(id(chain[0]['CA']), id(clone[0]['CA']))
459
460 # detached?
461 self.assertEqual(chain._structure, self.structure)
462 self.assertEqual(clone._structure, None)
463
464 def testSubregion(self):
465
466 sub = self.chain.subregion(1, self.chain.length)
467 self.assertEqual(list(self.chain.residues), list(sub.residues))
468
469 self.assertRaises(IndexError, self.chain.subregion, -1, 5)
470 self.assertRaises(IndexError, self.chain.subregion, 1, self.chain.length + 1)
471
472 def testFind(self):
473
474 self.assertEqual(self.chain.find('127'), self.chain[0])
475
476 self.chain[0].id = 127, 'X'
477 self.assertEqual(self.chain.find('127', 'X'), self.chain[0])
478
479 self.chain[0].id = 127, None
480 self.assertRaises(structure.EntityNotFoundError, self.chain.find, 127, 'X')
481 self.assertRaises(structure.EntityNotFoundError, self.chain.find, 999999)
482
483 def testComputeTorsion(self):
484
485 self.assertRaises(structure.InvalidOperation, lambda:self.chain.torsion)
486 self.chain.compute_torsion()
487
488 self.assertEqual(self.chain.residues[1].torsion.phi, None)
489 self.assertNotEqual(self.chain.residues[1].torsion.psi, None)
490
491 # http://www.fz-juelich.de/nic/cbb/wang/dssp/dssp/1nz9.dssp
492 self.assertAlmostEqual(self.chain.residues[2].torsion.phi, -134.597, places=3)
493 self.assertAlmostEqual(self.chain.residues[2].torsion.psi, 155.738, places=3)
494 self.assertAlmostEqual(self.chain.residues[2].torsion.omega, 179.916, places=3)
495
496 def testListCoordinates(self):
497
498 coords = self.chain.get_coordinates(('CA',))
499 self.assertEqual(coords[0].tolist(), self.chain[0]['CA'].vector.tolist())
500 self.assertEqual(len(coords), self.chain.length)
501
502 self.assertRaises(structure.Broken3DStructureError, self.chain.get_coordinates, ('H',))
503
504 def testSuperimpose(self):
505
506 clone = self.chain.clone()
507 si = self.chain.superimpose(clone)
508
509 self.assertAlmostEqual(si.rmsd, 0.0, places = 6)
510 for coord in si.translation:
511 self.assertAlmostEqual(coord, 0.0)
512
513 clone.transform(si.rotation, si.translation)
514 self.assertAlmostEqual(self.chain.rmsd(clone), 0, 5)
515
516 # not testable for now, but ensure at least no exception is raised
517 si = self.chain.superimpose(clone, what=('C', 'CA',))
518 si = self.chain.superimpose(clone, how=structure.AlignmentTypes.Local)
519
520 # make sure the subject is not moving (as it is the case in .align)
521 # - grab a different structure
522 diff = self.chain.clone()
523 diff[1]['CA'].vector += 2.0
524 x = diff[1]['CA'].vector[0]
525 # - superimpose them
526 si = self.chain.superimpose(diff)
527 # - assert diff is untouched
528 assert si.rmsd > 0, 'test with different structures'
529 self.assertEqual(diff[1]['CA'].vector[0], x)
530
531 self.assertRaises(ValueError, clone.superimpose, clone.subregion(1, 1))
532
533 def testAlign(self):
534
535 clone = self.chain.clone()
536 si = self.chain.align(clone)
537
538 self.assertAlmostEqual(si.rmsd, 0.0, places = 6)
539 for coord in si.translation:
540 self.assertAlmostEqual(coord, 0.0)
541
542 self.assertAlmostEqual(self.chain.rmsd(clone), 0, 5)
543
544 # mutate clone a bit to achieve RMSD != 0
545 clone[0]['CA'].vector[0] += 2.0
546 si = self.chain.align(clone)
547 self.assertNotEqual(si.rmsd, 0.0)
548
549 # ensure clone has been transformed; self.chain holds the original coords of clone
550 self.assertNotEqual(clone[3]['CA'].vector[0], self.chain[3]['CA'].vector[0])
551
552 self.assertRaises(ValueError, clone.align, clone.subregion(1, 1))
553
554 # not testable for now, but ensure at least no exception is raised
555 si = self.chain.align(clone, what=('C', 'CA',))
556 si = self.chain.align(clone, how=structure.AlignmentTypes.Local)
557
558 def testRMSD(self):
559
560 chain = self.chain
561 self.assertAlmostEqual(chain.rmsd(chain), 0.0, places=6)
562 self.assertAlmostEqual(chain.rmsd(chain, what=['N', 'CA', 'C', 'O']), 0.0, places=6)
563
564 self.assertRaises(ValueError, chain.rmsd, chain.subregion(1, 1))
565
566 def testTMSuperimpose(self):
567
568 clone = self.chain.clone()
569 si = self.chain.tm_superimpose(clone)
570
571 self.assertEqual(si.tm_score, 1.0)
572 for coord in si.translation:
573 self.assertAlmostEqual(coord, 0.0)
574
575 clone.transform(si.rotation, si.translation)
576 self.assertEqual(self.chain.tm_score(clone), 1.0)
577
578 # not testable for now, but ensure at least no exception is raised
579 si = self.chain.tm_superimpose(clone, what=('C', 'CA',))
580 si = self.chain.tm_superimpose(clone, how=structure.AlignmentTypes.Local)
581
582 # make sure the subject is not moving (as it is the case in .align)
583 # - grab a different structure
584 diff = self.chain.clone()
585 diff[1]['CA'].vector += 2.0
586 x = diff[1]['CA'].vector[0]
587 # - superimpose them
588 si = self.chain.tm_superimpose(diff)
589 # - assert diff is untouched
590 assert si.tm_score < 1, 'test with different structures'
591 self.assertEqual(diff[1]['CA'].vector[0], x)
592
593 self.assertRaises(ValueError, clone.tm_superimpose, clone.subregion(1, 1))
594
595 def testTMScore(self):
596
597 chain = self.chain
598 self.assertAlmostEqual(chain.tm_score(chain), 1.0, places=6)
599 self.assertAlmostEqual(chain.tm_score(chain, what=['N', 'CA', 'C', 'O']), 1.0, places=6)
600
601 self.assertRaises(ValueError, chain.tm_score, chain.subregion(1, 1))
602
603 def testGetitem(self):
604
605 self.assertEqual(self.chain.residues[1], self.chain[0])
606
607 self.assertRaises(csb.core.CollectionIndexError, lambda:self.chain.residues[0])
608 self.assertRaises(csb.core.CollectionIndexError, lambda:self.chain.residues[59])
609 self.assertRaises(IndexError, lambda:self.chain[58])
610
611 self.assertEqual(self.chain[0].type, structure.SequenceAlphabets.Protein.ALA)
612 self.assertEqual(self.chain[0].rank, 1)
613 self.assertEqual(self.chain[0].sequence_number, 127)
614 self.assertEqual(self.chain[0].id, '127')
615
616 def testAppend(self):
617
618 chain = self.chain.clone()
619 chain.compute_torsion()
620 assert chain.torsion is not None
621 residue = structure.ProteinResidue(9999, structure.SequenceAlphabets.Protein.ALA, 9999, 'A')
622
623 rank = chain.residues.append(residue)
624 self.assertTrue(chain.residues._contains('9999A'))
625 self.assertRaises(structure.InvalidOperation, lambda:chain.torsion)
626
627 self.assertEqual(chain[-1], residue)
628 self.assertEqual(chain.residues[59], residue)
629 self.assertEqual(rank, 59)
630
631 self.assertRaises(structure.DuplicateResidueIDError, chain.residues.append, residue)
632 # assert NOT raises DuplicateResidueIDError if id is None:
633 residue = structure.ProteinResidue(99999, structure.SequenceAlphabets.Protein.ALA)
634 chain.residues.append(residue)
635 chain.residues.append(residue)
636
637 def testContains(self):
638 self.assertTrue(self.chain.residues._contains('127'))
639
640 @test.unit
641 class TestResidue(test.Case):
642
643 def setUp(self):
644
645 super(TestResidue, self).setUp()
646
647 self.structure = self.config.getPickle('1nz9.model1.pickle')
648 self.chain = self.structure['A']
649 self.chain.compute_torsion()
650 self.residue = self.chain[0]
651
652 def testGetitem(self):
653
654 self.assertTrue('CA' in self.residue)
655 self.assertEqual(set(self.residue), set(['C', 'H2', 'CB', 'CA', 'H1', 'O', 'N', 'H3', 'HA', 'HB1', 'HB3', 'HB2']))
656
657 self.assertEqual(self.residue['CA'], self.residue.atoms['CA'])
658 self.assertEqual(self.residue['CA'], tuple(self.residue.items)[1])
659
660 self.assertEqual(self.residue['CA'].element, structure.ChemElements.C)
661 self.assertEqual(self.residue['CA'].serial_number, 2)
662
663 def testItems(self):
664 self.assertEqual(tuple(self.residue.items)[0], self.residue['N'])
665 self.assertTrue(tuple(self.residue.items)[0] < tuple(self.residue.items)[1])
666
667 def testHasStructure(self):
668
669 self.assertTrue(self.residue.has_structure)
670
671 residue = structure.ProteinResidue(111, 'ALA')
672 self.assertFalse(residue.has_structure)
673
674 def testId(self):
675
676 def assign(sn, ins=None):
677 self.residue.id = sn, ins
678
679 # should raise if the residue is part of a chain and SN=128 is already there (true)
680 self.assertRaises(structure.DuplicateResidueIDError, assign, 128)
681 self.assertRaises(structure.DuplicateResidueIDError, assign, '128 ')
682 # should not raise (same residue)
683 self.residue.id = 127, None
684
685 # sequence_number must be defined when an insertion_code is specified
686 self.assertRaises(structure.InvalidOperation, assign, None, 'X')
687
688 self.residue.id = 111127, 'X'
689 self.assertEqual(self.chain.find(111127, 'X'), self.residue)
690 self.residue.id = 127, None
691
692 def testSequenceNumber(self):
693 self.assertEqual(self.residue.sequence_number, 127)
694
695 def testInsertionCode(self):
696 self.assertEqual(self.residue.insertion_code, None)
697
698 def testType(self):
699 self.assertEqual(self.residue.type, structure.SequenceAlphabets.Protein.ALA)
700
701 def testIsModified(self):
702 self.assertFalse(self.residue.is_modified)
703 self.assertTrue(self.chain[37].is_modified)
704
705 def testLabel(self):
706 self.assertEqual(self.residue.label, repr(self.residue.type))
707 self.assertTrue(self.chain[37].label, 'MSE')
708
709 def testTorsion(self):
710 self.assertEqual(self.residue.torsion.phi, None)
711 self.assertNotEqual(self.residue.torsion.psi, None)
712
713 def testFactory(self):
714
715 factory = structure.Residue.create
716
717 nucleotide = factory(structure.SequenceTypes.NucleicAcid, 1, structure.SequenceAlphabets.Nucleic.Adenine)
718 aminoacid = factory(structure.SequenceTypes.Protein, 1, structure.SequenceAlphabets.Protein.ALA)
719 unknown = factory(structure.SequenceTypes.Unknown, 1, structure.SequenceAlphabets.Unknown.UNK)
720
721 self.assertTrue(isinstance(nucleotide, structure.NucleicResidue))
722 self.assertTrue(isinstance(aminoacid, structure.ProteinResidue))
723 self.assertTrue(isinstance(unknown, structure.UnknownResidue))
724
725 def testAppend(self):
726
727 # should raise if appending an atom with atom._residue (already part of another residue)
728 self.assertRaises(structure.InvalidOperation, self.residue.atoms.append, self.chain[2]['CA'])
729 # should not raise InvalidOperation (same residue)
730 self.assertRaises(structure.DuplicateAtomIDError, self.residue.atoms.append, self.residue['CA'])
731
732 atom = structure.Atom(999999, 'Cx', structure.ChemElements.C, numpy.array([1, 1, 1]))
733 self.residue.atoms.append(atom)
734 self.assertTrue(atom.name in self.residue)
735 self.assertEqual(atom.residue, self.residue)
736
737 # test alternate handling
738 atom2 = structure.Atom(999999, 'Cx', structure.ChemElements.C, numpy.array([2, 2, 2]), alternate=True)
739 self.residue.atoms.append(atom2)
740 self.assertTrue(isinstance(self.residue['Cx'], structure.DisorderedAtom))
741 self.assertEqual(self.residue['Cx'].length, 2)
742
743 atom3 = structure.Atom(999999, 'Cx', structure.ChemElements.C, numpy.array([3, 3, 3]))
744 self.residue.atoms.append(atom3)
745 self.assertEqual(self.residue['Cx'].length, 3)
746
747 @test.unit
748 class TestAtom(test.Case):
749
750 def setUp(self):
751
752 super(TestAtom, self).setUp()
753
754 self.structure = self.config.getPickle('1nz9.model1.pickle')
755 self.chain = self.structure['A']
756 self.residue = self.chain[0]
757 self.atom = self.residue['CA']
758
759 def testName(self):
760 self.assertEqual(self.atom.name, 'CA')
761
762 def testSerialNumber(self):
763 """
764 @bug: check for overlapping SNs in a Chain
765 """
766
767 def assign(sn):
768 self.atom.serial_number = sn
769
770 self.assertEqual(self.atom.serial_number, 2)
771 self.assertRaises(TypeError, assign, -2)
772
773 def testElement(self):
774 self.assertEqual(self.atom.element, structure.ChemElements.C)
775
776 def testResidue(self):
777 """
778 @todo: more checks are needed here (e.g. append an atom to different residues)
779 """
780 self.assertEqual(self.atom.residue, self.residue)
781
782 def testSorting(self):
783 self.assertTrue(self.residue['N'] < self.residue['CA'])
784
785 def testVector(self):
786
787 def assign(v):
788 self.atom.vector = v
789
790 self.assertEqual(self.atom.vector.tolist(), [-0.96399999999999997, -17.864999999999998, -6.46])
791 self.assertRaises(ValueError, assign, numpy.array([1]))
792
793 @test.unit
794 class TestDisorderedAtom(TestAtom):
795
796 def setUp(self):
797
798 super(TestDisorderedAtom, self).setUp()
799
800 self.structure = self.config.getPickle('1nz9.model1.pickle')
801 self.chain = self.structure['A']
802 self.residue = self.chain[0]
803 self.atom = self.residue['CA']
804
805 self.alt = structure.Atom(999, 'CA', structure.ChemElements.C,
806 self.atom.vector.copy(), alternate='B')
807
808 self.atom.occupancy = 0.9
809 self.alt.occupancy = 0.1
810 self.residue.atoms.append(self.alt)
811
812 self.disatom = self.residue['CA']
813
814 def testAppend(self):
815
816 self.assertEqual(self.residue.atoms['CA'].serial_number, 2)
817
818 alt = structure.Atom(1000, 'CA', structure.ChemElements.C,
819 self.atom.vector.copy(), alternate='C')
820
821 alt.occupancy = 1.0
822 self.residue.atoms.append(alt)
823
824 self.assertEqual(self.residue.atoms['CA'].serial_number, 1000)
825 self.assertTrue(isinstance(self.residue.atoms['CA'], structure.DisorderedAtom))
826
827 def testIteration(self):
828
829 atoms = list(self.residue.atoms['CA'])
830 self.assertEqual(len(atoms), 2)
831
832 def testLength(self):
833 self.assertEqual(self.disatom.length, 2)
834
835 def testFind(self):
836 self.assertTrue(self.disatom.find('B') is self.alt)
837 self.assertRaises(structure.EntityNotFoundError, self.disatom.find, 'X')
838
839
840 @test.unit
841 class TestSecondaryStructure(test.Case):
842 """
843 @todo: implement secondary structure tests
844 """
845
846 def setUp(self):
847
848 super(TestSecondaryStructure, self).setUp()
849
850 self.structure = self.config.getPickle('1nz9.model1.pickle')
851 self.chain = self.structure['A']
852 self.residue = self.chain[0]
853
854 @test.unit
855 class TestTorsionAngles(test.Case):
856
857 def setUp(self):
858
859 super(TestTorsionAngles, self).setUp()
860
861 self.structure = self.config.getPickle('1nz9.model1.pickle')
862 self.chain = self.structure['A']
863 self.chain.compute_torsion()
864
865 self.angles1 = structure.TorsionAnglesCollection()
866 self.angles2 = structure.TorsionAnglesCollection()
867 self.angles3 = structure.TorsionAnglesCollection()
868 self.angles4 = structure.TorsionAnglesCollection()
869
870 for dummy in range(10):
871 self.angles1.append(structure.TorsionAngles(20, 30, 180))
872 self.angles2.append(structure.TorsionAngles(20, 30, 180))
873 self.angles3.append(structure.TorsionAngles(20, 30, 180))
874 self.angles4.append(structure.TorsionAngles(20, 30, 180))
875
876 self.angles2[5].phi = 40
877 self.angles2[7].psi = 10
878 self.angles3[4].phi = None
879 self.angles4[1].phi = None
880
881 def testRMSD(self):
882
883 self.assertEqual(self.chain.torsion.rmsd(self.chain.torsion), 0.0)
884 self.assertNotEqual(self.angles1.rmsd(self.angles2), 0.0)
885 self.assertEqual(self.angles1.rmsd(self.angles4), 0.0)
886 self.assertAlmostEqual(self.angles1.rmsd(self.angles2), 0.005442, places=5)
887
888 self.assertRaises(structure.Broken3DStructureError, self.angles1.rmsd, self.angles3)
889 self.assertRaises(ValueError, self.angles1.rmsd, structure.TorsionAnglesCollection())
890
891 def testConversion(self):
892
893 ta = structure.TorsionAngles(0, 90, 180)
894
895 ta.to_radians()
896 self.assertEqual(ta.phi, 0)
897 self.assertAlmostEqual(ta.psi, 1.57, places=2)
898 self.assertAlmostEqual(ta.omega, 3.14, places=2)
899
900 ta.to_degrees()
901 self.assertEqual(ta.phi, 0)
902 self.assertEqual(ta.psi, 90)
903 self.assertEqual(ta.omega, 180)
904
905 def testBool(self):
906 self.assertTrue(structure.TorsionAngles(20, None, None))
907 self.assertFalse(structure.TorsionAngles(None, None, None))
908
909
910
911 if __name__ == '__main__':
912
913 test.Console()