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_distance(self):
# Make two simple structures.
structure1 = Cell()
structure1.add_atom(Atom([0, 0, 0], 0))
structure1.set_type_name(0, "Al")
structure2 = Cell()
structure2.add_atom(Atom([0, 0, 0], 0))
structure2.set_type_name(0, "Ni")
# Compute representations of each structure.
rep1 = self.r.compute_representation(structure1)
rep2 = self.r.compute_representation(structure2)
# Check that similarity between identical structures is 1.0.
self.assertAlmostEqual(1.0, self.r.compute_similarity(rep1, rep1),
delta=1e-6)
self.assertAlmostEqual(1.0, self.r.compute_similarity(rep2, rep2),
delta=1e-6)
# Check symmetry.
self.assertAlmostEqual(self.r.compute_similarity(rep1, rep2),
self.r.compute_similarity(rep2, rep1),
delta=1e-6)
# Check that similarity between these structures is less than 1.0.
self.assertTrue(self.r.compute_similarity(rep1, rep2) < 1.0)
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_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_results(self):
# Structure of a B2 crystal.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 0))
structure.add_atom(Atom([0.5, 0.5, 0.5], 1))
structure.set_type_name(0, "Al")
structure.set_type_name(1, "Ni")
entry = CrystalStructureEntry(structure, name="B2", radii=None)
entries = [entry]
# Create feature generator.
gen = ChemicalOrderingAttributeGenerator()
gen.set_weighted(False)
gen.set_shells([1, 2])
# Generate features.
features = gen.generate_features(entries)
# Test results.
self.assertAlmostEqual(0.142857, features.values[0][0], delta=1e-6)
self.assertAlmostEqual(0.04, features.values[0][1], delta=1e-6)
# Now with weights.
gen.set_weighted(True)
features = gen.generate_features(entries)
# Test results.
self.assertAlmostEqual(0.551982, features.values[0][0], delta=1e-6)
self.assertAlmostEqual(0.253856, features.values[0][1], delta=1e-6)
def test_results2(self):
# Create a L12-H3He structure.
# Structure of L12.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 1))
structure.add_atom(Atom([0.5, 0.5, 0], 0))
structure.add_atom(Atom([0.5, 0, 0.5], 0))
structure.add_atom(Atom([0, 0.5, 0.5], 0))
structure.set_type_name(0, "H")
structure.set_type_name(1, "He")
entries = [
CrystalStructureEntry(structure, name="L12-HHe", radii=None)
]
# Get the feature generator.
gen = self.get_generator()
gen.clear_shells()
gen.clear_elemental_properties()
gen.add_shell(1)
gen.add_elemental_property("Number")
# Generate features.
features = gen.generate_features(entries)
# Test the results.
self.assertEqual(5, features.shape[1])
np_tst.assert_array_almost_equal(
[0.166666667, 0.083333333, 0, 2.0 / 9, 2.0 / 9],
features.values[0])
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_vertex_replacement(self):
# Create cell.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 0))
# Create cell for atom1.
cell = VoronoiCell(structure.get_atom(0), radical=True)
# Compute faces.
images = [
AtomImage(structure.get_atom(0), sc)
for sc in VectorCombinationComputer(
structure.get_lattice_vectors(),
1.1).get_supercell_coordinates()
]
cell.compute_cell_helper(images)
# Make sure it turned out OK.
self.assertAlmostEqual(1.0, cell.get_volume(), delta=1e-6)
# Find position of atom that will take corner off.
p = Plane(p1=(0.4, 0.5, 0.5),
p2=(0.5, 0.4, 0.5),
p3=(0.5, 0.5, 0.4),
tolerance=1e-6)
atm_pos = p.project([0, 0, 0])
atm_pos *= 2
structure.add_atom(Atom(atm_pos, 0))
# Cut off the corner.
cell.compute_intersection(
VoronoiFace(cell.get_atom(),
AtomImage(structure.get_atom(1), [0, 0, 0]),
radical=False))
vol = cell.get_volume()
self.assertEqual(7, cell.n_faces())
# Compute a cell that will cut off just slightly more area.
p = Plane(p1=(0.4, 0.5, 0.5),
p2=(0.5, 0.35, 0.5),
p3=(0.5, 0.5, 0.35),
tolerance=1e-6)
atm_pos = p.project([0, 0, 0])
atm_pos *= 2
structure.add_atom(Atom(atm_pos, 0))
new_face = VoronoiFace(cell.get_atom(),
AtomImage(structure.get_atom(2), [0, 0, 0]),
radical=False)
self.assertTrue(cell.compute_intersection(new_face))
self.assertEqual(7, cell.n_faces())
self.assertTrue(cell.get_volume() < vol)
self.assertTrue(cell.geometry_is_valid())
# Remove that face.
cell.remove_face(new_face)
self.assertEqual(6, cell.n_faces())
self.assertEqual(6, cell.get_polyhedron_shape()[4])
self.assertAlmostEqual(1.0, cell.get_volume(), delta=1e-6)
self.assertTrue(cell.geometry_is_valid())
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_to_string(self):
# Make B2-CuZr
cell = Cell()
cell.add_atom(Atom([0, 0, 0], 0))
cell.add_atom(Atom([0.5, 0.5, 0.5], 1))
cell.set_type_name(0, "Cu")
cell.set_type_name(1, "Zr")
CuZr = CrystalStructureEntry(cell, "B2", None)
name = CuZr.__str__()
# print(name)
self.assertTrue("CuZr" in name)
self.assertTrue("B2" in name)
def test(self):
# Make two simple structures.
structure1 = Cell()
structure1.add_atom(Atom([0, 0, 0], 0))
structure1.set_type_name(0, "Al")
entries = []
entry1 = CrystalStructureEntry(structure1, name="Al", radii=None)
entries.append(entry1)
structure2 = Cell()
structure2.add_atom(Atom([0, 0, 0], 0))
structure2.set_type_name(0, "Ni")
structure2.add_atom(Atom([0, 0.5, 0], 1))
structure2.set_type_name(1, "Al")
structure2.add_atom(Atom([0, 0, 0.5], 1))
entry2 = CrystalStructureEntry(structure2, name="NiAl2", radii=None)
entries.append(entry2)
# Create feature generator.
gen = PRDFAttributeGenerator()
gen.set_cut_off_distance(3.0)
gen.set_n_points(5)
gen.set_elements(entries)
# Add extra element H.
gen.add_element(name="H")
# Generate features.
features = gen.generate_features(entries)
# Test results.
self.assertEqual(3 * 3 * 5, features.shape[1])
self.assertEqual(3 * 3 * 5, len(features.values[0]))
self.assertAlmostEqual(0, sum(features.values[0][0 : 4 * 5]),
delta=1e-6) # First 4 PRDFs are H-X.
self.assertTrue(max(features.values[0][4 * 5 : 5 * 5]) > 0)
self.assertAlmostEqual(0, sum(features.values[0][6 * 5 : 9 * 5]),
delta=1e-6) # Only Al in structure.
self.assertEqual(3 * 3 * 5, len(features.values[1]))
self.assertAlmostEqual(0, sum(features.values[1][0: 4 * 5]),
delta=1e-6) # First 4 PRDFs are H-X.
self.assertTrue(max(features.values[1][4 * 5: 5 * 5]) > 0)
self.assertTrue(max(features.values[1][5 * 5: 6 * 5]) > 0)
self.assertAlmostEqual(0, sum(features.values[1][6 * 5: 7 * 5]),
delta=1e-6) # Only Al in structure.
self.assertTrue(max(features.values[1][7 * 5: 8 * 5]) > 0)
self.assertTrue(max(features.values[1][8 * 5: 9 * 5]) > 0)
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_intersection(self):
# Create cell.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 0))
# Create cell for atom1.
cell = VoronoiCell(structure.get_atom(0), radical=True)
# Make sure direct faces match up with expectations.
neighboring_faces = []
neighboring_faces.append(AtomImage(structure.get_atom(0), [1, 0, 0]))
neighboring_faces.append(AtomImage(structure.get_atom(0), [-1, 0, 0]))
neighboring_faces.append(AtomImage(structure.get_atom(0), [0, 1, 0]))
neighboring_faces.append(AtomImage(structure.get_atom(0), [0, -1, 0]))
neighboring_faces.append(AtomImage(structure.get_atom(0), [0, 0, 2]))
neighboring_faces.append(AtomImage(structure.get_atom(0), [0, 0, -1]))
# Assemble cell.
cell.compute_cell_helper(neighboring_faces)
# Perform cut.
cut_face = VoronoiFace(cell.get_atom(),
AtomImage(cell.get_atom(), [0, 0, 1]),
radical=True)
cell.compute_intersection(cut_face)
# Check results.
self.assertTrue(cut_face.is_closed())
self.assertEqual(4, cut_face.n_edges())
self.assertTrue(cell.geometry_is_valid())
self.assertEqual(6, cell.n_faces())
self.assertAlmostEqual(1.0, cell.get_volume(), delta=1e-6)
def test_creation(self):
# Make a simple crystal.
cell = Cell()
cell.add_atom(Atom([0, 0, 0], 0))
# Initialize faces.
image = AtomImage(cell.get_atom(0), [0, 0, 1])
face1 = VoronoiFace(cell.get_atom(0), image, radical=True)
image = AtomImage(cell.get_atom(0), [0, 1, 0])
face2 = VoronoiFace(cell.get_atom(0), image, radical=True)
image = AtomImage(cell.get_atom(0), [1, 0, 0])
face3 = VoronoiFace(cell.get_atom(0), image, radical=True)
# Create edges.
edge1 = VoronoiEdge(face1, face2)
edge2 = VoronoiEdge(face1, face3)
# Create vertex.
vertex = VoronoiVertex(edge1=edge1, edge2=edge2)
# Test properties.
self.assertEqual(edge2, vertex.get_previous_edge())
self.assertEqual(edge1, vertex.get_next_edge())
# Make sure the order of edges on creation doesn't matter.
self.assertEqual(vertex, VoronoiVertex(edge1=edge2, edge2=edge1))
# Create a new vertex, ensure that it is different.
edge3 = VoronoiEdge(face2, face3)
self.assertFalse(vertex.__eq__(VoronoiVertex(edge1=edge3,
edge2=edge2)))
def test_constructor(self):
# Create a Voronoi tessellation of a BCC crystal.
bcc = Cell()
atom = Atom([0, 0, 0], 0)
bcc.add_atom(atom)
atom = Atom([0.5, 0.5, 0.5], 0)
bcc.add_atom(atom)
# Prepare.
tool = VoronoiCellBasedAnalysis(radical=True)
tool.analyze_structure(bcc)
# Create a new instance based on a B2 crystal.
b2 = bcc.__copy__()
b2.get_atom(1).set_type(1)
tool2 = VoronoiCellBasedAnalysis(old_tessellation=tool,
new_structure=b2)
def test_BCC(self):
# Structure of bcc.
structure = Cell()
atom = Atom([0, 0, 0], 0)
structure.add_atom(atom)
atom = Atom([0.5, 0.5, 0.5], 0)
structure.add_atom(atom)
# Prepare.
tool = VoronoiCellBasedAnalysis(radical=True)
tool.analyze_structure(structure)
# Check results.
n_eff = 11.95692194
np_tst.assert_array_almost_equal(
[n_eff, n_eff], tool.get_effective_coordination_numbers())
self.assertAlmostEqual(14.0, tool.face_count_average(), delta=1e-2)
self.assertAlmostEqual(0.0, tool.face_count_variance(), delta=1e-2)
self.assertAlmostEqual(14.0, tool.face_count_minimum(), delta=1e-2)
self.assertAlmostEqual(14.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)
self.assertAlmostEqual(0.68, tool.max_packing_efficiency(), delta=1e-2)
self.assertAlmostEqual(0, tool.mean_bcc_dissimilarity(), delta=1e-2)
self.assertAlmostEqual(14.0 / 12.0,
tool.mean_fcc_dissimilarity(),
delta=1e-2)
self.assertAlmostEqual(8.0 / 6.0,
tool.mean_sc_dissimilarity(),
delta=1e-2)
bond_lengths = tool.bond_lengths()
self.assertEqual(2, len(bond_lengths))
self.assertEqual(14, len(bond_lengths[0]))
self.assertAlmostEqual(math.sqrt(3) / 2,
bond_lengths[0][0],
delta=1e-6)
self.assertAlmostEqual(1.0, bond_lengths[0][12], delta=1e-6)
mean_bond_lengths = tool.mean_bond_lengths()
var_bond_lengths = tool.bond_length_variance(mean_bond_lengths)
self.assertTrue(var_bond_lengths[0] > 0)
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_supercell(self):
# Create cell.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 0))
# Create cell for atom1.
cell = VoronoiCell(structure.get_atom(0), radical=True)
# Compute faces.
images = [
AtomImage(structure.get_atom(0), sc)
for sc in VectorCombinationComputer(
structure.get_lattice_vectors(),
1.1).get_supercell_coordinates()
]
faces = cell.compute_faces(images)
# Get direct neighbors.
direct_faces = cell.compute_direct_neighbors(faces)
# Simple tests.
self.assertEqual(6, len(direct_faces))
self.assertEqual(len(images) - 6 - 1, len(faces))
# Make sure direct faces match up with expectations.
neighboring_faces = []
neighboring_faces.append(
VoronoiFace(structure.get_atom(0),
AtomImage(structure.get_atom(0), [1, 0, 0]),
radical=True))
neighboring_faces.append(
VoronoiFace(structure.get_atom(0),
AtomImage(structure.get_atom(0), [-1, 0, 0]),
radical=True))
neighboring_faces.append(
VoronoiFace(structure.get_atom(0),
AtomImage(structure.get_atom(0), [0, 1, 0]),
radical=True))
neighboring_faces.append(
VoronoiFace(structure.get_atom(0),
AtomImage(structure.get_atom(0), [0, -1, 0]),
radical=True))
neighboring_faces.append(
VoronoiFace(structure.get_atom(0),
AtomImage(structure.get_atom(0), [0, 0, 1]),
radical=True))
neighboring_faces.append(
VoronoiFace(structure.get_atom(0),
AtomImage(structure.get_atom(0), [0, 0, -1]),
radical=True))
# Test whether they are all there.
for f in neighboring_faces:
direct_faces.remove(f)
self.assertTrue(len(direct_faces) == 0)
def test_replacement(self):
# Make B2-CuZr
cell = Cell()
cell.add_atom(Atom([0, 0, 0], 0))
cell.add_atom(Atom([0.5, 0.5, 0.5], 1))
cell.set_type_name(0, "Cu")
cell.set_type_name(1, "Zr")
CuZr = CrystalStructureEntry(cell, "CuZr", None)
# Run Voronoi tessellation.
CuZr.compute_voronoi_tessellation()
# Make B2-NiZr
changes = {"Cu":"Ni"}
NiZr = CuZr.replace_elements(changes)
# Make sure the tessellation object did not change.
self.assertTrue(CuZr.compute_voronoi_tessellation() is
NiZr.compute_voronoi_tessellation())
# Make sure the two are still unchanged.
self.assertAlmostEqual(0.5, CuZr.get_element_fraction(name="Cu"),
delta=1e-6)
self.assertAlmostEqual(0.0, CuZr.get_element_fraction(name="Ni"),
delta=1e-6)
self.assertAlmostEqual(0.0, NiZr.get_element_fraction(name="Cu"),
delta=1e-6)
self.assertAlmostEqual(0.5, NiZr.get_element_fraction(name="Ni"),
delta=1e-6)
# Now, change the structure such that it has fewer types.
changes["Ni"] = "Zr"
bccZr = NiZr.replace_elements(changes)
# Make sure the structure only has one type.
self.assertAlmostEqual(1.0, bccZr.get_element_fraction(name="Zr"),
delta=1e-6)
self.assertEqual(1, bccZr.get_structure().n_types())
self.assertFalse(NiZr.compute_voronoi_tessellation() is
bccZr.compute_voronoi_tessellation())
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_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_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_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)
def test_FCC(self):
# Create the simulation cell.
structure = Cell()
structure.add_atom(Atom([0, 0, 0], 0))
structure.add_atom(Atom([0.5, 0.5, 0], 0))
structure.add_atom(Atom([0.5, 0, 0.5], 0))
structure.add_atom(Atom([0, 0.5, 0.5], 0))
# Run tessellation.
result = VoronoiTessellationCalculator.compute(structure,
radical=False)
# Test results.
self.assertEqual(structure.n_atoms(), len(result))
for cell in result:
self.assertTrue(cell.geometry_is_valid())
self.assertEqual(12, len(cell.get_faces()))
self.assertAlmostEqual(0.25, cell.get_volume(), delta=1e-6)
poly_index = cell.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(self):
# Make two simple structures.
structure1 = Cell()
structure1.add_atom(Atom([0, 0, 0], 0))
structure1.set_type_name(0, "Al")
entries = []
entry1 = CrystalStructureEntry(structure1, name="Al", radii=None)
entries.append(entry1)
structure2 = Cell()
structure2.add_atom(Atom([0, 0, 0], 0))
structure2.set_type_name(0, "Ni")
structure2.add_atom(Atom([0, 0.5, 0], 1))
structure2.set_type_name(1, "Al")
structure2.add_atom(Atom([0, 0, 0.5], 1))
entry2 = CrystalStructureEntry(structure2, name="NiAl2", radii=None)
entries.append(entry2)
# Create feature generator.
gen = CoulombMatrixAttributeGenerator()
gen.set_n_eigenvalues(10)
# Generate features.
features = gen.generate_features(entries)
# Test results.
self.assertEqual(10, features.shape[1])
self.assertNotAlmostEqual(0, features.values[0][0], delta=1e-6)
for i in range(1, 10):
self.assertAlmostEqual(0, features.values[0][i], delta=1e-6)
self.assertNotAlmostEqual(0, features.values[1][0], delta=1e-6)
self.assertNotAlmostEqual(0, features.values[1][1], delta=1e-6)
self.assertNotAlmostEqual(0, features.values[1][2], delta=1e-6)
for i in range(3, 10):
self.assertAlmostEqual(0, features.values[1][i], delta=1e-6)
def test_APRDF(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))
self.tool.set_n_windows(2)
self.tool.set_cut_off_distance(1.0)
self.tool.set_smoothing_factor(100)
self.tool.analyze_structure(structure)
# Trivial: Properties == 0.
ap_rdf = self.tool.compute_APRDF([0, 0])
np_tst.assert_array_almost_equal([0.5, 1],
self.tool.get_evaluation_distances())
np_tst.assert_array_almost_equal([0, 0], ap_rdf)
# Actual case.
ap_rdf = self.tool.compute_APRDF([1, 2])
# Assemble known contributors.
# [0] -> Number of neighbors * P_i * P_j
# [1] -> Bond distance
contributors = []
contributors.append([2 * 8 * 2 * 1, math.sqrt(3) / 2]) # A-B 1st NN.
contributors.append([6 * 1 * 1, 1]) # A-A 2nd NN.
contributors.append([6 * 2 * 2, 1]) # B-B 2nd NN.
contributors.append([8 * 1 * 1, math.sqrt(3)]) # A-A 3rd NN.
contributors.append([8 * 2 * 2, math.sqrt(3)]) # B-B 3rd NN.
eval_dist = [0.5, 1]
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, 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_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_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)
