def test_symmetrization(self): # Restricted to primitive_elemental materials due to the risk of # broken stoichiometry. For compound materials, use is_polar() # Get all slabs for P6/mmm Ti and Fm-3m Ag up to index of 2 all_Ti_slabs = generate_all_slabs( self.ti, 2, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, max_normal_search=2, symmetrize=True, ) all_Ag_fcc_slabs = generate_all_slabs( self.agfcc, 2, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, max_normal_search=2, symmetrize=True, ) all_slabs = [all_Ti_slabs, all_Ag_fcc_slabs] for i, slabs in enumerate(all_slabs): assymetric_count = 0 symmetric_count = 0 for i, slab in enumerate(slabs): sg = SpacegroupAnalyzer(slab) # Check if a slab is symmetric if not sg.is_laue(): assymetric_count += 1 else: symmetric_count += 1 # Check if slabs are all symmetric self.assertEqual(assymetric_count, 0) self.assertEqual(symmetric_count, len(slabs))
def from_bulk_and_miller(cls, structure, miller_index, min_slab_size=5.0, min_vacuum_size=10.0, max_normal_search=None, center_slab = True, selective_dynamics=False, undercoord_threshold = 0.09): """ This method constructs the adsorbate site finder from a bulk structure and a miller index, which allows the surface sites to be determined from the difference in bulk and slab coordination, as opposed to the height threshold. Args: structure (Structure): structure from which slab input to the ASF is constructed miller_index (3-tuple or list): miller index to be used min_slab_size (float): min slab size for slab generation min_vacuum_size (float): min vacuum size for slab generation max_normal_search (int): max normal search for slab generation center_slab (bool): whether to center slab in slab generation selective dynamics (bool): whether to assign surface sites to selective dynamics undercoord_threshold (float): threshold of "undercoordation" to use for the assignment of surface sites. Default is 0.1, for which surface sites will be designated if they are 10% less coordinated than their bulk counterpart """ # TODO: for some reason this works poorly with primitive cells vcf_bulk = VoronoiCoordFinder(structure) bulk_coords = [len(vcf_bulk.get_coordinated_sites(n)) for n in range(len(structure))] struct = structure.copy(site_properties = {'bulk_coordinations':bulk_coords}) slabs = generate_all_slabs(struct, max_index=max(miller_index), min_slab_size=min_slab_size, min_vacuum_size=min_vacuum_size, max_normal_search = max_normal_search, center_slab = center_slab) slab_dict = {slab.miller_index:slab for slab in slabs} if miller_index not in slab_dict: raise ValueError("Miller index not in slab dict") this_slab = slab_dict[miller_index] vcf_surface = VoronoiCoordFinder(this_slab, allow_pathological=True) surf_props = [] this_mi_vec = get_mi_vec(this_slab.miller_index) mi_mags = [np.dot(this_mi_vec, site.coords) for site in this_slab] average_mi_mag = np.average(mi_mags) for n, site in enumerate(this_slab): bulk_coord = this_slab.site_properties['bulk_coordinations'][n] slab_coord = len(vcf_surface.get_coordinated_sites(n)) mi_mag = np.dot(this_mi_vec, site.coords) undercoord = (bulk_coord - slab_coord)/bulk_coord if undercoord > undercoord_threshold and mi_mag > average_mi_mag: surf_props += ['surface'] else: surf_props += ['subsurface'] new_site_properties = {'surface_properties':surf_props} new_slab = this_slab.copy(site_properties=new_site_properties) return cls(new_slab, selective_dynamics)
def test_get_symmetric_sites(self): # Check to see if we get an equivalent site on one # surface if we add a new site to the other surface all_Ti_slabs = generate_all_slabs(self.ti, 2, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, max_normal_search=2, symmetrize=True) for slab in all_Ti_slabs: sorted_sites = sorted(slab, key=lambda site: site.frac_coords[2]) site = sorted_sites[-1] point = site.frac_coords point[2] = point[2] + 0.1 point2 = slab.get_symmetric_site(point) slab.append("O", point) slab.append("O", point2) # Check if slab is all symmetric sg = SpacegroupAnalyzer(slab) self.assertTrue(sg.is_laue())
def test_input_sets(self): # Test bulk bulk_set = MPSurfaceSet(self.struct_ir, bulk=True) self.assertFalse(bulk_set.auto_dipole) self.assertIsNone(bulk_set.incar.get('LDIPOL')) self.assertIsNone(bulk_set.incar.get('LVTOT')) # Test slab slab_set = MPSurfaceSet(self.slab_100) self.assertTrue(slab_set.auto_dipole) self.assertTrue(slab_set.incar.get('LDIPOL')) self.assertTrue(slab_set.incar.get('LVTOT')) banio3_slab = generate_all_slabs( PymatgenTest.get_structure('BaNiO3'), 1, 7.0, 20.0)[0] banio3_slab_set = MPSurfaceSet(banio3_slab) self.assertTrue(banio3_slab_set.incar['LDAU'], True) # Test adsorbates fe_ads = self.wf_1.fws[-1].tasks[-1]['additional_fields']['slab'].copy() fe_ads.replace_species({'H': 'O', "Ir": "Fe"}) fe_ads_set = MPSurfaceSet(fe_ads) self.assertFalse(fe_ads_set.incar['LDAU']) # Test interaction of adsorbates and LDAU banio3_ads = banio3_slab.copy() banio3_ads.add_adsorbate_atom([-1], 'O', 0.5) banio3_ads.add_site_property('surface_properties', ['surface'] * len( banio3_slab) + ['adsorbate']) banio3_ads_set = MPSurfaceSet(banio3_ads) self.assertTrue(banio3_ads_set.incar['LDAU']) banio3_ads_set_noldau = MPSurfaceSet( banio3_ads, user_incar_settings={'LDAU': False}) self.assertFalse(banio3_ads_set_noldau.incar['LDAU'])
def test_wf_functions(self): # Test slab trans params generator for slab in self.slabs: trans_params = get_slab_trans_params(slab) trans = SlabTransformation(**trans_params) new_slab = trans.apply_transformation(slab.oriented_unit_cell) self.assertTrue(np.allclose(new_slab.cart_coords, slab.cart_coords)) self.assertTrue(np.allclose(new_slab.lattice.matrix, slab.lattice.matrix)) # Try something a bit more complicated formulas = ['Si', 'Sn', 'SrTiO3', 'Li2O'] structs = [PymatgenTest.get_structure(s) for s in formulas] for struct in structs: slabs = generate_all_slabs(struct, max_index=2, min_slab_size=10, min_vacuum_size=20) for slab in slabs: trans_params = get_slab_trans_params(slab) trans = SlabTransformation(**trans_params) new_slab = trans.apply_transformation(slab.oriented_unit_cell) old_coords = np.around(slab.frac_coords, 10) % 1 new_coords = np.around(new_slab.frac_coords, 10) % 1 self.assertTrue(np.allclose(old_coords, new_coords)) self.assertTrue(np.allclose(new_slab.lattice.matrix, slab.lattice.matrix))
def test_as_dict(self): slabs = generate_all_slabs( self.ti, 1, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, ) slab = slabs[0] s = json.dumps(slab.as_dict()) d = json.loads(s) self.assertEqual(slab, Slab.from_dict(d)) # test initialising with a list scale_factor slab = Slab( self.zno55.lattice, self.zno55.species, self.zno55.frac_coords, self.zno55.miller_index, self.zno55.oriented_unit_cell, 0, self.zno55.scale_factor.tolist(), ) s = json.dumps(slab.as_dict()) d = json.loads(s) self.assertEqual(slab, Slab.from_dict(d))
def test_wf_functions(self): # Test slab trans params generator for slab in self.slabs: trans_params = get_slab_trans_params(slab) trans = SlabTransformation(**trans_params) new_slab = trans.apply_transformation(slab.oriented_unit_cell) self.assertTrue(np.allclose(new_slab.cart_coords, slab.cart_coords)) self.assertTrue( np.allclose(new_slab.lattice.matrix, slab.lattice.matrix)) # Try something a bit more complicated formulas = ['Si', 'Sn', 'SrTiO3', 'Li2O'] structs = [PymatgenTest.get_structure(s) for s in formulas] for struct in structs: slabs = generate_all_slabs(struct, max_index=2, min_slab_size=10, min_vacuum_size=20) for slab in slabs: trans_params = get_slab_trans_params(slab) trans = SlabTransformation(**trans_params) new_slab = trans.apply_transformation(slab.oriented_unit_cell) old_coords = np.around(slab.frac_coords, 10) % 1 new_coords = np.around(new_slab.frac_coords, 10) % 1 self.assertTrue(np.allclose(old_coords, new_coords)) self.assertTrue( np.allclose(new_slab.lattice.matrix, slab.lattice.matrix))
def test_input_sets(self): # Test bulk bulk_set = MPSurfaceSet(self.struct_ir, bulk=True) self.assertFalse(bulk_set.auto_dipole) self.assertIsNone(bulk_set.incar.get('LDIPOL')) self.assertIsNone(bulk_set.incar.get('LVTOT')) # Test slab slab_set = MPSurfaceSet(self.slab_100) self.assertTrue(slab_set.auto_dipole) self.assertTrue(slab_set.incar.get('LDIPOL')) self.assertTrue(slab_set.incar.get('LVTOT')) banio3_slab = generate_all_slabs(PymatgenTest.get_structure('BaNiO3'), 1, 7.0, 20.0)[0] banio3_slab_set = MPSurfaceSet(banio3_slab) self.assertTrue(banio3_slab_set.incar['LDAU'], True) # Test adsorbates fe_ads = self.wf_1.fws[-1].tasks[-1]['additional_fields']['slab'].copy( ) fe_ads.replace_species({'H': 'O', "Ir": "Fe"}) fe_ads_set = MPSurfaceSet(fe_ads) self.assertFalse(fe_ads_set.incar['LDAU']) # Test interaction of adsorbates and LDAU banio3_ads = banio3_slab.copy() banio3_ads.add_adsorbate_atom([-1], 'O', 0.5) banio3_ads.add_site_property('surface_properties', ['surface'] * len(banio3_slab) + ['adsorbate']) banio3_ads_set = MPSurfaceSet(banio3_ads) self.assertTrue(banio3_ads_set.incar['LDAU']) banio3_ads_set_noldau = MPSurfaceSet( banio3_ads, user_incar_settings={'LDAU': False}) self.assertFalse(banio3_ads_set_noldau.incar['LDAU'])
def test_nonstoichiometric_symmetrized_slab(self): # For the (111) halite slab, sometimes a nonstoichiometric # system is preferred over the stoichiometric Tasker 2. slabgen = SlabGenerator(self.MgO, (1, 1, 1), 10, 10, max_normal_search=1) slabs = slabgen.get_slabs(symmetrize=True) # We should end up with two terminations, one with # an Mg rich surface and another O rich surface self.assertEqual(len(slabs), 2) for slab in slabs: self.assertTrue(slab.is_symmetric()) # For a low symmetry primitive_elemental system such as # R-3m, there should be some nonsymmetric slabs # without using nonstoichiometric_symmetrized_slab slabs = generate_all_slabs(self.Dy, 1, 30, 30, center_slab=True, symmetrize=True) for s in slabs: self.assertTrue(s.is_symmetric()) self.assertGreater(len(s), len(self.Dy))
def proc_adsorb(cryst, mol, data): if data['method'] == 1: asf_slab = AdsorbateSiteFinder(cryst) ads_sites = asf_slab.find_adsorption_sites() ads_structs = asf_slab.generate_adsorption_structures( mol, repeat=data['repeat']) for i in range(len(ads_structs)): ads_struct = ads_structs[i] try: miller_str = [str(j) for j in cryst.miller_index] except: miller_str = ['adsorb'] filename = '_'.join(miller_str) + '-' + str(i) + '.vasp' ads_struct.to(filename=filename, fmt='POSCAR') else: slabs = generate_all_slabs(cryst, max_index=data['max_index'], min_slab_size=data['min_slab'], min_vacuum_size=data['min_vacum'], lll_reduce=True) for slab in slabs: asf_slab = AdsorbateSiteFinder(slab) ads_sites = asf_slab.find_adsorption_sites() ads_structs = asf_slab.generate_adsorption_structures( mol, repeat=data['repeat']) for i in range(len(ads_structs)): ads_struct = ads_structs[i] miller_str = [str(j) for j in slab.miller_index] filename = 'adsorb' + '_'.join(miller_str) + '-' + str( i) + '.vasp' ads_struct.to(filename=filename, fmt='POSCAR')
def test_generate_all_slabs(self): slabs = generate_all_slabs(self.cscl, 1, 10, 10) # Only three possible slabs, one each in (100), (110) and (111). self.assertEqual(len(slabs), 3) # make sure it generates reconstructions slabs = generate_all_slabs(self.Fe, 1, 10, 10, include_reconstructions=True) # Four possible slabs, (100), (110), (111) and the zigzag (100). self.assertEqual(len(slabs), 4) slabs = generate_all_slabs(self.cscl, 1, 10, 10, bonds={("Cs", "Cl"): 4}) # No slabs if we don't allow broken Cs-Cl self.assertEqual(len(slabs), 0) slabs = generate_all_slabs(self.cscl, 1, 10, 10, bonds={("Cs", "Cl"): 4}, max_broken_bonds=100) self.assertEqual(len(slabs), 3) slabs2 = generate_all_slabs(self.lifepo4, 1, 10, 10, bonds={("P", "O"): 3, ("Fe", "O"): 3}) self.assertEqual(len(slabs2), 0) # There should be only one possible stable surfaces, all of which are # in the (001) oriented unit cell slabs3 = generate_all_slabs(self.LiCoO2, 1, 10, 10, bonds={("Co", "O"): 3}) self.assertEqual(len(slabs3), 1) mill = (0, 0, 1) for s in slabs3: self.assertEqual(s.miller_index, mill) slabs1 = generate_all_slabs(self.lifepo4, 1, 10, 10, tol=0.1, bonds={("P", "O"): 3}) self.assertEqual(len(slabs1), 4) # Now we test this out for repair_broken_bonds() slabs1_repair = generate_all_slabs(self.lifepo4, 1, 10, 10, tol=0.1, bonds={("P", "O"): 3}, repair=True) self.assertGreater(len(slabs1_repair), len(slabs1)) # Lets see if there are no broken PO4 polyhedrons miller_list = get_symmetrically_distinct_miller_indices(self.lifepo4, 1) all_miller_list = [] for slab in slabs1_repair: hkl = tuple(slab.miller_index) if hkl not in all_miller_list: all_miller_list.append(hkl) broken = [] for site in slab: if site.species_string == "P": neighbors = slab.get_neighbors(site, 3) cn = 0 for nn in neighbors: cn += 1 if nn[0].species_string == "O" else 0 broken.append(cn != 4) self.assertFalse(any(broken)) # check if we were able to produce at least one # termination for each distinct Miller _index self.assertEqual(len(miller_list), len(all_miller_list))
def generate_all_slab(structs,fnames,max_index,min_slab_size,min_vac_size): for struct,fname in zip(structs,fnames): slabs=generate_all_slabs(struct,max_index=max_index,min_slab_size=min_slab_size,min_vacuum_size=min_vac_size,lll_reduce=True) for slab_struct in slabs: slab_struct.sort() miller_str=[str(i) for i in slab_struct.miller_index] filename='_'.join(miller_str)+"_"+fname+'.vasp' slab_struct.to(filename=filename,fmt='POSCAR')
def test_as_dict(self): slabs = generate_all_slabs(self.ti, 1, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True) slab = slabs[0] s = json.dumps(slab.as_dict()) d = json.loads(s) self.assertEqual(slab, Slab.from_dict(d))
def setUp(self): super(TestAdsorptionWorkflow, self).setUp() self.struct_ir = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.875728), ["Ir"], [[0, 0, 0]]) sgp = {"max_index": 1, "min_slab_size": 7.0, "min_vacuum_size": 20.0} slabs = generate_all_slabs(self.struct_ir, **sgp) slabs = [slab for slab in slabs if slab.miller_index==(1, 0, 0)] sgp.pop("max_index") self.wf_1 = get_wf_surface(slabs, [Molecule("H", [[0, 0, 0]])], self.struct_ir, sgp, db_file=os.path.join(db_dir, "db.json"))
def setUp(self): self.structure = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.5), ["Ni"], [[0, 0, 0]]) slabs = generate_all_slabs(self.structure, max_index=2, min_slab_size=6.0, min_vacuum_size=15.0, max_normal_search=1, center_slab=True) self.slab_dict = {''.join([str(i) for i in slab.miller_index]): slab for slab in slabs} self.asf_211 = AdsorbateSiteFinder(self.slab_dict["211"]) self.asf_100 = AdsorbateSiteFinder(self.slab_dict["100"]) self.asf_111 = AdsorbateSiteFinder(self.slab_dict["111"]) self.asf_110 = AdsorbateSiteFinder(self.slab_dict["110"])
def setUp(self): super(TestAdsorptionWorkflow, self).setUp() self.struct_ir = Structure.from_spacegroup( "Fm-3m", Lattice.cubic(3.875728), ["Ir"], [[0, 0, 0]]) sgp = {"max_index": 1, "min_slab_size": 7.0, "min_vacuum_size": 20.0} self.slabs = generate_all_slabs(self.struct_ir, **sgp) self.slab_100 = [slab for slab in self.slabs if slab.miller_index==(1, 0, 0)][0] self.wf_1 = get_wf_slab(self.slab_100, True, [Molecule("H", [[0, 0, 0]])], db_file=os.path.join(db_dir, "db.json"))
def test_generate_all_slabs(self): slabs = generate_all_slabs(self.cscl, 1, 10, 10) # Only three possible slabs, one each in (100), (110) and (111). self.assertEqual(len(slabs), 3) slabs = generate_all_slabs(self.cscl, 1, 10, 10, bonds={("Cs", "Cl"): 4}) # No slabs if we don't allow broken Cs-Cl self.assertEqual(len(slabs), 0) slabs = generate_all_slabs(self.cscl, 1, 10, 10, bonds={("Cs", "Cl"): 4}, max_broken_bonds=100) self.assertEqual(len(slabs), 3) slabs1 = generate_all_slabs(self.lifepo4, 1, 10, 10, tol=0.1, bonds={("P", "O"): 3}) self.assertEqual(len(slabs1), 4) slabs2 = generate_all_slabs(self.lifepo4, 1, 10, 10, bonds={("P", "O"): 3, ("Fe", "O"): 3}) self.assertEqual(len(slabs2), 0) # There should be only one possible stable surfaces, all of which are # in the (001) oriented unit cell slabs3 = generate_all_slabs(self.LiCoO2, 1, 10, 10, bonds={("Co", "O"): 3}) self.assertEqual(len(slabs3), 1) mill = (0, 0, 1) for s in slabs3: self.assertEqual(s.miller_index, mill)
def test_symmetrization(self): # Restricted to primitive_elemental materials due to the risk of # broken stoichiometry. For compound materials, use is_polar() # Get all slabs for P6/mmm Ti and Fm-3m Ag up to index of 2 all_Ti_slabs = generate_all_slabs(self.ti, 2, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, max_normal_search=2, symmetrize=True) all_Ag_fcc_slabs = generate_all_slabs(self.agfcc, 2, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, max_normal_search=2, symmetrize=True) all_slabs = [all_Ti_slabs, all_Ag_fcc_slabs] for i, slabs in enumerate(all_slabs): assymetric_count = 0 symmetric_count = 0 for i, slab in enumerate(slabs): sg = SpacegroupAnalyzer(slab) # Check if a slab is symmetric if not sg.is_laue(): assymetric_count += 1 else: symmetric_count += 1 # Check if slabs are all symmetric self.assertEqual(assymetric_count, 0) self.assertEqual(symmetric_count, len(slabs))
def get_wfs_all_slabs(bulk_structure, include_bulk_opt=False, adsorbates=None, max_index=1, slab_gen_params=None, ads_structures_params=None, ads_site_finder_params=None, vasp_cmd="vasp", db_file=None, add_molecules_in_box=False, user_incar_settings=None): """ Convenience constructor that allows a user to construct a workflow that finds all adsorption configurations (or slabs) for a given max miller index. Args: bulk_structure (Structure): bulk structure from which to construct slabs include_bulk_opt (bool): whether to include bulk optimization of oriented unit cells adsorbates ([Molecule]): adsorbates to place on surfaces max_index (int): max miller index slab_gen_params (dict): dictionary of kwargs for generate_all_slabs ads_structures_params (dict): dictionary of kwargs for generating of adsorption structures via AdsorptionSiteFinder vasp_cmd (str): vasp command db_file (str): location of db file add_molecules_in_box (bool): whether to add molecules in a box for the entire workflow Returns: list of slab-specific Workflows """ # TODO: these could be more well-thought out defaults sgp = slab_gen_params or {"min_slab_size": 7.0, "min_vacuum_size": 20.0} slabs = generate_all_slabs(bulk_structure, max_index=max_index, **sgp) wfs = [] for slab in slabs: slab_wf = get_wf_slab(slab, include_bulk_opt, adsorbates, ads_structures_params, ads_site_finder_params, vasp_cmd, db_file, user_incar_settings=user_incar_settings) wfs.append(slab_wf) if add_molecules_in_box: wfs.append( get_wf_molecules(adsorbates, db_file=db_file, vasp_cmd=vasp_cmd)) return wfs
def test_oriented_unit_cell(self): # Check to see if we get the fully reduced oriented unit # cell. This will also ensure that the constrain_latt # parameter for get_primitive_structure is working properly def surface_area(s): m = s.lattice.matrix return np.linalg.norm(np.cross(m[0], m[1])) all_slabs = generate_all_slabs(self.agfcc, 3, 10, 10, max_normal_search=3) for slab in all_slabs: ouc = slab.oriented_unit_cell self.assertAlmostEqual(surface_area(slab), surface_area(ouc)) self.assertGreaterEqual(len(slab), len(ouc))
def generate_all_slab(in_str): tmp_list = in_str.split('|') max_index = int(tmp_list[0]) min_slab_size = float(tmp_list[1]) min_vac_size = float(tmp_list[2]) slabs = generate_all_slabs(struct, max_index=max_index, min_slab_size=min_slab_size, min_vacuum_size=min_vac_size, lll_reduce=True) for slab_struct in slabs: slab_struct.sort() miller_str = [str(i) for i in slab_struct.miller_index] filename = '_'.join(miller_str) + '.vasp' slab_struct.to(filename=filename, fmt='POSCAR')
def test_oriented_unit_cell(self): # Check to see if we get the fully reduced oriented unit # cell. This will also ensure that the constrain_latt # parameter for get_primitive_structure is working properly def surface_area(s): m = s.lattice.matrix return np.linalg.norm(np.cross(m[0], m[1])) all_slabs = generate_all_slabs(self.agfcc, 2, 10, 10, max_normal_search=3) for slab in all_slabs: ouc = slab.oriented_unit_cell self.assertAlmostEqual(surface_area(slab), surface_area(ouc)) self.assertGreaterEqual(len(slab), len(ouc))
def setUp(self): super().setUp() self.struct_ir = Structure.from_spacegroup( "Fm-3m", Lattice.cubic(3.875728), ["Ir"], [[0, 0, 0]] ) sgp = {"max_index": 1, "min_slab_size": 7.0, "min_vacuum_size": 20.0} self.slabs = generate_all_slabs(self.struct_ir, **sgp) self.slab_100 = [slab for slab in self.slabs if slab.miller_index == (1, 0, 0)][ 0 ] self.wf_1 = get_wf_slab( self.slab_100, True, [Molecule("H", [[0, 0, 0]])], db_file=os.path.join(db_dir, "db.json"), )
def setUp(self): self.structure = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.5), ["Ni"], [[0, 0, 0]]) slabs = generate_all_slabs(self.structure, max_index=2, min_slab_size=6.0, min_vacuum_size=15.0, max_normal_search=1, center_slab=True) self.slab_dict = { ''.join([str(i) for i in slab.miller_index]): slab for slab in slabs } self.asf_211 = AdsorbateSiteFinder(self.slab_dict["211"]) self.asf_100 = AdsorbateSiteFinder(self.slab_dict["100"]) self.asf_111 = AdsorbateSiteFinder(self.slab_dict["111"]) self.asf_110 = AdsorbateSiteFinder(self.slab_dict["110"])
def __init__(self, struct, plane=(1, 0, 0), slab_depth=4, vacuum_size=15.0, max_normal_search=5, symmetrize=True, cut=True): if cut == True: mi = max(plane) slabs = generate_all_slabs(struct, min_slab_size=slab_depth, min_vacuum_size=vacuum_size, max_index=mi, in_unit_planes=True, center_slab=True, symmetrize=symmetrize, max_normal_search=max_normal_search) slab = [slab for slab in slabs if slab.miller_index == plane][0] ase_atoms = AseAtomsAdaptor.get_atoms(slab) self.blank_slab_pym = slab self.blank_slab_ase = ase_atoms self.minimal_unit_cell = ase_atoms.get_cell().T self.duplications = (1, 1, 1) self.plane = plane else: slab = struct ase_atoms = AseAtomsAdaptor.get_atoms(slab) self.blank_slab_pym = slab self.blank_slab_ase = ase_atoms self.minimal_unit_cell = ase_atoms.get_cell().T self.duplications = (1, 1, 1) self.plane = plane
def enumerate_surfaces(self, max_index, slab_depth, vacuum_size, plane='all', replicate=(1, 1, 1), max_normal_search=5, symmetrize=True, tol=0.1): surface_dict = {} max_index = int(max_index) slabs = generate_all_slabs(self.struct, min_slab_size=slab_depth, min_vacuum_size=vacuum_size, max_index=max_index, in_unit_planes=True, center_slab=True, symmetrize=symmetrize, max_normal_search=max_normal_search, tol=tol) print 'Surfaces enumerated.' if plane != 'all': slabs = [slab for slab in slabs if slab.miller_index == plane] count = 0 for slab in slabs: count += 1 r1, r2, r3 = replicate P = np.array([[r1, 0, 0], [0, r2, 0], [0, 0, r3]]) ase_slab = AseAtomsAdaptor.get_atoms(slab) ase_slab = make_supercell(ase_slab, P) formula = ase_slab.get_chemical_formula() plane = slab.miller_index plane_string = ''.join(map(str, plane)) surface_dict[formula + '_' + plane_string + '_' + str(count)] = ase_slab self.surface_dict = surface_dict
def slab_enumeration(bulk_structure, bulk): all_slabs = generate_all_slabs(bulk_structure, 2, 10, 20, bonds=None, tol=0.1, ftol=0.1, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, max_normal_search=None, symmetrize=False, repair=False, include_reconstructions=False, in_unit_planes=False) return [{ 'slab': slab, 'bulk_structure': bulk_structure, 'bulk': bulk } for slab in all_slabs]
def get_wfs_all_slabs(bulk_structure, include_bulk_opt=False, adsorbates=None, max_index=1, slab_gen_params=None, ads_structures_params=None, vasp_cmd="vasp", db_file=None, add_molecules_in_box=False): """ Convenience constructor that allows a user to construct a workflow that finds all adsorption configurations (or slabs) for a given max miller index. Args: bulk_structure (Structure): bulk structure from which to construct slabs include_bulk_opt (bool): whether to include bulk optimization of oriented unit cells adsorbates ([Molecule]): adsorbates to place on surfaces max_index (int): max miller index slab_gen_params (dict): dictionary of kwargs for generate_all_slabs ads_structures_params (dict): dictionary of kwargs for generating of adsorption structures via AdsorptionSiteFinder vasp_cmd (str): vasp command db_file (str): location of db file add_molecules_in_box (bool): whether to add molecules in a box for the entire workflow Returns: list of slab-specific Workflows """ # TODO: these could be more well-thought out defaults sgp = slab_gen_params or {"min_slab_size": 7.0, "min_vacuum_size": 20.0} slabs = generate_all_slabs(bulk_structure, max_index=max_index, **sgp) wfs = [] for slab in slabs: slab_wf = get_wf_slab(slab, include_bulk_opt, adsorbates, ads_structures_params, vasp_cmd, db_file) wfs.append(slab_wf) if add_molecules_in_box: wfs.append(get_wf_molecules(adsorbates, db_file=db_file, vasp_cmd=vasp_cmd)) return wfs
def get_wf_surface_all_slabs(bulk_structure, molecules, max_index=1, slab_gen_params=None, **kwargs): """ Convenience constructor that allows a user to construct a workflow that finds all adsorption configurations (or slabs) for a given max miller index. Args: bulk_structure (Structure): bulk structure from which to construct slabs molecules (list of Molecules): adsorbates to place on surfaces max_index (int): max miller index slab_gen_params (dict): dictionary of kwargs for generate_all_slabs Returns: Workflow """ sgp = slab_gen_params or {"min_slab_size": 7.0, "min_vacuum_size": 20.0} slabs = generate_all_slabs(bulk_structure, max_index=max_index, **sgp) return get_wf_surface(slabs, molecules, bulk_structure, sgp, **kwargs)
def create_all_slabs_buggy(initial_structure, miller_index, min_slab_size_ang, min_vacuum_size=0, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=False, max_normal_search=None, symmetrize=False): #, reorient_lattice=True): """ wraps the pymatgen function generate_all_slabs with some useful extras returns a dictionary of structures """ aiida_strucs = {} pymat_struc = initial_structure.get_pymatgen_structure() # currently the pymatgen method is buggy... no coordinates in x,y.... all_slabs = generate_all_slabs( pymat_struc, miller_index, min_slab_size_ang, min_vacuum_size, bonds=bonds, tol=tol, max_broken_bonds=max_broken_bonds, lll_reduce=lll_reduce, center_slab=center_slab, primitive=primitive, max_normal_search=max_normal_search, symmetrize=symmetrize) #, reorient_lattice=reorient_lattice) for slab in all_slabs: print slab #slab2 = #slab.get_orthogonal_c_slab() film_struc = StructureData(pymatgen_structure=slab2) film_struc.pbc = (True, True, False) aiida_strucs[slab.miller_index] = film_struc return aiida_strucs
def test_get_symmetric_sites(self): # Check to see if we get an equivalent site on one # surface if we add a new site to the other surface all_Ti_slabs = generate_all_slabs(self.ti, 2, 10, 10, bonds=None, tol=1e-3, max_broken_bonds=0, lll_reduce=False, center_slab=False, primitive=True, max_normal_search=2, symmetrize=True) for slab in all_Ti_slabs: sorted_sites = sorted(slab, key=lambda site: site.frac_coords[2]) site = sorted_sites[-1] point = np.array(site.frac_coords) point[2] = point[2] + 0.1 point2 = slab.get_symmetric_site(point) slab.append("O", point) slab.append("O", point2) # Check if slab is all symmetric sg = SpacegroupAnalyzer(slab) self.assertTrue(sg.is_laue())
def test_input_sets(self): # Test bulk bulk_set = MPSurfaceSet(self.struct_ir, bulk=True) self.assertFalse(bulk_set.auto_dipole) self.assertIsNone(bulk_set.incar.get("LDIPOL")) self.assertIsNone(bulk_set.incar.get("LVTOT")) # Test slab slab_set = MPSurfaceSet(self.slab_100) self.assertTrue(slab_set.auto_dipole) self.assertTrue(slab_set.incar.get("LDIPOL")) self.assertTrue(slab_set.incar.get("LVTOT")) banio3_slab = generate_all_slabs( PymatgenTest.get_structure("BaNiO3"), 1, 7.0, 20.0 )[0] banio3_slab_set = MPSurfaceSet(banio3_slab) self.assertTrue(banio3_slab_set.incar["LDAU"], True) # Test adsorbates fe_ads = self.wf_1.fws[-1].tasks[-1]["additional_fields"]["slab"].copy() fe_ads.replace_species({"H": "O", "Ir": "Fe"}) fe_ads_set = MPSurfaceSet(fe_ads) self.assertFalse(fe_ads_set.incar["LDAU"]) # Test interaction of adsorbates and LDAU banio3_ads = banio3_slab.copy() banio3_ads.add_adsorbate_atom([-1], "O", 0.5) banio3_ads.add_site_property( "surface_properties", ["surface"] * len(banio3_slab) + ["adsorbate"] ) banio3_ads_set = MPSurfaceSet(banio3_ads) self.assertTrue(banio3_ads_set.incar["LDAU"]) banio3_ads_set_noldau = MPSurfaceSet( banio3_ads, user_incar_settings={"LDAU": False} ) self.assertFalse(banio3_ads_set_noldau.incar["LDAU"])
def make_lammps(jdata, conf_dir, max_miller=2, static=False, relax_box=False, task_type='wrong-task'): kspacing = jdata['vasp_params']['kspacing'] fp_params = jdata['lammps_params'] model_dir = fp_params['model_dir'] type_map = fp_params['type_map'] model_dir = os.path.abspath(model_dir) model_name = fp_params['model_name'] if not model_name and task_type == 'deepmd': models = glob.glob(os.path.join(model_dir, '*pb')) model_name = [os.path.basename(ii) for ii in models] assert len(model_name) > 0, "No deepmd model in the model_dir" else: models = [os.path.join(model_dir, ii) for ii in model_name] model_param = { 'model_name': fp_params['model_name'], 'param_type': fp_params['model_param_type'] } ntypes = len(type_map) min_slab_size = jdata['min_slab_size'] min_vacuum_size = jdata['min_vacuum_size'] # get equi poscar # conf_path = os.path.abspath(conf_dir) # conf_poscar = os.path.join(conf_path, 'POSCAR') equi_path = re.sub('confs', global_equi_name, conf_dir) equi_path = os.path.join(equi_path, 'vasp-k%.2f' % kspacing) equi_path = os.path.abspath(equi_path) equi_contcar = os.path.join(equi_path, 'CONTCAR') assert os.path.exists( equi_contcar), "Please compute the equilibrium state using vasp first" task_path = re.sub('confs', global_task_name, conf_dir) task_path = os.path.abspath(task_path) if static: task_path = os.path.join(task_path, task_type + '-static') else: task_path = os.path.join(task_path, task_type) os.makedirs(task_path, exist_ok=True) cwd = os.getcwd() os.chdir(task_path) if os.path.isfile('POSCAR'): os.remove('POSCAR') os.symlink(os.path.relpath(equi_contcar), 'POSCAR') os.chdir(cwd) task_poscar = os.path.join(task_path, 'POSCAR') # gen strcture ss = Structure.from_file(task_poscar) # gen slabs all_slabs = generate_all_slabs(ss, max_miller, min_slab_size, min_vacuum_size) # make lammps.in if task_type == 'deepmd': if static: fc = lammps.make_lammps_eval('conf.lmp', ntypes, lammps.inter_deepmd, model_name) else: fc = lammps.make_lammps_equi('conf.lmp', ntypes, lammps.inter_deepmd, model_name, change_box=relax_box) elif task_type == 'meam': if static: fc = lammps.make_lammps_eval('conf.lmp', ntypes, lammps.inter_meam, model_param) else: fc = lammps.make_lammps_equi('conf.lmp', ntypes, lammps.inter_meam, model_param, change_box=relax_box) f_lammps_in = os.path.join(task_path, 'lammps.in') with open(f_lammps_in, 'w') as fp: fp.write(fc) cwd = os.getcwd() if task_type == 'deepmd': os.chdir(task_path) for ii in model_name: if os.path.exists(ii): os.remove(ii) for (ii, jj) in zip(models, model_name): os.symlink(os.path.relpath(ii), jj) share_models = glob.glob(os.path.join(task_path, '*pb')) else: share_models = models for ii in range(len(all_slabs)): slab = all_slabs[ii] miller_str = "m%d.%d.%dm" % ( slab.miller_index[0], slab.miller_index[1], slab.miller_index[2]) # make dir struct_path = os.path.join(task_path, 'struct-%03d-%s' % (ii, miller_str)) os.makedirs(struct_path, exist_ok=True) os.chdir(struct_path) for jj in ['conf.lmp', 'lammps.in'] + model_name: if os.path.isfile(jj): os.remove(jj) print("# %03d generate " % ii, struct_path, " \t %d atoms" % len(slab.sites)) # make conf slab.to('POSCAR', 'POSCAR') vasp.regulate_poscar('POSCAR', 'POSCAR') lammps.cvt_lammps_conf('POSCAR', 'conf.lmp') ptypes = vasp.get_poscar_types('POSCAR') lammps.apply_type_map('conf.lmp', type_map, ptypes) # record miller np.savetxt('miller.out', slab.miller_index, fmt='%d') # link lammps.in os.symlink(os.path.relpath(f_lammps_in), 'lammps.in') # link models for (ii, jj) in zip(share_models, model_name): os.symlink(os.path.relpath(ii), jj) cwd = os.getcwd()
def from_bulk_and_miller(cls, structure, miller_index, min_slab_size=8.0, min_vacuum_size=10.0, max_normal_search=None, center_slab=True, selective_dynamics=False, undercoord_threshold=0.09): """ This method constructs the adsorbate site finder from a bulk structure and a miller index, which allows the surface sites to be determined from the difference in bulk and slab coordination, as opposed to the height threshold. Args: structure (Structure): structure from which slab input to the ASF is constructed miller_index (3-tuple or list): miller index to be used min_slab_size (float): min slab size for slab generation min_vacuum_size (float): min vacuum size for slab generation max_normal_search (int): max normal search for slab generation center_slab (bool): whether to center slab in slab generation selective dynamics (bool): whether to assign surface sites to selective dynamics undercoord_threshold (float): threshold of "undercoordation" to use for the assignment of surface sites. Default is 0.1, for which surface sites will be designated if they are 10% less coordinated than their bulk counterpart """ # TODO: for some reason this works poorly with primitive cells # may want to switch the coordination algorithm eventually vnn_bulk = VoronoiNN(tol=0.05) bulk_coords = [ len(vnn_bulk.get_nn(structure, n)) for n in range(len(structure)) ] struct = structure.copy( site_properties={'bulk_coordinations': bulk_coords}) slabs = generate_all_slabs(struct, max_index=max(miller_index), min_slab_size=min_slab_size, min_vacuum_size=min_vacuum_size, max_normal_search=max_normal_search, center_slab=center_slab) slab_dict = {slab.miller_index: slab for slab in slabs} if miller_index not in slab_dict: raise ValueError("Miller index not in slab dict") this_slab = slab_dict[miller_index] vnn_surface = VoronoiNN(tol=0.05, allow_pathological=True) surf_props, undercoords = [], [] this_mi_vec = get_mi_vec(this_slab) mi_mags = [np.dot(this_mi_vec, site.coords) for site in this_slab] average_mi_mag = np.average(mi_mags) for n, site in enumerate(this_slab): bulk_coord = this_slab.site_properties['bulk_coordinations'][n] slab_coord = len(vnn_surface.get_nn(this_slab, n)) mi_mag = np.dot(this_mi_vec, site.coords) undercoord = (bulk_coord - slab_coord) / bulk_coord undercoords += [undercoord] if undercoord > undercoord_threshold and mi_mag > average_mi_mag: surf_props += ['surface'] else: surf_props += ['subsurface'] new_site_properties = { 'surface_properties': surf_props, 'undercoords': undercoords } new_slab = this_slab.copy(site_properties=new_site_properties) return cls(new_slab, selective_dynamics)
def get_all_slabs(structure=None, max_index=None, thicknesses=None, vacuums=None, make_fols=False, make_input_files=False, max_size=500, ox_states=None, is_symmetric=True, lll_reduce=True, center_slab=True, config_dict=PBEsol_slab_config, potcar_functional='PBE', update_incar=None, update_potcar=None, update_kpoints=None, **kwargs): """ Generates all unique slabs with specified maximum Miller index, minimum slab and vacuum thicknesses. It includes all combinations for multiple zero dipole symmetric terminations for the same Miller index. Note that using this method of slab generation will results in different slab index numbers as in the `get_one_hkl_slabs` - the slabs identified are the same, the index varies based on the position in the list of generated slabs. Args: structure: filename of structure file, takes all pymatgen-supported formats. max_index (int): maximum Miller index to be considered thicknesses (list): minimum size of the slab in angstroms. vacuums (list): minimum size of the vacuum in angstroms. make_fols (bool): makes folders containing POSCARs; default=False make_input_files (bool): makes INCAR, POTCAR and KPOINTS files in each of the folders; if True but make_fols is False it will make the folders regardless; default=False. max_size (int): the maximum number of atoms in the slab for the size warning; default=500. ox_states (list or dict): add oxidation states either by sites i.e. [3, 2, 2, 1, -2, -2, -2, -2] or by element i.e. {'Fe': 3, 'O':-2}; default=None which adds oxidation states by guess is_symmetric (bool): whether or not the slabs cleaved should have inversion symmetry. Needs to be False for slabs cleaved from a non-centrosymmetric bulk; default=True lll_reduce (bool): whether or not the slabs will be orthogonalized; default=True. center_slab (bool): position of the slab in the unit cell, if True the slab is centered with equal amounts of vacuum above and below; default=True config_dict (dict): specifies the dictionary used for generation of input files; default=PBEsol_slab_config potcar_functional (str): The functional used for POTCAR generation; default='PBE' update_incar (dict): overrides default INCAR settings; default=None update_kpoints (dict or kpoints object): overrides default kpoints settings, if supplied as dict should be as {'reciprocal_density': 100}; default=None update_potcar (dict): overrides default POTCAR settings; default=None Returns: POSCAR_hkl_slab_vac_index.vasp or hkl/slab_vac_index folders with POSCARs or hkl/slab_vac_index with all input files """ # Check all neccessary input parameters are present if not any([structure, max_index, thicknesses, vacuums]): raise ValueError('One or more of the required arguments (structure, ' 'max_index, thicknesses, vacuums) were not supplied.') # Import bulk relaxed structure, add oxidation states for slab dipole # calculations struc = Structure.from_file(structure) bulk_name = struc.formula.replace(" ", "") struc = oxidation_states(struc, ox_states=ox_states) # Iterate through vacuums and thicknessses provisional = [] for vacuum in vacuums: for thickness in thicknesses: all_slabs = generate_all_slabs(struc, max_index=max_index, min_slab_size=thickness, min_vacuum_size=vacuum, lll_reduce=lll_reduce, center_slab=center_slab, **kwargs) for i, slab in enumerate(all_slabs): # Get all the zero-dipole slabs with inversion symmetry if is_symmetric: if (slab.is_polar() == False) and (slab.is_symmetric() == True): provisional.append({ 'hkl': ''.join(map(str, slab.miller_index)), 'slab_t': thickness, 'vac_t': vacuum, 's_index': i, 'slab': slab }) # Get all the zero-dipole slabs wihtout inversion symmetry else: if not slab.is_polar(): provisional.append({ 'hkl': ''.join(map(str, slab.miller_index)), 'slab_t': thickness, 'vac_t': vacuum, 's_index': i, 'slab': slab }) # Iterate though provisional slabs to extract the unique slabs unique_list, unique_list_of_dicts, repeat, large = ([] for i in range(4)) for slab in provisional: if slab['slab'] not in unique_list: unique_list.append(slab['slab']) unique_list_of_dicts.append(slab) # For large slab size warning atoms = len(slab['slab'].atomic_numbers) if atoms > max_size: large.append('{}_{}_{}_{}'.format(slab['hkl'], slab['slab_t'], slab['vac_t'], slab['s_index'])) # For repeat slabs warning else: repeat.append('{}_{}_{}_{}'.format(slab['hkl'], slab['slab_t'], slab['vac_t'], slab['s_index'])) # Warnings for large and repeated slabs if repeat: warnings.formatwarning = custom_formatwarning warnings.warn( 'Not all combinations of hkl or slab/vac thicknesses ' 'were generated because of repeat structures. ' 'The repeat slabs are: ' + ', '.join(map(str, repeat))) if large: warnings.formatwarning = custom_formatwarning warnings.warn('Some generated slabs exceed the max size specified.' ' Slabs that exceed the max size are: ' + ', '.join(map(str, large))) # Makes folders hkl/slab_vac_index, if only make_input_files is true the # folders will also be made automatically. if make_fols or make_input_files: for slab in unique_list_of_dicts: os.makedirs(os.path.join( os.getcwd(), r'{}/{}_{}_{}'.format(slab['hkl'], slab['slab_t'], slab['vac_t'], slab['s_index'])), exist_ok=True) # Makes all VASP input files (KPOINTS, POTCAR, INCAR) based on the # config dictionary if make_input_files: vis = DictSet(structure=slab['slab'], config_dict=config_dict, potcar_functional=potcar_functional, user_incar_settings=update_incar, user_potcar_settings=update_potcar, user_kpoints_settings=update_kpoints, **kwargs) vis.write_input( os.path.join( os.getcwd(), r'{}/{}_{}_{}'.format(slab['hkl'], slab['slab_t'], slab['vac_t'], slab['s_index']))) # Makes the folders with POSCARs else: slab['slab'].to(fmt='poscar', filename=r'{}/{}_{}_{}/POSCAR'.format( slab['hkl'], slab['slab_t'], slab['vac_t'], slab['s_index'])) # Omits folders, makes POSCAR_hkl_slab_vac_index files in folder bulk_name else: os.makedirs(os.path.join(os.getcwd(), r'{}'.format(bulk_name)), exist_ok=True) for slab in unique_list_of_dicts: slab['slab'].to(fmt='poscar', filename='{}/POSCAR_{}_{}_{}_{}.vasp'.format( bulk_name, slab['hkl'], slab['slab_t'], slab['vac_t'], slab['s_index']))
# terminated in two different locations along the vector of the Miller index. For a # fcc structure such as Ni however, there should only be one way to cut a (111) slab. all_slabs = slabgen.get_slabs() print("The Ni(111) slab only has %s termination." % (len(all_slabs))) #len返回容器中的项目数 lattice = Lattice.cubic(5.46873) Si = Structure(lattice, ["Si", "Si", "Si", "Si", "Si", "Si", "Si", "Si"], [[0.00000, 0.00000, 0.50000], [0.75000, 0.75000, 0.75000], [0.00000, 0.50000, 0.00000], [0.75000, 0.25000, 0.25000], [0.50000, 0.00000, 0.00000], [0.25000, 0.75000, 0.25000], [0.50000, 0.50000, 0.50000], [0.25000, 0.25000, 0.75000]]) slabgen = SlabGenerator(Si, (1, 1, 1), 10, 10) print("Notice now there are actually now %s terminations that can be \ generated in the (111) direction for diamond Si" % (len(slabgen.get_slabs()))) all_slabs = generate_all_slabs(Si, 3, 10, 10) print("%s unique slab structures have been found for a max Miller index of 3" % (len(all_slabs))) # What are the Miller indices of these slabs?(晶面的米勒指数是用来表达晶面在晶体上之方向的一组无公约数的整数,他们的具体数值等于该晶面在结晶轴上所截截距的倒数比) for slab in all_slabs: print(slab.miller_index) print( "Notice some Miller indices are repeated. Again, this is due to there being more than one termination" ) # Now let's assume that we then calculated the surface energies for these slabs # Surface energy values in J/m^2 surface_energies_Ni = { (3, 2, 0): 2.3869, (1, 1, 0): 2.2862, (3, 1, 0): 2.3964,
def make_confs(self, path_to_work, path_to_equi, refine=False): path_to_work = os.path.abspath(path_to_work) if os.path.exists(path_to_work): dlog.warning('%s already exists' % path_to_work) else: os.makedirs(path_to_work) path_to_equi = os.path.abspath(path_to_equi) if 'start_confs_path' in self.parameter and os.path.exists(self.parameter['start_confs_path']): init_path_list = glob.glob(os.path.join(self.parameter['start_confs_path'], '*')) struct_init_name_list = [] for ii in init_path_list: struct_init_name_list.append(ii.split('/')[-1]) struct_output_name = path_to_work.split('/')[-2] assert struct_output_name in struct_init_name_list path_to_equi = os.path.abspath(os.path.join(self.parameter['start_confs_path'], struct_output_name, 'relaxation', 'relax_task')) task_list = [] cwd = os.getcwd() if self.reprod: print('surface reproduce starts') if 'init_data_path' not in self.parameter: raise RuntimeError("please provide the initial data path to reproduce") init_data_path = os.path.abspath(self.parameter['init_data_path']) task_list = make_repro(init_data_path, self.init_from_suffix, path_to_work, self.parameter.get('reprod_last_frame', True)) os.chdir(cwd) else: if refine: print('surface refine starts') task_list = make_refine(self.parameter['init_from_suffix'], self.parameter['output_suffix'], path_to_work) os.chdir(cwd) # record miller init_from_path = re.sub(self.parameter['output_suffix'][::-1], self.parameter['init_from_suffix'][::-1], path_to_work[::-1], count=1)[::-1] task_list_basename = list(map(os.path.basename, task_list)) for ii in task_list_basename: init_from_task = os.path.join(init_from_path, ii) output_task = os.path.join(path_to_work, ii) os.chdir(output_task) if os.path.isfile('miller.json'): os.remove('miller.json') if os.path.islink('miller.json'): os.remove('miller.json') os.symlink(os.path.relpath(os.path.join(init_from_task, 'miller.json')), 'miller.json') os.chdir(cwd) else: equi_contcar = os.path.join(path_to_equi, 'CONTCAR') if not os.path.exists(equi_contcar): raise RuntimeError("please do relaxation first") ptypes = vasp.get_poscar_types(equi_contcar) # gen structure ss = Structure.from_file(equi_contcar) # gen slabs all_slabs = generate_all_slabs(ss, self.miller, self.min_slab_size, self.min_vacuum_size) os.chdir(path_to_work) if os.path.isfile('POSCAR'): os.remove('POSCAR') if os.path.islink('POSCAR'): os.remove('POSCAR') os.symlink(os.path.relpath(equi_contcar), 'POSCAR') # task_poscar = os.path.join(output, 'POSCAR') for ii in range(len(all_slabs)): output_task = os.path.join(path_to_work, 'task.%06d' % ii) os.makedirs(output_task, exist_ok=True) os.chdir(output_task) for jj in ['INCAR', 'POTCAR', 'POSCAR', 'conf.lmp', 'in.lammps']: if os.path.exists(jj): os.remove(jj) task_list.append(output_task) print("# %03d generate " % ii, output_task, " \t %d atoms" % len(all_slabs[ii].sites)) # make confs all_slabs[ii].to('POSCAR', 'POSCAR.tmp') vasp.regulate_poscar('POSCAR.tmp', 'POSCAR') vasp.sort_poscar('POSCAR', 'POSCAR', ptypes) vasp.perturb_xz('POSCAR', 'POSCAR', self.pert_xz) # record miller dumpfn(all_slabs[ii].miller_index, 'miller.json') os.chdir(cwd) return task_list
def make_deepmd_lammps(jdata, conf_dir, max_miller = 2, static = False, relax_box = False, task_name = 'wrong-task') : fp_params = jdata['vasp_params'] kspacing = fp_params['kspacing'] deepmd_model_dir = jdata['deepmd_model_dir'] deepmd_type_map = jdata['deepmd_type_map'] ntypes = len(deepmd_type_map) deepmd_model_dir = os.path.abspath(deepmd_model_dir) deepmd_models = glob.glob(os.path.join(deepmd_model_dir, '*pb')) deepmd_models_name = [os.path.basename(ii) for ii in deepmd_models] min_slab_size = jdata['min_slab_size'] min_vacuum_size = jdata['min_vacuum_size'] # get equi poscar # conf_path = os.path.abspath(conf_dir) # conf_poscar = os.path.join(conf_path, 'POSCAR') equi_path = re.sub('confs', global_equi_name, conf_dir) equi_path = os.path.join(equi_path, 'vasp-k%.2f' % kspacing) equi_path = os.path.abspath(equi_path) equi_contcar = os.path.join(equi_path, 'CONTCAR') task_path = re.sub('confs', global_task_name, conf_dir) task_path = os.path.abspath(task_path) task_path = os.path.join(task_path, task_name) os.makedirs(task_path, exist_ok=True) cwd = os.getcwd() os.chdir(task_path) if os.path.isfile('POSCAR') : os.remove('POSCAR') os.symlink(os.path.relpath(equi_contcar), 'POSCAR') os.chdir(cwd) task_poscar = os.path.join(task_path, 'POSCAR') # gen strcture ss = Structure.from_file(task_poscar) # gen slabs all_slabs = generate_all_slabs(ss, max_miller, min_slab_size, min_vacuum_size) # make lammps.in if static : fc = lammps.make_lammps_eval('conf.lmp', ntypes, lammps.inter_deepmd, deepmd_models_name) else : fc = lammps.make_lammps_equi('conf.lmp', ntypes, lammps.inter_deepmd, deepmd_models_name, change_box = relax_box) f_lammps_in = os.path.join(task_path, 'lammps.in') with open(f_lammps_in, 'w') as fp : fp.write(fc) cwd = os.getcwd() for ii in range(len(all_slabs)) : slab = all_slabs[ii] miller_str = "m%d.%d.%dm" % (slab.miller_index[0], slab.miller_index[1], slab.miller_index[2]) # make dir struct_path = os.path.join(task_path, 'struct-%03d-%s' % (ii, miller_str)) os.makedirs(struct_path, exist_ok=True) os.chdir(struct_path) for jj in ['conf.lmp', 'lammps.in'] + deepmd_models_name : if os.path.isfile(jj): os.remove(jj) print("# %03d generate " % ii, struct_path, " \t %d atoms" % len(slab.sites)) # make conf slab.to('POSCAR', 'POSCAR') vasp.regulate_poscar('POSCAR', 'POSCAR') lammps.cvt_lammps_conf('POSCAR', 'conf.lmp') ptypes = vasp.get_poscar_types('POSCAR') lammps.apply_type_map('conf.lmp', deepmd_type_map, ptypes) # record miller np.savetxt('miller.out', slab.miller_index, fmt='%d') # link lammps.in os.symlink(os.path.relpath(f_lammps_in), 'lammps.in') # link models for (ii,jj) in zip(deepmd_models, deepmd_models_name) : os.symlink(os.path.relpath(ii), jj) cwd = os.getcwd()
def make_vasp(jdata, conf_dir, max_miller=2, relax_box=False, static=False): fp_params = jdata['vasp_params'] ecut = fp_params['ecut'] ediff = fp_params['ediff'] npar = fp_params['npar'] kpar = fp_params['kpar'] kspacing = fp_params['kspacing'] kgamma = fp_params['kgamma'] min_slab_size = jdata['min_slab_size'] min_vacuum_size = jdata['min_vacuum_size'] pert_xz = jdata['pert_xz'] # get conf poscar # conf_path = os.path.abspath(conf_dir) # conf_poscar = os.path.join(conf_path, 'POSCAR') equi_path = re.sub('confs', global_equi_name, conf_dir) equi_path = os.path.join(equi_path, 'vasp-k%.2f' % kspacing) equi_path = os.path.abspath(equi_path) equi_contcar = os.path.join(equi_path, 'CONTCAR') assert os.path.exists( equi_contcar), "Please compute the equilibrium state using vasp first" task_path = re.sub('confs', global_task_name, conf_dir) task_path = os.path.abspath(task_path) if static: task_path = os.path.join(task_path, 'vasp-static-k%.2f' % kspacing) else: task_path = os.path.join(task_path, 'vasp-k%.2f' % kspacing) os.makedirs(task_path, exist_ok=True) cwd = os.getcwd() os.chdir(task_path) if os.path.isfile('POSCAR'): os.remove('POSCAR') os.symlink(os.path.relpath(equi_contcar), 'POSCAR') os.chdir(cwd) task_poscar = os.path.join(task_path, 'POSCAR') ptypes = vasp.get_poscar_types(task_poscar) # gen strcture ss = Structure.from_file(task_poscar) # gen slabs all_slabs = generate_all_slabs(ss, max_miller, min_slab_size, min_vacuum_size) # gen incar if static: fc = vasp.make_vasp_static_incar(ecut, ediff, npar=npar, kpar=kpar, kspacing=kspacing, kgamma=kgamma) else: fc = vasp.make_vasp_relax_incar(ecut, ediff, True, relax_box, False, npar=npar, kpar=kpar, kspacing=kspacing, kgamma=kgamma) with open(os.path.join(task_path, 'INCAR'), 'w') as fp: fp.write(fc) # gen potcar with open(task_poscar, 'r') as fp: lines = fp.read().split('\n') ele_list = lines[5].split() potcar_map = jdata['potcar_map'] potcar_list = [] for ii in ele_list: assert os.path.exists(os.path.abspath( potcar_map[ii])), "No POTCAR in the potcar_map of %s" % (ii) potcar_list.append(os.path.abspath(potcar_map[ii])) with open(os.path.join(task_path, 'POTCAR'), 'w') as outfile: for fname in potcar_list: with open(fname) as infile: outfile.write(infile.read()) # gen tasks cwd = os.getcwd() for ii in range(len(all_slabs)): slab = all_slabs[ii] miller_str = "m%d.%d.%dm" % ( slab.miller_index[0], slab.miller_index[1], slab.miller_index[2]) # make dir struct_path = os.path.join(task_path, 'struct-%03d-%s' % (ii, miller_str)) os.makedirs(struct_path, exist_ok=True) os.chdir(struct_path) for jj in ['POSCAR', 'POTCAR', 'INCAR']: if os.path.isfile(jj): os.remove(jj) print("# %03d generate " % ii, struct_path, " \t %d atoms" % len(slab.sites)) # make conf slab.to('POSCAR', 'POSCAR.tmp') vasp.regulate_poscar('POSCAR.tmp', 'POSCAR') vasp.sort_poscar('POSCAR', 'POSCAR', ptypes) vasp.perturb_xz('POSCAR', 'POSCAR', pert_xz) # record miller np.savetxt('miller.out', slab.miller_index, fmt='%d') # link incar, potcar, kpoints os.symlink(os.path.relpath(os.path.join(task_path, 'INCAR')), 'INCAR') os.symlink(os.path.relpath(os.path.join(task_path, 'POTCAR')), 'POTCAR') cwd = os.getcwd()