def test_conversion(self):
# Make an FCC cell.
cell = Cell()
cell.set_basis(lengths=[3.5, 3.6, 3.4], angles=[89, 90, 91])
cell.add_atom(Atom([0, 0, 0], 0))
cell.add_atom(Atom([0.5, 0.5, 0], 1))
cell.add_atom(Atom([0.5, 0, 0.5], 1))
cell.add_atom(Atom([0, 0.5, 0.5], 1))
cell.set_type_name(0, "Al")
cell.set_type_name(1, "Ni")
# Convert it to string.
vio = VASP5IO()
temp = vio.convert_structure_to_string(cell)
# Convert it back.
new_cell = vio.parse_file(list_of_lines=temp)
# Check to make sure everything is good.
self.assertAlmostEqual(cell.volume(), new_cell.volume(), delta=1e-4)
self.assertEqual(cell.n_types(), new_cell.n_types())
np_tst.assert_array_almost_equal(cell.get_lattice_vectors()[1],
new_cell.get_lattice_vectors()[1],
decimal=4)
new_temp = vio.convert_structure_to_string(new_cell)
np_tst.assert_equal(temp, new_temp)
def test_matrix(self):
# Make a simple structure.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 0))
structure.set_type_name(0, "Al")
# Compute the sine matrix.
mat = self.r.compute_coulomb_matrix(structure)
self.assertEqual(1, mat.shape[0])
self.assertEqual(1, mat.shape[1])
self.assertAlmostEqual(0.5 * 13 ** 2.4, mat[0, 0],delta=1e-6)
# Add another atom and repeat.
structure.add_atom(Atom([0.5, 0.5, 0.5], 0))
mat = self.r.compute_coulomb_matrix(structure)
self.assertEqual(2, mat.shape[0])
self.assertEqual(2, mat.shape[1])
# Test: Is it insensitive to basis changes.
new_basis = structure.get_basis()
new_basis[1, 0] = 12
structure.set_basis(basis=new_basis)
self.assertAlmostEqual(1.0, structure.volume(), delta=1e-6)
mat2 = self.r.compute_coulomb_matrix(structure)
if np.linalg.norm(mat - mat2) > 1e-6:
sys.stderr.write("WARNING: Not insensitive to basis changes\n")
def test_unit_cell_choice(self):
# Create a B2 structure with lattice parameter of 1.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 0))
structure.add_atom(Atom([0.5, 0.5, 0.5], 1))
# Create a 2x1x1 supercell.
supercell = Cell()
supercell.set_basis(lengths=[2, 1, 1], angles=[90, 90, 90])
supercell.add_atom(Atom([0, 0, 0], 0))
supercell.add_atom(Atom([0.5, 0, 0], 0))
supercell.add_atom(Atom([0.25, 0.5, 0.5], 1))
supercell.add_atom(Atom([0.75, 0.5, 0.5], 1))
self.tool.set_cut_off_distance(3.0)
self.tool.set_n_windows(10)
self.tool.set_smoothing_factor(4)
# Compute the primitive cell AP-RDF.
self.tool.analyze_structure(structure)
p_ap_rdf = self.tool.compute_APRDF([1, 2])
# Compute the supercell AP-RDF.
self.tool.analyze_structure(supercell)
sc_ap_rdf = self.tool.compute_APRDF([1, 2])
# Compare results.
np_tst.assert_array_almost_equal(p_ap_rdf, sc_ap_rdf)
def test_big(self):
# Number of atoms in each direction.
n_atom = 4
structure = Cell()
structure.set_basis(lengths=[2 * n_atom, 2 * n_atom, 2 * n_atom],
angles=[90, 90, 90])
# Add a bunch of atoms.
step_size = 1.0 / n_atom
for x in range(n_atom):
for y in range(n_atom):
for z in range(n_atom):
new_pos = np.array([x, y, z], dtype=float) + \
np.random.random(3) / n_atom
new_pos *= step_size
structure.add_atom(Atom(new_pos, 0))
# Compute the cells.
cells = VoronoiTessellationCalculator.compute(structure, radical=True)
total_vol = 0.0
for cell in cells:
total_vol += cell.get_volume()
self.assertTrue(cell.geometry_is_valid())
vol_error = (total_vol - structure.volume()) / structure.volume()
self.assertAlmostEqual(0.0, vol_error, delta=1e-2)
def test_results2(self):
# Create a B1-HHe structure.
structure = Cell()
basis = np.zeros((3, 3))
basis[0] = np.array([0, 0.5, 0.5])
basis[1] = np.array([0.5, 0, 0.5])
basis[2] = np.array([0.5, 0.5, 0])
structure.set_basis(basis=basis)
structure.add_atom(Atom([0, 0, 0], 0))
structure.add_atom(Atom([0.5, 0.5, 0.5], 1))
structure.set_type_name(0, "H")
structure.set_type_name(1, "He")
entries = [CrystalStructureEntry(structure, name="B1-HHe", radii=None)]
# Get the feature generator.
gen = self.get_generator()
gen.clear_elemental_properties()
gen.add_elemental_property("Number")
# Generate features.
features = gen.generate_features(entries)
# Test the results.
self.assertEqual(self.expected_count(), features.shape[1])
np_tst.assert_array_almost_equal([1, 0, 1, 1, 0, 0, 0, 0, 0, 0],
features.values[0])
def test_FCC_primitive(self):
# Create the simulation cell.
structure = Cell()
structure.set_basis(lengths=[0.70710678118655, 0.70710678118655,
1.0], angles=[45, 90, 60])
structure.add_atom(Atom([0, 0, 0], 0))
# Run tessellation.
result = VoronoiTessellationCalculator.compute(structure,
radical=False)
# Test results.
self.assertEqual(structure.n_atoms(), len(result))
self.assertTrue(result[0].geometry_is_valid())
self.assertEqual(12, len(result[0].get_faces()))
poly_index = result[0].get_polyhedron_shape()
self.assertEqual(12, poly_index[4])
poly_index = result[0].get_coordination_shell_shape(result)
self.assertEqual(12, poly_index[4])
def test_equals(self):
# Make other cell
other = Cell()
# First check.
self.assertTrue(self.cell.__eq__(other))
# Adjust basis.
self.cell.set_basis(lengths=[1, 2, 3], angles=[70, 80, 90])
self.assertFalse(self.cell.__eq__(other))
other.set_basis(lengths=[1, 2, 3], angles=[70, 80, 90])
self.assertTrue(self.cell.__eq__(other))
# Add an atom to 0,0,0
self.cell.add_atom(Atom([0, 0, 0], 0))
self.assertFalse(self.cell.__eq__(other))
other.add_atom(Atom([0, 0, 0], 0))
self.assertTrue(self.cell.__eq__(other))
# Changing names.
self.cell.set_type_name(0, "Al")
self.assertFalse(self.cell.__eq__(other))
other.set_type_name(0, "Al")
self.assertTrue(self.cell.__eq__(other))
# Adding more atoms of different type.
self.cell.add_atom(Atom([0.5, 0.5, 0], 1))
other.add_atom(Atom([0.5, 0.5, 0], 0))
self.assertFalse(self.cell.__eq__(other))
other.get_atom(1).set_type(1)
self.assertTrue(self.cell.__eq__(other))
# Adding atoms with different positions.
self.cell.add_atom(Atom([0.5, 0, 0.5], 1))
other.add_atom(Atom([0, 0.5, 0.5], 1))
self.assertFalse(self.cell.__eq__(other))
# Adding atoms out of sequence.
other.add_atom(Atom([0.5, 0, 0.5], 1))
self.cell.add_atom(Atom([0, 0.5, 0.5], 1))
self.assertTrue(self.cell.__eq__(other))
def test(self):
structure = Cell()
structure.set_basis(lengths=[3.2, 3.2, 3.2], angles=[90, 90, 90])
structure.add_atom(Atom([0, 0, 0], 0))
structure.add_atom(Atom([0.5, 0.5, 0.5], 1))
structure.set_type_name(0, "Ni")
structure.set_type_name(1, "Al")
entry = CrystalStructureEntry(structure, name="B2-NiAl", radii=None)
entries = [entry]
# Create feature generator.
gen = APRDFAttributeGenerator()
gen.set_cut_off_distance(3.2)
gen.set_num_points(2)
gen.set_smoothing_parameter(100)
gen.add_elemental_property("Number")
# Generate features.
features = gen.generate_features(entries)
self.assertEqual(2, len(features.columns))
ap_rdf = features.values
# Assemble known contributors.
# [0] -> Number of neighbors * P_i * P_j
# [1] -> Bond distance
contributors = []
contributors.append([2 * 8 * 13 * 28, 3.2 * math.sqrt(3) / 2]) # A-B
# 1st NN.
contributors.append([6 * 13 * 13, 3.2 * 1]) # A-A 2nd NN.
contributors.append([6 * 28 * 28, 3.2 * 1]) # B-B 2nd NN.
contributors.append([8 * 13 * 13, 3.2 * math.sqrt(3)]) # A-A 3rd NN.
contributors.append([8 * 28 * 28, 3.2 * math.sqrt(3)]) # B-B 3rd NN.
eval_dist = [1.6, 3.2]
expected_ap_rdf = [
sum([c[0] * math.exp(-100 * (c[1] - r)**2)
for c in contributors]) / 2 for r in eval_dist
]
np_tst.assert_array_almost_equal(expected_ap_rdf, ap_rdf[0])
def test_random_packing(self):
# Number of atoms in each direction.
n_atom = 4
structure = Cell()
structure.set_basis(lengths=[2 * n_atom, 2 * n_atom, 2 * n_atom],
angles=[90, 90, 90])
# Add a bunch of atoms.
for x in range(n_atom):
for y in range(n_atom):
for z in range(n_atom):
structure.add_atom(Atom(np.random.random(3), 0))
# Compute the cells.
cells = VoronoiTessellationCalculator.compute(structure, radical=True)
total_vol = 0.0
for cell in cells:
total_vol += cell.get_volume()
self.assertTrue(cell.geometry_is_valid())
vol_error = (total_vol - structure.volume()) / structure.volume()
self.assertAlmostEqual(0.0, vol_error, delta=1e-2)
def test_B1(self):
# Structure of rocksalt.
structure = Cell()
basis = np.zeros((3, 3))
basis[0] = np.array([0, 0.5, 0.5])
basis[1] = np.array([0.5, 0, 0.5])
basis[2] = np.array([0.5, 0.5, 0])
structure.set_basis(basis=basis)
atom = Atom([0, 0, 0], 0)
structure.add_atom(atom)
atom = Atom([0.5, 0.5, 0.5], 1)
structure.add_atom(atom)
# Prepare.
tool = VoronoiCellBasedAnalysis(radical=True)
tool.analyze_structure(structure)
# Check results.
n_eff = 6
np_tst.assert_array_almost_equal(
[n_eff, n_eff], tool.get_effective_coordination_numbers())
self.assertAlmostEqual(6.0, tool.face_count_average(), delta=1e-2)
self.assertAlmostEqual(0.0, tool.face_count_variance(), delta=1e-2)
self.assertAlmostEqual(6.0, tool.face_count_minimum(), delta=1e-2)
self.assertAlmostEqual(6.0, tool.face_count_maximum(), delta=1e-2)
self.assertAlmostEqual(1,
len(tool.get_unique_polyhedron_shapes()),
delta=1e-2)
self.assertAlmostEqual(0.0, tool.volume_variance(), delta=1e-2)
self.assertAlmostEqual(0.5, tool.volume_fraction_minimum(), delta=1e-2)
self.assertAlmostEqual(0.5, tool.volume_fraction_maximum(), delta=1e-2)
np_tst.assert_array_almost_equal([1, -1],
tool.get_neighbor_ordering_parameters(
1, False)[0],
decimal=2)
np_tst.assert_array_almost_equal([-1, 1],
tool.get_neighbor_ordering_parameters(
2, False)[0],
decimal=2)
np_tst.assert_array_almost_equal([1, -1],
tool.get_neighbor_ordering_parameters(
3, False)[0],
decimal=2)
np_tst.assert_array_almost_equal([-1, 1],
tool.get_neighbor_ordering_parameters(
2, True)[0],
decimal=2)
np_tst.assert_array_almost_equal([1, -1],
tool.get_neighbor_ordering_parameters(
3, True)[0],
decimal=2)
np_tst.assert_array_almost_equal([1, -1],
tool.get_neighbor_ordering_parameters(
3, True)[0],
decimal=2)
self.assertAlmostEqual(1,
tool.warren_cowley_ordering_magnitude(1, False),
delta=1e-2)
self.assertAlmostEqual(1,
tool.warren_cowley_ordering_magnitude(2, False),
delta=1e-2)
self.assertAlmostEqual(1,
tool.warren_cowley_ordering_magnitude(1, True),
delta=1e-2)
self.assertAlmostEqual(1,
tool.warren_cowley_ordering_magnitude(2, True),
delta=1e-2)
bond_lengths = tool.bond_lengths()
self.assertEqual(2, len(bond_lengths))
self.assertEqual(6, len(bond_lengths[0]))
self.assertAlmostEqual(0.5, bond_lengths[0][0], delta=1e-6)
mean_bond_lengths = tool.mean_bond_lengths()
self.assertEqual(2, len(mean_bond_lengths))
self.assertAlmostEqual(0.5, mean_bond_lengths[0], delta=1e-6)
var_bond_lengths = tool.bond_length_variance(mean_bond_lengths)
self.assertAlmostEqual(0, var_bond_lengths[0], delta=1e-6)
# Neighbor property attributes.
np_tst.assert_array_almost_equal([1, 1],
tool.neighbor_property_differences(
[0, 1], 1))
np_tst.assert_array_almost_equal([0, 0],
tool.neighbor_property_differences(
[0, 1], 2))
np_tst.assert_array_almost_equal([0, 0],
tool.neighbor_property_variances(
[0, 1], 1))
np_tst.assert_array_almost_equal([0, 0],
tool.neighbor_property_variances(
[0, 1], 2))
class testCell(unittest.TestCase):
cell = None
# Create one instance per test.
def setUp(self):
self.cell = Cell()
# Destroy instance as soon as test is over.
def tearDown(self):
self.cell = None
def test_set_basis(self):
# Test using angles and lattice parameters as input.
self.cell.set_basis(lengths=[5.643, 6.621,4.885], angles=[91.83,
93.58, 107.69])
self.assertAlmostEqual(173.30, self.cell.volume(), delta=1e-2)
np_tst.assert_array_almost_equal([5.643, 6.621,4.885],
self.cell.get_lattice_parameters())
np_tst.assert_array_almost_equal([91.83, 93.58, 107.69],
self.cell.get_lattice_angles_radians(radians=False))
# Simple test with a primitive cell.
basis = np.zeros((3, 3))
basis[0] = np.array([0, 2.986, 2.986])
basis[1] = np.array([2.986, 0, 2.986])
basis[2] = np.array([2.986, 2.986, 0])
self.cell.set_basis(basis=basis)
self.assertAlmostEqual(13.312*4, self.cell.volume(), delta=1e-3)
np_tst.assert_array_almost_equal([4.223, 4.223, 4.223],
self.cell.get_lattice_parameters(),
decimal=3)
np_tst.assert_array_almost_equal([60, 60, 60],
self.cell.get_lattice_angles_radians(radians=False))
def test_aligned_basis(self):
# Simple test with a primitive cell.
basis = np.zeros((3, 3))
basis[0] = np.array([0, 2.986, 2.986])
basis[1] = np.array([2.986, 0, 2.986])
basis[2] = np.array([2.986, 2.986, 0])
self.cell.set_basis(basis=basis)
# Compute the aligned basis.
aligned_basis = self.cell.get_aligned_basis()
self.assertAlmostEqual(0, aligned_basis[1][0], delta=1e-6)
self.assertAlmostEqual(0, aligned_basis[2][0], delta=1e-6)
self.assertAlmostEqual(0, aligned_basis[2][1], delta=1e-6)
def test_clone(self):
self.cell.add_atom(Atom([0, 0, 0], 0))
self.cell.set_type_name(0, "A")
# Test adding atoms.
clone = self.cell.__copy__()
self.assertEqual(clone, self.cell)
clone.add_atom(Atom([0, 0.5, 0], 0))
self.assertFalse(clone.__eq__(self.cell))
# Test changing atom.
clone = self.cell.__copy__()
clone.get_atom(0).set_type(1)
self.assertFalse(clone.__eq__(self.cell))
# Test changing basis.
clone = self.cell.__copy__()
clone.set_basis(lengths=[2, 1, 1], angles=[90, 90, 90])
self.assertFalse(clone.__eq__(self.cell))
def test_lattice_vectors(self):
self.cell.set_basis(lengths=[1, 2, 3], angles=[80, 90, 70])
l_vec = self.cell.get_lattice_vectors()
np_tst.assert_array_almost_equal([[1.0, 0.0, 0.0], [0.684, 1.879,
0.0], [0.0, 0.554, 2.948]], l_vec, decimal=3)
# FCC primitive cell.
self.cell.set_basis(lengths=[0.70710678118655, 0.70710678118655,
0.70710678118655], angles=[60, 60, 60])
self.assertAlmostEqual(0.25, self.cell.volume(), delta=1e-6)
l_vec = self.cell.get_lattice_vectors()
self.assertAlmostEqual(0.70710678118655, norm(l_vec[0]),
delta=1e-2)
def test_fractional_to_cartesian(self):
self.cell.set_basis(lengths=[1, 2, 3], angles=[80, 90, 70])
np_tst.assert_array_almost_equal([0.2368, 0.5421, 0.8844],
self.cell.convert_fractional_to_cartesian([0.1, 0.2, 0.3]),
decimal=3)
def test_cartesian_to_fractional(self):
self.cell.set_basis(lengths=[1, 2, 3], angles=[80, 90, 70])
np_tst.assert_array_almost_equal([0.1, 0.2, 0.3],
self.cell.convert_cartesian_to_fractional([0.2368, 0.5421, 0.8844]),
decimal=3)
def test_supercell_translation(self):
self.cell.set_basis(lengths=[0.70710678118655, 0.70710678118655,
0.70710678118655], angles=[60, 60, 60])
self.assertAlmostEqual(0.25, self.cell.volume(), delta=1e-6)
l_vec = self.cell.get_lattice_vectors()
# Check a few.
pos = self.cell.get_periodic_image([0, 0, 0], 1, 0, 0)
np_tst.assert_array_almost_equal([0.70710678000000, 0, 0], pos,
decimal=3)
pos = self.cell.get_periodic_image([0, 0, 0], 1, 1, 0)
np_tst.assert_array_almost_equal([1.06066017000000, 0.61237243466821,
0], pos, decimal=3)
pos = self.cell.get_periodic_image([0, 0, 0], 1, 1, 1)
np_tst.assert_array_almost_equal([1.41421356000000, 0.81649657955762,
0.57735026918963], pos, decimal=3)
def test_equals(self):
# Make other cell
other = Cell()
# First check.
self.assertTrue(self.cell.__eq__(other))
# Adjust basis.
self.cell.set_basis(lengths=[1, 2, 3], angles=[70, 80, 90])
self.assertFalse(self.cell.__eq__(other))
other.set_basis(lengths=[1, 2, 3], angles=[70, 80, 90])
self.assertTrue(self.cell.__eq__(other))
# Add an atom to 0,0,0
self.cell.add_atom(Atom([0, 0, 0], 0))
self.assertFalse(self.cell.__eq__(other))
other.add_atom(Atom([0, 0, 0], 0))
self.assertTrue(self.cell.__eq__(other))
# Changing names.
self.cell.set_type_name(0, "Al")
self.assertFalse(self.cell.__eq__(other))
other.set_type_name(0, "Al")
self.assertTrue(self.cell.__eq__(other))
# Adding more atoms of different type.
self.cell.add_atom(Atom([0.5, 0.5, 0], 1))
other.add_atom(Atom([0.5, 0.5, 0], 0))
self.assertFalse(self.cell.__eq__(other))
other.get_atom(1).set_type(1)
self.assertTrue(self.cell.__eq__(other))
# Adding atoms with different positions.
self.cell.add_atom(Atom([0.5, 0, 0.5], 1))
other.add_atom(Atom([0, 0.5, 0.5], 1))
self.assertFalse(self.cell.__eq__(other))
# Adding atoms out of sequence.
other.add_atom(Atom([0.5, 0, 0.5], 1))
self.cell.add_atom(Atom([0, 0.5, 0.5], 1))
self.assertTrue(self.cell.__eq__(other))
def test_minimum_distance(self):
# Simple case: orthogonal axes.
# Origin.
self.cell.add_atom(Atom([0, 0, 0], 1))
# C face center.
self.cell.add_atom(Atom([0.5, 0.5, 0], 1))
dist = self.cell.get_minimum_distance(point1=[0, 0, 0], point2=[0.5,
0.5, 0])
self.assertAlmostEqual(math.sqrt(0.5), dist, delta=1e-6)
dist = self.cell.get_minimum_distance(point1=[0, 0, 0], point2=[2.5,
0.5, -10])
self.assertAlmostEqual(math.sqrt(0.5), dist, delta=1e-6)
# Difficult case: Non-conventional unit cell.
basis = self.cell.get_basis()
basis[1][0] = 108
self.cell.set_basis(basis=basis)
dist = self.cell.get_minimum_distance(point1=[0, 0, 0], point2=[0.5,
0.5, 0])
self.assertAlmostEqual(math.sqrt(0.5), dist, delta=1e-6)
dist = self.cell.get_minimum_distance(point1=[0, 0, 0], point2=[5.5,
0.5, 0])
self.assertAlmostEqual(math.sqrt(0.5), dist, delta=1e-6)
dist = self.cell.get_minimum_distance(point1=[0, 0, 0], point2=[5.5,
-10.5, 0])
self.assertAlmostEqual(math.sqrt(0.5), dist, delta=1e-6)
def test_get_closest_image_simple(self):
# Simple case: orthogonal axes.
# Origin.
self.cell.add_atom(Atom([0, 0, 0], 1))
# C face center.
self.cell.add_atom(Atom([0.75, 0.75, 0.75], 1))
image = self.cell.get_minimum_distance(center=0, neighbor=1)
np_tst.assert_array_almost_equal([-0.25, -0.25, -0.25],
image.get_position(), decimal=6)
np_tst.assert_array_equal([-1, -1, -1], image.get_supercell())
def test_get_closest_image_difficult(self):
# Difficult case: Non-conventional unit cell.
# Origin.
self.cell.add_atom(Atom([0, 0, 0], 1))
# Body face center.
self.cell.add_atom(Atom([0.5, 0.5, 0.5], 1))
basis = self.cell.get_basis()
basis[1][0] = 108
self.cell.set_basis(basis=basis)
image = self.cell.get_minimum_distance(center=0, neighbor=1)
np_tst.assert_array_almost_equal([-0.5, -0.5, 0.5],
image.get_position(), decimal=6)
np_tst.assert_array_equal([-1, 53, 0], image.get_supercell())
def test_replacement(self):
# Make the original cell B2-CuZr
self.cell.add_atom(Atom([0, 0, 0], 0))
self.cell.add_atom(Atom([0.5, 0.5, 0.5], 1))
self.cell.set_type_name(0, "Cu")
self.cell.set_type_name(1, "Zr")
# Replace Cu with Ni.
to_change = {"Cu":"Ni"}
self.cell.replace_type_names(to_change)
self.assertEqual("Ni", self.cell.get_type_name(0))
self.assertEqual("Zr", self.cell.get_type_name(1))
# Replace Ni with Cu and Zr with Ti.
to_change = {"Ni": "Cu", "Zr":"Ti"}
self.cell.replace_type_names(to_change)
self.assertEqual("Cu", self.cell.get_type_name(0))
self.assertEqual("Ti", self.cell.get_type_name(1))
# Exchange Cu and Ti.
to_change = {"Ti": "Cu", "Cu": "Ti"}
self.cell.replace_type_names(to_change)
self.assertEqual("Ti", self.cell.get_type_name(0))
self.assertEqual("Cu", self.cell.get_type_name(1))
# Make everything Cu.
to_change = {"Ti": "Cu"}
self.cell.replace_type_names(to_change)
self.assertEqual("Cu", self.cell.get_type_name(0))
self.assertEqual("Cu", self.cell.get_type_name(1))
# Make everything W.
to_change = {"Cu":"W"}
self.cell.replace_type_names(to_change)
self.assertEqual("W", self.cell.get_type_name(0))
self.assertEqual("W", self.cell.get_type_name(1))
# Merge types.
self.cell.merge_like_types()
self.assertEqual(1, self.cell.n_types())
def test_results(self):
# Create Dataset.
dataset = []
# Create primitive cell for B2-AlNi.
structure1 = Cell()
structure1.set_basis(lengths=[2.88, 2.88, 2.88], angles=[90, 90, 90])
structure1.add_atom(Atom([0, 0, 0], 0))
structure1.add_atom(Atom([0.5, 0.5, 0.5], 1))
structure1.set_type_name(0, "Al")
structure1.set_type_name(1, "Ni")
entry1 = CrystalStructureEntry(structure1,
name="Primitive",
radii=None)
dataset.append(entry1)
# Create Scaled Cell.
structure2 = Cell()
structure2.set_basis(lengths=[3.0, 3.0, 3.0], angles=[90, 90, 90])
structure2.add_atom(Atom([0, 0, 0], 0))
structure2.add_atom(Atom([0.5, 0.5, 0.5], 1))
structure2.set_type_name(0, "Al")
structure2.set_type_name(1, "Ni")
entry2 = CrystalStructureEntry(structure2, name="Scaled", radii=None)
dataset.append(entry2)
# Create a cell where A & B are swapped.
structure3 = Cell()
structure3.set_basis(lengths=[3.0, 3.0, 3.0], angles=[90, 90, 90])
structure3.add_atom(Atom([0, 0, 0], 0))
structure3.add_atom(Atom([0.5, 0.5, 0.5], 1))
structure3.set_type_name(0, "Al")
structure3.set_type_name(1, "Ni")
entry3 = CrystalStructureEntry(structure3, name="Scaled", radii=None)
dataset.append(entry3)
# Create a 2x1x1 supercell.
structure4 = Cell()
structure4.set_basis(lengths=[6.0, 3.0, 3.0], angles=[90, 90, 90])
structure4.add_atom(Atom([0, 0, 0], 0))
structure4.add_atom(Atom([0.5, 0, 0], 0))
structure4.add_atom(Atom([0.25, 0.5, 0.5], 1))
structure4.add_atom(Atom([0.75, 0.5, 0.5], 1))
structure4.set_type_name(0, "Ni")
structure4.set_type_name(1, "Al")
entry4 = CrystalStructureEntry(structure4,
name="Primitive",
radii=None)
dataset.append(entry4)
# Generate features.
gen = self.get_generator()
features = gen.generate_features(dataset)
# Make sure the correct number were generated.
ec = self.expected_count()
self.assertEqual(ec, features.shape[1])
for i in range(len(dataset)):
self.assertEqual(ec, len(features.values[i]))
# Make sure scaling doesn't effect it.
for i in range(ec):
self.assertAlmostEqual(features.values[0][i],
features.values[1][i],
delta=1e-6)
# Make sure its permutationally-invariant.
for i in range(ec):
self.assertAlmostEqual(features.values[0][i],
features.values[2][i],
delta=1e-6)
# Make sure it passes supercell.
for i in range(ec):
self.assertAlmostEqual(features.values[0][i],
features.values[3][i],
delta=1e-6)
class testPairDistanceAnalysis(unittest.TestCase):
def setUp(self):
self.structure = Cell()
self.structure.set_basis(lengths=[1, 1, 1], angles=[90, 90, 90])
self.structure.add_atom(Atom([0, 0, 0], 0))
self.pda = PairDistanceAnalysis()
self.pda.analyze_structure(self.structure)
def tearDown(self):
self.structure = None
self.pda = None
def test_get_all_neighbors_of_atom(self):
# With orthorhombic basis.
self.pda.set_cutoff_distance(1.1)
output = self.pda.get_all_neighbors_of_atom(0)
self.assertEqual(6, len(output))
self.assertAlmostEqual(1.0, output[0][1], delta=1e-6)
# Adding a second atom.
self.structure.add_atom(Atom([0.5, 0.5, 0.5], 0))
output = self.pda.get_all_neighbors_of_atom(0)
self.assertEqual(14, len(output))
# Altering the basis to something weird.
new_basis = self.structure.get_basis()
new_basis[1][0] = 14
output = self.pda.get_all_neighbors_of_atom(0)
self.assertEqual(14, len(output))
# Check that images match up.
center_pos = self.structure.get_atom(0).get_position_cartesian()
for image in output:
v = image[0].get_position() - center_pos
self.assertAlmostEqual(image[1], norm(v), delta=1e-6)
def test_PRDF(self):
# With orthorhombic basis.
self.pda.set_cutoff_distance(2.1)
# Run code.
prdf = self.pda.compute_PRDF(50)
self.assertEqual(1, len(prdf))
self.assertEqual(1, len(prdf[0]))
self.assertEqual(50, len(prdf[0][0]))
# Make sure that it finds 4 peaks.
n_peaks = 0
for val in prdf[0][0]:
if val > 0:
n_peaks += 1
self.assertEqual(4, n_peaks)
# Add another atom, repeat.
self.structure.add_atom(Atom([0.5, 0.5, 0.5], 1))
# Run again.
prdf = self.pda.compute_PRDF(50)
self.assertEqual(2, len(prdf))
self.assertEqual(2, len(prdf[0]))
self.assertEqual(50, len(prdf[0][0]))
# Make sure A-B prdf has 2 peaks.
n_peaks = 0
for val in prdf[0][1]:
if val > 0:
n_peaks += 1
self.assertEqual(2, n_peaks)
# Increase basis.
self.structure.set_basis(lengths=[2, 2, 2], angles=[90, 90, 90])
self.pda.analyze_structure(self.structure)
# Run again.
prdf = self.pda.compute_PRDF(50)
self.assertEqual(2, len(prdf))
self.assertEqual(2, len(prdf[0]))
self.assertEqual(50, len(prdf[0][0]))
# Make sure A-B prdf has 1 peaks.
n_peaks = 0
for val in prdf[0][1]:
if val > 0:
n_peaks += 1
self.assertEqual(1, n_peaks)