def test_update_isoset(self): c = Specie("Cu") t = Specie("Ti") m = [[-0.5, -0.5, -0.5], [-0.5, 0.5, 0.5], [ 0.5, -0.5, 0.5]] ele_sea = SitesGrid.sea(2, 2, 2, c) cell_mother_stru = CStru(m, ele_sea).get_cell() sym = get_symmetry(cell_mother_stru, symprec=1e-5) ops = [(r, t) for r, t in zip(sym['rotations'], sym['translations'])] sym_perm = sogen.get_permutation_cell(cell_mother_stru) sites_0 = [[[c, c], [c, c]], [[c, c], [t, c]]] sg_0 = SitesGrid(sites_0) cstru01 = CStru(m, sg_0) number01 = cstru01.get_cell()[2] isoset_init = set() isoset_init_copy = isoset_init.copy() isoset_a01 = sogen._update_isoset(isoset_init, number01, sym_perm) self.assertNotEqual(isoset_a01, isoset_init_copy) self.assertIsInstance(isoset_a01, set) isoset_a01_copy = isoset_a01.copy() isoset_a02 = sogen._update_isoset(isoset_a01, number01, sym_perm) self.assertEqual(isoset_a02, isoset_a01_copy) self.assertLessEqual(len(isoset_a01), len(ops))
def __init__(self, infile, comment, element, speckle, trs, refined, outmode): # read comment & zoom from setting file first # if not exist, read from cmd args, then default self.cell = GeneralIO.from_file(infile) self.comment = comment or self.cell.comment self.element = element # Get number and index of target element num = self.cell.numbers if element is None: tgt_ele = int(num[1]) else: tgt_ele = Specie(element).Z tgt_ele_index = np.where(num == tgt_ele)[0] self.n = tgt_ele_index.size self.s1, self.s2 = speckle # self.ele for function all-speckle-gen-of-ele in run self.ele = Specie.from_num(tgt_ele) # if there no restriction given then no restriction if trs != (): self.tr = trs[0] else: self.tr = None self.refined = refined self.outmode = outmode
def test_get_cell(self): c = Specie("Cu") t = Specie("Ti") m = [[-0.5, -0.5, -0.5], [-0.5, 0.5, 0.5], [0.5, -0.5, 0.5]] sites01 = [[[c]]] sites02 = [[[t, c, t], [t, t, c]]] sg01 = SitesGrid(sites01) sg02 = SitesGrid(sites02) cstru01 = CStru(m, sg01) cstru02 = CStru(m, sg02) lat01, pos01, num01 = cstru01.get_cell() lat02, pos02, num02 = cstru02.get_cell() self.assertTrue( np.allclose( lat01, np.array([[-0.5, -0.5, -0.5], [-0.5, 0.5, 0.5], [0.5, -0.5, 0.5]]))) self.assertTrue(np.allclose(pos01, np.array([[0, 0, 0]]))) self.assertTrue(np.allclose(num01, np.array([29]))) self.assertTrue( np.allclose( lat02, np.array([[-0.5, -0.5, -0.5], [-1, 1, 1], [1.5, -1.5, 1.5]]))) self.assertTrue( np.allclose( pos02, np.array([[0, 0, 0], [0, 0, 1 / 3], [0, 0, 2 / 3], [0, 1 / 2, 0], [0, 1 / 2, 1 / 3], [0, 1 / 2, 2 / 3]]))) self.assertTrue(np.allclose(num02, np.array([22, 29, 22, 22, 22, 29])))
def test_all_speckle_gen_of_ele(self): big_gen = self.binary_ocu_gen.all_speckle_gen_of_ele(4, Specie("S"), Specie('Ti')) num_list = [1, 4, 4, 8] gen_list = [i for i in big_gen] for c, r_gen in zip(num_list, gen_list): r_length = len([i for i in r_gen]) self.assertEqual(r_length, c)
def __init__(self, position, ele): self._position = tuple(position) if isinstance(ele, Specie): self._element = ele elif isinstance(ele, int): self._element = Specie.from_num(ele) else: self._element = Specie(ele)
def test_gen_nodup(self): nodup_gen = self.binary_ocu_gen.gen_nodup('c', 3, Specie('Ti')) l = [i for i in nodup_gen] self.assertEqual(len(l), 4) nodup_gen = self.binary_ocu_gen.gen_nodup_of_ele(Specie("S"), 3, Specie('Ti')) l = [i for i in nodup_gen] self.assertEqual(len(l), 4)
def test_gen_dup(self): dup_gen = self.binary_ocu_gen.gen_dup('c', 3, Specie('Ti')) l = [i for i in dup_gen] self.assertEqual(len(l), 56) # test case for provide element as input dup_gen = self.binary_ocu_gen.gen_dup_of_ele(Specie("S"), 3, Specie('Ti')) l = [i for i in dup_gen] self.assertEqual(len(l), 56)
def __init__(self, infile, cenele, radius, ele, refined): gcell = GeneralIO.from_file(infile) self.infile = infile self.basefname = os.path.basename(infile) self.mcell = ModifiedCell.from_gcell(gcell) self.clarifier = VerboseAtomRemoveClarifier(Specie(cenele), radius, Specie(ele)) self.refined = refined
def test_gen_speckle(self): c = Specie("Cu") t = Specie("Ti") sites = [[[c, c], [t, t]], [[c, t], [t, c]]] self.sg = SitesGrid(sites) gen = SitesGrid.gen_speckle(Specie("Cu"), (2, 2, 2), Specie("Ti"), 4) from collections import Iterator self.assertIsInstance(gen, Iterator) self.assertIn(self.sg, gen) self.assertEqual(next(gen).to_array().sum(), 204) self.assertEqual(next(gen).to_array().sum(), 204)
def test_gen_nodup_unitary(self): nodup_gen = self.ocu_gen.gen_nodup_unitary(3, Specie('B')) l = [i for i in nodup_gen] self.assertEqual(len(l), 9) nodup_gen = self.ocu_gen.gen_nodup_unitary(4, Specie('B')) l = [i for i in nodup_gen] self.assertEqual(len(l), 21) nodup_gen = self.ocu_gen.gen_nodup_unitary(1, Specie('B')) l = [i for i in nodup_gen] self.assertEqual(len(l), 1)
def test_gen_nodup_cstru(self): c = Specie("Cu") t = Specie("Ti") m = [[-0.5, -0.5, -0.5], [-0.5, 0.5, 0.5], [ 0.5, -0.5, 0.5]] ele_sea = SitesGrid.sea(2, 2, 2, c) cell_mother_stru = CStru(m, ele_sea).get_cell() sym = get_symmetry(cell_mother_stru, symprec=1e-3) ops = [(r, t) for r, t in zip(sym['rotations'], sym['translations'])] sites_0 = [[[c, c], [c, c]], [[c, c], [t, c]]] sg_0 = SitesGrid(sites_0) cstru01 = CStru(m, sg_0) gen_01 = sogen.gen_nodup_cstru(m, c, (2,2,2), t, 1) nodup_01 = [stru for stru in gen_01] self.assertEqual(len(nodup_01), 1) gen_02 = sogen.gen_nodup_cstru(m, c, (1,2,8), t, 4) nodup_02 = [stru for stru in gen_02] # eq_(len(nodup_02), 51) m_tri = [[0, 0, 20], [1, 0, 0], [0.5, 0.8660254, 0]] ele_sea = SitesGrid.sea(1, 3, 3, c) cell_mother_stru = CStru(m, ele_sea).get_cell() sym = get_symmetry(cell_mother_stru, symprec=1e-3) ops = [(r, t) for r, t in zip(sym['rotations'], sym['translations'])] sites_0 = [[[c, c, c], [c, c, c], [c, c, c]]] sg_0 = SitesGrid(sites_0) cstru01 = CStru(m, sg_0) gen_01 = sogen.gen_nodup_cstru(m_tri, c, (1,3,3), t, 2) nodup_01 = [stru for stru in gen_01] self.assertEqual(len(nodup_01), 2) gen_02 = sogen.gen_nodup_cstru(m_tri, c, (1,3,3), t, 3) nodup_02 = [stru for stru in gen_02] self.assertEqual(len(nodup_02), 4) gen_03 = sogen.gen_nodup_cstru(m_tri, c, (1,5,5), t, 2) nodup_03 = [stru for stru in gen_03] self.assertEqual(len(nodup_03), 4)
def comment(self): from collections import Counter, OrderedDict atoms_name_list = list( map(lambda x: Specie.to_name(x), list(self.numbers))) d = Counter(atoms_name_list) ordered_atoms = OrderedDict( sorted(d.items(), key=lambda x: Specie(x[0]).Z)) if 'G' in ordered_atoms: del ordered_atoms['G'] comment = ''.join( ['{}{}'.format(k, v) for k, v in ordered_atoms.items()]) return comment
def setUp(self): arr_lat = np.array([[3.0, 0, 0], [0, 2.0, 0.0], [0, 0, 1.0]]) positions = [[0.00000, 0.00000, 0.00000], [0.00000, 0.50000, 0.00000], [0.33333, 0.00000, 0.00000], [0.33333, 0.50000, 0.00000], [0.66666, 0.00000, 0.00000], [0.66666, 0.50000, 0.00000], [0.16666, 0.25000, 0.50000], [0.16666, 0.75000, 0.50000], [0.50000, 0.25000, 0.50000], [0.50000, 0.75000, 0.50000], [0.83333, 0.25000, 0.50000], [0.83333, 0.75000, 0.50000]] arr_positions = np.array(positions) arr_numbers = np.array([5, 6, 6, 6, 5, 6, 6, 6, 6, 6, 6, 6]) self.cell = GeneralCell(arr_lat, arr_positions, arr_numbers) self.carbon_restrc = MinDistanceRestriction((Specie('C'), 0.85)) self.boron_restrc = MinDistanceRestriction((Specie('B'), 1.01))
def __init__(self, settings, comment, element, speckle, nspeckle, zoom, trs, refined, outmode, mpr): # read comment & zoom from setting file first # if not exist, read from cmd args, then default if zoom is None: try: zoom = settings['zoom'] except: zoom = 1 self.zoom = zoom if comment is None: try: comment = settings['comment'] except: comment = 'default' self.comment = comment lat = np.array(settings['lattice']) pos = np.array(settings['positions']) num = np.array(settings['numbers']) self.cell = GeneralCell(lat * self.zoom, pos, num) self.element = element # Get number and index of target element if element is None: tgt_ele = int(num[1]) else: tgt_ele = Specie(element).Z tgt_ele_index = np.where(num == tgt_ele)[0] self.s1, self.s2 = speckle self.n1, self.n2 = nspeckle # self.ele for function all-speckle-gen-of-ele in run self.ele = Specie.from_num(tgt_ele) # if there no restriction given then no restriction if trs != (): self.tr = trs[0] else: self.tr = None self.refined = refined self.outmode = outmode self.mpr = mpr self.n0 = tgt_ele_index.size - self.n1 - self.n2
def run(self): # Create directory contain POSCARs import random import string rd_suffix = ''.join( random.choices(string.ascii_uppercase + string.digits, k=5)) working_path = os.getcwd() out_dir = os.path.join( working_path, 'STRUCTURES_{0:}_{1:}'.format(self.comment, rd_suffix)) if not os.path.exists(out_dir): os.makedirs(out_dir) else: shutil.rmtree(out_dir) os.makedirs(out_dir) ogg = OccupyGenerator(self.cell) if self.tr is not None: tr = (Specie(self.tr[0]), self.tr[1]) applied_restriction = MinDistanceRestriction(tr) for n1 in range(1, self.n - 1): for n2 in range(1, self.n - n1): g = ogg.gen_nodup_trinary_alloy(Specie(self.s1), n1, Specie(self.s2), n2) for n_count, c in enumerate(g): if self.tr is not None: condition = c.is_primitive( ) and applied_restriction.is_satisfied(c) else: condition = c.is_primitive() if condition: if self.refined: c = c.get_refined_pcell() out = GeneralIO(c) f_suffix = ''.join( random.choices(string.ascii_uppercase + string.digits, k=4)) ofname = "STRUCTURE_{:}_{:}.{:}".format( c.comment, f_suffix, self.outmode) lastpath = os.path.join(out_dir, ofname) out.write_file(lastpath)
def from_string(content): # move empty line lines = [l for l in content.split('\n') if l.rstrip()] comment = lines[0] zoom = float(lines[1]) lattice = np.around(np.array([[float(i) for i in line.split()] for line in lines[2:5]]), decimals=6) if zoom < 0: # In vasp, a negative scale factor is treated as a volume. We need # to translate this to a proper lattice vector scaling. vol = abs(np.linalg.det(lattice)) lattice *= (-zoom / vol)**(1 / 3) else: lattice *= zoom nsymbols = [Specie(s).Z for s in lines[5].split()] natoms = [int(i) for i in lines[6].split()] numbers = [] for i, s in enumerate(natoms): numbers += s * [nsymbols[i]] numbers = np.array(numbers) positions = np.around(np.array([[float(i) for i in line.split()[0:3]] for line in lines[8:]]), decimals=6) return lattice, positions, numbers
def __init__(self, gcell): self.lattice = np.around(gcell.lattice, decimals=6) self.positions = np.around(gcell.positions, decimals=6) self.numbers = gcell.numbers atoms_name_list = list( map(lambda x: Specie.to_name(x), list(self.numbers))) d = Counter(atoms_name_list) ordered_atoms = OrderedDict( sorted(d.items(), key=lambda x: Specie(x[0]).Z)) # remove Ghostatoms if 'G' in ordered_atoms: del ordered_atoms['G'] self.comment = ''.join( ['{}{}'.format(k, v) for k, v in ordered_atoms.items()])
def test_all_speckle_gen_unitary(self): big_gen = self.ocu_gen.all_speckle_gen_unitary(4, Specie('B')) num_list = [1, 5, 9, 21] gen_list = [i for i in big_gen] for c, r_gen in zip(num_list, gen_list): r_length = len([i for i in r_gen]) self.assertEqual(r_length, c)
def test_get_cartesian(self): arr_lat = np.array([[3.0, 0, 0], [0, 2.0, 0.0], [0, 0, 1.0]]) positions = [[0.00000, 0.00000, 0.00000], [0.00000, 0.50000, 0.00000], [0.33333, 0.00000, 0.00000], [0.33333, 0.50000, 0.00000], [0.66666, 0.00000, 0.00000], [0.66666, 0.50000, 0.00000], [0.16666, 0.25000, 0.50000], [0.16666, 0.75000, 0.50000], [0.50000, 0.25000, 0.50000], [0.50000, 0.75000, 0.50000], [0.83333, 0.25000, 0.50000], [0.83333, 0.75000, 0.50000]] arr_positions = np.array(positions) arr_numbers = np.array([6] * 12) cell = GeneralCell(arr_lat, arr_positions, arr_numbers) cart_coor = cell.get_cartesian() cart_ans = np.array([[0., 0., 0.], [0., 1., 0.], [0.49998, 0.5, 0.5], [0.49998, 1.5, 0.5], [0.99999, 0., 0.], [0.99999, 1., 0.], [1.5, 0.5, 0.5], [1.5, 1.5, 0.5], [1.99998, 0., 0.], [1.99998, 1., 0.], [2.49999, 0.5, 0.5], [2.49999, 1.5, 0.5]]) self.assertTrue(np.allclose(cart_coor, cart_ans)) arr_numbers = np.array([6, 6, 6, 5, 6, 5, 6, 6, 6, 6, 6, 6]) cell = GeneralCell(arr_lat, arr_positions, arr_numbers) cart_coor = cell.get_cartesian(Specie('B')) cart_ans = np.array([[0.49998, 1.5, 0.5], [0.99999, 1., 0.]])
def setUp(self): g = GhostSpecie() b = Specie("B") self.sites = [[[b, b], [g, g]], [[b, g], [g, b]]] self.sg = SitesGrid(self.sites) self.allg0 = SitesGrid.sea(2, 2, 2, GhostSpecie()) self.allg = SitesGrid.sea(4, 2, 2, GhostSpecie())
def test_equal(self): s1 = Site((1, 2, 0), 'S') s2 = Site((1, 2, 0), Specie('S')) s3 = Site((1, 2, 0), 16) self.assertEqual(s1, s1) self.assertEqual(s1, s2) self.assertEqual(s1, s3)
def test_gen_2nodup_gen(self): init_gen = (i for i in [self.cell]) add_one_speckle_gen = self.ocu_gen.gen_add_one_speckle_unitary(init_gen, Specie("B")) # l = [s for s in add_one_speckle_gen] nodup_gen = self.ocu_gen.gen_2nodup_gen(add_one_speckle_gen) l = [s for s in nodup_gen] # print(l) self.assertEqual(len(l), 1)
def setUp(self): self.m = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] g = GhostSpecie() b = Specie("B") self.sites = [[[g, b], [g, g]], [[b, b], [b, g]]] self.arr = np.array([0, 5, 0, 0, 5, 5, 5, 0]).reshape([2, 2, 2]) self.sg = SitesGrid(self.sites) self.s = CStru(self.m, self.sg)
def __init__(self, gcell, zoom=1): self.lattice = gcell.lattice self.positions = gcell.positions self.numbers = gcell.numbers self.atoms_name_list = list( map(lambda x: Specie.to_name(x), list(self.numbers))) self.zoom = zoom
def test_equal(self): m_0 = [[1, 1, 1], [0, 0, 1], [1, 0, 0]] g = GhostSpecie() b = Specie("B") sites_0 = [[[b, b], [g, g]], [[b, g], [g, b]]] sg_0 = SitesGrid(sites_0) diff_m = CStru(m_0, self.sg) diff_s = CStru(self.m, sg_0) self.assertEqual(self.s, self.s) self.assertNotEqual(diff_m, self.s) self.assertNotEqual(diff_s, self.s)
def test_gen_nodup_exch(self): lattice = np.array([[5.0, 0.0000000000, 0.0000000000], [2.5, 4.330127, 0.0000000000], [0.0000000000, 0.0000000000, 20]]) positions = np.array([[0.666667, 0.000000, 0.5281], [0.000000, 0.333333, 0.5281], [0.333333, 0.666667, 0.5281], [0.000000, 0.000000, 0.6115], [0.500000, 0.000000, 0.6115], [0.000000, 0.500000, 0.6115], [0.500000, 0.500000, 0.6115]]) numbers = np.array([12, 12, 12, 28, 28, 28, 28]) gcell = GeneralCell(lattice, positions, numbers) ocu_gen = OccupyGenerator(gcell) nodup_gen = ocu_gen.gen_nodup_exch(Specie('Mg'), Specie('Ni'), 1) l = [i for i in nodup_gen] self.assertEqual(len(l), 3) ocu_gen = OccupyGenerator(gcell) nodup_gen = ocu_gen.gen_nodup_exch(Specie('Mg'), Specie('Ni'), 2) l = [i for i in nodup_gen] self.assertEqual(len(l), 4) ocu_gen = OccupyGenerator(gcell) nodup_gen = ocu_gen.gen_nodup_exch(Specie('Mg'), Specie('Ni'), 3) l = [i for i in nodup_gen] self.assertEqual(len(l), 2)
def __init__(self, numbers): self._lattice = np.array(_buckyball["lattice"]) numbers = np.array(numbers) # Sorting positions (x,y,z) init_positions = np.array(_buckyball["positions"]) init_index = self._get_new_id_seq(init_positions, numbers) self._positions = init_positions[init_index] self._atom_numbers = numbers self._spg_cell = (self._lattice, self._positions, self._atom_numbers) self._carbon = Specie("C") self._sym_perm = list(_perm_table)
def run(self): # Create directory contain POSCARs import random import string rd_suffix = ''.join( random.choices(string.ascii_uppercase + string.digits, k=5)) working_path = os.getcwd() out_dir = os.path.join( working_path, 'STRUCTURES_{0:}_{1:}'.format(self.comment, rd_suffix)) if not os.path.exists(out_dir): os.makedirs(out_dir) else: shutil.rmtree(out_dir) os.makedirs(out_dir) ogg = OccupyGenerator(self.cell) g = ogg.gen_nodup_of_ele(self.ele, self.n, self.speckle) # sym for getting degeneracy sym_perm = self.cell.get_symmetry_permutation() if self.tr is not None: tr = (Specie(self.tr[0]), self.tr[1]) applied_restriction = MinDistanceRestriction(tr) for n_count, c in enumerate(g): if self.mpr: if self.tr is not None: condition = c.is_primitive( ) and applied_restriction.is_satisfied(c) else: condition = c.is_primitive() else: if self.tr is not None: condition = applied_restriction.is_satisfied(c) else: condition = True if condition: if self.refined: c = c.get_refined_pcell() out = GeneralIO(c) f_suffix = ''.join( random.choices(string.ascii_uppercase + string.digits, k=4)) ofname = "STRUCTURE_{:}_D{:}D_{:}.{:}".format( c.comment, c.get_degeneracy(sym_perm), f_suffix, self.outmode) lastpath = os.path.join(out_dir, ofname) out.write_file(lastpath)
def run(self): # Create directory contain POSCARs import random import string rd_suffix = ''.join( random.choices(string.ascii_uppercase + string.digits, k=4)) working_path = os.getcwd() out_dir = os.path.join( working_path, 'STRUCTURES_{0:}_{1:}'.format(self.comment, rd_suffix)) if not os.path.exists(out_dir): os.makedirs(out_dir) else: shutil.rmtree(out_dir) os.makedirs(out_dir) ogg = OccupyGenerator(self.cell) gg = ogg.all_speckle_gen_of_ele(self.nmax, self.ele, self.speckle) if self.tr is not None: tr = (Specie(self.tr[0]), self.tr[1]) applied_restriction = MinDistanceRestriction(tr) for i, outer_gen in enumerate(gg): # print("Processing: {0:3}s substitue {1:2d}...".format(speckle, i+1)) for n_count, c in enumerate(outer_gen): if self.mpr: if self.tr is not None: condition = c.is_primitive( ) and applied_restriction.is_satisfied(c) else: condition = c.is_primitive() else: if self.tr is not None: condition = applied_restriction.is_satisfied(c) else: condition = True if condition: if self.refined: c = c.get_refined_pcell() out = GeneralIO(c) f_suffix = ''.join( random.choices(string.ascii_uppercase + string.digits, k=4)) ofname = "STRUCTURE_{:}_{:}.{:}".format( c.comment, f_suffix, self.outmode) lastpath = os.path.join(out_dir, ofname) out.write_file(lastpath)
def setUp(self): self.latt = np.array([[4.898979, 0.000000, 0.000000], [2.449490, 4.242641, 0.000000], [1.632993, -0.000000, 4.618802]]) self.pos = np.array([[0.208333, 0.333333, 0.375000], [0.375000, 0.000000, 0.875000], [0.541667, 0.666667, 0.375000], [0.708333, 0.333333, 0.875000], [0.875000, 0.000000, 0.375000], [0.000000, 0.000000, 0.000000], [0.166667, 0.666667, 0.500000], [0.333333, 0.333333, 0.000000], [0.500000, 0.000000, 0.500000], [0.666667, 0.666667, 0.000000], [0.833333, 0.333333, 0.500000], [0.041667, 0.666667, 0.875000]]) self.numbers = np.array( [16, 16, 16, 16, 55, 30, 30, 30, 30, 30, 30, 55]) self.modcell = ModifiedCell(self.latt, self.pos, self.numbers) ele = Specie('Zn') r = 2 self.nearZnClarifier = VerboseAtomRemoveClarifier( Specie('Cs'), r, Specie('Zn'))