def write_band_structure_kpoints(structure, n_kpts=20, dim=2, ibzkpt_path="../"): """ Writes a KPOINTS file for band structure calculations. Does not use the typical linemode syntax for NSCF calculations, but uses the IBZKPT + high-symmetry path syntax described in http://cms.mpi.univie.ac.at/wiki/index.php/Si_bandstructure so that SCF calculations can be performed. This is more reliable than re-using the CHGCAR from a previous run, which often results in "dimensions on the CHGCAR are different" errors in VASP. Args: structure (Structure): structure for determining k-path n_kpts (int): number of divisions along high-symmetry lines dim (int): 2 for a 2D material, 3 for a 3D material. ibzkpt_path (str): location of IBZKPT file. Defaults to one directory up. """ ibz_lines = open(os.path.join(ibzkpt_path, "IBZKPT")).readlines() n_ibz_kpts = int(ibz_lines[1].split()[0]) kpath = HighSymmKpath(structure) Kpoints.automatic_linemode(n_kpts, kpath).write_file('KPOINTS') if dim == 2: remove_z_kpoints() linemode_lines = open('KPOINTS').readlines() abs_path = [] i = 4 while i < len(linemode_lines): start_kpt = linemode_lines[i].split() end_kpt = linemode_lines[i + 1].split() increments = [(float(end_kpt[0]) - float(start_kpt[0])) / 20, (float(end_kpt[1]) - float(start_kpt[1])) / 20, (float(end_kpt[2]) - float(start_kpt[2])) / 20] abs_path.append(start_kpt[:3] + ['0', start_kpt[4]]) for n in range(1, 20): abs_path.append([ str(float(start_kpt[0]) + increments[0] * n), str(float(start_kpt[1]) + increments[1] * n), str(float(start_kpt[2]) + increments[2] * n), '0' ]) abs_path.append(end_kpt[:3] + ['0', end_kpt[4]]) i += 3 n_linemode_kpts = len(abs_path) with open('KPOINTS', 'w') as kpts: kpts.write('Automatically generated mesh\n') kpts.write('{}\n'.format(n_ibz_kpts + n_linemode_kpts)) kpts.write('Reciprocal Lattice\n') for line in ibz_lines[3:]: kpts.write(line) for point in abs_path: kpts.write('{}\n'.format(' '.join(point)))
def test_remove_z_kpoints(self): os.chdir(os.path.join(PACKAGE_PATH, 'stability/tests/BiTeCl')) structure = Structure.from_file('POSCAR') kpath = HighSymmKpath(structure) Kpoints.automatic_linemode(20, kpath).write_file('KPOINTS') remove_z_kpoints() test_lines = open('KPOINTS').readlines() control_lines = open('../BiTeCl_control/KPOINTS').readlines() self.assertEqual(test_lines, control_lines) os.system('rm KPOINTS')
def get_kpoints_wannier(structure, n_kpts=1, dim=2): kpath = HighSymmKpath(structure) os.system('mv KPOINTS K_temp') Kpoints.automatic_linemode(n_kpts, kpath).write_file('KPOINTS') if dim == 2: remove_z_kpoints() path = find_kpath(f='KPOINTS') os.system('rm KPOINTS') os.system('mv K_temp KPOINTS') return path
def test_remove_z_kpoints(self): os.chdir(os.path.join(ROOT, 'BiTeCl')) structure = Structure.from_file('POSCAR') kpath = HighSymmKpath(structure) Kpoints.automatic_linemode(20, kpath).write_file('KPOINTS') remove_z_kpoints() test_file = open('KPOINTS') test_lines = test_file.readlines() control_file = open('../BiTeCl_control/KPOINTS') control_lines = control_file.readlines() self.assertEqual(test_lines, control_lines) os.system('rm KPOINTS') test_file.close() control_file.close()
def hse06_bandstructure_kpoints(struct, nkpts=20): ''' Generate HSE06 bandstructure KPOINTS Append high-symmetry path points to the IBZKPT file and set weight of all the high-symmetry path points to zero and then write to "KPOINTS" High-symmetry path kpoints is saved as a backup file named 'KPOINTS_bak' Note: We asssert the IBZKPT file is valid ''' def chunks(lst, n): for i in range(0, len(lst), n): yield lst[i:i + n] hsk = HighSymmKpath(struct) sym_kpts = Kpoints.automatic_linemode(nkpts, hsk) sym_kpts.write_file("KPOINTS_bak") kpts = sym_kpts.kpts nsegs = sym_kpts.num_kpts kpoints_result = [] for rng in chunks(kpts, 2): start, end = rng kpoints_result.append(np.linspace(start, end, nsegs)) kpoints_result = np.array(kpoints_result).reshape((-1, 3)) KPOINTS = open('IBZKPT').readlines() for i in range(kpoints_result.shape[0]): x, y, z = kpoints_result[i, :] KPOINTS.append("{:20.14f}{:20.14f}{:20.14f}{:14}\n".format(x, y, z, 0)) KPOINTS[1] = "{:8}\n".format(len(KPOINTS) - 3) with open("KPOINTS", 'w') as f: print("".join(KPOINTS), file=f) pass
def line_int(cls): """ Initialize list of kpoints along a high-symmetry path through the Brillouin zone. Uses a path defined by the pymatgen HighSymmPath class with a defined number of kpoint subdivisions between the path nodes. Example:: Line_mode KPOINTS file 100 Line_mode Reciprocal 0.0 0.0 0.0 ! Gamma 0.0 0.5 0.0 ! X 0.0 0.5 0.0 ! X ... 0.0 0.5 0.0 ! X 0.5 0.5 0.0 ! M 0.5 0.5 0.5 ! R """ if cls.kpoint_params['shift'] is not None: warnings.warn("Line kpoint mode: Ignoring defined shift") if cls.kpoint_params['sympath'] is None: raise KpointWrapperError("Missing non-optional kpoint line mode " "parameter 'sympath'") divisions = cls.kpoint_params['kpoints'] sympath = cls.kpoint_params['sympath'] return Kpoints.automatic_linemode(divisions, sympath)
def test_remove_z_kpoints(self): os.chdir(os.path.join(ROOT, 'BiTeCl')) structure = Structure.from_file('POSCAR') kpath = HighSymmKpath(structure) Kpoints.automatic_linemode(20, kpath).write_file('KPOINTS') remove_z_kpoints() test_file = open('KPOINTS') test_lines = test_file.readlines() print (test_lines) control_file = open('../BiTeCl_control/KPOINTS') control_lines = control_file.readlines() print (control_lines) self.assertEqual(test_lines, control_lines) os.system('rm KPOINTS') test_file.close() control_file.close()
def run_pbe_calculation(dim=2, submit=True, force_overwrite=False): """ Setup and submit a normal PBE calculation for band structure along high symmetry k-paths. Args: dim (int): 2 for relaxing a 2D material, 3 for a 3D material. submit (bool): Whether or not to submit the job. force_overwrite (bool): Whether or not to overwrite files if an already converged vasprun.xml exists in the directory. """ PBE_INCAR_DICT = {'EDIFF': 1e-6, 'IBRION': 2, 'ISIF': 3, 'ISMEAR': 1, 'NSW': 0, 'LVTOT': True, 'LVHAR': True, 'LORBIT': 1, 'LREAL': 'Auto', 'NPAR': 4, 'PREC': 'Accurate', 'LWAVE': True, 'SIGMA': 0.1, 'ENCUT': 500, 'ISPIN': 2} directory = os.getcwd().split('/')[-1] if not os.path.isdir('pbe_bands'): os.mkdir('pbe_bands') if force_overwrite or not is_converged('pbe_bands'): os.system('cp CONTCAR pbe_bands/POSCAR') if os.path.isfile('POTCAR'): os.system('cp POTCAR pbe_bands/') PBE_INCAR_DICT.update({'MAGMOM': get_magmom_string()}) Incar.from_dict(PBE_INCAR_DICT).write_file('pbe_bands/INCAR') structure = Structure.from_file('POSCAR') kpath = HighSymmKpath(structure) Kpoints.automatic_linemode(20, kpath).write_file('pbe_bands/KPOINTS') os.chdir('pbe_bands') if dim == 2: remove_z_kpoints() if QUEUE == 'pbs': write_pbs_runjob(directory, 1, 16, '800mb', '6:00:00', VASP) submission_command = 'qsub runjob' elif QUEUE == 'slurm': write_slurm_runjob(directory, 16, '800mb', '6:00:00', VASP) submission_command = 'sbatch runjob' if submit: os.system(submission_command) os.chdir('../')
def write_vasp_input(structure: IStructure, kpath_division: int, write_dir: str = "."): vasp_input = VaspInput( Incar.from_file("INCAR"), Kpoints.automatic_linemode(kpath_division, HighSymmKpath(structure)), Poscar(structure), Potcar.from_file("POTCAR")) vasp_input.write_input(write_dir)
def band_structure_kpath(struct,dirname,nkpts=30): #struct=Structure.from_file('POSCAR') #ana_struct=SpacegroupAnalyzer(struct) #pst=ana_struct.find_primitive() # First brillouin zone ibz = HighSymmKpath(struct) linemode_kpoints = Kpoints.automatic_linemode(nkpts,ibz) linemode_kpoints.write_file(os.path.join(dirname, "KPOINTS"))
def hse06_bandstructure_kpoints(struct, nkpts=20, kmesh=(11, 11, 11), is_shift=(0, 0, 0), ibzkpt_file=False): ''' Generate HSE06 bandstructure KPOINTS Append high-symmetry path points to the IBZKPT file and set weight of all the high-symmetry path points to zero and then write to "KPOINTS" High-symmetry path kpoints is saved as a backup file named 'KPOINTS_bak' Note: We asssert the IBZKPT file is valid ''' def chunks(lst, n): for i in range(0, len(lst), n): yield lst[i:i + n] hsk = HighSymmKpath(struct) sym_kpts = Kpoints.automatic_linemode(nkpts, hsk) sym_kpts.write_file("KPOINTS_bak") # high-symmetry k-points kpts = sym_kpts.kpts nsegs = sym_kpts.num_kpts # Line mode k-points line_kpts = [] for rng in chunks(kpts, 2): start, end = rng line_kpts.append(np.linspace(start, end, nsegs)) ln_kpts_vec = np.array(line_kpts).reshape((-1, 3)) ln_kpts_wht = np.zeros(ln_kpts_vec.shape[0]) ln_kpts = np.c_[ln_kpts_vec, ln_kpts_wht] if ibzkpt_file: kpoints = open('IBZKPT', "r").readlines() kpoints[1] = "{:8}\n".format( int(kpoints[1].strip()) + ln_kpts.shape[0]) with open("KPOINTS", "w") as K: K.write("".join(kpoints)) np.savetxt(K, ln_kpts, fmt="%20.14f%20.14f%20.14f%14d") else: # generate irreducible k-points in the BZ ana_struct = SpacegroupAnalyzer(struct) ir_kpts_with_wht = ana_struct.get_ir_reciprocal_mesh(mesh=kmesh, is_shift=is_shift) ir_kpts_vec = np.array([x[0] for x in ir_kpts_with_wht]) ir_kpts_wht = np.array([x[1] for x in ir_kpts_with_wht]) ir_kpts = np.c_[ir_kpts_vec, ir_kpts_wht] with open("KPOINTS", "w") as K: K.write("Generated by MAPTOOL\n") K.write("{:8d}\n".format(ln_kpts.shape[0] + ir_kpts.shape[0])) K.write("Reciprocal Lattice\n") np.savetxt(K, ir_kpts, fmt="%20.14f%20.14f%20.14f%14d") np.savetxt(K, ln_kpts, fmt="%20.14f%20.14f%20.14f%14d")
def write_kpoints_along_hs_path(self, divisions=5): """ writes a KPOINTS file for band structure calculation use """ hs_kpoints_file_name = os.path.join(self._save_to_path, 'KPOINTS') structure = Structure.from_file( os.path.join(self._save_to_path, 'POSCAR')) kpath = HighSymmKpath(structure) kpts = Kpoints.automatic_linemode(divisions=divisions, ibz=kpath) kpts.write_file(hs_kpoints_file_name)
def band_structure_kpath(struct, dirname, nkpts=30): """ Generate KPOINTS file for band structure calculation via pymatgen's symmetry analyzing system. """ #struct=Structure.from_file('POSCAR') #ana_struct=SpacegroupAnalyzer(struct) #pst=ana_struct.find_primitive() # First brillouin zone ibz = HighSymmKpath(struct) linemode_kpoints = Kpoints.automatic_linemode(nkpts, ibz) linemode_kpoints.write_file(os.path.join(dirname, "KPOINTS"))
def get_path_dependent_Kpoints(self, divisions = 10): ''' Gets the primitive unit cell from the CONTCAR file as primitive_structure ''' ''' Gets the high symmetry k path of the primitive unit cell as k_path ''' ''' Returns the pymatgen.io.vasp.inputs.Kpoints object, with symmetric k points specified ''' ''' NOTE: divisions is the number of points sampled along each path between k points, default = 10''' primitive_structure = Structure.from_file(self.cwd + '/CONTCAR', primitive=True) k_path = HighSymmKpath(primitive_structure) kpoints = Kpoints.automatic_linemode(divisions, k_path) return kpoints
def set_kpoints(self, kpoint): """ set the kpoint """ if self.Grid_type == 'M': self.kpoints = Kpoints.monkhorst_automatic(kpts=kpoint) elif self.Grid_type == 'A': self.kpoints = Kpoints.automatic(subdivisions=kpoint) elif self.Grid_type == 'G': self.kpoints = Kpoints.gamma_automatic(kpts=kpoint) elif self.Grid_type == '3DD': self.kpoints = Kpoints.automatic_density_by_vol(structure= \ self.poscar.structure, kppvol=kpoint) elif self.Grid_type == 'band': self.kpoints = Kpoints.automatic_linemode(divisions=kpoint, \ ibz=HighSymmKpath(self.poscar.structure))
def set_kpoints(self, kpoint): """ set the kpoint """ if self.Grid_type == 'M': self.kpoints = Kpoints.monkhorst_automatic(kpts=kpoint) elif self.Grid_type == 'A': self.kpoints = Kpoints.automatic(subdivisions=kpoint) elif self.Grid_type == 'G': self.kpoints = Kpoints.gamma_automatic(kpts=kpoint) elif self.Grid_type == '3DD': self.kpoints = Kpoints.automatic_density_by_vol(structure= \ self.poscar.structure, kppvol=kpoint) elif self.Grid_type == 'band': self.kpoints = Kpoints.automatic_linemode(divisions=kpoint, \ ibz=HighSymmKpath( self.poscar.structure))
def generate_line(ndiv=20, dim=2, for_scan_hse=False): """ Generate linemode KPOINTS. Parameters ---------- [optional] ndiv (int): number of divisions along high-symmetry lines. Default=20. [optional] dim (int): dimensionality of structure. Default=2. [optional] for_scan_hse (bool): to generate special KPOINTS for SCAN/HSE?. Default=False. """ dir_sub = os.getcwd() poscar = Poscar.from_file(os.path.join(dir_sub, "POSCAR"), check_for_POTCAR=False, read_velocities=False) structure = poscar.structure ## use pymatgen symmetry functions to determine the high-symmetry k-path kpts_line = Kpoints.automatic_linemode(int(ndiv), HighSymmKpath(structure)) ## if 2D structure specified, remove k-points with non-zero z-component if int(dim) == 2: kpts_line = remove_z_kpoints(kpts_line) if not for_scan_hse: ## write out regular KPOINT file for bandstructure calc. with PBE kpts_line.write_file(os.path.join(dir_sub, "KPOINTS_bands")) else: ## get regular grid kpoints from IBZKPT file ibz_lines, n_ibz_kpts = get_ibzkpts() ## get explicit kpoints between each high-symmetry point abs_path = get_kpts_line_explicit(kpts_line, int(ndiv)) ## write out special KPOINT file for bandstructure calc. with SCAN/HSE with open(os.path.join(dir_sub, "KPOINTS_bands_SCAN"), 'w') as f: f.write('Special KPOINTS file\n') f.write('{}\n'.format(n_ibz_kpts + len(abs_path))) f.write('Reciprocal Lattice\n') for line in ibz_lines[3:]: f.write(line) for point in abs_path: f.write('{}\n'.format(' '.join(point)))
def set_kpoints(self, kpoint): """ set the kpoint """ if self.Grid_type == 'M': self.kpoints = Kpoints.monkhorst_automatic(kpts=kpoint) elif self.Grid_type == 'A': self.kpoints = Kpoints.automatic(subdivisions=kpoint) elif self.Grid_type == 'G': self.kpoints = Kpoints.gamma_automatic(kpts=kpoint) elif self.Grid_type == '3DD': self.kpoints = Kpoints.automatic_density_by_vol(structure= \ self.poscar.structure, kppvol=kpoint) elif self.Grid_type == 'band': self.kpoints = Kpoints.automatic_linemode(divisions=kpoint, \ ibz=HighSymmKpath(self.poscar.structure)) name = self.kpoint_to_name(kpoint, self.Grid_type) job_dir = self.job_dir + os.sep + self.key_to_name('KPOINTS') \ + os.sep + name return job_dir
def set_kpoints(self, kpoint): """ set the kpoint """ if self.Grid_type == 'M': self.kpoints = Kpoints.monkhorst_automatic(kpts = kpoint) elif self.Grid_type == 'A': self.kpoints = Kpoints.automatic(subdivisions = kpoint) elif self.Grid_type == 'G': self.kpoints = Kpoints.gamma_automatic(kpts = kpoint) elif self.Grid_type == '3DD': self.kpoints = Kpoints.automatic_density_by_vol(structure=\ self.poscar.structure, kppvol=kpoint) elif self.Grid_type == 'band': self.kpoints = Kpoints.automatic_linemode(divisions=kpoint,\ ibz=HighSymmKpath(self.poscar.structure)) name = self.kpoint_to_name(kpoint, self.Grid_type) job_dir = self.job_dir +os.sep+ self.key_to_name('KPOINTS') \ + os.sep + name return job_dir
# Requires: pymatgen module # Generates KPOINTS.bands file with high symmetry lines added for # an arbitrary POSCAR with symmetry precision=1e-3 import pymatgen as mg from pymatgen.symmetry.bandstructure import HighSymmKpath from pymatgen.io.vasp.inputs import Kpoints struct = mg.Structure.from_file("POSCAR") kpath = HighSymmKpath(struct) kpoints = Kpoints.automatic_linemode(16, kpath) kpoints.write_file("KPOINTS.bands")
def write_hs_kpoints(self): save_dir = 'VaspInputsDir/' + self.mp_id + '/' kpts = Kpoints.automatic_linemode(divisions=1, ibz=self.kpath) kpts.write_file(save_dir + 'KPOINTS')
from pymatgen.io.vasp.inputs import Kpoints from pymatgen.core import Structure from pymatgen.symmetry.bandstructure import HighSymmKpath struct = Structure.from_file("POSCAR") kpath = HighSymmKpath(struct) kpts = Kpoints.automatic_linemode(divisions=40, ibz=kpath) kpts.write_file("KPOINTS") print(kpts)
def get_2D_hse_kpoints(struct_for_path, ibzkpth): """ Args: struct_for_path: Structure from which linemode k-points will be generated. ibzkpth: Returns: the Kpoints file object in the form of a string ready for execution by MPInterfaces calibrate objects """ # Read IBZKPT from prep step ibz_lines = open(ibzkpth).readlines() n_ibz_kpts = int(ibz_lines[1].split()[0]) # Read linemode KPOINTs from the dict (makes sure it is Kpoints # file with only 20 per atom for the optimized settings # Kpoints.from_dict(kpoint_dict).write_file('linemode_KPOINTS') kpath = HighSymmKpath(struct_for_path) Kpoints.automatic_linemode(20, kpath).write_file('KPOINTS_linemode') remove_z_kpoints_linemode() linemode_lines = open('KPOINTS_linemode').readlines() # put them together abs_path = [] for i in range(4, len(linemode_lines), 3): start_kpt = linemode_lines[i].split() end_kpt = linemode_lines[i + 1].split() increments = [(float(end_kpt[0]) - float(start_kpt[0])) / 20, (float(end_kpt[1]) - float(start_kpt[1])) / 20, (float(end_kpt[2]) - float(start_kpt[2])) / 20] abs_path.append(start_kpt[:3] + ['0', start_kpt[4]]) for n in range(1, 20): abs_path.append([ str(float(start_kpt[0]) + increments[0] * n), str(float(start_kpt[1]) + increments[1] * n), str(float(start_kpt[2]) + increments[2] * n), '0' ]) abs_path.append(end_kpt[:3] + ['0', end_kpt[4]]) n_linemode_kpts = len(abs_path) # write out the kpoints file and return the object Kpoints_hse_file = '\n'.join( ['Automatically generated mesh', '{}'.format(n_ibz_kpts + n_linemode_kpts), 'Reciprocal Lattice', '{}'.format(str(''.join([line for line in ibz_lines[3:]])))]) + \ '{}'.format(str('\n'.join( [' '.join(point) for point in abs_path]))) ## can be used for test print out # with open('KPOINTS_HSE', 'w') as kpts: # kpts.write('Automatically generated mesh\n') # kpts.write('{}\n'.format(n_ibz_kpts + n_linemode_kpts)) # kpts.write('Reciprocal Lattice\n') # for line in ibz_lines[3:]: # kpts.write(line) # for point in abs_path: # kpts.write('{}\n'.format(' '.join(point))) return Kpoints_hse_file
def run_hse_calculation(dim=2, submit=True, force_overwrite=False, destroy_prep_directory=False): """ Setup/submit an HSE06 calculation to get an accurate band structure. Requires a previous IBZKPT from a standard DFT run. See http://cms.mpi.univie.ac.at/wiki/index.php/Si_bandstructure for more details. Args: dim (int): 2 for relaxing a 2D material, 3 for a 3D material. submit (bool): Whether or not to submit the job. force_overwrite (bool): Whether or not to overwrite files if an already converged vasprun.xml exists in the directory. destroy_prep_directory (bool): whether or not to remove (rm -r) the hse_prep directory, if it exists. This can help to automatically clean up and save space. """ HSE_INCAR_DICT = { 'LHFCALC': True, 'HFSCREEN': 0.2, 'AEXX': 0.25, 'ALGO': 'D', 'TIME': 0.4, 'NSW': 0, 'LVTOT': True, 'LVHAR': True, 'LORBIT': 11, 'LWAVE': True, 'NPAR': 8, 'PREC': 'Accurate', 'EDIFF': 1e-4, 'ENCUT': 450, 'ICHARG': 2, 'ISMEAR': 1, 'SIGMA': 0.1, 'IBRION': 2, 'ISIF': 3, 'ISPIN': 2 } if not os.path.isdir('hse_bands'): os.mkdir('hse_bands') if force_overwrite or not is_converged('hse_bands'): os.chdir('hse_bands') os.system('cp ../CONTCAR ./POSCAR') if os.path.isfile('../POTCAR'): os.system('cp ../POTCAR .') HSE_INCAR_DICT.update( {'MAGMOM': get_magmom_string(Structure.from_file('POSCAR'))}) Incar.from_dict(HSE_INCAR_DICT).write_file('INCAR') # Re-use the irreducible brillouin zone KPOINTS from a # previous standard DFT run. if os.path.isdir('../hse_prep'): ibz_lines = open('../hse_prep/IBZKPT').readlines() if destroy_prep_directory: os.system('rm -r ../hse_prep') else: ibz_lines = open('../IBZKPT').readlines() n_ibz_kpts = int(ibz_lines[1].split()[0]) kpath = HighSymmKpath(Structure.from_file('POSCAR')) Kpoints.automatic_linemode(20, kpath).write_file('KPOINTS') if dim == 2: remove_z_kpoints() linemode_lines = open('KPOINTS').readlines() abs_path = [] i = 4 while i < len(linemode_lines): start_kpt = linemode_lines[i].split() end_kpt = linemode_lines[i + 1].split() increments = [(float(end_kpt[0]) - float(start_kpt[0])) / 20, (float(end_kpt[1]) - float(start_kpt[1])) / 20, (float(end_kpt[2]) - float(start_kpt[2])) / 20] abs_path.append(start_kpt[:3] + ['0', start_kpt[4]]) for n in range(1, 20): abs_path.append([ str(float(start_kpt[0]) + increments[0] * n), str(float(start_kpt[1]) + increments[1] * n), str(float(start_kpt[2]) + increments[2] * n), '0' ]) abs_path.append(end_kpt[:3] + ['0', end_kpt[4]]) i += 3 n_linemode_kpts = len(abs_path) with open('KPOINTS', 'w') as kpts: kpts.write('Automatically generated mesh\n') kpts.write('{}\n'.format(n_ibz_kpts + n_linemode_kpts)) kpts.write('Reciprocal Lattice\n') for line in ibz_lines[3:]: kpts.write(line) for point in abs_path: kpts.write('{}\n'.format(' '.join(point))) if QUEUE_SYSTEM == 'pbs': write_pbs_runjob('{}_hsebands'.format(os.getcwd().split('/')[-2]), 2, 64, '1800mb', '50:00:00', VASP_STD_BIN) submission_command = 'qsub runjob' elif QUEUE_SYSTEM == 'slurm': write_slurm_runjob( '{}_hsebands'.format(os.getcwd().split('/')[-2]), 64, '1800mb', '50:00:00', VASP_STD_BIN) submission_command = 'sbatch runjob' if submit: _ = subprocess.check_output(submission_command.split()) os.chdir('../')
def gen_hs_kpoints(structure): kpath = HighSymmKpath(structure) kpts = Kpoints.automatic_linemode(divisions=7, ibz=kpath) kpts.write_file('KPOINTS')
def run_hse_calculation(dim=2, submit=True, force_overwrite=False, destroy_prep_directory=False): """ Setup/submit an HSE06 calculation to get an accurate band structure. Requires a previous IBZKPT from a standard DFT run. See http://cms.mpi.univie.ac.at/wiki/index.php/Si_bandstructure for more details. Args: dim (int): 2 for relaxing a 2D material, 3 for a 3D material. submit (bool): Whether or not to submit the job. force_overwrite (bool): Whether or not to overwrite files if an already converged vasprun.xml exists in the directory. destroy_prep_directory (bool): whether or not to remove (rm -r) the hse_prep directory, if it exists. This can help you to automatically clean up and save space. """ HSE_INCAR_DICT = {'LHFCALC': True, 'HFSCREEN': 0.2, 'AEXX': 0.25, 'ALGO': 'D', 'TIME': 0.4, 'NSW': 0, 'LVTOT': True, 'LVHAR': True, 'LORBIT': 11, 'LWAVE': True, 'NPAR': 8, 'PREC': 'Accurate', 'EDIFF': 1e-4, 'ENCUT': 450, 'ICHARG': 2, 'ISMEAR': 1, 'SIGMA': 0.1, 'IBRION': 2, 'ISIF': 3, 'ISPIN': 2} if not os.path.isdir('hse_bands'): os.mkdir('hse_bands') if force_overwrite or not is_converged('hse_bands'): os.chdir('hse_bands') os.system('cp ../CONTCAR ./POSCAR') if os.path.isfile('../POTCAR'): os.system('cp ../POTCAR .') HSE_INCAR_DICT.update({'MAGMOM': get_magmom_string()}) Incar.from_dict(HSE_INCAR_DICT).write_file('INCAR') # Re-use the irreducible brillouin zone KPOINTS from a # previous standard DFT run. if os.path.isdir('../hse_prep'): ibz_lines = open('../hse_prep/IBZKPT').readlines() if destroy_prep_directory: os.system('rm -r ../hse_prep') else: ibz_lines = open('../IBZKPT').readlines() n_ibz_kpts = int(ibz_lines[1].split()[0]) kpath = HighSymmKpath(Structure.from_file('POSCAR')) Kpoints.automatic_linemode(20, kpath).write_file('KPOINTS') if dim == 2: remove_z_kpoints() linemode_lines = open('KPOINTS').readlines() abs_path = [] i = 4 while i < len(linemode_lines): start_kpt = linemode_lines[i].split() end_kpt = linemode_lines[i+1].split() increments = [ (float(end_kpt[0]) - float(start_kpt[0])) / 20, (float(end_kpt[1]) - float(start_kpt[1])) / 20, (float(end_kpt[2]) - float(start_kpt[2])) / 20 ] abs_path.append(start_kpt[:3] + ['0', start_kpt[4]]) for n in range(1, 20): abs_path.append( [str(float(start_kpt[0]) + increments[0] * n), str(float(start_kpt[1]) + increments[1] * n), str(float(start_kpt[2]) + increments[2] * n), '0'] ) abs_path.append(end_kpt[:3] + ['0', end_kpt[4]]) i += 3 n_linemode_kpts = len(abs_path) with open('KPOINTS', 'w') as kpts: kpts.write('Automatically generated mesh\n') kpts.write('{}\n'.format(n_ibz_kpts + n_linemode_kpts)) kpts.write('Reciprocal Lattice\n') for line in ibz_lines[3:]: kpts.write(line) for point in abs_path: kpts.write('{}\n'.format(' '.join(point))) if QUEUE == 'pbs': write_pbs_runjob('{}_hsebands'.format( os.getcwd().split('/')[-2]), 2, 64, '1800mb', '50:00:00', VASP) submission_command = 'qsub runjob' elif QUEUE == 'slurm': write_slurm_runjob('{}_hsebands'.format( os.getcwd().split('/')[-2]), 64, '1800mb', '50:00:00', VASP) submission_command = 'sbatch runjob' if submit: os.system(submission_command) os.chdir('../')
exit(1) # symmetry information struct_sym = SpacegroupAnalyzer(struct) print("\nLattice details:") print("----------------") print("lattice type : {0}".format(struct_sym.get_lattice_type())) print("space group : {0} ({1})".format(struct_sym.get_spacegroup_symbol(), struct_sym.get_spacegroup_number())) # Compute first brillouin zone ibz = HighSymmKpath(struct) print("ibz type : {0}".format(ibz.name)) ibz.get_kpath_plot(savefig="path.png") # print specific kpoints in the first brillouin zone print("\nList of high symmetry k-points:") print("-------------------------------") for key, val in ibz.kpath["kpoints"].items(): print("%8s %s" % (key, str(val))) # suggested path for the band structure print("\nSuggested paths in first brillouin zone:") print("----------------------------------------") for i, path in enumerate(ibz.kpath["path"]): print(" %2d:" % (i + 1), " -> ".join(path)) # write the KPOINTS file print("\nWrite file KPOINTS") Kpoints.automatic_linemode(ndiv, ibz).write_file("KPOINTS")
def drawkpt(struct, ndiv="10"): # symmetry information struct_sym = SpacegroupAnalyzer(struct) print("\nLattice details:") print("----------------") print("lattice type : {0}".format(struct_sym.get_lattice_type())) print( "space group : {0} ({1})".format( struct_sym.get_space_group_symbol(), struct_sym.get_space_group_number())) # Compute first brillouin zone ibz = HighSymmKpath(struct) print("ibz type : {0}".format(ibz.name)) [x, y, z] = list(map(list, zip(*ibz.get_kpoints()[0]))) fig = plt.figure("Brillouin Zone and High Symm Pts") ax = fig.gca(projection='3d') ax.plot(x, y, z) for i, name in enumerate(ibz.get_kpoints()[1]): if name != '': #print(" name {0} : [{1},{2},{3}]".format(name, x[i],y[i],z[i])) ax.text(x[i], y[i], z[i], '%s' % (name), color='k', size="15") new_lat = ibz.prim_rec bz_array = new_lat.get_wigner_seitz_cell() bz_faces = Poly3DCollection(bz_array) bz_faces.set_edgecolor('k') bz_faces.set_facecolor((0, 1, 1, 0.4)) ax.add_collection3d(bz_faces) ax.set_xlim(-1, 1) ax.set_ylim(-1, 1) ax.set_zlim(-1, 1) ax.set_xlabel('X') ax.set_ylabel('Y') ax.set_zlabel('Z') fig.suptitle( "Brillouin Zone and K_Path of \n {0}".format( struct.get_primitive_structure().formula)) fig.show() # if input("press [s]ave to save brillouin zone figure as it is \n") == "s": # fig.savefig("BZ_KPath.svg", bbox_inches='tight') # plt.close(fig) # print specific kpoints in the first brillouin zone print("\nList of high symmetry k-points:") print("-------------------------------") for key, val in ibz.kpath["kpoints"].items(): print("%8s %s" % (key, str(val))) # suggested path for the band structure print("\nSuggested paths in first brillouin zone:") print("----------------------------------------") for i, path in enumerate(ibz.kpath["path"]): print(" %2d:" % (i + 1), " -> ".join(path)) # write the KPOINTS file print("\nWrite file KPOINTS") kpt = Kpoints.automatic_linemode(ndiv, ibz) # if input("write kpt in cwd ?") == "Y": # kpt.write_file(os.path.join( # folder, "linear_KPOINTS")) return(kpt)
exit(1) # symmetry information struct_sym = SpacegroupAnalyzer(struct) print("\nLattice details:") print("----------------") print("lattice type : {0}".format(struct_sym.get_lattice_type())) print("space group : {0} ({1})".format(struct_sym.get_space_group_symbol(), struct_sym.get_space_group_number())) # Compute first brillouin zone ibz = HighSymmKpath(struct) print("ibz type : {0}".format(ibz.name)) #ibz.get_kpath_plot(savefig="path.png") # print specific kpoints in the first brillouin zone print("\nList of high symmetry k-points:") print("-------------------------------") for key, val in ibz.kpath["kpoints"].items(): print("%8s %s" % (key, str(val))) # suggested path for the band structure print("\nSuggested paths in first brillouin zone:") print("----------------------------------------") for i, path in enumerate(ibz.kpath["path"]): print(" %2d:" % (i + 1), " -> ".join(path)) # write the KPOINTS file print("\nWrite file KPOINTS") Kpoints.automatic_linemode(ndiv, ibz).write_file("KPOINTS")
def hs_kpath_gen(working_dir: str = './'): structure = Structure.from_file(working_dir+'POSCAR') kpath = HighSymmKpath(structure) kpts = Kpoints.automatic_linemode(divisions=1, ibz=kpath) kpts.write_file(working_dir+'KPOINTS')
def set_kpoints(self, kpoint=None, poscar=None, ibzkpth=None): """ set the kpoint """ # useful to check if a poscar is supplied from setup_poscar_jobs (most often the case) # or this is a single poscar use case if not poscar: poscar = self.poscar # splitting into two if elif branches means fewer if statements to check on # a run # Most general method of setting the k-points for # different grid types # NOTE: requires that at least one k-points value be passed # as a turn - knobs list value # this is not true for values that may be caculated out of # a database # use this part only if this is a non-database run for example # for k-points calibration if not self.database: if self.Grid_type == 'M': self.kpoints = Kpoints.monkhorst_automatic(kpts=kpoint) elif self.Grid_type == 'A': self.kpoints = Kpoints.automatic(subdivisions=kpoint) elif self.Grid_type == 'G': self.kpoints = Kpoints.gamma_automatic(kpts=kpoint) elif self.Grid_type == '3D_vol': self.kpoints = Kpoints.automatic_density_by_vol(structure=poscar.structure, kppvol=kpoint) elif self.Grid_type == 'bulk_bands_pbe': self.kpoints = Kpoints.automatic_linemode(divisions=kpoint, ibz=HighSymmKpath( poscar.structure)) elif self.Grid_type == 'D': self.kpoints = Kpoints.automatic_density(structure=poscar.structure,kppa=kpoint) elif self.Grid_type == 'Finer_G_Mesh': # kpoint is the scaling factor and self.kpoints is the old kpoint mesh self.logger.info('Setting Finer G Mesh for {0} by scale {1}'.format(kpoint, self.finer_kpoint)) self.kpoints = Kpoints.gamma_automatic(kpts = \ [i * self.finer_kpoint for i in kpoint]) self.logger.info('Finished scaling operation of k-mesh') # applicable for database runs # future constructs or settinsg can be activated via a yaml file # database yaml file or better still the input deck from its speification # decides what combination of input calibrate constructor settings to use # one of them being the grid_type tag elif self.database == 'twod': # set of kpoints settings according to the 2D database profile # the actual settings of k-points density # will in future come from any database input file set if self.Grid_type == 'hse_bands_2D_prep': kpoint_dict = Kpoints.automatic_gamma_density(poscar.structure, 200).as_dict() kpoint_dict['kpoints'][0][2] = 1 # remove z kpoints self.kpoints = Kpoints.from_dict(kpoint_dict) elif self.Grid_type == 'hse_bands_2D': # can at most return the path to the correct kpoints file # needs kpoints to be written out in instrument in a different way # not using the Kpoints object self.kpoints = get_2D_hse_kpoints(poscar.structure, ibzkpth) elif self.Grid_type == 'bands_2D': kpoint_dict = Kpoints.automatic_linemode(divisions=20, ibz=HighSymmKpath(poscar.structure)).as_dict() self.kpoints = Kpoints.from_dict(kpoint_dict) elif self.Grid_type == 'relax_2D': # general relaxation settings for 2D kpoint_dict = Kpoints.automatic_gamma_density(poscar.structure, 1000).as_dict() kpoint_dict['kpoints'][0][2] = 1 self.kpoints = Kpoints.from_dict(kpoint_dict) elif self.Grid_type == 'relax_3D': # general relaxation settings for 3D kpoint_dict = Kpoints.automatic_gamma_density( poscar.structure, 1000) self.kpoints = Kpoints.from_dict(kpoint_dict)