Example #1
0
    def test_noetools(self):
        """Self test for NMR.NOEtools.

        Calculate and compare crosspeak peaklist files
        Adapted from Doc/examples/nmr/simplepredict.py by Robert Bussell, Jr.
        """
        self.xpk_i_file = os.path.join("NMR", "noed.xpk")
        # out_example.xpk is created by running Doc/examples/nmr/simplepredict.py
        # with noed.xpk as an input file.
        self.xpk_expected = os.path.join("NMR", "out_example.xpk")

        self.f_number, self.f_predicted = tempfile.mkstemp()
        os.close(self.f_number)

        # Calculate crosspeak from a peaklist input file
        # and save to a temporal file for comparison.
        try:
            self.peaklist = xpktools.Peaklist(self.xpk_i_file)
            self.res_dict = self.peaklist.residue_dict("H1")
            max_res = self.res_dict["maxres"]
            min_res = self.res_dict["minres"]

            self.peaklist.write_header(self.f_predicted)

            inc = 1  # The NOE increment (n where i->i+n and i->i-n are noes)
            count = 0  # A counter that number the output data lines in order
            res = min_res  # minimum residue number in the set
            out_list = []  # Holds the output data

            while res <= max_res:
                noe1 = NOEtools.predictNOE(self.peaklist, "15N2", "H1", res,
                                           res + inc)
                noe2 = NOEtools.predictNOE(self.peaklist, "15N2", "H1", res,
                                           res - inc)

                if noe1 != "":
                    noe1 = noe1 + "\012"
                    noe1 = xpktools.replace_entry(noe1, 1, count)
                    out_list.append(noe1)
                    count += 1

                    if noe2 != "":
                        noe2 = noe2 + "\012"
                        noe2 = xpktools.replace_entry(noe2, 1, count)
                        out_list.append(noe2)
                        count += 1
                res += 1

            # Open the output file and write the data
            with open(self.f_predicted, "a") as outfile:
                outfile.writelines(
                    out_list)  # Write the output lines to the file

            # Compare the content of the predicted output file with expected file
            pre_content = open(self.f_predicted).read()
            exp_content = open(self.xpk_expected).read()
            self.assertEqual(pre_content, exp_content)

        finally:
            os.remove(self.f_predicted)
Example #2
0
    def test_xpktools(self):
        """Self test for NMR.xpktools."""
        self.xpk_file = "NMR/noed.xpk"

        self.peaklist = xpktools.Peaklist(self.xpk_file)
        # Peaklist attributes checks
        self.assertEqual(self.peaklist.firstline, "label dataset sw sf ")
        self.assertEqual(self.peaklist.axislabels, "H1 15N2 N15 ")
        self.assertEqual(self.peaklist.dataset, "test.nv")
        self.assertEqual(self.peaklist.sw, "{1571.86 } {1460.01 } {1460.00 }")
        self.assertEqual(self.peaklist.sf,
                         "{599.8230 } { 60.7860 } { 60.7860 }")
        self.assertEqual(
            self.peaklist.datalabels,
            " H1.L  H1.P  H1.W  H1.B  H1.E  "
            "H1.J  15N2.L  15N2.P  15N2.W  15N2.B  "
            "15N2.E  15N2.J  N15.L  N15.P  N15.W  "
            "N15.B  N15.E  N15.J  vol  int  stat ",
        )
        # Peaklist data check
        self.assertEqual(len(self.peaklist.data), 8)
        self.assertEqual(
            self.peaklist.data[0],
            "0  3.hn   8.853   0.021   0.010   ++   "
            "0.000   3.n   120.104   0.344   0.010   PP"
            "   0.000   3.n   120.117   0.344   0.010   "
            "PP   0.000  1.18200 1.18200 0",
        )
        self.assertEqual(
            self.peaklist.data[7],
            "8  10.hn   7.663   0.021   0.010   ++   "
            "0.000   10.n   118.341   0.324   0.010   "
            "+E   0.000   10.n   118.476   0.324   "
            "0.010   +E   0.000  0.49840 0.49840 0",
        )

        # Peaklist residue dict check
        self.assertEqual(len(self.peaklist.residue_dict("H1")["10"]), 1)
        self.assertEqual(
            self.peaklist.residue_dict("H1")["10"][0],
            "8  10.hn   7.663   0.021"
            "   0.010   ++   0.000   "
            "10.n   118.341   0.324   "
            "0.010   +E   0.000   10.n"
            "   118.476   0.324   0.010"
            "   +E   0.000  0.49840 "
            "0.49840 0",
        )
Example #3
0
# * * * * * * * * * * MAIN * * * * * * * * * *

# ***** INITS *****

inc = 1                      # The NOE increment (n where i->i+n and i->i-n are noes)
infn = "./noed.xpk"          # Input peaklist
outfn = "./out_example.xpk"  # Output peaklist
detectatom = "H1"           # Directly detected atom
relayatom = "N15"           # J-coupling from here to detected atom
fromatom = "15N2"           # The other labelled nucleus

#  First the peaklist is read into a data class from xpktools
#  that contains methods for easily extracting information from
#  the peaklist file

peaklist = xpktools.Peaklist(infn)  # infn is the name of the xpk file

# The class attribute residue_dict allows the data lines
# to be separated from the header and returned here to
# the dictionary <dict> as a list indexed by the assignment
# of any of the nuclei in the file -- here, the detected atom
# is used

dict = peaklist.residue_dict(detectatom)

# As well as the data, the dictionary contains two other entries,
# corresponding to the maximum and minimum residues indexed

MAXRES = dict["maxres"]
MINRES = dict["minres"]