def trilayer(doped = None):
a = 5.43
fcc = Lattice([[a/2,a/2,0],[a/2,0,a/2],[0,a/2,a/2]])
trilayer = Structure(fcc,['Si']*2,[[0.00,0.00,0.00],[0.25,0.25,0.25]])
# Make the cell cubic
trilayer.make_supercell([[1,1,-1],[1,-1,1],[-1,1,1]])
trilayer.make_supercell([[1,1,0],[1,-1,0],[0,0,4]])
# Rotate the cell
rt = 0.70710678118654746
symmop = SymmOp.from_rotation_and_translation([[rt,rt,0],[rt,-rt,0],[0,0,1]])
trilayer.apply_operation(symmop)
if doped is not None:
frac_coords = numpy.array([0.5,0.0,0.5])
for i,atom in enumerate(trilayer):
if numpy.linalg.norm(atom.frac_coords-frac_coords) < 0.001:
trilayer.replace(i,doped,frac_coords)
for z in [0.375,0.625]:
for xy in [0.00,0.50]:
trilayer.append('Mn',[xy,xy,z])
return trilayer
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Substitution structure, decorated with charge
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = self.bulk_structure.copy()
defect_structure.make_supercell(supercell)
#create a trivial defect structure to find where supercell transformation moves the lattice
struct_for_defect_site = Structure(self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
poss_deflist = sorted(defect_structure.get_sites_in_sphere(
defect_site.coords, 2, include_index=True),
key=lambda x: x[1])
defindex = poss_deflist[0][2]
subsite = defect_structure.pop(defindex)
defect_structure.append(self.site.specie.symbol,
subsite.coords,
coords_are_cartesian=True)
defect_structure.set_charge(self.charge)
return defect_structure
def make_InAs001_surface(inas_layers = 4, licras_layers = 4, vacuum_layers = 8):
total_layers = inas_layers + licras_layers + vacuum_layers
err = 1./total_layers/10
a = Length(6.0583, "ang")
fcc_lattice = np.array([[.0,.5,.5],[.5,.0,.5],[.5,.5,.0]])
lattice = Lattice(fcc_lattice * a)
surface = Structure(lattice, ['Li', 'Cr', 'As'], [[0.50,0.50,0.50],[0.00,0.00,0.00],[0.25,0.25,0.25]])
surface.make_supercell([[0,0,1],[1,-1,0],[1,1,-1]])
surface.make_supercell([[1,0,0],[0,1,0],[0,0,total_layers]])
to_remove = []
print (1.*inas_layers / total_layers)
print 1.*(inas_layers+licras_layers)/total_layers
print 1. - 1. / vacuum_layers
print err
for idx,site in enumerate(surface):
if (site.frac_coords[2] - 1.*inas_layers / total_layers) < -err:
if site.specie.symbol == 'Li': to_remove.append(idx)
if site.specie.symbol == 'Cr': surface.replace(idx,Element('In'))
if (site.frac_coords[2] - 1. + 1./vacuum_layers/8.) > -err:
surface.replace(idx,Element('H'))
elif (1.*(inas_layers+licras_layers)/total_layers) - site.frac_coords[2] < err:
to_remove.append(idx)
surface.remove_sites(to_remove)
selective_dynamics = len(surface) * [[True,True,True]]
for idx,site in enumerate(surface):
if (np.linalg.norm(site.frac_coords) < err):
selective_dynamics[idx] = [False,False,False]
return surface.get_sorted_structure(),np.array(selective_dynamics)
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Substitution structure, decorated with charge.
If bulk structure had any site properties, all of these properties are
removed in the resulting defect structure.
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = Structure( self.bulk_structure.copy().lattice,
[site.specie for site in self.bulk_structure],
[site.frac_coords for site in self.bulk_structure],
to_unit_cell=True, coords_are_cartesian = False,
site_properties = None) #remove all site_properties
defect_structure.make_supercell(supercell)
#create a trivial defect structure to find where supercell transformation moves the defect
struct_for_defect_site = Structure( self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True, coords_are_cartesian = False)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
poss_deflist = sorted(
defect_structure.get_sites_in_sphere(defect_site.coords, 0.1, include_index=True), key=lambda x: x[1])
defindex = poss_deflist[0][2]
subsite = defect_structure.pop(defindex)
defect_structure.append(self.site.specie.symbol, subsite.coords, coords_are_cartesian=True,
properties = None)
defect_structure.set_charge(self.charge)
return defect_structure
def test_primitive_on_large_supercell(self):
coords = [[0, 0, 0], [0.5, 0.5, 0], [0, 0.5, 0.5], [0.5, 0, 0.5]]
fcc_ag = Structure(Lattice.cubic(4.09), ["Ag"] * 4, coords)
fcc_ag.make_supercell([2, 2, 2])
fcc_ag_prim = fcc_ag.get_primitive_structure()
self.assertEqual(len(fcc_ag_prim), 1)
self.assertAlmostEqual(fcc_ag_prim.volume, 17.10448225)
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Interstitial structure, decorated with charge
If bulk structure had any site properties, all of these properties are
removed in the resulting defect structure
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = Structure( self.bulk_structure.copy().lattice,
[site.specie for site in self.bulk_structure],
[site.frac_coords for site in self.bulk_structure],
to_unit_cell=True, coords_are_cartesian = False,
site_properties = None) #remove all site_properties
defect_structure.make_supercell(supercell)
#create a trivial defect structure to find where supercell transformation moves the defect site
struct_for_defect_site = Structure( self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True, coords_are_cartesian = False)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
defect_structure.append(self.site.specie.symbol, defect_site.coords, coords_are_cartesian=True,
properties = None)
defect_structure.set_charge(self.charge)
return defect_structure
def test_primitive_on_large_supercell(self):
coords = [[0, 0, 0], [0.5, 0.5, 0], [0, 0.5, 0.5], [0.5, 0, 0.5]]
fcc_ag = Structure(Lattice.cubic(4.09), ["Ag"] * 4, coords)
fcc_ag.make_supercell([2, 2, 2])
fcc_ag_prim = fcc_ag.get_primitive_structure()
self.assertEqual(len(fcc_ag_prim), 1)
self.assertAlmostEqual(fcc_ag_prim.volume, 17.10448225)
def generate_Si_cluster():
from pymatgen.io.xyz import XYZ
coords = [[0, 0, 0], [0.75, 0.5, 0.75]]
lattice = Lattice.from_parameters(a=3.84, b=3.84, c=3.84, alpha=120, beta=90, gamma=60)
struct = Structure(lattice, ['Si', 'Si'], coords)
struct.make_supercell([2, 2, 2])
# Creating molecule for testing
mol = Molecule.from_sites(struct)
XYZ(mol).write_file(os.path.join(test_dir, "Si_cluster.xyz"))
# Rorate the whole molecule
mol_rotated = mol.copy()
rotate(mol_rotated, seed=42)
XYZ(mol_rotated).write_file(os.path.join(test_dir, "Si_cluster_rotated.xyz"))
# Perturbing the atom positions
mol_perturbed = mol.copy()
perturb(mol_perturbed, 0.3, seed=42)
XYZ(mol_perturbed).write_file(os.path.join(test_dir, "Si_cluster_perturbed.xyz"))
# Permuting the order of the atoms
mol_permuted = mol.copy()
permute(mol_permuted, seed=42)
XYZ(mol_permuted).write_file(os.path.join(test_dir, "Si_cluster_permuted.xyz"))
# All-in-one
mol2 = mol.copy()
rotate(mol2, seed=42)
perturb(mol2, 0.3, seed=42)
permute(mol2, seed=42)
XYZ(mol2).write_file(os.path.join(test_dir, "Si_cluster_2.xyz"))
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Vacancy structure, decorated with charge
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = self.bulk_structure.copy()
defect_structure.make_supercell(supercell)
# create a trivial defect structure to find where supercell transformation moves the lattice
struct_for_defect_site = Structure(
self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True,
)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
poss_deflist = sorted(
defect_structure.get_sites_in_sphere(defect_site.coords, 0.1, include_index=True),
key=lambda x: x[1],
)
defindex = poss_deflist[0][2]
defect_structure.remove_sites([defindex])
defect_structure.set_charge(self.charge)
return defect_structure
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Interstitial structure, decorated with charge
If bulk structure had any site properties, all of these properties are
removed in the resulting defect structure
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = Structure(
self.bulk_structure.copy().lattice,
[site.specie for site in self.bulk_structure],
[site.frac_coords for site in self.bulk_structure],
to_unit_cell=True,
coords_are_cartesian=False,
site_properties=None) # remove all site_properties
defect_structure.make_supercell(supercell)
# create a trivial defect structure to find where supercell transformation moves the defect site
struct_for_defect_site = Structure(self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True,
coords_are_cartesian=False)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
defect_structure.append(self.site.specie.symbol,
defect_site.coords,
coords_are_cartesian=True,
properties=None)
defect_structure.set_charge(self.charge)
return defect_structure
def test_disordered_supercell_primitive_cell(self):
l = Lattice.cubic(2)
f = [[0.5, 0.5, 0.5]]
sp = [{'Si': 0.54738}]
s = Structure(l, sp, f)
#this supercell often breaks things
s.make_supercell([[0, -1, 1], [-1, 1, 0], [1, 1, 1]])
self.assertEqual(len(s.get_primitive_structure()), 1)
def test_disordered_supercell_primitive_cell(self):
l = Lattice.cubic(2)
f = [[0.5, 0.5, 0.5]]
sp = [{'Si': 0.54738}]
s = Structure(l, sp, f)
#this supercell often breaks things
s.make_supercell([[0,-1,1],[-1,1,0],[1,1,1]])
self.assertEqual(len(s.get_primitive_structure()), 1)
def cluster_Si4():
a = 5.43
c = a/2
fcc = Lattice([[a/2,a/2,0],[a/2,0,c/2],[0,a/2,c/2]])
cluster = Structure(fcc,['Si'],[[0.25,0.25,0.25]])
cluster.make_supercell([[1,1,-1],[1,-1,1],[-1,1,1]])
return cluster
def cluster_Mn4():
a = 5.43
c = a/2*7/4
bcc = Lattice([[a/2,a/2,-c/2],[a/2,-a/2,c/2],[-a/2,a/2,c/2]])
cluster = Structure(bcc,['Mn']*2,[[0.00,0.00,0.00],[1./2,1./4,3./4]])
# Make the orthogonal cubic
cluster.make_supercell([[1,1,0],[1,0,1],[0,1,1]])
return cluster
def SiMn_Isite():
a = 5.43
fcc = Lattice([[a/2,a/2,0],[a/2,0,a/2],[0,a/2,a/2]])
isite = Structure(fcc,['Si']*2,[[0.00,0.00,0.00],[0.25,0.25,0.25]])
# Make the cell cubic
isite.make_supercell([[1,1,-1],[1,-1,1],[-1,1,1]])
# Insert Mn atom
isite.append('Mn',[0.50,0.50,0.50])
return isite
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Substitution structure, decorated with charge
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = self.bulk_structure.copy()
defect_structure.make_supercell(supercell)
# consider modifying velocity property to make sure defect site is decorated
# consistently with bulk structure for final defect_structure
defect_properties = self.site.properties.copy()
if ('velocities' in self.bulk_structure.site_properties) and \
'velocities' not in defect_properties:
if all(vel == self.bulk_structure.site_properties['velocities'][0]
for vel in
self.bulk_structure.site_properties['velocities']):
defect_properties[
'velocities'] = self.bulk_structure.site_properties[
'velocities'][0]
else:
raise ValueError(
"No velocity property specified for defect site and "
"bulk_structure velocities are not homogeneous. Please specify this "
"property within the initialized defect_site object.")
#create a trivial defect structure to find where supercell transformation moves the lattice
site_properties_for_fake_struct = {
prop: [val]
for prop, val in defect_properties.items()
}
struct_for_defect_site = Structure(
self.bulk_structure.copy().lattice, [self.site.specie],
[self.site.frac_coords],
to_unit_cell=True,
site_properties=site_properties_for_fake_struct)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
poss_deflist = sorted(defect_structure.get_sites_in_sphere(
defect_site.coords, 2, include_index=True),
key=lambda x: x[1])
defindex = poss_deflist[0][2]
subsite = defect_structure.pop(defindex)
defect_structure.append(self.site.specie.symbol,
subsite.coords,
coords_are_cartesian=True,
properties=defect_site.properties)
defect_structure.set_charge(self.charge)
return defect_structure
def test_get_all_neighbors_and_get_neighbors(self):
s = self.struct
r = random.uniform(3, 6)
all_nn = s.get_all_neighbors(r, True)
for i in range(len(s)):
self.assertEqual(len(all_nn[i]), len(s.get_neighbors(s[i], r)))
for site, nns in zip(s, all_nn):
for nn in nns:
self.assertTrue(nn[0].is_periodic_image(s[nn[2]]))
d = sum((site.coords - nn[0].coords)**2)**0.5
self.assertAlmostEqual(d, nn[1])
s = Structure(Lattice.cubic(1), ['Li'], [[0, 0, 0]])
s.make_supercell([2, 2, 2])
self.assertEqual(sum(map(len, s.get_all_neighbors(3))), 976)
def test_get_all_neighbors_and_get_neighbors(self):
s = self.struct
r = random.uniform(3, 6)
all_nn = s.get_all_neighbors(r, True)
for i in range(len(s)):
self.assertEqual(len(all_nn[i]), len(s.get_neighbors(s[i], r)))
for site, nns in zip(s, all_nn):
for nn in nns:
self.assertTrue(nn[0].is_periodic_image(s[nn[2]]))
d = sum((site.coords - nn[0].coords) ** 2) ** 0.5
self.assertAlmostEqual(d, nn[1])
s = Structure(Lattice.cubic(1), ['Li'], [[0,0,0]])
s.make_supercell([2,2,2])
self.assertEqual(sum(map(len, s.get_all_neighbors(3))), 976)
def SiMn_Ssite():
a = 5.43
fcc = Lattice([[a/2,a/2,0],[a/2,0,a/2],[0,a/2,a/2]])
ssite = Structure(fcc,['Si']*2,[[0.00,0.00,0.00],[0.25,0.25,0.25]])
# Make the cell cubic
ssite.make_supercell([[1,1,-1],[1,-1,1],[-1,1,1]])
# Insert Mn atom
Mnsite = numpy.array([0.25,0.25,0.25]);
for i,atom in enumerate(ssite):
if numpy.linalg.norm(atom.frac_coords-Mnsite) < 0.01:
del ssite[i]
ssite.append('Mn',Mnsite)
return ssite
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Substitution structure, decorated with charge.
If bulk structure had any site properties, all of these properties are
removed in the resulting defect structure.
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = Structure(
self.bulk_structure.copy().lattice,
[site.specie for site in self.bulk_structure],
[site.frac_coords for site in self.bulk_structure],
to_unit_cell=True,
coords_are_cartesian=False,
site_properties=None,
) # remove all site_properties
defect_structure.make_supercell(supercell)
# create a trivial defect structure to find where supercell transformation moves the defect
struct_for_defect_site = Structure(
self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True,
coords_are_cartesian=False,
)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
poss_deflist = sorted(
defect_structure.get_sites_in_sphere(defect_site.coords,
0.1,
include_index=True),
key=lambda x: x[1],
)
defindex = poss_deflist[0][2]
subsite = defect_structure.pop(defindex)
defect_structure.append(
self.site.specie.symbol,
subsite.coords,
coords_are_cartesian=True,
properties=None,
)
defect_structure.set_charge(self.charge)
return defect_structure
def test_apply_transformation_mult(self):
# Test returning multiple structures from each transformation.
disord = Structure(
np.eye(3) * 4.209,
[{"Cs+": 0.5, "K+": 0.5}, "Cl-"],
[[0, 0, 0], [0.5, 0.5, 0.5]],
)
disord.make_supercell([2, 2, 1])
tl = [
EnumerateStructureTransformation(),
OrderDisorderedStructureTransformation(),
]
t = SuperTransformation(tl, nstructures_per_trans=10)
self.assertEqual(len(t.apply_transformation(disord, return_ranked_list=20)), 8)
t = SuperTransformation(tl)
self.assertEqual(len(t.apply_transformation(disord, return_ranked_list=20)), 2)
def Si512Mn():
a = 5.43
fcc = Lattice([[a/2,a/2,0],[a/2,0,a/2],[0,a/2,a/2]])
supercell = Structure(fcc,['Si']*2,[[0.00,0.00,0.00],[0.25,0.25,0.25]])
# Make the cell cubic
supercell.make_supercell([[1,1,-1],[1,-1,1],[-1,1,1]])
supercell.make_supercell([4,4,4])
# Insert Mn atom
Mnsite = numpy.array([0.50,0.50,0.50])
for i,atom in enumerate(supercell):
if numpy.linalg.norm(atom.frac_coords - Mnsite) < 0.01:
supercell.translate_sites([i],[1./8,1./8,1./8])
supercell.append('Mn',[0.50,0.50,0.50])
break
return supercell
def make_Si001_surface(Si_layers = 4, vacuum_layers = 4):
total_layers = Si_layers + vacuum_layers
a = Length(5.431, "ang")
fcc_lattice = np.array([[.0,.5,.5],[.5,.0,.5],[.5,.5,.0]])
lattice = Lattice(fcc_lattice * a)
surface = Structure(lattice, ['Si','Si'], [[0.00,0.00,0.00],[0.25,0.25,0.25]])
surface.make_supercell([[0,0,1],[1,-1,0],[1,1,-1]])
surface.make_supercell([[2,0,0],[0,2,0],[0,0,total_layers]])
to_remove = []
for idx,site in enumerate(surface):
if (site.frac_coords[2] > 1.0*Si_layers/total_layers):
to_remove.append(idx)
surface.remove_sites(to_remove)
print to_remove
selective_dynamics = len(surface) * [[True,True,True]]
for idx,site in enumerate(surface):
if (site.frac_coords[2] < 0.001):
selective_dynamics[idx] = [False,False,False]
surface.replace(idx,Element('H'))
return surface.get_sorted_structure(),np.array(selective_dynamics)
def make_trilayer(xyscale = 2, zscale = 4):
a = Length(5.431,"ang")
fcc_lattice = np.array([[.0,.5,.5],[.5,.0,.5],[.5,.5,.0]])
lattice = Lattice(fcc_lattice * a)
trilayer = Structure(lattice, ['Si','Si'], [[0.00,0.00,0.00],[0.25,0.25,0.25]])
trilayer.make_supercell([[0,0,1],[1,-1,0],[1,1,-1]])
trilayer.make_supercell([[xyscale,0,0],[0,xyscale,0],[0,0,zscale]])
# Dope the Ga sites
for idx,site in enumerate(trilayer):
if np.linalg.norm(site.frac_coords - np.array([+.0,+.5,.0])) < 1e-10:
trilayer.replace(idx,Element('Ga'))
if np.linalg.norm(site.frac_coords - np.array([+.5,+.0,.0])) < 1e-10:
trilayer.replace(idx,Element('Ga'))
# Insert the Mn sites
trilayer.append('Mn', [0.0,0.0,zscale*a-a/2], coords_are_cartesian=True)
trilayer.append('Mn', [0,a,zscale*a-a/2], coords_are_cartesian=True)
trilayer.append('Mn', [0.0,0.0,a/2], coords_are_cartesian=True)
trilayer.append('Mn', [0,a,a/2], coords_are_cartesian=True)
return trilayer.get_sorted_structure()
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Substitution structure, decorated with charge
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = self.bulk_structure.copy()
defect_structure.make_supercell(supercell)
# consider modifying velocity property to make sure defect site is decorated
# consistently with bulk structure for final defect_structure
defect_properties = self.site.properties.copy()
if ('velocities' in self.bulk_structure.site_properties) and \
'velocities' not in defect_properties:
if all( vel == self.bulk_structure.site_properties['velocities'][0]
for vel in self.bulk_structure.site_properties['velocities']):
defect_properties['velocities'] = self.bulk_structure.site_properties['velocities'][0]
else:
raise ValueError("No velocity property specified for defect site and "
"bulk_structure velocities are not homogeneous. Please specify this "
"property within the initialized defect_site object.")
#create a trivial defect structure to find where supercell transformation moves the lattice
site_properties_for_fake_struct = {prop: [val] for prop,val in defect_properties.items()}
struct_for_defect_site = Structure( self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True,
site_properties = site_properties_for_fake_struct)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
poss_deflist = sorted(
defect_structure.get_sites_in_sphere(defect_site.coords, 2, include_index=True), key=lambda x: x[1])
defindex = poss_deflist[0][2]
subsite = defect_structure.pop(defindex)
defect_structure.append(self.site.specie.symbol, subsite.coords, coords_are_cartesian=True,
properties = defect_site.properties)
defect_structure.set_charge(self.charge)
return defect_structure
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Interstitial structure, decorated with charge
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = self.bulk_structure.copy()
defect_structure.make_supercell(supercell)
#create a trivial defect structure to find where supercell transformation moves the lattice
struct_for_defect_site = Structure(self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
defect_structure.append(self.site.specie.symbol,
defect_site.coords,
coords_are_cartesian=True)
defect_structure.set_charge(self.charge)
return defect_structure
def generate_defect_structure(self, supercell=(1, 1, 1)):
"""
Returns Defective Vacancy structure, decorated with charge
Args:
supercell (int, [3x1], or [[]] (3x3)): supercell integer, vector, or scaling matrix
"""
defect_structure = self.bulk_structure.copy()
defect_structure.make_supercell(supercell)
#create a trivial defect structure to find where supercell transformation moves the lattice
struct_for_defect_site = Structure( self.bulk_structure.copy().lattice,
[self.site.specie],
[self.site.frac_coords],
to_unit_cell=True)
struct_for_defect_site.make_supercell(supercell)
defect_site = struct_for_defect_site[0]
poss_deflist = sorted(
defect_structure.get_sites_in_sphere(defect_site.coords, 0.1, include_index=True), key=lambda x: x[1])
defindex = poss_deflist[0][2]
defect_structure.remove_sites([defindex])
defect_structure.set_charge(self.charge)
return defect_structure
import pymatgen as mg
from pymatgen.core.structure import Structure
filename = raw_input('file name:')
l = raw_input('x scale:')
m = raw_input('y scale:')
n = raw_input('z scale:')
struct = mg.read_structure(filename)
Structure.make_supercell(struct, [l, m, n])
mg.write_structure(struct, "poscar_temp")
f = open("poscar_temp")
w = open("mast.inp", "w")
def getinfo(line):
line = line.strip('\n')
data = line.split(' ')
while 1:
try:
data.remove('')
except:
break
return data
line = []
elenum = []
line.append(f.readline())
class StructureTest(PymatgenTest):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
self.structure = Structure(lattice, ["Si", "Si"], coords)
def test_mutable_sequence_methods(self):
s = self.structure
s[0] = "Fe"
self.assertEqual(s.formula, "Fe1 Si1")
s[0] = "Fe", [0.5, 0.5, 0.5]
self.assertEqual(s.formula, "Fe1 Si1")
self.assertArrayAlmostEqual(s[0].frac_coords, [0.5, 0.5, 0.5])
s.reverse()
self.assertEqual(s[0].specie, Element("Si"))
self.assertArrayAlmostEqual(s[0].frac_coords, [0.75, 0.5, 0.75])
s[0] = {"Mn": 0.5}
self.assertEqual(s.formula, "Mn0.5 Fe1")
del s[1]
self.assertEqual(s.formula, "Mn0.5")
s[0] = "Fe", [0.9, 0.9, 0.9], {"magmom": 5}
self.assertEqual(s.formula, "Fe1")
self.assertEqual(s[0].magmom, 5)
def test_non_hash(self):
self.assertRaises(TypeError, dict, [(self.structure, 1)])
def test_sort(self):
s = self.structure
s[0] = "F"
s.sort()
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
s.sort(key=lambda site: site.species_string)
self.assertEqual(s[0].species_string, "F")
self.assertEqual(s[1].species_string, "Si")
s.sort(key=lambda site: site.species_string, reverse=True)
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
def test_append_insert_remove_replace(self):
s = self.structure
s.insert(1, "O", [0.5, 0.5, 0.5])
self.assertEqual(s.formula, "Si2 O1")
self.assertTrue(s.ntypesp == 2)
self.assertTrue(s.symbol_set == ("Si", "O"))
self.assertTrue(s.indices_from_symbol("Si") == (0,2))
self.assertTrue(s.indices_from_symbol("O") == (1,))
del s[2]
self.assertEqual(s.formula, "Si1 O1")
self.assertTrue(s.indices_from_symbol("Si") == (0,))
self.assertTrue(s.indices_from_symbol("O") == (1,))
s.append("N", [0.25, 0.25, 0.25])
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
self.assertTrue(s.symbol_set == ("Si", "O", "N"))
self.assertTrue(s.indices_from_symbol("Si") == (0,))
self.assertTrue(s.indices_from_symbol("O") == (1,))
self.assertTrue(s.indices_from_symbol("N") == (2,))
s[0] = "Ge"
self.assertEqual(s.formula, "Ge1 N1 O1")
self.assertTrue(s.symbol_set == ("Ge", "O", "N"))
s.replace_species({"Ge": "Si"})
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
s.replace_species({"Si": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.5 Ge0.5 N1 O1")
#this should change the .5Si .5Ge sites to .75Si .25Ge
s.replace_species({"Ge": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.75 Ge0.25 N1 O1")
# In this case, s.ntypesp is ambiguous.
# for the time being, we raise AttributeError.
with self.assertRaises(AttributeError):
s.ntypesp
s.remove_species(["Si"])
self.assertEqual(s.formula, "Ge0.25 N1 O1")
s.remove_sites([1, 2])
self.assertEqual(s.formula, "Ge0.25")
def test_add_site_property(self):
s = self.structure
s.add_site_property("charge", [4.1, -5])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[1].charge, -5)
s.add_site_property("magmom", [3, 2])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[0].magmom, 3)
def test_propertied_structure(self):
#Make sure that site properties are set to None for missing values.
s = self.structure
s.add_site_property("charge", [4.1, -5])
s.append("Li", [0.3, 0.3 ,0.3])
self.assertEqual(len(s.site_properties["charge"]), 3)
def test_perturb(self):
d = 0.1
pre_perturbation_sites = self.structure.sites[:]
self.structure.perturb(distance=d)
post_perturbation_sites = self.structure.sites
for i, x in enumerate(pre_perturbation_sites):
self.assertAlmostEqual(x.distance(post_perturbation_sites[i]), d,
3, "Bad perturbation distance")
def test_add_oxidation_states(self):
oxidation_states = {"Si": -4}
self.structure.add_oxidation_state_by_element(oxidation_states)
for site in self.structure:
for k in site.species_and_occu.keys():
self.assertEqual(k.oxi_state, oxidation_states[k.symbol],
"Wrong oxidation state assigned!")
oxidation_states = {"Fe": 2}
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_element,
oxidation_states)
self.structure.add_oxidation_state_by_site([2, -4])
self.assertEqual(self.structure[0].specie.oxi_state, 2)
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_site,
[1])
def test_remove_oxidation_states(self):
co_elem = Element("Co")
o_elem = Element("O")
co_specie = Specie("Co", 2)
o_specie = Specie("O", -2)
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice.cubic(10)
s_elem = Structure(lattice, [co_elem, o_elem], coords)
s_specie = Structure(lattice, [co_specie, o_specie], coords)
s_specie.remove_oxidation_states()
self.assertEqual(s_elem, s_specie, "Oxidation state remover "
"failed")
def test_apply_operation(self):
op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 90)
s = self.structure.copy()
s.apply_operation(op)
self.assertArrayAlmostEqual(
s.lattice.matrix,
[[0.000000, 3.840198, 0.000000],
[-3.325710, 1.920099, 0.000000],
[2.217138, -0.000000, 3.135509]], 5)
op = SymmOp([[1, 1, 0, 0.5], [1, 0, 0, 0.5], [0, 0, 1, 0.5],
[0, 0, 0, 1]])
s = self.structure.copy()
s.apply_operation(op, fractional=True)
self.assertArrayAlmostEqual(
s.lattice.matrix,
[[5.760297, 3.325710, 0.000000],
[3.840198, 0.000000, 0.000000],
[0.000000, -2.217138, 3.135509]], 5)
def test_apply_strain(self):
s = self.structure
initial_coord = s[1].coords
s.apply_strain(0.01)
self.assertAlmostEqual(
s.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(s[1].coords, initial_coord * 1.01)
a1, b1, c1 = s.lattice.abc
s.apply_strain([0.1, 0.2, 0.3])
a2, b2, c2 = s.lattice.abc
self.assertAlmostEqual(a2 / a1, 1.1)
self.assertAlmostEqual(b2 / b1, 1.2)
self.assertAlmostEqual(c2 / c1, 1.3)
def test_scale_lattice(self):
initial_coord = self.structure[1].coords
self.structure.scale_lattice(self.structure.volume * 1.01 ** 3)
self.assertArrayAlmostEqual(
self.structure.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(self.structure[1].coords,
initial_coord * 1.01)
def test_translate_sites(self):
self.structure.translate_sites([0, 1], [0.5, 0.5, 0.5],
frac_coords=True)
self.assertArrayEqual(self.structure.frac_coords[0],
[0.5, 0.5, 0.5])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=False)
self.assertArrayAlmostEqual(self.structure.cart_coords[0],
[3.38014845, 1.05428585, 2.06775453])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=True, to_unit_cell=False)
self.assertArrayAlmostEqual(self.structure.frac_coords[0],
[1.00187517, 1.25665291, 1.15946374])
def test_mul(self):
self.structure *= [2, 1, 1]
self.assertEqual(self.structure.formula, "Si4")
s = [2, 1, 1] * self.structure
self.assertEqual(s.formula, "Si8")
self.assertIsInstance(s, Structure)
s = self.structure * [[1, 0, 0], [2, 1, 0], [0, 0, 2]]
self.assertEqual(s.formula, "Si8")
self.assertArrayAlmostEqual(s.lattice.abc,
[7.6803959, 17.5979979, 7.6803959])
def test_make_supercell(self):
self.structure.make_supercell([2, 1, 1])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell([[1, 0, 0], [2, 1, 0], [0, 0, 1]])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell(2)
self.assertEqual(self.structure.formula, "Si32")
self.assertArrayAlmostEqual(self.structure.lattice.abc,
[15.360792, 35.195996, 7.680396], 5)
def test_disordered_supercell_primitive_cell(self):
l = Lattice.cubic(2)
f = [[0.5, 0.5, 0.5]]
sp = [{'Si': 0.54738}]
s = Structure(l, sp, f)
#this supercell often breaks things
s.make_supercell([[0,-1,1],[-1,1,0],[1,1,1]])
self.assertEqual(len(s.get_primitive_structure()), 1)
def test_another_supercell(self):
#this is included b/c for some reason the old algo was failing on it
s = self.structure.copy()
s.make_supercell([[0, 2, 2], [2, 0, 2], [2, 2, 0]])
self.assertEqual(s.formula, "Si32")
s = self.structure.copy()
s.make_supercell([[0, 2, 0], [1, 0, 0], [0, 0, 1]])
self.assertEqual(s.formula, "Si4")
def test_to_from_dict(self):
d = self.structure.as_dict()
s2 = Structure.from_dict(d)
self.assertEqual(type(s2), Structure)
def test_to_from_file_string(self):
for fmt in ["cif", "json", "poscar", "cssr", "yaml", "xsf"]:
s = self.structure.to(fmt=fmt)
self.assertIsNotNone(s)
ss = Structure.from_str(s, fmt=fmt)
self.assertArrayAlmostEqual(
ss.lattice.lengths_and_angles,
self.structure.lattice.lengths_and_angles, decimal=5)
self.assertArrayAlmostEqual(ss.frac_coords,
self.structure.frac_coords)
self.assertIsInstance(ss, Structure)
self.structure.to(filename="POSCAR.testing")
self.assertTrue(os.path.exists("POSCAR.testing"))
os.remove("POSCAR.testing")
self.structure.to(filename="structure_testing.json")
self.assertTrue(os.path.exists("structure_testing.json"))
s = Structure.from_file("structure_testing.json")
self.assertEqual(s, self.structure)
os.remove("structure_testing.json")
def test_from_spacegroup(self):
s1 = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]])
self.assertEqual(s1.formula, "Li8 O4")
s2 = Structure.from_spacegroup(225, Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]])
self.assertEqual(s1, s2)
s2 = Structure.from_spacegroup(225, Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]],
site_properties={"charge": [1, -2]})
self.assertEqual(sum(s2.site_properties["charge"]), 0)
s = Structure.from_spacegroup("Pm-3m", Lattice.cubic(3), ["Cs", "Cl"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
self.assertEqual(s.formula, "Cs1 Cl1")
self.assertRaises(ValueError, Structure.from_spacegroup,
"Pm-3m", Lattice.tetragonal(1, 3), ["Cs", "Cl"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
def test_merge_sites(self):
species = [{'Ag': 0.5}, {'Cl': 0.25}, {'Cl': 0.1},
{'Ag': 0.5}, {'F': 0.15}, {'F': 0.1}]
coords = [[0, 0, 0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5],
[0, 0, 0], [0.5, 0.5, 1.501], [0.5, 0.5, 1.501]]
s = Structure(Lattice.cubic(1), species, coords)
s.merge_sites()
self.assertEqual(s[0].specie.symbol, 'Ag')
self.assertEqual(s[1].species_and_occu,
Composition({'Cl': 0.35, 'F': 0.25}))
self.assertArrayAlmostEqual(s[1].frac_coords, [.5, .5, .5005])
def test_properties(self):
self.assertEqual(self.structure.num_sites, len(self.structure))
self.structure.make_supercell(2)
self.structure[1] = "C"
sites = list(self.structure.group_by_types())
self.assertEqual(sites[-1].specie.symbol, "C")
self.structure.add_oxidation_state_by_element({"Si": 4, "C": 2})
self.assertEqual(self.structure.charge, 62)
def test_init_error(self):
self.assertRaises(StructureError, Structure, Lattice.cubic(3), ["Si"], [[0, 0, 0], [0.5, 0.5, 0.5]])
def test_from_sites(self):
self.structure.add_site_property("hello", [1, 2])
s = Structure.from_sites(self.structure, to_unit_cell=True)
self.assertEqual(s.site_properties["hello"][1], 2)
def test_magic(self):
s = Structure.from_sites(self.structure)
self.assertEqual(s, self.structure)
self.assertNotEqual(s, None)
s.apply_strain(0.5)
self.assertNotEqual(s, self.structure)
self.assertNotEqual(self.structure * 2, self.structure)
class StructureTest(PymatgenTest):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
self.structure = Structure(lattice, ["Si", "Si"], coords)
def test_mutable_sequence_methods(self):
s = self.structure
s[0] = "Fe"
self.assertEqual(s.formula, "Fe1 Si1")
s[0] = "Fe", [0.5, 0.5, 0.5]
self.assertEqual(s.formula, "Fe1 Si1")
self.assertArrayAlmostEqual(s[0].frac_coords, [0.5, 0.5, 0.5])
s.reverse()
self.assertEqual(s[0].specie, Element("Si"))
self.assertArrayAlmostEqual(s[0].frac_coords, [0.75, 0.5, 0.75])
s[0] = {"Mn": 0.5}
self.assertEqual(s.formula, "Mn0.5 Fe1")
del s[1]
self.assertEqual(s.formula, "Mn0.5")
s[0] = "Fe", [0.9, 0.9, 0.9], {"magmom": 5}
self.assertEqual(s.formula, "Fe1")
self.assertEqual(s[0].magmom, 5)
def test_non_hash(self):
self.assertRaises(TypeError, dict, [(self.structure, 1)])
def test_sort(self):
s = self.structure
s[0] = "F"
s.sort()
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
s.sort(key=lambda site: site.species_string)
self.assertEqual(s[0].species_string, "F")
self.assertEqual(s[1].species_string, "Si")
s.sort(key=lambda site: site.species_string, reverse=True)
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
def test_append_insert_remove_replace(self):
s = self.structure
s.insert(1, "O", [0.5, 0.5, 0.5])
self.assertEqual(s.formula, "Si2 O1")
self.assertTrue(s.ntypesp == 2)
self.assertTrue(s.symbol_set == ("Si", "O"))
self.assertTrue(s.indices_from_symbol("Si") == (0, 2))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
del s[2]
self.assertEqual(s.formula, "Si1 O1")
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
s.append("N", [0.25, 0.25, 0.25])
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
self.assertTrue(s.symbol_set == ("Si", "O", "N"))
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
self.assertTrue(s.indices_from_symbol("N") == (2, ))
s[0] = "Ge"
self.assertEqual(s.formula, "Ge1 N1 O1")
self.assertTrue(s.symbol_set == ("Ge", "O", "N"))
s.replace_species({"Ge": "Si"})
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
s.replace_species({"Si": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.5 Ge0.5 N1 O1")
#this should change the .5Si .5Ge sites to .75Si .25Ge
s.replace_species({"Ge": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.75 Ge0.25 N1 O1")
# In this case, s.ntypesp is ambiguous.
# for the time being, we raise AttributeError.
with self.assertRaises(AttributeError):
s.ntypesp
s.remove_species(["Si"])
self.assertEqual(s.formula, "Ge0.25 N1 O1")
s.remove_sites([1, 2])
self.assertEqual(s.formula, "Ge0.25")
def test_add_site_property(self):
s = self.structure
s.add_site_property("charge", [4.1, -5])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[1].charge, -5)
s.add_site_property("magmom", [3, 2])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[0].magmom, 3)
def test_propertied_structure(self):
#Make sure that site properties are set to None for missing values.
s = self.structure
s.add_site_property("charge", [4.1, -5])
s.append("Li", [0.3, 0.3, 0.3])
self.assertEqual(len(s.site_properties["charge"]), 3)
def test_perturb(self):
d = 0.1
pre_perturbation_sites = self.structure.sites[:]
self.structure.perturb(distance=d)
post_perturbation_sites = self.structure.sites
for i, x in enumerate(pre_perturbation_sites):
self.assertAlmostEqual(x.distance(post_perturbation_sites[i]), d,
3, "Bad perturbation distance")
def test_add_oxidation_states(self):
oxidation_states = {"Si": -4}
self.structure.add_oxidation_state_by_element(oxidation_states)
for site in self.structure:
for k in site.species_and_occu.keys():
self.assertEqual(k.oxi_state, oxidation_states[k.symbol],
"Wrong oxidation state assigned!")
oxidation_states = {"Fe": 2}
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_element,
oxidation_states)
self.structure.add_oxidation_state_by_site([2, -4])
self.assertEqual(self.structure[0].specie.oxi_state, 2)
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_site, [1])
def test_remove_oxidation_states(self):
co_elem = Element("Co")
o_elem = Element("O")
co_specie = Specie("Co", 2)
o_specie = Specie("O", -2)
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice.cubic(10)
s_elem = Structure(lattice, [co_elem, o_elem], coords)
s_specie = Structure(lattice, [co_specie, o_specie], coords)
s_specie.remove_oxidation_states()
self.assertEqual(s_elem, s_specie, "Oxidation state remover " "failed")
def test_apply_operation(self):
op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 90)
s = self.structure.copy()
s.apply_operation(op)
self.assertArrayAlmostEqual(
s.lattice.matrix,
[[0.000000, 3.840198, 0.000000], [-3.325710, 1.920099, 0.000000],
[2.217138, -0.000000, 3.135509]], 5)
op = SymmOp([[1, 1, 0, 0.5], [1, 0, 0, 0.5], [0, 0, 1, 0.5],
[0, 0, 0, 1]])
s = self.structure.copy()
s.apply_operation(op, fractional=True)
self.assertArrayAlmostEqual(
s.lattice.matrix,
[[5.760297, 3.325710, 0.000000], [3.840198, 0.000000, 0.000000],
[0.000000, -2.217138, 3.135509]], 5)
def test_apply_strain(self):
s = self.structure
initial_coord = s[1].coords
s.apply_strain(0.01)
self.assertAlmostEqual(
s.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(s[1].coords, initial_coord * 1.01)
a1, b1, c1 = s.lattice.abc
s.apply_strain([0.1, 0.2, 0.3])
a2, b2, c2 = s.lattice.abc
self.assertAlmostEqual(a2 / a1, 1.1)
self.assertAlmostEqual(b2 / b1, 1.2)
self.assertAlmostEqual(c2 / c1, 1.3)
def test_scale_lattice(self):
initial_coord = self.structure[1].coords
self.structure.scale_lattice(self.structure.volume * 1.01**3)
self.assertArrayAlmostEqual(
self.structure.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(self.structure[1].coords,
initial_coord * 1.01)
def test_translate_sites(self):
self.structure.translate_sites([0, 1], [0.5, 0.5, 0.5],
frac_coords=True)
self.assertArrayEqual(self.structure.frac_coords[0], [0.5, 0.5, 0.5])
self.structure.translate_sites([0], [0.5, 0.5, 0.5], frac_coords=False)
self.assertArrayAlmostEqual(self.structure.cart_coords[0],
[3.38014845, 1.05428585, 2.06775453])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=True,
to_unit_cell=False)
self.assertArrayAlmostEqual(self.structure.frac_coords[0],
[1.00187517, 1.25665291, 1.15946374])
def test_mul(self):
self.structure *= [2, 1, 1]
self.assertEqual(self.structure.formula, "Si4")
s = [2, 1, 1] * self.structure
self.assertEqual(s.formula, "Si8")
self.assertIsInstance(s, Structure)
s = self.structure * [[1, 0, 0], [2, 1, 0], [0, 0, 2]]
self.assertEqual(s.formula, "Si8")
self.assertArrayAlmostEqual(s.lattice.abc,
[7.6803959, 17.5979979, 7.6803959])
def test_make_supercell(self):
self.structure.make_supercell([2, 1, 1])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell([[1, 0, 0], [2, 1, 0], [0, 0, 1]])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell(2)
self.assertEqual(self.structure.formula, "Si32")
self.assertArrayAlmostEqual(self.structure.lattice.abc,
[15.360792, 35.195996, 7.680396], 5)
def test_disordered_supercell_primitive_cell(self):
l = Lattice.cubic(2)
f = [[0.5, 0.5, 0.5]]
sp = [{'Si': 0.54738}]
s = Structure(l, sp, f)
#this supercell often breaks things
s.make_supercell([[0, -1, 1], [-1, 1, 0], [1, 1, 1]])
self.assertEqual(len(s.get_primitive_structure()), 1)
def test_another_supercell(self):
#this is included b/c for some reason the old algo was failing on it
s = self.structure.copy()
s.make_supercell([[0, 2, 2], [2, 0, 2], [2, 2, 0]])
self.assertEqual(s.formula, "Si32")
s = self.structure.copy()
s.make_supercell([[0, 2, 0], [1, 0, 0], [0, 0, 1]])
self.assertEqual(s.formula, "Si4")
def test_to_from_dict(self):
d = self.structure.as_dict()
s2 = Structure.from_dict(d)
self.assertEqual(type(s2), Structure)
def test_to_from_file_string(self):
for fmt in ["cif", "json", "poscar", "cssr", "yaml", "xsf"]:
s = self.structure.to(fmt=fmt)
self.assertIsNotNone(s)
ss = Structure.from_str(s, fmt=fmt)
self.assertArrayAlmostEqual(
ss.lattice.lengths_and_angles,
self.structure.lattice.lengths_and_angles,
decimal=5)
self.assertArrayAlmostEqual(ss.frac_coords,
self.structure.frac_coords)
self.assertIsInstance(ss, Structure)
self.structure.to(filename="POSCAR.testing")
self.assertTrue(os.path.exists("POSCAR.testing"))
os.remove("POSCAR.testing")
self.structure.to(filename="structure_testing.json")
self.assertTrue(os.path.exists("structure_testing.json"))
s = Structure.from_file("structure_testing.json")
self.assertEqual(s, self.structure)
os.remove("structure_testing.json")
def test_from_spacegroup(self):
s1 = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]])
self.assertEqual(s1.formula, "Li8 O4")
s2 = Structure.from_spacegroup(225, Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]])
self.assertEqual(s1, s2)
s2 = Structure.from_spacegroup(225,
Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]],
site_properties={"charge": [1, -2]})
self.assertEqual(sum(s2.site_properties["charge"]), 0)
s = Structure.from_spacegroup("Pm-3m", Lattice.cubic(3), ["Cs", "Cl"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
self.assertEqual(s.formula, "Cs1 Cl1")
self.assertRaises(ValueError, Structure.from_spacegroup, "Pm-3m",
Lattice.tetragonal(1, 3), ["Cs", "Cl"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
def test_merge_sites(self):
species = [{
'Ag': 0.5
}, {
'Cl': 0.25
}, {
'Cl': 0.1
}, {
'Ag': 0.5
}, {
'F': 0.15
}, {
'F': 0.1
}]
coords = [[0, 0, 0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0, 0, 0],
[0.5, 0.5, 1.501], [0.5, 0.5, 1.501]]
s = Structure(Lattice.cubic(1), species, coords)
s.merge_sites()
self.assertEqual(s[0].specie.symbol, 'Ag')
self.assertEqual(s[1].species_and_occu,
Composition({
'Cl': 0.35,
'F': 0.25
}))
self.assertArrayAlmostEqual(s[1].frac_coords, [.5, .5, .5005])
def Interface_generator(Ini_sub_slab, Ini_film_slab, sub_tr_mat, film_tr_mat,
distance, fparam):
raw_ini_sub_slab_mat = np.array(Ini_sub_slab.lattice.matrix)
raw_ini_film_slab_mat = np.array(Ini_film_slab.lattice.matrix)
sub_reduction = reduce_vectors(raw_ini_sub_slab_mat[0],
raw_ini_sub_slab_mat[1])
film_reduction = reduce_vectors(raw_ini_film_slab_mat[0],
raw_ini_film_slab_mat[1])
reduced_sub_mat = np.array(
[sub_reduction[0], sub_reduction[1], raw_ini_sub_slab_mat[2]])
reduced_film_mat = np.array(
[film_reduction[0], film_reduction[1], raw_ini_film_slab_mat[2]])
red_Ini_sub_slab = Structure(mg.Lattice(reduced_sub_mat),
Ini_sub_slab.species,
Ini_sub_slab.cart_coords,
to_unit_cell=True,
coords_are_cartesian=True)
red_Ini_film_slab = Structure(mg.Lattice(reduced_film_mat),
Ini_film_slab.species,
Ini_film_slab.cart_coords,
to_unit_cell=True,
coords_are_cartesian=True)
red_Ini_sub_slab.make_supercell(scaling_matrix=scale_mat(sub_tr_mat))
red_Ini_film_slab.make_supercell(scaling_matrix=scale_mat(film_tr_mat))
Ini_sub_mat = red_Ini_sub_slab.lattice.matrix
Ini_film_mat = red_Ini_film_slab.lattice.matrix
sub_r_vecs = reduce_vectors(Ini_sub_mat[0], Ini_sub_mat[1])
film_r_vecs = reduce_vectors(Ini_film_mat[0], Ini_film_mat[1])
sub_mat = np.array([sub_r_vecs[0], sub_r_vecs[1], Ini_sub_mat[2]])
film_mat = np.array([film_r_vecs[0], film_r_vecs[1], Ini_film_mat[2]])
AB_C = np.dot(np.cross(sub_mat[0], sub_mat[1]), sub_mat[2])
if AB_C > 0:
Is_right_handed = True
else:
#Is_right_handed = False
Is_right_handed = True
modif_sub_struc = mg.Structure(mg.Lattice(sub_mat),
red_Ini_sub_slab.species,
red_Ini_sub_slab.cart_coords,
to_unit_cell=True,
coords_are_cartesian=True)
modif_film_struc = mg.Structure(mg.Lattice(film_mat),
red_Ini_film_slab.species,
red_Ini_film_slab.cart_coords,
to_unit_cell=True,
coords_are_cartesian=True)
sub_sl_vecs = [
modif_sub_struc.lattice.matrix[0], modif_sub_struc.lattice.matrix[1]
]
film_sl_vecs = [
modif_film_struc.lattice.matrix[0], modif_film_struc.lattice.matrix[1]
]
film_angel = angle(film_sl_vecs[0], film_sl_vecs[1])
sub_angel = angle(sub_sl_vecs[0], sub_sl_vecs[1])
u_size = fparam * (np.linalg.norm(
sub_sl_vecs[0])) + (1 - fparam) * (np.linalg.norm(film_sl_vecs[0]))
v_size = fparam * (np.linalg.norm(
sub_sl_vecs[1])) + (1 - fparam) * (np.linalg.norm(film_sl_vecs[1]))
mean_angle = fparam * sub_angel + (1 - fparam) * film_angel
sub_rot_mat = [[
u_size, 0, 0
], [v_size * math.cos(mean_angle), v_size * math.sin(mean_angle), 0],
[0, 0,
np.linalg.norm(modif_sub_struc.lattice.matrix[2])]]
film_rot_mat = [
[u_size, 0, 0],
[v_size * math.cos(mean_angle), v_size * math.sin(mean_angle), 0],
[0, 0, -np.linalg.norm(modif_film_struc.lattice.matrix[2])]
]
film_normal = np.cross(film_sl_vecs[0], film_sl_vecs[1])
sub_normal = np.cross(sub_sl_vecs[0], sub_sl_vecs[1])
film_un = film_normal / np.linalg.norm(film_normal)
sub_un = sub_normal / np.linalg.norm(sub_normal)
film_sl_vecs.append(film_un)
L1_mat = np.transpose(film_sl_vecs)
L1_res = [[u_size, v_size * math.cos(mean_angle), 0],
[0, v_size * math.sin(mean_angle), 0], [0, 0, 1]]
L1_mat_inv = np.linalg.inv(L1_mat)
L1 = np.matmul(L1_res, L1_mat_inv)
sub_sl_vecs.append(sub_un)
L2_mat = np.transpose(sub_sl_vecs)
L2_res = [[u_size, v_size * math.cos(mean_angle), 0],
[0, v_size * math.sin(mean_angle), 0], [0, 0, -1]]
L2_mat_inv = np.linalg.inv(L2_mat)
L2 = np.matmul(L2_res, L2_mat_inv)
sub_rot_lattice = mg.Lattice(sub_rot_mat)
film_rot_lattice = mg.Lattice(film_rot_mat)
r_sub_coords = np.array(modif_sub_struc.cart_coords)
r_film_coords = np.array(modif_film_struc.cart_coords)
for ii in range(len(r_sub_coords)):
r_sub_coords[ii] = np.matmul(L2, r_sub_coords[ii])
for ii in range(len(r_film_coords)):
r_film_coords[ii] = np.matmul(L1, r_film_coords[ii])
sub_slab = mg.Structure(sub_rot_lattice,
modif_sub_struc.species,
r_sub_coords,
to_unit_cell=True,
coords_are_cartesian=True)
film_slab = mg.Structure(film_rot_lattice,
modif_film_struc.species,
r_film_coords,
to_unit_cell=True,
coords_are_cartesian=True)
sub_sp_num = len(sub_slab.types_of_specie)
film_sp_num = len(film_slab.types_of_specie)
sub_slab_mat = np.array(sub_slab.lattice.matrix)
film_slab_mat = np.array(film_slab.lattice.matrix)
sub_slab_coords = sub_slab.cart_coords
film_slab_coords = film_slab.cart_coords
sub_slab_zmat = sub_slab_coords[:, [2]]
film_slab_zmat = film_slab_coords[:, [2]]
sub_slab_zmat = sub_slab_zmat - min(sub_slab_zmat)
film_slab_zmat = film_slab_zmat - min(film_slab_zmat)
sub_max_z = max(sub_slab_zmat)
sub_min_z = min(sub_slab_zmat)
modif_film_slab_zmat = film_slab_zmat + sub_max_z - sub_min_z + distance
film_slab_coords[:, [2]] = modif_film_slab_zmat
sub_slab_coords[:, [2]] = sub_slab_zmat
sub_max_z = max(sub_slab_zmat)
film_min_z = min(modif_film_slab_zmat)
sub_max_list = coords_sperator_2(sub_slab_zmat, sub_sp_num, True)
film_min_list = coords_sperator(modif_film_slab_zmat, film_sp_num, False)
interface_coords = np.concatenate((sub_slab_coords, film_slab_coords),
axis=0)
interface_species = sub_slab.species + film_slab.species
interface_latt = sub_slab_mat
interface_latt[2][2] = abs(sub_slab_mat[2][2]) + abs(
film_slab_mat[2][2]) + distance
Adding_val = 0.5 * (interface_latt[2][2] - max(interface_coords[:, [2]]))
sub_max_list += Adding_val
film_min_list += Adding_val
sub_max_z += Adding_val
film_min_z += Adding_val
interface_coords[:, [2]] += 0.5 * (interface_latt[2][2] -
max(interface_coords[:, [2]]))
sub_slab_coords[:, [2]] += Adding_val
film_slab_coords[:, [2]] += Adding_val
interface_lattice = mg.Lattice(interface_latt)
interface_struc = mg.Structure(interface_lattice,
interface_species,
interface_coords,
to_unit_cell=True,
coords_are_cartesian=True)
interface_struc = interface_struc.get_reduced_structure()
return [
interface_struc, [sub_sp_num, film_sp_num], sub_slab_coords,
film_slab_coords, sub_slab, film_slab, Is_right_handed
]
def __init__(self,
structure,
max_min_oxi=None,
substitutions=None,
oxi_states=None,
cellmax=128,
antisites_flag=True,
include_interstitials=False,
interstitial_elements=None,
intersites=None,
standardized=False,
struct_type='semiconductor'):
"""
Args:
structure (Structure):
the bulk structure.
max_min_oxi (dict):
The minimal and maximum oxidation state of each element as a
dict. For instance {"O":(-2,0)}. If not given, the oxi-states
of pymatgen are considered.
substitutions (dict):
The allowed substitutions of elements as a dict. If not given,
intrinsic defects are computed. If given, intrinsic (e.g.,
anti-sites) and extrinsic are considered explicitly specified.
Example: {"Co":["Zn","Mn"]} means Co sites can be substituted
by Mn or Zn.
oxi_states (dict):
The oxidation state of the elements in the compound e.g.
{"Fe":2,"O":-2}. If not given, the oxidation state of each
site is computed with bond valence sum. WARNING: Bond-valence
method can fail for mixed-valence compounds.
cellmax (int):
Maximum number of atoms allowed in the supercell.
antisites_flag (bool):
If False, don't generate antisites.
include_interstitials (bool):
If true, do generate interstitial defect configurations
(default: False).
interstitial_elements ([str]):
List of strings containing symbols of the elements that are
to be considered for interstitial sites. The default (None)
triggers self-interstitial generation,
given that include_interstitials is True.
intersites ([PeriodicSite]):
A list of PeriodicSites in the bulk structure on which we put
interstitials. Note that you still have to set flag
include_interstitials to True in order to make use of this
manual way of providing interstitial sites.
If this is used, then no additional interstitials are generated
beyond the list that is provided in intersites.
standardized (bool):
If True, use the primitive standard structure as unit cell
for generating the defect configurations (default is False).
The primitive standard structure is obtained from the
SpacegroupAnalyzer class with a symprec of 0.01.
struct_type (string):
Options are 'semiconductor' and 'insulator'. If semiconductor
is selected, charge states based on database of semiconductors
is used to assign defect charges. For insulators, defect
charges are conservatively assigned.
"""
max_min_oxi = max_min_oxi if max_min_oxi is not None else {}
substitutions = substitutions if substitutions is not None else {}
oxi_states = oxi_states if oxi_states is not None else {}
interstitial_elements = interstitial_elements if interstitial_elements is not None else []
intersites = intersites if intersites is not None else []
self.defects = []
self.cellmax = cellmax
self.substitutions = {}
self.struct_type = struct_type
for key, val in substitutions.items():
self.substitutions[key] = val
spa = SpacegroupAnalyzer(structure, symprec=1e-2)
prim_struct = spa.get_primitive_standard_structure()
if standardized:
self.struct = prim_struct
else:
self.struct = structure
struct_species = self.struct.types_of_specie
if self.struct_type == 'semiconductor':
self.defect_charger = DefectChargerSemiconductor(
self.struct, min_max_oxi=max_min_oxi)
elif self.struct_type == 'insulator':
self.defect_charger = DefectChargerInsulator(self.struct)
elif self.struct_type == 'manual':
self.defect_charger = DefectChargerUserCustom(
self.struct, oxi_states=oxi_states)
elif self.struct_type == 'ionic':
self.defect_charger = DefectChargerIonic(self.struct)
else:
raise NotImplementedError
if include_interstitials and interstitial_elements:
for elem_str in interstitial_elements:
if not Element.is_valid_symbol(elem_str):
raise ValueError("invalid interstitial element"
" \"{}\"".format(elem_str))
sc_scale = get_optimized_sc_scale(self.struct, cellmax)
self.defects = {}
sc = self.struct.copy()
sc.make_supercell(sc_scale)
self.defects['bulk'] = {
'name': 'bulk',
'supercell': {
'size': sc_scale,
'structure': sc
}
}
# If interstitials are provided as a list of PeriodicSites,
# make sure that the lattice has not changed.
if include_interstitials and intersites:
for intersite in intersites: #list of PeriodicSite objects
if intersite.lattice != self.struct.lattice:
raise RuntimeError(
"Discrepancy between lattices"
" underlying the input interstitials and"
" the bulk structure; possibly because of"
" standardizing the input structure.")
vacancies = []
as_defs = []
sub_defs = []
VG = VacancyGenerator(self.struct)
print("Setting up defects...")
for i, vac in enumerate(VG):
vac_site = vac.site
vac_symbol = vac.site.specie.symbol
vac_sc = vac.generate_defect_structure(sc_scale)
#create a trivial defect structure to find where supercell transformation moves the lattice
struct_for_defect_site = Structure(
vac.bulk_structure.copy().lattice, [vac.site.specie],
[vac.site.frac_coords],
to_unit_cell=True,
coords_are_cartesian=False)
struct_for_defect_site.make_supercell(sc_scale)
vac_sc_site = struct_for_defect_site[0]
charges_vac = self.defect_charger.get_charges(
'vacancy', vac_symbol)
vacancies.append({
'name': "vac_{}_{}".format(i + 1, vac_symbol),
'unique_site': vac_site,
'bulk_supercell_site': vac_sc_site,
'defect_type': 'vacancy',
'site_specie': vac_symbol,
'site_multiplicity': vac.multiplicity,
'supercell': {
'size': sc_scale,
'structure': vac_sc
},
'charges': charges_vac
})
if antisites_flag:
for as_specie in set(struct_species):
SG = SubstitutionGenerator(self.struct, as_specie)
for i, sub in enumerate(SG):
as_symbol = as_specie.symbol
as_sc = sub.generate_defect_structure(sc_scale)
# create a trivial defect structure to find where supercell transformation moves the defect
struct_for_defect_site = Structure(
sub.bulk_structure.copy().lattice, [sub.site.specie],
[sub.site.frac_coords],
to_unit_cell=True,
coords_are_cartesian=False)
struct_for_defect_site.make_supercell(sc_scale)
as_sc_site = struct_for_defect_site[0]
#get bulk_site (non sc)
poss_deflist = sorted(
sub.bulk_structure.get_sites_in_sphere(
sub.site.coords, 0.01, include_index=True),
key=lambda x: x[1])
if not len(poss_deflist):
raise ValueError(
"Could not find substitution site inside bulk structure for {}?"
.format(sub.name))
defindex = poss_deflist[0][2]
as_site = sub.bulk_structure[defindex]
vac_symbol = as_site.specie
charges_as = self.defect_charger.get_charges(
'antisite', vac_symbol, as_symbol)
as_defs.append({
'name':
"as_{}_{}_on_{}".format(i + 1, as_symbol, vac_symbol),
'unique_site':
as_site,
'bulk_supercell_site':
as_sc_site,
'defect_type':
'antisite',
'site_specie':
vac_symbol,
'substitution_specie':
as_symbol,
'site_multiplicity':
sub.multiplicity,
'supercell': {
'size': sc_scale,
'structure': as_sc
},
'charges':
charges_as
})
for vac_symbol, subspecie_list in self.substitutions.items():
for subspecie_symbol in subspecie_list:
SG = SubstitutionGenerator(self.struct, subspecie_symbol)
for i, sub in enumerate(SG):
sub_symbol = sub.site.specie.symbol
#get bulk_site (non sc)
poss_deflist = sorted(
sub.bulk_structure.get_sites_in_sphere(
sub.site.coords, 0.1, include_index=True),
key=lambda x: x[1])
if not len(poss_deflist):
raise ValueError(
"Could not find substitution site inside bulk structure for {}?"
.format(sub.name))
defindex = poss_deflist[0][2]
sub_site = self.struct[defindex]
this_vac_symbol = sub_site.specie.symbol
if (sub_symbol != subspecie_symbol) or (this_vac_symbol !=
vac_symbol):
continue
else:
sub_sc = sub.generate_defect_structure(sc_scale)
# create a trivial defect structure to find where supercell transformation moves the defect
struct_for_defect_site = Structure(
sub.bulk_structure.copy().lattice,
[sub.site.specie], [sub.site.frac_coords],
to_unit_cell=True,
coords_are_cartesian=False)
struct_for_defect_site.make_supercell(sc_scale)
sub_sc_site = struct_for_defect_site[0]
charges_sub = self.defect_charger.get_charges(
'substitution', vac_symbol, subspecie_symbol)
sub_defs.append({
'name':
"sub_{}_{}_on_{}".format(i + 1, subspecie_symbol,
vac_symbol),
'unique_site':
sub_site,
'bulk_supercell_site':
sub_sc_site,
'defect_type':
'substitution',
'site_specie':
vac_symbol,
'substitution_specie':
subspecie_symbol,
'site_multiplicity':
sub.multiplicity,
'supercell': {
'size': sc_scale,
'structure': sub_sc
},
'charges':
charges_sub
})
self.defects['vacancies'] = vacancies
self.defects['substitutions'] = sub_defs
self.defects['substitutions'] += as_defs
if include_interstitials:
interstitials = []
if interstitial_elements:
inter_elems = interstitial_elements
else:
inter_elems = [elem.symbol for elem in \
self.struct.composition.elements]
if len(inter_elems) == 0:
raise RuntimeError("empty element list for interstitials")
if intersites:
#manual specification of interstitials
for i, intersite in enumerate(intersites):
for elt in inter_elems:
name = "inter_{}_{}".format(i + 1, elt)
if intersite.lattice != self.struct.lattice:
err_msg = "Lattice matching error occurs between provided interstitial and the bulk structure."
if standardized:
err_msg += "\nLikely because the standardized flag was used. Turn this flag off or reset " \
"your interstitial PeriodicSite to match the standardized form of the bulk structure."
raise ValueError(err_msg)
else:
intersite_object = Interstitial(
self.struct, intersite)
# create a trivial defect structure to find where supercell transformation moves the defect site
struct_for_defect_site = Structure(
intersite_object.bulk_structure.copy().lattice,
[intersite_object.site.specie],
[intersite_object.site.frac_coords],
to_unit_cell=True,
coords_are_cartesian=False)
struct_for_defect_site.make_supercell(sc_scale)
site_sc = struct_for_defect_site[0]
sc_with_inter = intersite_object.generate_defect_structure(
sc_scale)
charges_inter = self.defect_charger.get_charges(
'interstitial', elt)
interstitials.append({
'name':
name,
'unique_site':
intersite_object.site,
'bulk_supercell_site':
site_sc,
'defect_type':
'interstitial',
'site_specie':
intersite_object.site.specie.symbol,
'site_multiplicity':
intersite_object.multiplicity,
'supercell': {
'size': sc_scale,
'structure': sc_with_inter
},
'charges':
charges_inter
})
else:
print(
"Searching for interstitial sites (this can take awhile)..."
)
for elt in inter_elems:
#TODO: Add ability to use other interstitial finding methods in pymatgen
IG = InterstitialGenerator(self.struct, elt)
for i, intersite_object in enumerate(IG):
name = intersite_object.name
# create a trivial defect structure to find where supercell transformation moves the defect site
struct_for_defect_site = Structure(
intersite_object.bulk_structure.copy().lattice,
[intersite_object.site.specie],
[intersite_object.site.frac_coords],
to_unit_cell=True,
coords_are_cartesian=False)
struct_for_defect_site.make_supercell(sc_scale)
site_sc = struct_for_defect_site[0]
sc_with_inter = intersite_object.generate_defect_structure(
sc_scale)
charges_inter = self.defect_charger.get_charges(
'interstitial', elt)
interstitials.append({
'name':
"inter_{}_{}".format(
i + 1, elt), #TODO fix naming convention
'unique_site':
intersite_object.site,
'bulk_supercell_site':
site_sc,
'defect_type':
'interstitial',
'site_specie':
intersite_object.site.specie.symbol,
'site_multiplicity':
intersite_object.multiplicity,
'supercell': {
'size': sc_scale,
'structure': sc_with_inter
},
'charges':
charges_inter
})
self.defects['interstitials'] = interstitials
print("\nNumber of jobs created:")
tottmp = 0
for j in self.defects.keys():
if j == 'bulk':
print(" bulk = 1")
tottmp += 1
else:
print(" {}:".format(j))
for lis in self.defects[j]:
print(" {} = {}".format(lis['name'],
len(lis['charges'])))
tottmp += len(lis['charges'])
print("Total (non dielectric) jobs created = {}\n".format(tottmp))
class StructureTest(PymatgenTest):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
self.structure = Structure(lattice, ["Si", "Si"], coords)
def test_mutable_sequence_methods(self):
s = self.structure
s[0] = "Fe"
self.assertEqual(s.formula, "Fe1 Si1")
s[0] = "Fe", [0.5, 0.5, 0.5]
self.assertEqual(s.formula, "Fe1 Si1")
self.assertArrayAlmostEqual(s[0].frac_coords, [0.5, 0.5, 0.5])
s.reverse()
self.assertEqual(s[0].specie, Element("Si"))
self.assertArrayAlmostEqual(s[0].frac_coords, [0.75, 0.5, 0.75])
s[0] = {"Mn": 0.5}
self.assertEqual(s.formula, "Mn0.5 Fe1")
del s[1]
self.assertEqual(s.formula, "Mn0.5")
s[0] = "Fe", [0.9, 0.9, 0.9], {"magmom": 5}
self.assertEqual(s.formula, "Fe1")
self.assertEqual(s[0].magmom, 5)
def test_non_hash(self):
self.assertRaises(TypeError, dict, [(self.structure, 1)])
def test_sort(self):
s = self.structure
s[0] = "F"
s.sort()
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
s.sort(key=lambda site: site.species_string)
self.assertEqual(s[0].species_string, "F")
self.assertEqual(s[1].species_string, "Si")
s.sort(key=lambda site: site.species_string, reverse=True)
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
def test_append_insert_remove_replace(self):
s = self.structure
s.insert(1, "O", [0.5, 0.5, 0.5])
self.assertEqual(s.formula, "Si2 O1")
self.assertTrue(s.ntypesp == 2)
self.assertTrue(s.symbol_set == ("Si", "O"))
self.assertTrue(s.indices_from_symbol("Si") == (0, 2))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
s.remove(2)
self.assertEqual(s.formula, "Si1 O1")
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
s.append("N", [0.25, 0.25, 0.25])
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
self.assertTrue(s.symbol_set == ("Si", "O", "N"))
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
self.assertTrue(s.indices_from_symbol("N") == (2, ))
s.replace(0, "Ge")
self.assertEqual(s.formula, "Ge1 N1 O1")
self.assertTrue(s.symbol_set == ("Ge", "O", "N"))
s.replace_species({"Ge": "Si"})
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
s.replace_species({"Si": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.5 Ge0.5 N1 O1")
#this should change the .5Si .5Ge sites to .75Si .25Ge
s.replace_species({"Ge": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.75 Ge0.25 N1 O1")
# In this case, s.ntypesp is ambiguous.
# for the time being, we raise AttributeError.
with self.assertRaises(AttributeError):
s.ntypesp
s.remove_species(["Si"])
self.assertEqual(s.formula, "Ge0.25 N1 O1")
s.remove_sites([1, 2])
self.assertEqual(s.formula, "Ge0.25")
def test_add_site_property(self):
s = self.structure
s.add_site_property("charge", [4.1, -5])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[1].charge, -5)
s.add_site_property("magmom", [3, 2])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[0].magmom, 3)
def test_perturb(self):
d = 0.1
pre_perturbation_sites = self.structure.sites[:]
self.structure.perturb(distance=d)
post_perturbation_sites = self.structure.sites
for i, x in enumerate(pre_perturbation_sites):
self.assertAlmostEqual(x.distance(post_perturbation_sites[i]), d,
3, "Bad perturbation distance")
def test_add_oxidation_states(self):
oxidation_states = {"Si": -4}
self.structure.add_oxidation_state_by_element(oxidation_states)
for site in self.structure:
for k in site.species_and_occu.keys():
self.assertEqual(k.oxi_state, oxidation_states[k.symbol],
"Wrong oxidation state assigned!")
oxidation_states = {"Fe": 2}
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_element,
oxidation_states)
self.structure.add_oxidation_state_by_site([2, -4])
self.assertEqual(self.structure[0].specie.oxi_state, 2)
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_site, [1])
def test_remove_oxidation_states(self):
co_elem = Element("Co")
o_elem = Element("O")
co_specie = Specie("Co", 2)
o_specie = Specie("O", -2)
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice.cubic(10)
s_elem = Structure(lattice, [co_elem, o_elem], coords)
s_specie = Structure(lattice, [co_specie, o_specie], coords)
s_specie.remove_oxidation_states()
self.assertEqual(s_elem, s_specie, "Oxidation state remover " "failed")
def test_apply_operation(self):
op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 90)
self.structure.apply_operation(op)
self.assertArrayAlmostEqual(
self.structure.lattice.matrix,
[[0.000000, 3.840198, 0.000000], [-3.325710, 1.920099, 0.000000],
[2.217138, -0.000000, 3.135509]], 5)
def test_apply_strain(self):
s = self.structure
initial_coord = s[1].coords
s.apply_strain(0.01)
self.assertAlmostEqual(
s.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(s[1].coords, initial_coord * 1.01)
a1, b1, c1 = s.lattice.abc
s.apply_strain([0.1, 0.2, 0.3])
a2, b2, c2 = s.lattice.abc
self.assertAlmostEqual(a2 / a1, 1.1)
self.assertAlmostEqual(b2 / b1, 1.2)
self.assertAlmostEqual(c2 / c1, 1.3)
def test_scale_lattice(self):
initial_coord = self.structure[1].coords
self.structure.scale_lattice(self.structure.volume * 1.01**3)
self.assertArrayAlmostEqual(
self.structure.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(self.structure[1].coords,
initial_coord * 1.01)
def test_translate_sites(self):
self.structure.translate_sites([0, 1], [0.5, 0.5, 0.5],
frac_coords=True)
self.assertArrayEqual(self.structure.frac_coords[0], [0.5, 0.5, 0.5])
self.structure.translate_sites([0], [0.5, 0.5, 0.5], frac_coords=False)
self.assertArrayAlmostEqual(self.structure.cart_coords[0],
[3.38014845, 1.05428585, 2.06775453])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=True,
to_unit_cell=False)
self.assertArrayAlmostEqual(self.structure.frac_coords[0],
[1.00187517, 1.25665291, 1.15946374])
def test_make_supercell(self):
self.structure.make_supercell([2, 1, 1])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell([[1, 0, 0], [2, 1, 0], [0, 0, 1]])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell(2)
self.assertEqual(self.structure.formula, "Si32")
self.assertArrayAlmostEqual(self.structure.lattice.abc,
[15.360792, 35.195996, 7.680396], 5)
def test_disordered_supercell_primitive_cell(self):
l = Lattice.cubic(2)
f = [[0.5, 0.5, 0.5]]
sp = [{'Si': 0.54738}]
s = Structure(l, sp, f)
#this supercell often breaks things
s.make_supercell([[0, -1, 1], [-1, 1, 0], [1, 1, 1]])
self.assertEqual(len(s.get_primitive_structure()), 1)
def test_another_supercell(self):
#this is included b/c for some reason the old algo was failing on it
s = self.structure.copy()
s.make_supercell([[0, 2, 2], [2, 0, 2], [2, 2, 0]])
self.assertEqual(s.formula, "Si32")
s = self.structure.copy()
s.make_supercell([[0, 2, 0], [1, 0, 0], [0, 0, 1]])
self.assertEqual(s.formula, "Si4")
def test_to_from_dict(self):
d = self.structure.to_dict
s2 = Structure.from_dict(d)
self.assertEqual(type(s2), Structure)
def test_propertied_structure_mod(self):
prop_structure = Structure(self.structure.lattice, ["Si"] * 2,
self.structure.frac_coords,
site_properties={'magmom': [5, -5]})
prop_structure.append("C", [0.25, 0.25, 0.25])
d = prop_structure.to_dict
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
s2 = Structure.from_dict(d)
self.assertEqual(len(w), 1)
self.assertEqual(
str(w[0].message),
'Not all sites have property magmom. Missing values are set '
'to None.')
def make_super(size,filename):
shutil.copyfile('POSCAR_primitive', filename)
struct = mg.read_structure(filename)
Structure.make_supercell(struct,size)
mg.write_structure(struct,filename)
class StructureTest(PymatgenTest):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
self.structure = Structure(lattice, ["Si", "Si"], coords)
def test_mutable_sequence_methods(self):
s = self.structure
s[0] = "Fe"
self.assertEqual(s.formula, "Fe1 Si1")
s[0] = "Fe", [0.5, 0.5, 0.5]
self.assertEqual(s.formula, "Fe1 Si1")
self.assertArrayAlmostEqual(s[0].frac_coords, [0.5, 0.5, 0.5])
s.reverse()
self.assertEqual(s[0].specie, Element("Si"))
self.assertArrayAlmostEqual(s[0].frac_coords, [0.75, 0.5, 0.75])
s[0] = {"Mn": 0.5}
self.assertEqual(s.formula, "Mn0.5 Fe1")
del s[1]
self.assertEqual(s.formula, "Mn0.5")
s[0] = "Fe", [0.9, 0.9, 0.9], {"magmom": 5}
self.assertEqual(s.formula, "Fe1")
self.assertEqual(s[0].magmom, 5)
def test_non_hash(self):
self.assertRaises(TypeError, dict, [(self.structure, 1)])
def test_append_insert_remove_replace(self):
s = self.structure
s.insert(1, "O", [0.5, 0.5, 0.5])
self.assertEqual(s.formula, "Si2 O1")
self.assertTrue(s.ntypesp == 2)
self.assertTrue(s.symbol_set == ("Si", "O"))
self.assertTrue(s.indices_from_symbol("Si") == (0,2))
self.assertTrue(s.indices_from_symbol("O") == (1,))
s.remove(2)
self.assertEqual(s.formula, "Si1 O1")
self.assertTrue(s.indices_from_symbol("Si") == (0,))
self.assertTrue(s.indices_from_symbol("O") == (1,))
s.append("N", [0.25, 0.25, 0.25])
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
self.assertTrue(s.symbol_set == ("Si", "O", "N"))
self.assertTrue(s.indices_from_symbol("Si") == (0,))
self.assertTrue(s.indices_from_symbol("O") == (1,))
self.assertTrue(s.indices_from_symbol("N") == (2,))
s.replace(0, "Ge")
self.assertEqual(s.formula, "Ge1 N1 O1")
self.assertTrue(s.symbol_set == ("Ge", "O", "N"))
s.replace_species({"Ge": "Si"})
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
s.replace_species({"Si": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.5 Ge0.5 N1 O1")
#this should change the .5Si .5Ge sites to .75Si .25Ge
s.replace_species({"Ge": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.75 Ge0.25 N1 O1")
# In this case, s.ntypesp is ambiguous.
# for the time being, we raise AttributeError.
with self.assertRaises(AttributeError):
s.ntypesp
s.remove_species(["Si"])
self.assertEqual(s.formula, "Ge0.25 N1 O1")
s.remove_sites([1, 2])
self.assertEqual(s.formula, "Ge0.25")
def test_add_site_property(self):
s = self.structure
s.add_site_property("charge", [4.1, -5])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[1].charge, -5)
s.add_site_property("magmom", [3, 2])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[0].magmom, 3)
def test_perturb(self):
d = 0.1
pre_perturbation_sites = self.structure.sites[:]
self.structure.perturb(distance=d)
post_perturbation_sites = self.structure.sites
for i, x in enumerate(pre_perturbation_sites):
self.assertAlmostEqual(x.distance(post_perturbation_sites[i]), d,
3, "Bad perturbation distance")
def test_add_oxidation_states(self):
oxidation_states = {"Si": -4}
self.structure.add_oxidation_state_by_element(oxidation_states)
for site in self.structure:
for k in site.species_and_occu.keys():
self.assertEqual(k.oxi_state, oxidation_states[k.symbol],
"Wrong oxidation state assigned!")
oxidation_states = {"Fe": 2}
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_element,
oxidation_states)
self.structure.add_oxidation_state_by_site([2, -4])
self.assertEqual(self.structure[0].specie.oxi_state, 2)
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_site,
[1])
def test_remove_oxidation_states(self):
co_elem = Element("Co")
o_elem = Element("O")
co_specie = Specie("Co", 2)
o_specie = Specie("O", -2)
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice.cubic(10)
s_elem = Structure(lattice, [co_elem, o_elem], coords)
s_specie = Structure(lattice, [co_specie, o_specie], coords)
s_specie.remove_oxidation_states()
self.assertEqual(s_elem, s_specie, "Oxidation state remover "
"failed")
def test_apply_operation(self):
op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 90)
self.structure.apply_operation(op)
self.assertArrayAlmostEqual(
self.structure.lattice.matrix,
[[0.000000, 3.840198, 0.000000],
[-3.325710, 1.920099, 0.000000],
[2.217138, -0.000000, 3.135509]], 5)
def test_apply_strain(self):
s = self.structure
initial_coord = s[1].coords
s.apply_strain(0.01)
self.assertAlmostEqual(
s.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(s[1].coords, initial_coord * 1.01)
a1, b1, c1 = s.lattice.abc
s.apply_strain([0.1, 0.2, 0.3])
a2, b2, c2 = s.lattice.abc
self.assertAlmostEqual(a2 / a1, 1.1)
self.assertAlmostEqual(b2 / b1, 1.2)
self.assertAlmostEqual(c2 / c1, 1.3)
def test_scale_lattice(self):
initial_coord = self.structure[1].coords
self.structure.scale_lattice(self.structure.volume * 1.01 ** 3)
self.assertArrayAlmostEqual(
self.structure.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(self.structure[1].coords,
initial_coord * 1.01)
def test_translate_sites(self):
self.structure.translate_sites([0, 1], [0.5, 0.5, 0.5],
frac_coords=True)
self.assertArrayEqual(self.structure.frac_coords[0],
[0.5, 0.5, 0.5])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=False)
self.assertArrayAlmostEqual(self.structure.cart_coords[0],
[3.38014845, 1.05428585, 2.06775453])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=True, to_unit_cell=False)
self.assertArrayAlmostEqual(self.structure.frac_coords[0],
[1.00187517, 1.25665291, 1.15946374])
def test_make_supercell(self):
self.structure.make_supercell([2, 1, 1])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell([[1, 0, 0], [2, 1, 0], [0, 0, 1]])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell(2)
self.assertEqual(self.structure.formula, "Si32")
self.assertArrayAlmostEqual(self.structure.lattice.abc,
[15.360792, 35.195996, 7.680396], 5)
def test_disordered_supercell_primitive_cell(self):
l = Lattice.cubic(2)
f = [[0.5, 0.5, 0.5]]
sp = [{'Si': 0.54738}]
s = Structure(l, sp, f)
#this supercell often breaks things
s.make_supercell([[0,-1,1],[-1,1,0],[1,1,1]])
self.assertEqual(len(s.get_primitive_structure()), 1)
def test_another_supercell(self):
#this is included b/c for some reason the old algo was failing on it
s = self.structure.copy()
s.make_supercell([[0, 2, 2], [2, 0, 2], [2, 2, 0]])
self.assertEqual(s.formula, "Si32")
s = self.structure.copy()
s.make_supercell([[0, 2, 0], [1, 0, 0], [0, 0, 1]])
self.assertEqual(s.formula, "Si4")
def test_to_from_dict(self):
d = self.structure.to_dict
s2 = Structure.from_dict(d)
self.assertEqual(type(s2), Structure)
import pymatgen as mg
from pymatgen.core.structure import Structure
filename = raw_input("file name:")
l = raw_input("x scale:")
m = raw_input("y scale:")
n = raw_input("z scale:")
struct = mg.read_structure(filename)
Structure.make_supercell(struct, [l, m, n])
mg.write_structure(struct, "poscar_temp")
f = open("poscar_temp")
w = open("mast.inp", "w")
def getinfo(line):
line = line.strip("\n")
data = line.split(" ")
while 1:
try:
data.remove("")
except:
break
return data
line = []
elenum = []
line.append(f.readline())
class StructureTest(PymatgenTest):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
self.structure = Structure(lattice, ["Si", "Si"], coords)
def test_non_hash(self):
self.assertRaises(TypeError, dict, [(self.structure, 1)])
def test_append_insert_remove_replace(self):
s = self.structure
s.insert(1, "O", [0.5, 0.5, 0.5])
self.assertEqual(s.formula, "Si2 O1")
self.assertTrue(s.ntypesp == 2)
self.assertTrue(s.symbol_set == ("Si", "O"))
self.assertTrue(s.indices_from_symbol("Si") == (0,2))
self.assertTrue(s.indices_from_symbol("O") == (1,))
s.remove(2)
self.assertEqual(s.formula, "Si1 O1")
self.assertTrue(s.indices_from_symbol("Si") == (0,))
self.assertTrue(s.indices_from_symbol("O") == (1,))
s.append("N", [0.25, 0.25, 0.25])
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
self.assertTrue(s.symbol_set == ("Si", "O", "N"))
self.assertTrue(s.indices_from_symbol("Si") == (0,))
self.assertTrue(s.indices_from_symbol("O") == (1,))
self.assertTrue(s.indices_from_symbol("N") == (2,))
s.replace(0, "Ge")
self.assertEqual(s.formula, "Ge1 N1 O1")
self.assertTrue(s.symbol_set == ("Ge", "O", "N"))
s.replace_species({"Ge": "Si"})
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
s.replace_species({"Si": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.5 Ge0.5 N1 O1")
#this should change the .5Si .5Ge sites to .75Si .25Ge
s.replace_species({"Ge": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.75 Ge0.25 N1 O1")
# In this case, s.ntypesp is ambiguous.
# for the time being, we raise AttributeError.
with self.assertRaises(AttributeError):
s.ntypesp
s.remove_species(["Si"])
self.assertEqual(s.formula, "Ge0.25 N1 O1")
s.remove_sites([1, 2])
self.assertEqual(s.formula, "Ge0.25")
def test_add_site_property(self):
s = self.structure
s.add_site_property("charge", [4.1, -5])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[1].charge, -5)
s.add_site_property("magmom", [3, 2])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[0].magmom, 3)
def test_perturb(self):
d = 0.1
pre_perturbation_sites = self.structure.sites[:]
self.structure.perturb(distance=d)
post_perturbation_sites = self.structure.sites
for i, x in enumerate(pre_perturbation_sites):
self.assertAlmostEqual(x.distance(post_perturbation_sites[i]), d,
3, "Bad perturbation distance")
def test_add_oxidation_states(self):
oxidation_states = {"Si": -4}
self.structure.add_oxidation_state_by_element(oxidation_states)
for site in self.structure:
for k in site.species_and_occu.keys():
self.assertEqual(k.oxi_state, oxidation_states[k.symbol],
"Wrong oxidation state assigned!")
oxidation_states = {"Fe": 2}
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_element,
oxidation_states)
self.structure.add_oxidation_state_by_site([2, -4])
self.assertEqual(self.structure[0].specie.oxi_state, 2)
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_site,
[1])
def test_remove_oxidation_states(self):
co_elem = Element("Co")
o_elem = Element("O")
co_specie = Specie("Co", 2)
o_specie = Specie("O", -2)
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice.cubic(10)
s_elem = Structure(lattice, [co_elem, o_elem], coords)
s_specie = Structure(lattice, [co_specie, o_specie], coords)
s_specie.remove_oxidation_states()
self.assertEqual(s_elem, s_specie, "Oxidation state remover "
"failed")
def test_apply_operation(self):
op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 90)
self.structure.apply_operation(op)
self.assertArrayAlmostEqual(
self.structure.lattice.matrix,
[[0.000000, 3.840198, 0.000000],
[-3.325710, 1.920099, 0.000000],
[2.217138, -0.000000, 3.135509]], 5)
def test_apply_strain(self):
self.structure.apply_strain(0.01)
self.assertAlmostEqual(
self.structure.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
def test_translate_sites(self):
self.structure.translate_sites([0, 1], [0.5, 0.5, 0.5],
frac_coords=True)
self.assertArrayEqual(self.structure.frac_coords[0],
[0.5, 0.5, 0.5])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=False)
self.assertArrayAlmostEqual(self.structure.cart_coords[0],
[3.38014845, 1.05428585, 2.06775453])
def test_make_supercell(self):
self.structure.make_supercell([2, 1, 1])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell([[1, 0, 0], [2, 1, 0], [0, 0, 1]])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell(2)
self.assertEqual(self.structure.formula, "Si32")
self.assertArrayAlmostEqual(self.structure.lattice.abc,
[15.360792, 35.195996, 7.680396], 5)
def test_to_from_dict(self):
d = self.structure.to_dict
s2 = Structure.from_dict(d)
self.assertEqual(type(s2), Structure)
class StructureTest(PymatgenTest):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
self.structure = Structure(lattice, ["Si", "Si"], coords)
def test_non_hash(self):
self.assertRaises(TypeError, dict, [(self.structure, 1)])
def test_append_insert_remove_replace(self):
s = self.structure
s.insert(1, "O", [0.5, 0.5, 0.5])
self.assertEqual(s.formula, "Si2 O1")
self.assertTrue(s.ntypesp == 2)
self.assertTrue(s.symbol_set == ("Si", "O"))
self.assertTrue(s.indices_from_symbol("Si") == (0, 2))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
s.remove(2)
self.assertEqual(s.formula, "Si1 O1")
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
s.append("N", [0.25, 0.25, 0.25])
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
self.assertTrue(s.symbol_set == ("Si", "O", "N"))
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
self.assertTrue(s.indices_from_symbol("N") == (2, ))
s.replace(0, "Ge")
self.assertEqual(s.formula, "Ge1 N1 O1")
self.assertTrue(s.symbol_set == ("Ge", "O", "N"))
s.replace_species({"Ge": "Si"})
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
s.replace_species({"Si": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.5 Ge0.5 N1 O1")
#this should change the .5Si .5Ge sites to .75Si .25Ge
s.replace_species({"Ge": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.75 Ge0.25 N1 O1")
# In this case, s.ntypesp is ambiguous.
# for the time being, we raise AttributeError.
with self.assertRaises(AttributeError):
s.ntypesp
s.remove_species(["Si"])
self.assertEqual(s.formula, "Ge0.25 N1 O1")
s.remove_sites([1, 2])
self.assertEqual(s.formula, "Ge0.25")
def test_add_site_property(self):
s = self.structure
s.add_site_property("charge", [4.1, -5])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[1].charge, -5)
s.add_site_property("magmom", [3, 2])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[0].magmom, 3)
def test_perturb(self):
d = 0.1
pre_perturbation_sites = self.structure.sites[:]
self.structure.perturb(distance=d)
post_perturbation_sites = self.structure.sites
for i, x in enumerate(pre_perturbation_sites):
self.assertAlmostEqual(x.distance(post_perturbation_sites[i]), d,
3, "Bad perturbation distance")
def test_add_oxidation_states(self):
oxidation_states = {"Si": -4}
self.structure.add_oxidation_state_by_element(oxidation_states)
for site in self.structure:
for k in site.species_and_occu.keys():
self.assertEqual(k.oxi_state, oxidation_states[k.symbol],
"Wrong oxidation state assigned!")
oxidation_states = {"Fe": 2}
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_element,
oxidation_states)
self.structure.add_oxidation_state_by_site([2, -4])
self.assertEqual(self.structure[0].specie.oxi_state, 2)
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_site, [1])
def test_remove_oxidation_states(self):
co_elem = Element("Co")
o_elem = Element("O")
co_specie = Specie("Co", 2)
o_specie = Specie("O", -2)
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice.cubic(10)
s_elem = Structure(lattice, [co_elem, o_elem], coords)
s_specie = Structure(lattice, [co_specie, o_specie], coords)
s_specie.remove_oxidation_states()
self.assertEqual(s_elem, s_specie, "Oxidation state remover " "failed")
def test_apply_operation(self):
op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 90)
self.structure.apply_operation(op)
self.assertArrayAlmostEqual(
self.structure.lattice.matrix,
[[0.000000, 3.840198, 0.000000], [-3.325710, 1.920099, 0.000000],
[2.217138, -0.000000, 3.135509]], 5)
def test_apply_strain(self):
self.structure.apply_strain(0.01)
self.assertAlmostEqual(
self.structure.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
def test_translate_sites(self):
self.structure.translate_sites([0, 1], [0.5, 0.5, 0.5],
frac_coords=True)
self.assertArrayEqual(self.structure.frac_coords[0], [0.5, 0.5, 0.5])
self.structure.translate_sites([0], [0.5, 0.5, 0.5], frac_coords=False)
self.assertArrayAlmostEqual(self.structure.cart_coords[0],
[3.38014845, 1.05428585, 2.06775453])
def test_make_supercell(self):
self.structure.make_supercell([2, 1, 1])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell([[1, 0, 0], [2, 1, 0], [0, 0, 1]])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell(2)
self.assertEqual(self.structure.formula, "Si32")
self.assertArrayAlmostEqual(self.structure.lattice.abc,
[15.360792, 35.195996, 7.680396], 5)
def test_to_from_dict(self):
d = self.structure.to_dict
s2 = Structure.from_dict(d)
self.assertEqual(type(s2), Structure)
class StructureTest(PymatgenTest):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
self.structure = Structure(lattice, ["Si", "Si"], coords)
def test_mutable_sequence_methods(self):
s = self.structure
s[0] = "Fe"
self.assertEqual(s.formula, "Fe1 Si1")
s[0] = "Fe", [0.5, 0.5, 0.5]
self.assertEqual(s.formula, "Fe1 Si1")
self.assertArrayAlmostEqual(s[0].frac_coords, [0.5, 0.5, 0.5])
s.reverse()
self.assertEqual(s[0].specie, Element("Si"))
self.assertArrayAlmostEqual(s[0].frac_coords, [0.75, 0.5, 0.75])
s[0] = {"Mn": 0.5}
self.assertEqual(s.formula, "Mn0.5 Fe1")
del s[1]
self.assertEqual(s.formula, "Mn0.5")
s[0] = "Fe", [0.9, 0.9, 0.9], {"magmom": 5}
self.assertEqual(s.formula, "Fe1")
self.assertEqual(s[0].magmom, 5)
# Test atomic replacement.
s["Fe"] = "Mn"
self.assertEqual(s.formula, "Mn1")
# Test slice replacement.
s = PymatgenTest.get_structure("Li2O")
s[1:3] = "S"
self.assertEqual(s.formula, "Li1 S2")
def test_non_hash(self):
self.assertRaises(TypeError, dict, [(self.structure, 1)])
def test_sort(self):
s = self.structure
s[0] = "F"
s.sort()
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
s.sort(key=lambda site: site.species_string)
self.assertEqual(s[0].species_string, "F")
self.assertEqual(s[1].species_string, "Si")
s.sort(key=lambda site: site.species_string, reverse=True)
self.assertEqual(s[0].species_string, "Si")
self.assertEqual(s[1].species_string, "F")
def test_append_insert_remove_replace(self):
s = self.structure
s.insert(1, "O", [0.5, 0.5, 0.5])
self.assertEqual(s.formula, "Si2 O1")
self.assertTrue(s.ntypesp == 2)
self.assertTrue(s.symbol_set == ("Si", "O"))
self.assertTrue(s.indices_from_symbol("Si") == (0, 2))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
del s[2]
self.assertEqual(s.formula, "Si1 O1")
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
s.append("N", [0.25, 0.25, 0.25])
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
self.assertTrue(s.symbol_set == ("Si", "O", "N"))
self.assertTrue(s.indices_from_symbol("Si") == (0, ))
self.assertTrue(s.indices_from_symbol("O") == (1, ))
self.assertTrue(s.indices_from_symbol("N") == (2, ))
s[0] = "Ge"
self.assertEqual(s.formula, "Ge1 N1 O1")
self.assertTrue(s.symbol_set == ("Ge", "O", "N"))
s.replace_species({"Ge": "Si"})
self.assertEqual(s.formula, "Si1 N1 O1")
self.assertTrue(s.ntypesp == 3)
s.replace_species({"Si": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.5 Ge0.5 N1 O1")
#this should change the .5Si .5Ge sites to .75Si .25Ge
s.replace_species({"Ge": {"Ge": 0.5, "Si": 0.5}})
self.assertEqual(s.formula, "Si0.75 Ge0.25 N1 O1")
# In this case, s.ntypesp is ambiguous.
# for the time being, we raise AttributeError.
with self.assertRaises(AttributeError):
s.ntypesp
s.remove_species(["Si"])
self.assertEqual(s.formula, "Ge0.25 N1 O1")
s.remove_sites([1, 2])
self.assertEqual(s.formula, "Ge0.25")
def test_add_site_property(self):
s = self.structure
s.add_site_property("charge", [4.1, -5])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[1].charge, -5)
s.add_site_property("magmom", [3, 2])
self.assertEqual(s[0].charge, 4.1)
self.assertEqual(s[0].magmom, 3)
def test_propertied_structure(self):
#Make sure that site properties are set to None for missing values.
s = self.structure
s.add_site_property("charge", [4.1, -5])
s.append("Li", [0.3, 0.3, 0.3])
self.assertEqual(len(s.site_properties["charge"]), 3)
def test_perturb(self):
d = 0.1
pre_perturbation_sites = self.structure.sites[:]
self.structure.perturb(distance=d)
post_perturbation_sites = self.structure.sites
for i, x in enumerate(pre_perturbation_sites):
self.assertAlmostEqual(x.distance(post_perturbation_sites[i]), d,
3, "Bad perturbation distance")
def test_add_oxidation_states(self):
oxidation_states = {"Si": -4}
self.structure.add_oxidation_state_by_element(oxidation_states)
for site in self.structure:
for k in site.species_and_occu.keys():
self.assertEqual(k.oxi_state, oxidation_states[k.symbol],
"Wrong oxidation state assigned!")
oxidation_states = {"Fe": 2}
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_element,
oxidation_states)
self.structure.add_oxidation_state_by_site([2, -4])
self.assertEqual(self.structure[0].specie.oxi_state, 2)
self.assertRaises(ValueError,
self.structure.add_oxidation_state_by_site, [1])
def test_remove_oxidation_states(self):
co_elem = Element("Co")
o_elem = Element("O")
co_specie = Specie("Co", 2)
o_specie = Specie("O", -2)
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = Lattice.cubic(10)
s_elem = Structure(lattice, [co_elem, o_elem], coords)
s_specie = Structure(lattice, [co_specie, o_specie], coords)
s_specie.remove_oxidation_states()
self.assertEqual(s_elem, s_specie, "Oxidation state remover " "failed")
def test_apply_operation(self):
op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 90)
s = self.structure.copy()
s.apply_operation(op)
self.assertArrayAlmostEqual(
s.lattice.matrix,
[[0.000000, 3.840198, 0.000000], [-3.325710, 1.920099, 0.000000],
[2.217138, -0.000000, 3.135509]], 5)
op = SymmOp([[1, 1, 0, 0.5], [1, 0, 0, 0.5], [0, 0, 1, 0.5],
[0, 0, 0, 1]])
s = self.structure.copy()
s.apply_operation(op, fractional=True)
self.assertArrayAlmostEqual(
s.lattice.matrix,
[[5.760297, 3.325710, 0.000000], [3.840198, 0.000000, 0.000000],
[0.000000, -2.217138, 3.135509]], 5)
def test_apply_strain(self):
s = self.structure
initial_coord = s[1].coords
s.apply_strain(0.01)
self.assertAlmostEqual(
s.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(s[1].coords, initial_coord * 1.01)
a1, b1, c1 = s.lattice.abc
s.apply_strain([0.1, 0.2, 0.3])
a2, b2, c2 = s.lattice.abc
self.assertAlmostEqual(a2 / a1, 1.1)
self.assertAlmostEqual(b2 / b1, 1.2)
self.assertAlmostEqual(c2 / c1, 1.3)
def test_scale_lattice(self):
initial_coord = self.structure[1].coords
self.structure.scale_lattice(self.structure.volume * 1.01**3)
self.assertArrayAlmostEqual(
self.structure.lattice.abc,
(3.8785999130369997, 3.878600984287687, 3.8785999130549516))
self.assertArrayAlmostEqual(self.structure[1].coords,
initial_coord * 1.01)
def test_translate_sites(self):
self.structure.translate_sites([0, 1], [0.5, 0.5, 0.5],
frac_coords=True)
self.assertArrayEqual(self.structure.frac_coords[0], [0.5, 0.5, 0.5])
self.structure.translate_sites([0], [0.5, 0.5, 0.5], frac_coords=False)
self.assertArrayAlmostEqual(self.structure.cart_coords[0],
[3.38014845, 1.05428585, 2.06775453])
self.structure.translate_sites([0], [0.5, 0.5, 0.5],
frac_coords=True,
to_unit_cell=False)
self.assertArrayAlmostEqual(self.structure.frac_coords[0],
[1.00187517, 1.25665291, 1.15946374])
def test_mul(self):
self.structure *= [2, 1, 1]
self.assertEqual(self.structure.formula, "Si4")
s = [2, 1, 1] * self.structure
self.assertEqual(s.formula, "Si8")
self.assertIsInstance(s, Structure)
s = self.structure * [[1, 0, 0], [2, 1, 0], [0, 0, 2]]
self.assertEqual(s.formula, "Si8")
self.assertArrayAlmostEqual(s.lattice.abc,
[7.6803959, 17.5979979, 7.6803959])
def test_make_supercell(self):
self.structure.make_supercell([2, 1, 1])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell([[1, 0, 0], [2, 1, 0], [0, 0, 1]])
self.assertEqual(self.structure.formula, "Si4")
self.structure.make_supercell(2)
self.assertEqual(self.structure.formula, "Si32")
self.assertArrayAlmostEqual(self.structure.lattice.abc,
[15.360792, 35.195996, 7.680396], 5)
def test_disordered_supercell_primitive_cell(self):
l = Lattice.cubic(2)
f = [[0.5, 0.5, 0.5]]
sp = [{'Si': 0.54738}]
s = Structure(l, sp, f)
#this supercell often breaks things
s.make_supercell([[0, -1, 1], [-1, 1, 0], [1, 1, 1]])
self.assertEqual(len(s.get_primitive_structure()), 1)
def test_another_supercell(self):
#this is included b/c for some reason the old algo was failing on it
s = self.structure.copy()
s.make_supercell([[0, 2, 2], [2, 0, 2], [2, 2, 0]])
self.assertEqual(s.formula, "Si32")
s = self.structure.copy()
s.make_supercell([[0, 2, 0], [1, 0, 0], [0, 0, 1]])
self.assertEqual(s.formula, "Si4")
def test_to_from_dict(self):
d = self.structure.as_dict()
s2 = Structure.from_dict(d)
self.assertEqual(type(s2), Structure)
def test_to_from_abivars(self):
"""Test as_dict, from_dict with fmt == abivars."""
d = self.structure.as_dict(fmt="abivars")
s2 = Structure.from_dict(d, fmt="abivars")
self.assertEqual(s2, self.structure)
self.assertEqual(type(s2), Structure)
def test_to_from_file_string(self):
for fmt in ["cif", "json", "poscar", "cssr", "yaml", "xsf"]:
s = self.structure.to(fmt=fmt)
self.assertIsNotNone(s)
ss = Structure.from_str(s, fmt=fmt)
self.assertArrayAlmostEqual(
ss.lattice.lengths_and_angles,
self.structure.lattice.lengths_and_angles,
decimal=5)
self.assertArrayAlmostEqual(ss.frac_coords,
self.structure.frac_coords)
self.assertIsInstance(ss, Structure)
self.structure.to(filename="POSCAR.testing")
self.assertTrue(os.path.exists("POSCAR.testing"))
os.remove("POSCAR.testing")
self.structure.to(filename="structure_testing.json")
self.assertTrue(os.path.exists("structure_testing.json"))
s = Structure.from_file("structure_testing.json")
self.assertEqual(s, self.structure)
os.remove("structure_testing.json")
def test_from_spacegroup(self):
s1 = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]])
self.assertEqual(s1.formula, "Li8 O4")
s2 = Structure.from_spacegroup(225, Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]])
self.assertEqual(s1, s2)
s2 = Structure.from_spacegroup(225,
Lattice.cubic(3), ["Li", "O"],
[[0.25, 0.25, 0.25], [0, 0, 0]],
site_properties={"charge": [1, -2]})
self.assertEqual(sum(s2.site_properties["charge"]), 0)
s = Structure.from_spacegroup("Pm-3m", Lattice.cubic(3), ["Cs", "Cl"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
self.assertEqual(s.formula, "Cs1 Cl1")
self.assertRaises(ValueError, Structure.from_spacegroup, "Pm-3m",
Lattice.tetragonal(1, 3), ["Cs", "Cl"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
self.assertRaises(ValueError, Structure.from_spacegroup, "Pm-3m",
Lattice.cubic(3), ["Cs"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
def test_from_magnetic_spacegroup(self):
# AFM MnF
s1 = Structure.from_magnetic_spacegroup(
"P4_2'/mnm'", Lattice.tetragonal(4.87, 3.30), ["Mn", "F"],
[[0, 0, 0], [0.30, 0.30, 0.00]], {'magmom': [4, 0]})
self.assertEqual(s1.formula, "Mn2 F4")
self.assertEqual(sum(map(float, s1.site_properties['magmom'])), 0)
self.assertEqual(max(map(float, s1.site_properties['magmom'])), 4)
self.assertEqual(min(map(float, s1.site_properties['magmom'])), -4)
# AFM LaMnO3, ordered on (001) planes
s2 = Structure.from_magnetic_spacegroup(
"Pn'ma'", Lattice.orthorhombic(5.75, 7.66,
5.53), ["La", "Mn", "O", "O"],
[[0.05, 0.25, 0.99], [0.00, 0.00, 0.50], [0.48, 0.25, 0.08],
[0.31, 0.04, 0.72]], {'magmom': [0, Magmom([4, 0, 0]), 0, 0]})
self.assertEqual(s2.formula, "La4 Mn4 O12")
self.assertEqual(sum(map(float, s2.site_properties['magmom'])), 0)
self.assertEqual(max(map(float, s2.site_properties['magmom'])), 4)
self.assertEqual(min(map(float, s2.site_properties['magmom'])), -4)
def test_merge_sites(self):
species = [{
'Ag': 0.5
}, {
'Cl': 0.25
}, {
'Cl': 0.1
}, {
'Ag': 0.5
}, {
'F': 0.15
}, {
'F': 0.1
}]
coords = [[0, 0, 0], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0, 0, 0],
[0.5, 0.5, 1.501], [0.5, 0.5, 1.501]]
s = Structure(Lattice.cubic(1), species, coords)
s.merge_sites(mode="s")
self.assertEqual(s[0].specie.symbol, 'Ag')
self.assertEqual(s[1].species_and_occu,
Composition({
'Cl': 0.35,
'F': 0.25
}))
self.assertArrayAlmostEqual(s[1].frac_coords, [.5, .5, .5005])
# Test for TaS2 with spacegroup 166 in 160 setting.
l = Lattice.from_lengths_and_angles([3.374351, 3.374351, 20.308941],
[90.000000, 90.000000, 120.000000])
species = ["Ta", "S", "S"]
coords = [[0.000000, 0.000000,
0.944333], [0.333333, 0.666667, 0.353424],
[0.666667, 0.333333, 0.535243]]
tas2 = Structure.from_spacegroup(160, l, species, coords)
assert len(tas2) == 13
tas2.merge_sites(mode="d")
assert len(tas2) == 9
l = Lattice.from_lengths_and_angles([3.587776, 3.587776, 19.622793],
[90.000000, 90.000000, 120.000000])
species = ["Na", "V", "S", "S"]
coords = [[0.333333, 0.666667,
0.165000], [0.000000, 0.000000, 0.998333],
[0.333333, 0.666667, 0.399394],
[0.666667, 0.333333, 0.597273]]
navs2 = Structure.from_spacegroup(160, l, species, coords)
assert len(navs2) == 18
navs2.merge_sites(mode="d")
assert len(navs2) == 12
def test_properties(self):
self.assertEqual(self.structure.num_sites, len(self.structure))
self.structure.make_supercell(2)
self.structure[1] = "C"
sites = list(self.structure.group_by_types())
self.assertEqual(sites[-1].specie.symbol, "C")
self.structure.add_oxidation_state_by_element({"Si": 4, "C": 2})
self.assertEqual(self.structure.charge, 62)
def test_set_item(self):
s = self.structure.copy()
s[0] = "C"
self.assertEqual(s.formula, "Si1 C1")
s[(0, 1)] = "Ge"
self.assertEqual(s.formula, "Ge2")
s[0:2] = "Sn"
self.assertEqual(s.formula, "Sn2")
s = self.structure.copy()
s["Si"] = "C"
self.assertEqual(s.formula, "C2")
s["C"] = "C0.25Si0.5"
self.assertEqual(s.formula, "Si1 C0.5")
s["C"] = "C0.25Si0.5"
self.assertEqual(s.formula, "Si1.25 C0.125")
def test_init_error(self):
self.assertRaises(StructureError, Structure, Lattice.cubic(3), ["Si"],
[[0, 0, 0], [0.5, 0.5, 0.5]])
def test_from_sites(self):
self.structure.add_site_property("hello", [1, 2])
s = Structure.from_sites(self.structure, to_unit_cell=True)
self.assertEqual(s.site_properties["hello"][1], 2)
def test_magic(self):
s = Structure.from_sites(self.structure)
self.assertEqual(s, self.structure)
self.assertNotEqual(s, None)
s.apply_strain(0.5)
self.assertNotEqual(s, self.structure)
self.assertNotEqual(self.structure * 2, self.structure)
