Пример #1
0
    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(path=self.file_name)

        # Long messages
        self.longMessage = True
Пример #2
0
    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(atom_syms=self.good_direct_atoms,
                           coords=self.good_direct_geom)

        # Long messages
        self.longMessage = True
Пример #3
0
    def test_XYZ_BadUsageBadNoneParamsWithIters(self):

        from opan.xyz import OpanXYZ

        # Load the test file
        x = OpanXYZ(path=self.file_name)

        # Check error on multiple Nones passed
        with self.assertRaises(ValueError):
            [d for d in x.dist_iter(None, None, 1)]

        # Check error on None passed with iterable
        with self.assertRaises(ValueError):
            [d for d in x.dist_iter(None, [0, 1, 2], 3)]
Пример #4
0
    def test_XYZ_BadUsageBadNoneParamsWithIters(self):

        from opan.xyz import OpanXYZ

        # Load the test file
        x = OpanXYZ(path=self.file_name)

        # Check error on multiple Nones passed
        with self.assertRaises(ValueError):
            [d for d in x.dist_iter(None, None, 1)]

        # Check error on None passed with iterable
        with self.assertRaises(ValueError):
            [d for d in x.dist_iter(None, [0,1,2], 3)]
Пример #5
0
    def test_XYZ_BadUsageNoneInAngleIterAtom(self):
        # Confirm that an error is thrown when using angle_iter called with
        #  'error_invalid=True', when 'None' is passed as one of the 'at_n'
        #  parameters.

        from opan.xyz import OpanXYZ

        # Load the test file
        x = OpanXYZ(path=self.file_name)

        # Check that error is not raised when error_invalid == False, but
        #  *is* raised when error_invalid == True.
        try:
            [a for a in x.angle_iter(0,0,None,1, invalid_error=False)]
        except Exception:
            self.fail("Unexpected error raised in 'angle_iter' call")

        with self.assertRaises(ValueError):
            [a for a in x.angle_iter(0, 0, None, 1, invalid_error=True)]
Пример #6
0
    def test_XYZ_BadUsageBadDisplIndices(self):

        from opan.xyz import OpanXYZ

        # Load the test file
        x = OpanXYZ(path=self.file_name)

        # Try invalid arguments to dist_single, in both positions
        self.assertRaises(IndexError, x.displ_single, 0, 1000000, 0)
        self.assertRaises(IndexError, x.displ_single, 0, 0, 1000000)
Пример #7
0
    def test_XYZ_BadUsageNoneInAngleIterAtom(self):
        # Confirm that an error is thrown when using angle_iter called with
        #  'error_invalid=True', when 'None' is passed as one of the 'at_n'
        #  parameters.

        from opan.xyz import OpanXYZ

        # Load the test file
        x = OpanXYZ(path=self.file_name)

        # Check that error is not raised when error_invalid == False, but
        #  *is* raised when error_invalid == True.
        try:
            [a for a in x.angle_iter(0, 0, None, 1, invalid_error=False)]
        except Exception:
            self.fail("Unexpected error raised in 'angle_iter' call")

        with self.assertRaises(ValueError):
            [a for a in x.angle_iter(0, 0, None, 1, invalid_error=True)]
Пример #8
0
    def test_XYZ_AltFileDataFirstCuAtomnum(self):

        from opan.xyz import OpanXYZ
        from opan.error import XYZError

        try:
            xyz = OpanXYZ(path=(self.file_name + self.names.Cu_1st_as_atomnum))
        except XYZError:  # pragma: no cover
            self.fail("XYZ import failed when success was expected.")

        self.assertEqual(xyz.atom_syms[0].upper(), self.good_direct_atoms[0])
Пример #9
0
    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(path=self.file_name)

        # Long messages
        self.longMessage = True
Пример #10
0
    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(atom_syms=self.good_direct_atoms,
                                            coords=self.good_direct_geom)

        # Long messages
        self.longMessage = True
Пример #11
0
    def test_XYZ_BadUsageBadDihedIndices(self):

        from opan.xyz import OpanXYZ

        # Load the test file
        x = OpanXYZ(path=self.file_name)

        # Try invalid arguments to dihed_single, in all four positions
        self.assertRaises(IndexError, x.dihed_single, 0, 1000000, 1, 2, 3)
        self.assertRaises(IndexError, x.dihed_single, 0, 0, 1000, 2, 3)
        self.assertRaises(IndexError, x.dihed_single, 0, 0, 1, 20000, 3)
        self.assertRaises(IndexError, x.dihed_single, 0, 0, 1, 2, 3000000)

        # Test for catch on duplicate indices
        self.assertRaises(ValueError, x.dihed_single, 0, 0, 0, 0, 0)
Пример #12
0
    def test_XYZ_BadUsageBadAngleIndices(self):

        from opan.xyz import OpanXYZ

        # Load the test file
        x = OpanXYZ(path=self.file_name)

        # Try invalid arguments to angle_single, in all three positions
        self.assertRaises(IndexError, x.angle_single, 0, 1000000, 1, 2)
        self.assertRaises(IndexError, x.angle_single, 0, 0, 1000000, 2)
        self.assertRaises(IndexError, x.angle_single, 0, 0, 1, 200000)

        # Try inputs where at_1 == at_2 or at_3 == at_2
        self.assertRaises(ValueError, x.angle_single, 0, 1, 1, 2)
        self.assertRaises(ValueError, x.angle_single, 0, 1, 2, 2)
Пример #13
0
    def test_XYZ_BadUsageReInitFileData(self):
        # Should pitch a fit if someone uses the private file method to try to
        #  reinit an OpanXYZ instance

        from opan.error import XYZError
        from opan.xyz import OpanXYZ

        # Should work fine
        xyz = OpanXYZ(path=self.file_name)

        # Should raise error to re-init with same contents.
        self.assertErrorAndTypecode(XYZError,
                                    xyz._load_file,
                                    XYZError.OVERWRITE,
                                    XYZ_path=self.file_name)
Пример #14
0
    def test_XYZ_BadUsageLinearDihedAngle(self):

        import os
        from opan.xyz import OpanXYZ
        from opan.error import XYZError

        # Construct path to benzene test file
        bz_path = os.path.join(os.path.pardir, 'test', 'resource', 'inertia',
                               'C6H6_Planar.xyz')

        # Load benzene test file from inside inertia
        x = OpanXYZ(path=bz_path)

        # From testing, the (6,0,3) H-C-C angle is 180 degrees
        self.assertErrorAndTypecode(XYZError, x.dihed_single, XYZError.DIHED,
                                    0, 6, 0, 3, 4)
Пример #15
0
    def test_XYZ_BadUsageReInitDirectData(self):
        # Should pitch a fit if someone uses the private data method to try to
        #  reinit an OpanXYZ instance

        from opan.error import XYZError
        from opan.xyz import OpanXYZ

        # Should work fine
        xyz = OpanXYZ(coords=self.good_direct_geom,
                      atom_syms=self.good_direct_atoms)

        # Should raise error to re-init with same contents.
        self.assertErrorAndTypecode(XYZError,
                                    xyz._load_data,
                                    XYZError.OVERWRITE,
                                    coords=self.good_direct_geom,
                                    atom_syms=self.good_direct_atoms)
Пример #16
0
class TestOpanXYZGoodDirectData(SuperOpanXYZ):
    # Confirming sanity of an OpanXYZ generated directly from data.
    # There are checks here of some of the generated resuls when using
    #  'x_iter' methods with 'None'.

    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(atom_syms=self.good_direct_atoms,
                                            coords=self.good_direct_geom)

        # Long messages
        self.longMessage = True

    def test_XYZ_GoodDirectDataNumAtoms(self):
        self.assertEqual(self.xyz.num_atoms, len(self.good_direct_atoms))

    def test_XYZ_GoodDirectDataNumGeoms(self):
        self.assertEqual(self.xyz.num_geoms, 1)

    def test_XYZ_GoodDirectDataNumCoords(self):
        self.assertEqual(self.xyz.geoms[0].shape[0], self.xyz.num_atoms * 3)

    def test_XYZ_GoodDirectDataCoords(self):
        for i in range(self.good_direct_geom[0].shape[0]):
            self.assertAlmostEqual(self.xyz.geoms[0][i],
                    self.good_direct_geom[0][i],
                    delta=1e-8,
                    msg="Coordinates element (" + str(i) + ')')

    def test_XYZ_GoodDirectDataIterO1Dist(self):
        for tup in zip(
                    self.good_direct_O1Dist,
                    self.xyz.dist_iter(0,1,None),
                    range(self.good_direct_O1Dist.shape[0])
                        ):
            self.assertAlmostEqual(tup[0], tup[1], delta=1e-5,
                    msg="Distance between O1 and atom #" + str(tup[2]) +
                            " (" + self.xyz.atom_syms[tup[2]].capitalize() +
                            ")")

    def test_XYZ_GoodDirectDataIterCuO1Angle(self):
        for tup in zip(
                    self.good_direct_CuO1Angle,
                    self.xyz.angle_iter(0,0,1,None),
                    range(self.good_direct_CuO1Angle.shape[0])
                        ):
            self.assertAlmostEqual(tup[0], tup[1], delta=5e-3,
                    msg="Angle Cu-O-X with atom #" + str(tup[2]) +
                            " (" + self.xyz.atom_syms[tup[2]].capitalize() +
                            ")")

    def test_XYZ_GoodDirectDataIterDihed(self):
        for tup in zip(
                    self.good_direct_Dihed,
                    self.xyz.dihed_iter(0,None, 1,0,2),
                    range(self.good_direct_Dihed.shape[0])
                        ):
            self.assertAlmostEqual(tup[0], tup[1], delta=5e-3,
                    msg="Dihedral with atom #" + str(tup[2]) +
                            " (" + self.xyz.atom_syms[tup[2]].capitalize() +
                            ")")
Пример #17
0
class TestOpanXYZGoodFileData(SuperOpanXYZ):
    # Ensuring importing a known OpenBabel xyz file with good data reports
    #  the correct geometric parameters, etc.

    @classmethod
    def setUpClass(cls):
        from opan.test.utils import setUpTestDir

        # Set up the directory and add the good file
        setUpTestDir(cls.testdir)

        # Write the file
        with open(cls.file_name, 'w') as f:
            f.write(cls.file_text_good)

    @classmethod
    def tearDownClass(cls):
        import os
        from opan.test.utils import tearDownTestDir

        # Delete the xyz file
        os.remove(cls.file_name)

        # Remove the test directory
        tearDownTestDir(cls.testdir)

    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(path=self.file_name)

        # Long messages
        self.longMessage = True

    def test_XYZ_GoodFileDataNumAtoms(self):
        self.assertEqual(self.xyz.num_atoms, self.num_atoms)

    def test_XYZ_GoodFileDataNumGeoms(self):
        self.assertEqual(self.xyz.num_geoms, self.num_geoms)

    def test_XYZ_GoodFileDataAtomSyms(self):
        for i in range(len(self.xyz.atom_syms)):
            self.assertEqual(self.xyz.atom_syms[i],
                             self.atom_syms[i],
                             msg="Coordinates element (" + str(i) + ')')

    def test_XYZ_GoodFileDataCoords(self):
        for g in range(len(self.geoms)):
            for i in range(self.geoms[g].shape[0]):
                self.assertAlmostEqual(self.xyz.geoms[g][i],
                                       self.geoms[g][i],
                                       delta=1e-6,
                                       msg="Geometry #" + str(g) +
                                       ", coordinate element #" + str(i))

    def test_XYZ_GoodFileDataDistances(self):
        for t in zip(self.dist_Cu_O, self.xyz.dist_iter(None, 0, 1),
                     range(self.dist_Cu_O.shape[0])):
            self.assertAlmostEqual(t[0],
                                   t[1],
                                   delta=1e-5,
                                   msg="Cu-O distance mismatch at geom #" +
                                   str(t[2]) + ": " + str(t[0:2]))
        for t in zip(self.dist_O_H1, self.xyz.dist_iter(None, 1, 2),
                     range(self.dist_O_H1.shape[0])):
            self.assertAlmostEqual(t[0],
                                   t[1],
                                   delta=1e-5,
                                   msg="O-H1 distance mismatch at geom #" +
                                   str(t[2]) + ": " + str(t[0:2]))

    def test_XYZ_GoodFileDataAngles(self):
        for t in zip(self.angle_Cu_O_H1, self.xyz.angle_iter(None, 0, 1, 2),
                     range(self.angle_Cu_O_H1.shape[0])):
            self.assertAlmostEqual(t[0],
                                   t[1],
                                   delta=1e-2,
                                   msg="Cu-O-H1 angle mismatch at geom #" +
                                   str(t[2]) + ": " + str(t[0:2]))

    def test_XYZ_GoodFileDataDihedrals(self):
        for t in zip(self.dihed_H2_O_Cu_H1,
                     self.xyz.dihed_iter(None, 3, 1, 0, 2),
                     range(self.dihed_H2_O_Cu_H1.shape[0])):
            self.assertAlmostEqual(
                t[0],
                t[1],
                delta=1e-2,
                msg="H2-Cu-O-H1 dihedral mismatch at geom #" + str(t[2]) +
                ": " + str(t[0:2]))

    def test_XYZ_GoodFileDataIterGeom(self):

        import numpy as np

        idxs = [1, 4, 8]
        for t in zip(
                np.array(self.geoms)[idxs], self.xyz.geom_iter(idxs),
                range(len(idxs))):
            for i in range(t[0].shape[0]):
                self.assertAlmostEqual(t[0][i], t[1][i], delta=1e-6,
                        msg="Geometry #" + str(t[2]) + \
                                ", coordinate element #" + str(i))

    def test_XYZ_GoodFileDataDisplacements(self):

        for t in zip(self.displ_Cu_O, self.xyz.displ_iter(None, 0, 1),
                     range(len(self.displ_Cu_O))):
            for i in range(self.displ_Cu_O[0].shape[0]):
                self.assertAlmostEqual(
                    t[0][i],
                    t[1][i],
                    delta=1e-6,
                    msg="Displacement #{0}, dimension #{1}".format(t[2], i))

    def test_XYZ_GoodFileDataZeroDisplacement(self):

        # Have to use assertTrue b/c numpy confuses assertEqual &c.
        self.assertTrue(all(self.xyz.displ_single(0, 0, 0) == [0.0, 0.0, 0.0]))
Пример #18
0
class TestOpanXYZGoodDirectData(SuperOpanXYZ):
    # Confirming sanity of an OpanXYZ generated directly from data.
    # There are checks here of some of the generated resuls when using
    #  'x_iter' methods with 'None'.

    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(atom_syms=self.good_direct_atoms,
                           coords=self.good_direct_geom)

        # Long messages
        self.longMessage = True

    def test_XYZ_GoodDirectDataNumAtoms(self):
        self.assertEqual(self.xyz.num_atoms, len(self.good_direct_atoms))

    def test_XYZ_GoodDirectDataNumGeoms(self):
        self.assertEqual(self.xyz.num_geoms, 1)

    def test_XYZ_GoodDirectDataNumCoords(self):
        self.assertEqual(self.xyz.geoms[0].shape[0], self.xyz.num_atoms * 3)

    def test_XYZ_GoodDirectDataCoords(self):
        for i in range(self.good_direct_geom[0].shape[0]):
            self.assertAlmostEqual(self.xyz.geoms[0][i],
                                   self.good_direct_geom[0][i],
                                   delta=1e-8,
                                   msg="Coordinates element (" + str(i) + ')')

    def test_XYZ_GoodDirectDataIterO1Dist(self):
        for tup in zip(self.good_direct_O1Dist, self.xyz.dist_iter(0, 1, None),
                       range(self.good_direct_O1Dist.shape[0])):
            self.assertAlmostEqual(
                tup[0],
                tup[1],
                delta=1e-5,
                msg="Distance between O1 and atom #" + str(tup[2]) + " (" +
                self.xyz.atom_syms[tup[2]].capitalize() + ")")

    def test_XYZ_GoodDirectDataIterCuO1Angle(self):
        for tup in zip(self.good_direct_CuO1Angle,
                       self.xyz.angle_iter(0, 0, 1, None),
                       range(self.good_direct_CuO1Angle.shape[0])):
            self.assertAlmostEqual(
                tup[0],
                tup[1],
                delta=5e-3,
                msg="Angle Cu-O-X with atom #" + str(tup[2]) + " (" +
                self.xyz.atom_syms[tup[2]].capitalize() + ")")

    def test_XYZ_GoodDirectDataIterDihed(self):
        for tup in zip(self.good_direct_Dihed,
                       self.xyz.dihed_iter(0, None, 1, 0, 2),
                       range(self.good_direct_Dihed.shape[0])):
            self.assertAlmostEqual(
                tup[0],
                tup[1],
                delta=5e-3,
                msg="Dihedral with atom #" + str(tup[2]) + " (" +
                self.xyz.atom_syms[tup[2]].capitalize() + ")")
Пример #19
0
class TestOpanXYZGoodFileData(SuperOpanXYZ):
    # Ensuring importing a known OpenBabel xyz file with good data reports
    #  the correct geometric parameters, etc.

    @classmethod
    def setUpClass(cls):
        from opan.test.utils import setUpTestDir

        # Set up the directory and add the good file
        setUpTestDir(cls.testdir)

        # Write the file
        with open(cls.file_name, 'w') as f:
            f.write(cls.file_text_good)

    @classmethod
    def tearDownClass(cls):
        import os
        from opan.test.utils import tearDownTestDir

        # Delete the xyz file
        os.remove(cls.file_name)

        # Remove the test directory
        tearDownTestDir(cls.testdir)

    def setUp(self):
        # Load the object

        # Imports
        from opan.xyz import OpanXYZ

        # Create the object
        self.xyz = OpanXYZ(path=self.file_name)

        # Long messages
        self.longMessage = True

    def test_XYZ_GoodFileDataNumAtoms(self):
        self.assertEqual(self.xyz.num_atoms, self.num_atoms)

    def test_XYZ_GoodFileDataNumGeoms(self):
        self.assertEqual(self.xyz.num_geoms, self.num_geoms)

    def test_XYZ_GoodFileDataAtomSyms(self):
        for i in range(len(self.xyz.atom_syms)):
            self.assertEqual(self.xyz.atom_syms[i],
                    self.atom_syms[i],
                    msg="Coordinates element (" + str(i) + ')')

    def test_XYZ_GoodFileDataCoords(self):
        for g in range(len(self.geoms)):
            for i in range(self.geoms[g].shape[0]):
                self.assertAlmostEqual(self.xyz.geoms[g][i],
                        self.geoms[g][i],
                        delta=1e-6,
                        msg="Geometry #" + str(g) +
                                ", coordinate element #" + str(i))

    def test_XYZ_GoodFileDataDistances(self):
        for t in zip(self.dist_Cu_O, self.xyz.dist_iter(None, 0, 1),
                                        range(self.dist_Cu_O.shape[0])):
            self.assertAlmostEqual(t[0], t[1], delta=1e-5,
                        msg="Cu-O distance mismatch at geom #" + str(t[2]) +
                        ": " + str(t[0:2]))
        for t in zip(self.dist_O_H1, self.xyz.dist_iter(None, 1, 2),
                                        range(self.dist_O_H1.shape[0])):
            self.assertAlmostEqual(t[0], t[1], delta=1e-5,
                        msg="O-H1 distance mismatch at geom #" + str(t[2]) +
                        ": " + str(t[0:2]))

    def test_XYZ_GoodFileDataAngles(self):
        for t in zip(self.angle_Cu_O_H1, self.xyz.angle_iter(None, 0, 1, 2),
                                        range(self.angle_Cu_O_H1.shape[0])):
            self.assertAlmostEqual(t[0], t[1], delta=1e-2,
                        msg="Cu-O-H1 angle mismatch at geom #" + str(t[2]) +
                        ": " + str(t[0:2]))

    def test_XYZ_GoodFileDataDihedrals(self):
        for t in zip(self.dihed_H2_O_Cu_H1,
                                    self.xyz.dihed_iter(None, 3, 1, 0, 2),
                                    range(self.dihed_H2_O_Cu_H1.shape[0])):
            self.assertAlmostEqual(t[0], t[1], delta=1e-2,
                        msg="H2-Cu-O-H1 dihedral mismatch at geom #" +
                        str(t[2]) + ": " + str(t[0:2]))

    def test_XYZ_GoodFileDataIterGeom(self):

        import numpy as np

        idxs = [1,4,8]
        for t in zip(np.array(self.geoms)[idxs],
                        self.xyz.geom_iter(idxs),
                        range(len(idxs))
                    ):
            for i in range(t[0].shape[0]):
                self.assertAlmostEqual(t[0][i], t[1][i], delta=1e-6,
                        msg="Geometry #" + str(t[2]) + \
                                ", coordinate element #" + str(i))

    def test_XYZ_GoodFileDataDisplacements(self):

        for t in zip(self.displ_Cu_O,
                        self.xyz.displ_iter(None, 0, 1),
                        range(len(self.displ_Cu_O))
                    ):
            for i in range(self.displ_Cu_O[0].shape[0]):
                self.assertAlmostEqual(t[0][i], t[1][i], delta=1e-6,
                        msg="Displacement #{0}, dimension #{1}".format(t[2], i))

    def test_XYZ_GoodFileDataZeroDisplacement(self):

        # Have to use assertTrue b/c numpy confuses assertEqual &c.
        self.assertTrue(all(self.xyz.displ_single(0,0,0) == [0.0, 0.0, 0.0]))