def test3(self):
l = Lattice.cubic(100)
s1 = PeriodicSite('Li', [99.5, 0, 1], l, coords_are_cartesian=True)
s2 = PeriodicSite('Sn', [99.5, 1, 0], l, coords_are_cartesian=True)
s3 = PeriodicSite('Li', [0.5, 0, 0], l, coords_are_cartesian=True)
s = Structure.from_sites([s1, s2, s3])
coords = np.array(s.cart_coords)[:, None, :]
cd = CoordData(coords, s)
gtc = GaussianTripletColumns(rrange=[1, 10], c=0.5)
f = gtc.make(cd)
self.assertAlmostEqual(f[0, 0], 0)
self.assertAlmostEqual(f[1, 8], -0.41849511)
self.assertAlmostEqual(f[2, 8], 0.83699023)
self.assertAlmostEqual(f[3, 32], -0.83699023)
def _make_sites(self):
""" """
self.sites = []
self.coords = []
for raw in self.atoms:
proc = [
s.strip()
for s in (raw[:6], raw[6:11], raw[12:16], raw[16], raw[17:20],
raw[21], raw[22:26], raw[26], raw[30:38], raw[38:46],
raw[46:54], raw[54:60], raw[60:66], raw[72:76],
raw[76:78], raw[78:])
]
coord = np.dot(self.cart_to_lat, np.array(
proc[8:11], dtype=float)) + self.translate
props = dict(serial=proc[1],
name=proc[2],
altloc=proc[3],
residue=proc[4],
chain=proc[5],
sequence=proc[6],
segment=proc[13])
self.coords.append(coord)
self.sites.append(
PeriodicSite(Composition({proc[-2]: float(proc[11])}),
coord,
self.lattice,
coords_are_cartesian=True,
properties=props))
return
def make_supercell(self, scaling_matrix):
"""
Create a supercell. Very similar to pymatgen's Structure.make_supercell
However, we need to make sure that all fractional coordinates that equal
to 1 will become 0 and the lattice are redefined so that x_c = [0, 0, c]
Args:
scaling_matrix (3x3 matrix): The scaling matrix to make supercell.
"""
s = self * scaling_matrix
for i, site in enumerate(s):
f_coords = np.mod(site.frac_coords, 1)
# The following for loop is probably not necessary. But I will leave
# it here for now.
for j, v in enumerate(f_coords):
if abs(v - 1) < 1e-6:
f_coords[j] = 0
s[i] = PeriodicSite(site.specie,
f_coords,
site.lattice,
properties=site.properties)
self._sites = s.sites
self._lattice = s.lattice
new_lat = Lattice.from_lengths_and_angles(
*s.lattice.lengths_and_angles)
self.modify_lattice(new_lat)
def periodic_muon_site(self):
"""The periodic single muon site"""
structure = self.pristine_structure_supercell.copy()
mupos = self.relax_muon_site.frac_coords
return PeriodicSite("H",
mupos,
structure.lattice,
coords_are_cartesian=False)
def from_dict(cls, d):
lattice = Lattice.from_dict(d["lattice"])
sites = [PeriodicSite.from_dict(sd, lattice) for sd in d["sites"]]
s = Structure.from_sites(sites)
return cls(
lattice=lattice,
species=s.species_and_occu, coords=s.frac_coords,
miller_index=d["miller_index"],
oriented_unit_cell=Structure.from_dict(d["oriented_unit_cell"]),
shift=d["shift"],
scale_factor=MontyDecoder().process_decoded(d["scale_factor"]),
site_properties=s.site_properties, energy=d["energy"]
)
def get_sitej(self, site_index, image_index):
"""
Assuming there is some value in the connectivity array at indices
(1, 3, 12). sitei can be obtained directly from the input structure
(structure[1]). sitej can be obtained by passing 3, 12 to this function
Args:
site_index (int): index of the site (3 in the example)
image_index (int): index of the image (12 in the example)
"""
atoms_n_occu = self.s[site_index].species
lattice = self.s.lattice
coords = self.s[site_index].frac_coords + self.offsets[image_index]
return PeriodicSite(atoms_n_occu, coords, lattice)
def __init__(self, supercell_matrix, cluster_expansion):
"""
Args:
supercell matrix: array describing the supercell, e.g. [[1,0,0],[0,1,0],[0,0,1]]
cluster_expansion: ClusterExpansion object
"""
self.basis = cluster_expansion.basis
self.supercell_matrix = np.array(supercell_matrix)
self.prim_to_supercell = np.linalg.inv(self.supercell_matrix)
self.cluster_expansion = cluster_expansion
self.supercell = cluster_expansion.structure.copy()
self.supercell.make_supercell(self.supercell_matrix)
self.size = int(round(np.abs(np.linalg.det(self.supercell_matrix))))
self.bits = get_bits(self.supercell)
self.nbits = np.array([len(b)-1 for b in self.bits])
self.fcoords = np.array(self.supercell.frac_coords)
self._generate_mappings()
if self.cluster_expansion.use_ewald:
#lazily generate the difficult ewald parts
self.ewald_inds = []
ewald_sites = []
for bits, s in zip(self.bits, self.supercell):
inds = np.zeros(max(self.nbits) + 1) - 1
for i, b in enumerate(bits):
if b == 'Vacancy':
#inds.append(-1)
continue
inds[i] = len(ewald_sites)
ewald_sites.append(PeriodicSite(b, s.frac_coords, s.lattice))
self.ewald_inds.append(inds)
self.ewald_inds = np.array(self.ewald_inds, dtype=np.int)
self._ewald_structure = Structure.from_sites(ewald_sites)
self._ewald_matrix = None
self._partial_ems = None
self._all_ewalds = None
self._range = np.arange(len(self.nbits))
else:
self._all_ewalds = np.zeros((0, 0, 0), dtype=np.float)
self.ewald_inds = np.zeros((0, 0), dtype=np.int)
def periodic_muon_site(self):
"""get muon position as a PeriodicSite
Parameters
----------
positions : nd.array
numpy.array of fractional position of host atoms (including muon)
Returns:
mu_positions : PeriodicSite
Periodic muon site positions
"""
structure = self.structure_sc.copy()
positions = self.positions
mu_positions = list()
for mu_i, mu in enumerate(self.positions):
mu_positions.append(
PeriodicSite("H", [mu_p for mu_p in positions[mu_i][-1]],
structure.lattice,
coords_are_cartesian=False))
return mu_positions
def test_symmetrized_structure(self):
t = OrderDisorderedStructureTransformation(symmetrized_structures=True)
c = []
sp = []
c.append([0.5, 0.5, 0.5])
sp.append('Si4+')
c.append([0.45, 0.45, 0.45])
sp.append({"Si4+": 0.5})
c.append([0.56, 0.56, 0.56])
sp.append({"Si4+": 0.5})
c.append([0.25, 0.75, 0.75])
sp.append({"Si4+": 0.5})
c.append([0.75, 0.25, 0.25])
sp.append({"Si4+": 0.5})
l = Lattice.cubic(5)
s = Structure(l, sp, c)
test_site = PeriodicSite("Si4+", c[2], l)
s = SymmetrizedStructure(s, 'not_real', [0, 1, 1, 2, 2])
output = t.apply_transformation(s)
self.assertTrue(test_site in output.sites)
def periodic_muon_equivalent_site(self):
"""get muon position as a PeriodicSite
Parameters
----------
positions : numpy.ndarray
3D muon positions (including muon)
Returns:
PeriodicSite of muon positions
"""
#frac_coords = self.ase_muon_find_equiv()
positions = self.muon_equivalent_sites
structure = self.pristine_structure_supercell.copy()
periodic_sites = list()
for mu, i in enumerate(positions):
periodic_sites.append(
PeriodicSite("H", [mu_i for mu_i in positions[mu]],
structure.lattice,
coords_are_cartesian=False))
return periodic_sites
def delete_bt_layer(self, bt, tol=0.25, axis=2):
"""
Delete bottom or top layer of the structure.
Args:
bt (str): Specify whether it's a top or bottom layer delete. "b"
means bottom layer and "t" means top layer.
tol (float), Angstrom: Tolerance factor to determine whether two
atoms are at the same plane.
Default to 0.25
axis (int): The direction of top and bottom layers. 0: x, 1: y, 2: z
"""
if bt == "t":
l1, l2 = (-1, -2)
else:
l1, l2 = (0, 1)
l = self.lattice.abc[axis]
layers = self.sort_sites_in_layers(tol=tol, axis=axis)
l_dist = abs(layers[l1][0].coords[axis] - layers[l2][0].coords[axis])
l_vector = [1, 1]
l_vector.insert(axis, (l - l_dist) / l)
new_lat = Lattice(self.lattice.matrix * np.array(l_vector)[:, None])
layers.pop(l1)
sites = reduce(lambda x, y: np.concatenate((x, y), axis=0), layers)
new_sites = []
l_dist = 0 if bt == "t" else l_dist
l_vector = [0, 0]
l_vector.insert(axis, l_dist)
for i in sites:
new_sites.append(
PeriodicSite(i.specie,
i.coords - l_vector,
new_lat,
coords_are_cartesian=True))
self._sites = new_sites
self._lattice = new_lat
def test2(self):
l = Lattice.cubic(100)
s1 = PeriodicSite('Li', [99.5, 0, 1.1], l, coords_are_cartesian=True)
s2 = PeriodicSite('Sn', [99.5, 1, 0], l, coords_are_cartesian=True)
s3 = PeriodicSite('Li', [0.5, 0, 0], l, coords_are_cartesian=True)
s4 = PeriodicSite('Li', [59.5, 0, 1.1], l, coords_are_cartesian=True)
s5 = PeriodicSite('Sn', [59.5, 1, 0], l, coords_are_cartesian=True)
s6 = PeriodicSite('Li', [60.5, 0, 0], l, coords_are_cartesian=True)
s = Structure.from_sites([s1, s2, s3, s4, s5, s6])
coords = np.array(s.cart_coords)[:, None, :]
cd = CoordData(coords, s)
gtc = GaussianTripletColumns(rrange=np.arange(1, 1.1, 1), c=0.5)
f = gtc.make(cd)
self.assertAlmostEqual(f[9, 0], 0)
self.assertAlmostEqual(f[10, 1], -0.36030969)
self.assertAlmostEqual(f[11, 1], 0.79268132)
self.assertAlmostEqual(f[12, 4], -0.64481206)
self.assertAlmostEqual(f[13, 4], 1.36543144)
self.assertAlmostEqual(np.sum(f), 0)
def structure_from_occu(self, occu):
sites = []
for b, o, s in zip(self.bits, occu, self.supercell):
if b[o] != 'Vacancy':
sites.append(PeriodicSite(b[o], s.frac_coords, self.supercell.lattice))
return Structure.from_sites(sites)
def get_structure_graph_scene(
self,
origin=None,
draw_image_atoms=True,
bonded_sites_outside_unit_cell=True,
hide_incomplete_edges=False,
incomplete_edge_length_scale=0.3,
color_edges_by_edge_weight=True,
edge_weight_color_scale="coolwarm",
explicitly_calculate_polyhedra_hull=False,
legend: Optional[Legend] = None,
) -> Scene:
origin = origin or list(
-self.structure.lattice.get_cartesian_coords([0.5, 0.5, 0.5]))
legend = legend or Legend(self.structure)
primitives = defaultdict(list)
sites_to_draw = self._get_sites_to_draw(
draw_image_atoms=draw_image_atoms,
bonded_sites_outside_unit_cell=bonded_sites_outside_unit_cell,
)
color_edges = False
if color_edges_by_edge_weight:
weights = [e[2].get("weight") for e in self.graph.edges(data=True)]
weights = np.array([w for w in weights if w])
if any(weights):
cmap = get_cmap(edge_weight_color_scale)
# try to keep color scheme symmetric around 0
weight_max = max([abs(min(weights)), max(weights)])
weight_min = -weight_max
def get_weight_color(weight):
if not weight:
weight = 0
x = (weight - weight_min) / (weight_max - weight_min)
return "#{:02x}{:02x}{:02x}".format(
*[int(c * 255) for c in cmap(x)[0:3]])
color_edges = True
for (idx, jimage) in sites_to_draw:
site = self.structure[idx]
if jimage != (0, 0, 0):
connected_sites = self.get_connected_sites(idx, jimage=jimage)
site = PeriodicSite(
site.species,
np.add(site.frac_coords, jimage),
site.lattice,
properties=site.properties,
)
else:
connected_sites = self.get_connected_sites(idx)
connected_sites = [
cs for cs in connected_sites
if (cs.index, cs.jimage) in sites_to_draw
]
connected_sites_not_drawn = [
cs for cs in connected_sites
if (cs.index, cs.jimage) not in sites_to_draw
]
if color_edges:
connected_sites_colors = [
get_weight_color(cs.weight) for cs in connected_sites
]
connected_sites_not_drawn_colors = [
get_weight_color(cs.weight) for cs in connected_sites_not_drawn
]
else:
connected_sites_colors = None
connected_sites_not_drawn_colors = None
site_scene = site.get_scene(
connected_sites=connected_sites,
connected_sites_not_drawn=connected_sites_not_drawn,
hide_incomplete_edges=hide_incomplete_edges,
incomplete_edge_length_scale=incomplete_edge_length_scale,
connected_sites_colors=connected_sites_colors,
connected_sites_not_drawn_colors=connected_sites_not_drawn_colors,
explicitly_calculate_polyhedra_hull=
explicitly_calculate_polyhedra_hull,
legend=legend,
)
for scene in site_scene.contents:
primitives[scene.name] += scene.contents
primitives["unit_cell"].append(self.structure.lattice.get_scene())
return Scene(
name=self.structure.composition.reduced_formula,
origin=origin,
contents=[
Scene(name=k, contents=v, origin=origin)
for k, v in primitives.items()
],
)
def generate_supercells(
bulk_structure,
grid_size = 4,
supercell = (2, 2, 2),
method = 'grid',
positions=None
):
"""
This is a wrapper to various methods to generate different interstitial impurities.
Parameters
----------
bulk_structure : Structure object
A unitcell (magnetic or not) structure in form of Pymatgen Structure object
grid_size : int
A grid size in all lattice directions to generate uniform
grid for interstitial impurities implemented by Pietro Bonfa. Default=4.
supercell : tuple, numpy.ndarray
Supercell size in a, b and c direction. Default = (2, 2, 2)
method : str
The method to generate interstial impurities. Default='grid'
positions : None
A numpy.ndarray of muon positions if `method="manual"`.
Returns
-------
structure_list : list
A list of supercell structure containing interstitial impurities
"""
#magnetic_structure = CollinearMagneticStructureAnalyzer(bulk_structure, make_primitive=False)
#if magnetic_structure.is_magnetic:
# #spin_bulk_structure = magnetic_structure.get_structure_with_spin()
# spin_bulk_structure =
# spin_bulk_structure.make_supercell(supercell)
site_properties_preservation = bulk_structure.copy()
site_properties_preservation.make_supercell(supercell)
structure_list = []
## Manually set ?
if method == 'manual':
if positions is None:
raise ValueError('Position must be specified in manual mode!')
r = []
for position in positions:
defect_site = PeriodicSite("H", position, bulk_structure.lattice, coords_are_cartesian=False)
r.append(Interstitial(bulk_structure, defect_site, charge=0.))
elif method == 'tess':
r = []
for position in tess_interstitials(bulk_structure):
defect_site = PeriodicSite("H", position, bulk_structure.lattice, coords_are_cartesian=False)
r.append(Interstitial(bulk_structure, defect_site, charge=0.))
elif method == 'infit':
r = list(InterstitialGenerator( bulk_structure, 'H'))
elif method == 'grid':
r = []
for position in generate_uniform_grid(bulk_structure, grid_size):
defect_site = PeriodicSite("H", position, bulk_structure.lattice, coords_are_cartesian=False)
r.append(Interstitial(bulk_structure, defect_site, charge=0.))
else:
r = list(VoronoiInterstitialGenerator( bulk_structure, 'H'))
for i,v in enumerate(r):
struct=v.generate_defect_structure(supercell=supercell)
## Preserve magnetic structure
#if (magnetic_structure.is_magnetic):
# spins = np.zeros(struct.num_sites)
# # TODO: check non collinear...
# for site1 in spin_bulk_structure:
# for i, site2 in enumerate(struct):
# if np.allclose(site1.coords, site2.coords, atol = site2.position_atol):
# spins[i] = site1.specie.spin
# break
#
# struct.add_spin_by_site(spins)
for site1 in site_properties_preservation:
for i, site2 in enumerate(struct):
if np.allclose(site1.coords, site2.coords, atol = site2.position_atol):
#spins[i] = site1.specie.spin
struct[i].properties = site1.properties
break
# Remove symmetry
if method != 'manual':
# Here we assume, manual muon site are perturb.
# Performs a random perturbation of the sites in the structure
# to break symmetries. A distance of 1e-4 Angs. surely does nothing
# However we can perturb the muon site with a random vector with
# 0.1 Angs. distance
struct.perturb(distance=0.0001)
struct.translate_sites(-1, 0.1 * np.random.random(3), frac_coords=False)
if struct.is_valid():
structure_list.append(struct)
return structure_list
def get_structure_graph_scene(
self,
origin=None,
draw_image_atoms=True,
bonded_sites_outside_unit_cell=True,
hide_incomplete_edges=False,
incomplete_edge_length_scale=0.3,
color_edges_by_edge_weight=True,
edge_weight_color_scale="coolwarm",
explicitly_calculate_polyhedra_hull=False,
legend: Optional[Legend] = None,
group_by_symmetry: bool = True,
) -> Scene:
origin = origin or list(
-self.structure.lattice.get_cartesian_coords([0.5, 0.5, 0.5]))
legend = legend or Legend(self.structure)
primitives = defaultdict(list)
sites_to_draw = self._get_sites_to_draw(
draw_image_atoms=draw_image_atoms,
bonded_sites_outside_unit_cell=bonded_sites_outside_unit_cell,
)
color_edges = False
if color_edges_by_edge_weight:
weights = [e[2].get("weight") for e in self.graph.edges(data=True)]
weights = np.array([w for w in weights if w])
if any(weights):
cmap = get_cmap(edge_weight_color_scale)
# try to keep color scheme symmetric around 0
weight_max = max([abs(min(weights)), max(weights)])
weight_min = -weight_max
def get_weight_color(weight):
if not weight:
weight = 0
x = (weight - weight_min) / (weight_max - weight_min)
return "#{:02x}{:02x}{:02x}".format(
*[int(c * 255) for c in cmap(x)[0:3]])
color_edges = True
idx_to_wyckoff = {}
if group_by_symmetry:
sga = SpacegroupAnalyzer(self.structure)
struct_sym = sga.get_symmetrized_structure()
for equiv_idxs, wyckoff in zip(struct_sym.equivalent_indices,
struct_sym.wyckoff_symbols):
for idx in equiv_idxs:
idx_to_wyckoff[idx] = wyckoff
for (idx, jimage) in sites_to_draw:
site = self.structure[idx]
if jimage != (0, 0, 0):
connected_sites = self.get_connected_sites(idx, jimage=jimage)
site = PeriodicSite(
site.species,
np.add(site.frac_coords, jimage),
site.lattice,
properties=site.properties,
)
else:
connected_sites = self.get_connected_sites(idx)
connected_sites = [
cs for cs in connected_sites
if (cs.index, cs.jimage) in sites_to_draw
]
connected_sites_not_drawn = [
cs for cs in connected_sites
if (cs.index, cs.jimage) not in sites_to_draw
]
if color_edges:
connected_sites_colors = [
get_weight_color(cs.weight) for cs in connected_sites
]
connected_sites_not_drawn_colors = [
get_weight_color(cs.weight) for cs in connected_sites_not_drawn
]
else:
connected_sites_colors = None
connected_sites_not_drawn_colors = None
site_scene = site.get_scene(
connected_sites=connected_sites,
connected_sites_not_drawn=connected_sites_not_drawn,
hide_incomplete_edges=hide_incomplete_edges,
incomplete_edge_length_scale=incomplete_edge_length_scale,
connected_sites_colors=connected_sites_colors,
connected_sites_not_drawn_colors=connected_sites_not_drawn_colors,
explicitly_calculate_polyhedra_hull=
explicitly_calculate_polyhedra_hull,
legend=legend,
)
for scene in site_scene.contents:
if group_by_symmetry and scene.name == "atoms" and idx in idx_to_wyckoff:
# will rename to e.g. atoms_N_4e
scene.name = f"atoms_{site_scene.name}_{idx_to_wyckoff[idx]}"
# this is a proof-of-concept to demonstrate hover labels, could create label
# automatically from site properties instead
scene.contents[
0].tooltip = f"{site_scene.name} ({idx_to_wyckoff[idx]})"
primitives[scene.name] += scene.contents
primitives["unit_cell"].append(self.structure.lattice.get_scene())
return Scene(
name="StructureGraph",
origin=origin,
contents=[
Scene(name=k, contents=v, origin=origin)
for k, v in primitives.items()
],
)
def get_structure_graph_scene(
self,
origin=(0, 0, 0),
draw_image_atoms=True,
bonded_sites_outside_unit_cell=True,
hide_incomplete_bonds=False,
explicitly_calculate_polyhedra_hull=False,
) -> Scene:
primitives = defaultdict(list)
sites_to_draw = self._get_sites_to_draw(
draw_image_atoms=draw_image_atoms,
bonded_sites_outside_unit_cell=bonded_sites_outside_unit_cell,
)
for (idx, jimage) in sites_to_draw:
site = self.structure[idx]
if jimage != (0, 0, 0):
connected_sites = self.get_connected_sites(idx, jimage=jimage)
site = PeriodicSite(
site.species,
np.add(site.frac_coords, jimage),
site.lattice,
properties=site.properties,
)
else:
connected_sites = self.get_connected_sites(idx)
true_number_of_connected_sites = len(connected_sites)
connected_sites_being_drawn = [
cs for cs in connected_sites
if (cs.index, cs.jimage) in sites_to_draw
]
number_of_connected_sites_drawn = len(connected_sites_being_drawn)
all_connected_sites_present = (
true_number_of_connected_sites == number_of_connected_sites_drawn)
if hide_incomplete_bonds:
# only draw bonds if the destination site is also being drawn
connected_sites = connected_sites_being_drawn
site_scene = site.get_scene(
connected_sites=connected_sites,
all_connected_sites_present=all_connected_sites_present,
origin=origin,
explicitly_calculate_polyhedra_hull=
explicitly_calculate_polyhedra_hull,
)
for scene in site_scene.contents:
primitives[scene.name] += scene.contents
# we are here ...
# select polyhedra
# split by atom type at center
# see if any intersect, if yes split further
# order sets, with each choice, go to add second set etc if don't intersect
# they intersect if centre atom forms vertex of another atom (caveat: centre atom may not actually be inside polyhedra! not checking for this, add todo)
# def _set_intersects() ->bool:
# def _split_set() ->List: (by type, then..?)
# def _order_sets()... pick 1, ask can add 2? etc
primitives["unit_cell"].append(
self.structure.lattice.get_scene(origin=origin))
return Scene(
name=self.structure.composition.reduced_formula,
contents=[Scene(name=k, contents=v) for k, v in primitives.items()],
)
def get_all_neighbors_and_image(structure, r, include_index=False):
"""
Modified from `pymatgen
<http://pymatgen.org/_modules/pymatgen/core/structure.html#IStructure.get_all_neighbors>`_
to return image (used for mapping to supercell), and to use the f2py wrapped
OpenMP dist subroutine to get the distances (smaller memory footprint and faster
than numpy).
Get neighbours for each atom in the unit cell, out to a distance r
Returns a list of list of neighbors for each site in structure.
Use this method if you are planning on looping over all sites in the
crystal. If you only want neighbors for a particular site, use the
method get_neighbors as it may not have to build such a large supercell
However if you are looping over all sites in the crystal, this method
is more efficient since it only performs one pass over a large enough
supercell to contain all possible atoms out to a distance r.
The return type is a [(site, dist) ...] since most of the time,
subsequent processing requires the distance.
Args:
- r (float): Radius of sphere.
- include_index (bool): Whether to include the non-supercell site
- in the returned data
Returns:
- A list of a list of nearest neighbors for each site, i.e.,
[[(site, dist, index, image) ...], ..]. Index only supplied if include_index = True.
The index is the index of the site in the original (non-supercell)
structure. This is needed for ewaldmatrix by keeping track of which
sites contribute to the ewald sum.
"""
recp_len = np.array(structure.lattice.reciprocal_lattice.abc)
maxr = np.ceil((r + 0.15) * recp_len / (2 * math.pi))
nmin = np.floor(np.min(structure.frac_coords, axis=0)) - maxr
nmax = np.ceil(np.max(structure.frac_coords, axis=0)) + maxr
all_ranges = [np.arange(x, y) for x, y in zip(nmin, nmax)]
latt = structure._lattice
neighbors = [list() for i in range(len(structure._sites))]
all_fcoords = np.mod(structure.frac_coords, 1)
coords_in_cell = latt.get_cartesian_coords(all_fcoords)
site_coords = structure.cart_coords
indices = np.arange(len(structure))
for image in itertools.product(*all_ranges):
coords = latt.get_cartesian_coords(image) + coords_in_cell
all_dists = dist.dist(coords, site_coords, len(coords))
all_within_r = np.bitwise_and(all_dists <= r, all_dists > 1e-8)
for (j, d, within_r) in zip(indices, all_dists, all_within_r):
nnsite = PeriodicSite(
structure[j].specie,
coords[j],
latt,
properties=structure[j].properties,
coords_are_cartesian=True,
)
for i in indices[within_r]:
item = (nnsite, d[i], j, image) if include_index else (nnsite, d[i])
neighbors[i].append(item)
return neighbors
def trialstep(self, spch_config, energy_now):
e0 = energy_now
structure = spch_config.structure.copy()
structure_Osite = spch_config.structure.copy()
structure_Osite.remove_species(["Pt", "Zr"])
base_Osite = spch_config.Osite_struct.copy()
# base_Osite.append("He", [0,0,0])
# base_Osite.append("He", [0.4,0.5,0])
# base_Osite.append("He", [0.3, 0.2, 0.4])
# Osite.append("He", [0,0,0])
# Osite.append("He", [0.4,0.5,0])
# Osite.append("He", [0.3, 0.2, 0.4])
# Figure out where the vacancies are by comparing with base_structure
# filled_sites = self.matcher_site.get_mapping(base_Osite,
# Osite)
# if not filled_sites.any():
# print("something went wrong at matching")
# sys.exit(1)
# vac_struct = base_Osite
# vac_struct.remove_sites(filled_sites)
# Make sure the correct number of vacancies have been detected
# assert len(vac_struct)==int(spch_config.N_Ovac*len(spch_config.Osite_struct))
# choose one vacancy and one O atom randomly and flip
# Osites = structure.indices_from_symbol("O")
# O_flip = rand.choice(Osites)
# del structure[O_flip]
# choose one O atom and move it
Osites = structure.indices_from_symbol("O")
O_flip = rand.choice(Osites)
del structure[O_flip]
ntrial = 0
while True:
ntrial += 1
Omove_candidate = PeriodicSite(
"O",
[
rand.random(),
rand.random(),
rand.uniform(spch_config.ZrO2boxZ[0], spch_config.ZrO2boxZ[1]),
],
structure[0].lattice,
)
okflag = True
for site in structure:
if site.distance_and_image(Omove_candidate)[0] < 1.5:
okflag = False
break
if okflag:
break
print("It took ", ntrial, " trials to find space for O")
print(Omove_candidate.frac_coords)
structure.append(
"O", Omove_candidate.frac_coords, properties={"velocities": [0, 0, 0]}
)
# print(vac_flip.frac_coords)
# structure.append("O", vac_candidate.frac_coords,properties={"velocities":[0]})
# structure.to(fmt="poscar", filename="POSCAR.1")
# Backup structure of previous step
structure0 = spch_config.structure
spch_config.structure = structure
# do vasp calculation on structure
e1 = self.energy(spch_config)
# return old spch structure
spch_config.structure = structure0
# Simply pass new structure in dconfig to be used by newconfig():
dconfig = structure
dE = e1 - e0
return dconfig, dE
def get_structure_graph_scene(
self,
origin=(0, 0, 0),
draw_image_atoms=True,
bonded_sites_outside_unit_cell=True,
hide_incomplete_edges=False,
incomplete_edge_length_scale=0.3,
color_edges_by_edge_weight=True,
edge_weight_color_scale="coolwarm",
explicitly_calculate_polyhedra_hull=False,
) -> Scene:
primitives = defaultdict(list)
sites_to_draw = self._get_sites_to_draw(
draw_image_atoms=draw_image_atoms,
bonded_sites_outside_unit_cell=bonded_sites_outside_unit_cell,
)
color_edges = False
if color_edges_by_edge_weight:
weights = [e[2].get("weight") for e in self.graph.edges(data=True)]
weights = np.array([w for w in weights if w])
if any(weights):
cmap = get_cmap(edge_weight_color_scale)
# try to keep color scheme symmetric around 0
weight_max = max([abs(min(weights)), max(weights)])
weight_min = -weight_max
def get_weight_color(weight):
if not weight:
weight = 0
x = (weight - weight_min) / (weight_max - weight_min)
return "#{:02x}{:02x}{:02x}".format(
*[int(c * 255) for c in cmap(x)[0:3]])
color_edges = True
for (idx, jimage) in sites_to_draw:
site = self.structure[idx]
if jimage != (0, 0, 0):
connected_sites = self.get_connected_sites(idx, jimage=jimage)
site = PeriodicSite(
site.species,
np.add(site.frac_coords, jimage),
site.lattice,
properties=site.properties,
)
else:
connected_sites = self.get_connected_sites(idx)
connected_sites = [
cs for cs in connected_sites
if (cs.index, cs.jimage) in sites_to_draw
]
connected_sites_not_drawn = [
cs for cs in connected_sites
if (cs.index, cs.jimage) not in sites_to_draw
]
if color_edges:
connected_sites_colors = [
get_weight_color(cs.weight) for cs in connected_sites
]
connected_sites_not_drawn_colors = [
get_weight_color(cs.weight) for cs in connected_sites_not_drawn
]
else:
connected_sites_colors = None
connected_sites_not_drawn_colors = None
site_scene = site.get_scene(
connected_sites=connected_sites,
connected_sites_not_drawn=connected_sites_not_drawn,
hide_incomplete_edges=hide_incomplete_edges,
incomplete_edge_length_scale=incomplete_edge_length_scale,
connected_sites_colors=connected_sites_colors,
connected_sites_not_drawn_colors=connected_sites_not_drawn_colors,
origin=origin,
explicitly_calculate_polyhedra_hull=
explicitly_calculate_polyhedra_hull,
)
for scene in site_scene.contents:
primitives[scene.name] += scene.contents
# we are here ...
# select polyhedra
# split by atom type at center
# see if any intersect, if yes split further
# order sets, with each choice, go to add second set etc if don't intersect
# they intersect if centre atom forms vertex of another atom (caveat: centre atom may not actually be inside polyhedra! not checking for this, add todo)
# def _set_intersects() ->bool:
# def _split_set() ->List: (by type, then..?)
# def _order_sets()... pick 1, ask can add 2? etc
primitives["unit_cell"].append(
self.structure.lattice.get_scene(origin=origin))
return Scene(
name=self.structure.composition.reduced_formula,
contents=[Scene(name=k, contents=v) for k, v in primitives.items()],
)
def folded_coords(site: PeriodicSite, center: GenCoords) -> GenCoords:
_, image = site.distance_and_image_from_frac_coords(center)
return tuple(site.frac_coords - image)
structure = Poscar.from_file('POSCAR_unit').structure
default_inputs = DefaultInputs(structure)
incar_settings = default_inputs.get_incar_default(xc='PBE')
incar_settings['LVTOT'] = '.TRUE.'
kpoints = Kpoints.gamma_automatic(kpts=(2, 2, 2))
supercell_size = 3
structure.make_supercell(supercell_size)
structure_pure = structure.copy()
for el in charge_states_dict:
structure = structure_pure.copy()
for s in structure.sites:
if s.species_string == 'Na':
defect_site = PeriodicSite(el, s.frac_coords, s.lattice)
break
substitution = Substitution(structure, defect_site)
defect_site_coords = defect_site.frac_coords
structure = substitution.generate_defect_structure()
structure.get_sorted_structure()
for charge in charge_states_dict[el]:
path = os.path.join(os.getcwd(), f'{el}-substitution',
f'Charged{charge}')
default_inputs = DefaultInputs(structure)
potcar_symbols = []
for s in default_inputs.potcar_symbols:
def end_point_wf(mp_id, pair_index, image_num, moving_cation, col):
"""
:param col: collection name
:param mp_id: mp_id in the db_scripts
:param pair_index: pair_index in the db_scripts
:param image_num: index number of the image on the path from the db_scripts
:param moving_cation: pymatgen.Element object, represeting the moving cation, e.g. Element('Mg')
:return:
"""
MyDB.db_access().connect()
collection = MyDB.db_access().collection(col)
doc = collection.find_one({'mp-id': mp_id, 'pair_index': pair_index})
# Calculation that is already successful
if 'MEP_energy' in doc.keys() and ("image_{}".format(image_num)
in doc['MEP_energy']):
if doc['MEP_energy']['image_{}'.format(
image_num)]['status'] == 'success':
return
else:
# Calculation that has halted halfway due to errors
if 'CONTCAR_struct' in doc['MEP_energy']['image_{}'.format(
image_num)].keys():
struct = Structure.from_dict(doc["MEP_energy"][
"image_{}".format(image_num)]["CONTCAR_struct"])
# Calculation that has not been run before
else:
struct = Structure.from_dict(doc['gamma_structure'])
cation_site = PeriodicSite.from_dict(doc['path'][image_num])
struct.insert(0,
cation_site.specie,
cation_site.frac_coords,
properties=doc['path'][image_num]['properties'])
else:
struct = Structure.from_dict(doc['gamma_structure'])
cation_site = PeriodicSite.from_dict(doc['path'][image_num])
struct.insert(0,
cation_site.specie,
cation_site.frac_coords,
properties=doc['path'][image_num]['properties'])
task1 = WritePointRunInput(structure=struct.as_dict(),
moving_cation=moving_cation.as_dict())
task2 = PointCustodianRun(handlers='all')
task3 = PointRunAnalyze()
fw = Firework(
[task1, task2, task3],
spec={
"mp_id": mp_id,
"pair_index": pair_index,
"image_num": image_num,
"collection": col,
"_queueadapter": {
'nnodes': 128,
'walltime': '10:00:00',
'queue': 'Q.JCESR',
'job_name': "{}_{}".format(doc["pretty_formula"], image_num)
}
})
wf_list = [fw]
wf_depend = {}
wf = Workflow(wf_list, wf_depend)
MyDB.db_access().close()
return wf
