File: test_PDB_Superimposer.py

package info (click to toggle)
python-biopython 1.78%2Bdfsg-4
  • links: PTS, VCS
  • area: main
  • in suites: bullseye
  • size: 65,756 kB
  • sloc: python: 221,141; xml: 178,777; ansic: 13,369; sql: 1,208; makefile: 131; sh: 70
file content (119 lines) | stat: -rw-r--r-- 6,477 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
# Copyright 2017 by Francesco Gastaldello. All rights reserved.
#
# Converted by Francesco Gastaldello from an older unit test copyright 2004
# by Thomas Hamelryck.
#
# This file is part of the Biopython distribution and governed by your
# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
# Please see the LICENSE file that should have been included as part of this
# package.
"""Unit tests for the Bio.PDB.Superimposer module."""

import unittest

try:
    import numpy
except ImportError:
    from Bio import MissingPythonDependencyError

    raise MissingPythonDependencyError(
        "Install NumPy if you want to use Bio.PDB."
    ) from None

from Bio.PDB import Superimposer, Selection
from Bio.PDB import PDBParser


class SuperimposerTests(unittest.TestCase):
    """Test Superimposer module."""

    def test_Superimposer(self):
        """Test on module that superimpose two protein structures."""
        pdb1 = "PDB/1A8O.pdb"
        p = PDBParser()
        s1 = p.get_structure("FIXED", pdb1)
        fixed = Selection.unfold_entities(s1, "A")
        s2 = p.get_structure("MOVING", pdb1)
        moving = Selection.unfold_entities(s2, "A")
        rot = numpy.identity(3).astype("f")
        tran = numpy.array((1.0, 2.0, 3.0), "f")
        for atom in moving:
            atom.transform(rot, tran)
        sup = Superimposer()
        sup.set_atoms(fixed, moving)
        self.assertTrue(numpy.allclose(sup.rotran[0], numpy.identity(3)))
        self.assertTrue(numpy.allclose(sup.rotran[1], numpy.array([-1.0, -2.0, -3.0])))
        self.assertAlmostEqual(sup.rms, 0.0, places=3)
        # Turn black code style off
        # fmt: off
        atom_list = ["N", "C", "C", "O", "C", "C", "SE", "C", "N", "C", "C",
                     "O", "C", "C", "O", "O", "N", "C", "C", "O", "C", "C",
                     "C", "C", "N", "C", "C", "O", "C", "C", "C", "N", "C",
                     "N", "N", "N", "C", "C", "O", "C", "C", "C", "O", "N",
                     "N", "C", "C", "O", "N", "C", "C", "O", "C", "C", "C",
                     "N", "C", "C", "O", "C", "C", "C", "C", "N", "N", "C",
                     "C", "O", "C", "C", "C", "O", "O", "N", "C", "C", "O",
                     "C", "C", "C", "N", "C", "C", "O", "C", "C", "C", "C",
                     "C", "C", "C", "N", "C", "C", "O", "C", "C", "C", "N",
                     "C", "N", "N", "N", "C", "C", "O", "C", "C", "O", "O",
                     "N", "C", "C", "O", "C", "C", "C", "C", "C", "C", "C",
                     "O", "N", "C", "C", "O", "C", "C", "C", "N", "C", "C",
                     "O", "C", "C", "O", "O", "N", "C", "C", "O", "C", "C",
                     "C", "N", "C", "N", "N", "N", "C", "C", "O", "C", "C",
                     "C", "C", "C", "C", "C", "N", "C", "C", "O", "C", "C",
                     "C", "C", "C", "C", "C", "O", "N", "C", "C", "O", "C",
                     "C", "C", "C", "N", "N", "C", "C", "O", "C", "O", "C",
                     "N", "C", "C", "O", "C", "C", "C", "C", "N", "C", "C",
                     "O", "C", "C", "C", "N", "C", "N", "N", "N", "C", "C",
                     "O", "C", "N", "C", "C", "O", "C", "C", "C", "O", "O",
                     "N", "C", "C", "O", "C", "C", "C", "O", "N", "N", "C",
                     "C", "O", "C", "N", "C", "C", "O", "C", "O", "N", "C",
                     "C", "O", "C", "C", "C", "O", "N", "N", "C", "C", "O",
                     "C", "C", "C", "O", "O", "N", "C", "C", "O", "C", "C",
                     "C", "N", "C", "C", "O", "C", "C", "C", "C", "N", "N",
                     "C", "C", "O", "C", "C", "O", "N", "N", "C", "C", "O",
                     "C", "C", "C", "C", "N", "C", "C", "C", "C", "C", "N",
                     "C", "C", "O", "C", "C", "SE", "C", "N", "C", "C", "O",
                     "C", "O", "C", "N", "C", "C", "O", "C", "C", "C", "O",
                     "O", "N", "C", "C", "O", "C", "O", "C", "N", "C", "C",
                     "O", "C", "C", "C", "C", "N", "C", "C", "O", "C", "C",
                     "C", "C", "N", "C", "C", "O", "C", "C", "C", "N", "C",
                     "C", "O", "C", "C", "C", "O", "N", "N", "C", "C", "O",
                     "C", "C", "O", "N", "N", "C", "C", "O", "C", "N", "C",
                     "C", "O", "C", "C", "O", "N", "N", "C", "C", "O", "C",
                     "C", "C", "N", "C", "C", "O", "C", "C", "O", "O", "N",
                     "C", "C", "O", "C", "S", "N", "C", "C", "O", "C", "C",
                     "C", "C", "N", "N", "C", "C", "O", "C", "O", "C", "N",
                     "C", "C", "O", "C", "C", "C", "C", "N", "C", "C", "O",
                     "C", "C", "C", "C", "N", "C", "C", "O", "C", "C", "C",
                     "C", "N", "N", "C", "C", "O", "C", "N", "C", "C", "O",
                     "C", "C", "C", "C", "N", "C", "C", "O", "N", "C", "C",
                     "O", "C", "C", "C", "N", "C", "C", "O", "N", "C", "C",
                     "O", "C", "N", "C", "C", "O", "C", "O", "C", "N", "C",
                     "C", "O", "C", "C", "C", "C", "N", "C", "C", "O", "C",
                     "C", "C", "O", "O", "N", "C", "C", "O", "C", "C", "C",
                     "O", "O", "N", "C", "C", "O", "C", "C", "SE", "C", "N",
                     "C", "C", "O", "C", "C", "SE", "C", "N", "C", "C", "O",
                     "C", "O", "C", "N", "C", "C", "O", "C", "N", "C", "C",
                     "O", "C", "S", "N", "C", "C", "O", "C", "C", "C", "O",
                     "N", "N", "C", "C", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O",
                     "O", "O", "O", "O", "O", "O"]
        # Turn black code style on
        # fmt: on
        sup.apply(moving)
        atom_moved = []
        for aa in moving:
            atom_moved.append(aa.element)
        self.assertEqual(atom_moved, atom_list)


if __name__ == "__main__":
    runner = unittest.TextTestRunner(verbosity=2)
    unittest.main(testRunner=runner)