def test_crossover(self):
"""Tests that disabling/enabling crossover works as expected."""
pos = [[0.1, 0.1, 0.1]]
species = [1, 8]
nmax = 5
lmax = 5
# GTO
desc = SOAP(
species=species,
rbf="gto",
crossover=True,
rcut=3,
nmax=nmax,
lmax=lmax,
periodic=False,
)
hh_loc_full = desc.get_location(("H", "H"))
oo_loc_full = desc.get_location(("O", "O"))
full_output = desc.create(H2O, positions=pos)
desc.crossover = False
hh_loc = desc.get_location(("H", "H"))
oo_loc = desc.get_location(("O", "O"))
partial_output = desc.create(H2O, positions=pos)
self.assertTrue(oo_loc_full != oo_loc)
self.assertTrue(
np.array_equal(full_output[:, hh_loc_full], partial_output[:, hh_loc])
)
self.assertTrue(
np.array_equal(full_output[:, oo_loc_full], partial_output[:, oo_loc])
)
# Polynomial
desc = SOAP(
species=species,
rbf="polynomial",
crossover=True,
rcut=3,
nmax=lmax,
lmax=lmax,
periodic=False,
)
hh_loc_full = desc.get_location(("H", "H"))
oo_loc_full = desc.get_location(("O", "O"))
full_output = desc.create(H2O, pos)
desc.crossover = False
hh_loc = desc.get_location(("H", "H"))
oo_loc = desc.get_location(("O", "O"))
partial_output = desc.create(H2O, pos)
self.assertTrue(oo_loc_full != oo_loc)
self.assertTrue(
np.array_equal(full_output[:, hh_loc_full], partial_output[:, hh_loc])
)
self.assertTrue(
np.array_equal(full_output[:, oo_loc_full], partial_output[:, oo_loc])
)
def test_get_location_w_crossover(self):
"""Tests that disabling/enabling crossover works as expected.
"""
# With crossover
species = ["H", "O", "C"]
desc = SOAP(species=species,
rbf="gto",
crossover=True,
rcut=3,
nmax=5,
lmax=5,
periodic=False)
# Symbols
loc_hh = desc.get_location(("H", "H"))
loc_ho = desc.get_location(("H", "O"))
loc_oh = desc.get_location(("O", "H"))
loc_oo = desc.get_location(("O", "O"))
loc_cc = desc.get_location(("C", "C"))
loc_co = desc.get_location(("C", "O"))
loc_ch = desc.get_location(("C", "H"))
# Undefined elements
with self.assertRaises(ValueError):
desc.get_location((2, 1))
with self.assertRaises(ValueError):
desc.get_location(("He", "H"))
# Check that slices in the output are correctly empty or filled
co2 = molecule("CO2")
h2o = molecule("H2O")
co2_out = desc.create(co2)
h2o_out = desc.create(h2o)
# Check that slices with reversed atomic numbers are identical
self.assertTrue(loc_ho == loc_oh)
# H-H
self.assertTrue(co2_out[:, loc_hh].sum() == 0)
self.assertTrue(h2o_out[:, loc_hh].sum() != 0)
# H-C
self.assertTrue(co2_out[:, loc_ch].sum() == 0)
self.assertTrue(h2o_out[:, loc_ch].sum() == 0)
# H-O
self.assertTrue(co2_out[:, loc_ho].sum() == 0)
self.assertTrue(h2o_out[:, loc_ho].sum() != 0)
# C-O
self.assertTrue(co2_out[:, loc_co].sum() != 0)
self.assertTrue(h2o_out[:, loc_co].sum() == 0)
# C-C
self.assertTrue(co2_out[:, loc_cc].sum() != 0)
self.assertTrue(h2o_out[:, loc_cc].sum() == 0)
# O-O
self.assertTrue(co2_out[:, loc_oo].sum() != 0)
self.assertTrue(h2o_out[:, loc_oo].sum() != 0)
print(copper.get_pbc())
periodic_soap = SOAP(species=[29],
rcut=rcut,
nmax=nmax,
lmax=nmax,
periodic=True,
sparse=False)
soap_copper = periodic_soap.create(copper)
print(soap_copper)
print(soap_copper.sum(axis=1))
# Locations
# The locations of specific element combinations can be retrieved like this.
hh_loc = soap.get_location(("H", "H"))
ho_loc = soap.get_location(("H", "O"))
# These locations can be directly used to slice the corresponding part from an
# SOAP output for e.g. plotting.
soap_water[0, hh_loc]
soap_water[0, ho_loc]
# Sparse output
soap = SOAP(species=species, rcut=rcut, nmax=nmax, lmax=lmax, sparse=True)
soap_water = soap.create(water)
print(type(soap_water))
soap = SOAP(species=species, rcut=rcut, nmax=nmax, lmax=lmax, sparse=False)
soap_water = soap.create(water)
print(type(soap_water))
def test_basis(self):
"""Tests that the output vectors for both GTO and polynomial radial
basis behave correctly.
"""
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,
)
for rbf in ["gto", "polynomial"]:
desc = SOAP(
species=[1, 6, 8],
rcut=5,
nmax=1,
lmax=1,
rbf=rbf,
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
hh_loc = desc.get_location(("H", "H"))
h_part1 = vec1[hh_loc]
h_part2 = vec2[hh_loc]
h_part4 = vec4[hh_loc]
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_loc = desc.get_location(("H", "C"))
co_loc = desc.get_location(("C", "O"))
hc_part1 = vec1[hc_loc]
hc_part4 = vec4[hc_loc]
co_part6 = vec6[co_loc]
co_part7 = vec7[co_loc]
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)
