Example #1
0
    def test_basis(self):
        """Tests that the output vectors behave correctly as a basis.
        """
        sys1 = Atoms(symbols=["H", "H"], positions=[[1, 0, 0], [0, 1, 0]], cell=[2, 2, 2], pbc=True)
        sys2 = Atoms(symbols=["O", "O"], positions=[[1, 0, 0], [0, 1, 0]], cell=[2, 2, 2], pbc=True)
        sys3 = Atoms(symbols=["C", "C"], positions=[[1, 0, 0], [0, 1, 0]], cell=[2, 2, 2], pbc=True)
        sys4 = Atoms(symbols=["H", "C"], positions=[[-1, 0, 0], [1, 0, 0]], cell=[2, 2, 2], pbc=True)
        sys5 = Atoms(symbols=["H", "C"], positions=[[1, 0, 0], [0, 1, 0]], cell=[2, 2, 2], pbc=True)
        sys6 = Atoms(symbols=["H", "O"], positions=[[1, 0, 0], [0, 1, 0]], cell=[2, 2, 2], pbc=True)
        sys7 = Atoms(symbols=["C", "O"], positions=[[1, 0, 0], [0, 1, 0]], cell=[2, 2, 2], pbc=True)

        desc = SOAP(
            atomic_numbers=[1, 6, 8],
            rcut=5,
            nmax=3,
            lmax=5,
            periodic=False,
            crossover=True,
            sparse=False
        )

        # Create vectors for each system
        vec1 = desc.create(sys1, positions=[[0, 0, 0]])[0, :]
        vec2 = desc.create(sys2, positions=[[0, 0, 0]])[0, :]
        vec3 = desc.create(sys3, positions=[[0, 0, 0]])[0, :]
        vec4 = desc.create(sys4, positions=[[0, 0, 0]])[0, :]
        vec5 = desc.create(sys5, positions=[[0, 0, 0]])[0, :]
        vec6 = desc.create(sys6, positions=[[0, 0, 0]])[0, :]
        vec7 = desc.create(sys7, positions=[[0, 0, 0]])[0, :]

        # The dot-product should be zero when there are no overlapping elements
        dot = np.dot(vec1, vec2)
        self.assertEqual(dot, 0)
        dot = np.dot(vec2, vec3)
        self.assertEqual(dot, 0)

        # The dot-product should be non-zero when there are overlapping elements
        dot = np.dot(vec4, vec5)
        self.assertNotEqual(dot, 0)

        # Check that self-terms are in correct location
        n_elem_feat = desc.get_number_of_element_features()
        h_part1 = vec1[0:n_elem_feat]
        h_part2 = vec2[0:n_elem_feat]
        h_part4 = vec4[0:n_elem_feat]
        self.assertNotEqual(np.sum(h_part1), 0)
        self.assertEqual(np.sum(h_part2), 0)
        self.assertNotEqual(np.sum(h_part4), 0)

        # Check that cross terms are in correct location
        hc_part1 = vec1[1*n_elem_feat:2*n_elem_feat]
        hc_part4 = vec4[1*n_elem_feat:2*n_elem_feat]
        co_part6 = vec6[4*n_elem_feat:5*n_elem_feat]
        co_part7 = vec7[4*n_elem_feat:5*n_elem_feat]
        self.assertEqual(np.sum(hc_part1), 0)
        self.assertNotEqual(np.sum(hc_part4), 0)
        self.assertEqual(np.sum(co_part6), 0)
        self.assertNotEqual(np.sum(co_part7), 0)
Example #2
0
    def test_crossover(self):
        """Tests that disabling/enabling crossover works as expected.
        """
        pos = [[0.1, 0.1, 0.1]]

        # GTO
        desc = SOAP(species=[1, 8],
                    rbf="gto",
                    crossover=True,
                    rcut=3,
                    nmax=5,
                    lmax=5,
                    periodic=False)
        n_elem_feat = desc.get_number_of_element_features()
        full_output = desc.create(H2O, positions=pos)
        desc.crossover = False
        partial_output = desc.create(H2O, positions=pos)
        self.assertTrue(
            np.array_equal(full_output[:, 0:n_elem_feat],
                           partial_output[:, 0:n_elem_feat]))
        self.assertTrue(
            np.array_equal(full_output[:, 2 * n_elem_feat:],
                           partial_output[:, n_elem_feat:]))

        # Polynomial
        desc = SOAP(species=[1, 8],
                    rbf="polynomial",
                    crossover=True,
                    rcut=3,
                    nmax=5,
                    lmax=5,
                    periodic=False)
        n_elem_feat = desc.get_number_of_element_features()
        full_output = desc.create(H2O, pos)
        desc.crossover = False
        partial_output = desc.create(H2O, pos)
        self.assertTrue(
            np.array_equal(full_output[:, 0:n_elem_feat],
                           partial_output[:, 0:n_elem_feat]))
        self.assertTrue(
            np.array_equal(full_output[:, 2 * n_elem_feat:],
                           partial_output[:, n_elem_feat:]))