def test_static_run_correction(self): shutil.copy("OSZICAR.empty", "OSZICAR") s1 = Structure.from_file("POSCAR") incar = Incar.from_file("INCAR") # Test for NSW 0 incar.update({"NSW": 0}) incar.write_file("INCAR") h = VaspErrorHandler("vasp.out") self.assertEqual(h.check(), True) d = h.correct() self.assertEqual(d["errors"], ["zpotrf"]) s2 = Structure.from_file("POSCAR") self.assertAlmostEqual(s2.volume, s1.volume, 3) self.assertEqual(Incar.from_file("INCAR")["ISYM"], 0) # Test for ISIF 0-2 incar.update({"NSW": 99, "ISIF": 2}) incar.write_file("INCAR") h = VaspErrorHandler("vasp.out") self.assertEqual(h.check(), True) d = h.correct() self.assertEqual(d["errors"], ["zpotrf"]) s2 = Structure.from_file("POSCAR") self.assertAlmostEqual(s2.volume, s1.volume, 3) self.assertEqual(Incar.from_file("INCAR")["ISYM"], 0)
def test_check_correct_scan_metal(self): h = IncorrectSmearingHandler() self.assertTrue(h.check()) d = h.correct() self.assertEqual(d["errors"], ["IncorrectSmearing"]) self.assertEqual(Incar.from_file("INCAR")["ISMEAR"], 2) self.assertEqual(Incar.from_file("INCAR")["SIGMA"], 0.2) os.remove("vasprun.xml")
def test_eddrmm(self): h = VaspErrorHandler("vasp.eddrmm") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["eddrmm"]) i = Incar.from_file("INCAR") self.assertEqual(i["ALGO"], "Normal") self.assertEqual(h.correct()["errors"], ["eddrmm"]) i = Incar.from_file("INCAR") self.assertEqual(i["POTIM"], 0.25)
def test_rhosyg_vasp6(self): h = VaspErrorHandler("vasp6.rhosyg") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["rhosyg"]) i = Incar.from_file("INCAR") self.assertEqual(i["SYMPREC"], 1e-4) self.assertEqual(h.correct()["errors"], ["rhosyg"]) i = Incar.from_file("INCAR") self.assertEqual(i["ISYM"], 0)
def get_Incar(self): ''' Reads the file titled INCAR from the current working directory ''' ''' Updates the old_incar object to the new_incar object using self.tags ''' ''' Returns both the old_incar and new_incar objects (pymatgen.io.vasp.inputs.Incar) ''' old_incar = Incar.from_file(self.path + '/INCAR') new_incar = Incar.from_file(self.path + '/INCAR') new_incar.update(self.tags) return old_incar, new_incar
def test_posmap_vasp6(self): h = VaspErrorHandler("vasp6.posmap") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["posmap"]) i = Incar.from_file("INCAR") self.assertAlmostEqual(i["SYMPREC"], 1e-6) self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["posmap"]) i = Incar.from_file("INCAR") self.assertAlmostEqual(i["SYMPREC"], 1e-4)
def test_bravais(self): h = VaspErrorHandler("vasp6.bravais") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["bravais"]) i = Incar.from_file("INCAR") self.assertEqual(i["SYMPREC"], 1e-4) shutil.copy("INCAR.symprec", "INCAR") h = VaspErrorHandler("vasp6.bravais") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["bravais"]) i = Incar.from_file("INCAR") self.assertEqual(i["SYMPREC"], 1e-5)
def plot_enc_convergence(directory="../vasp/examples/SiOptb88/", plot=False, filename="."): """ Plot convergence for plane-wave cut-off data Works only if jobs run through jarvis-tools framework Args: directory: parent directory for job run Returns: matplotlib object, converged cut-off value """ x = [] y = [] for a in glob.glob(str(directory) + str("/*.json")): if "MAIN-RELAX" in a: main_inc = str(a.split(".json")[0]) + str("/") + str("INCAR") main_inc_obj = Incar.from_file(main_inc) convg_encut = float(main_inc_obj["ENCUT"]) elif "ENCUT" in a: run = str(a.split(".json")[0]) + str("/") + str("vasprun.xml") contcar = Structure.from_file((a.split(".json")[0]) + str("/") + str("CONTCAR")) vrun = Vasprun(run) infile = str(a.split(".json")[0]) + str("/") + str("INCAR") inc = Incar.from_file(infile) encut = inc["ENCUT"] en = float( vrun.final_energy) # /float(contcar.composition.num_atoms) x.append(encut) y.append(en) order = np.argsort(x) xs = np.array(x)[order] ys = np.array(y)[order] plt = get_publication_quality_plot(14, 10) plt.ylabel("Energy (eV)") plt.plot(xs, ys, "s-", linewidth=2, markersize=10) plt.xlabel("Increment in ENCUT ") ax = plt.gca() ax.get_yaxis().get_major_formatter().set_useOffset(False) plt.title(str("Converged at ") + str(int(convg_encut)) + str("eV"), fontsize=26) # filename=str('Encut.png') plt.tight_layout() if plot == True: plt.savefig(filename) plt.close() return plt, convg_encut
def test_finite_difference_ncore(self): h = VaspErrorHandler("vasp.fd_ncore") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["dfpt_ncore"]) incar = Incar.from_file("INCAR") self.assertTrue("NPAR" not in incar) self.assertTrue("NCORE" not in incar)
def get_directories_VaspJobNotDone(root_dir): with cd(root_dir): ### avoid the link problems root_dir_real = os.getcwd() scan = subprocess.Popen(['find', root_dir_real, '-name', 'POSCAR'], stdout=subprocess.PIPE) scan.wait() pos_coll = scan.stdout.read().split() pos_dirs = [os.path.split(i)[0] for i in pos_coll] vaspjob_dirs = [] for dir in pos_dirs: try: pos = Poscar.from_file(os.path.join(dir, 'POSCAR')) pot = Potcar.from_file(os.path.join(dir, 'POTCAR')) incar = Incar.from_file(os.path.join(dir, 'INCAR')) kpt = Kpoints.from_file(os.path.join(dir, 'KPOINTS')) except: print 'input files are not ready in %s' % dir else: try: out = Outcar(os.path.join(dir, 'OUTCAR')) if len(out.run_stats) != 7: vaspjob_dir.append(dir) except: vaspjob_dirs.append(dir) return vaspjob_dirs
def generate_input(self, directory, step, xc, import_kpath): flags = {} flags.update(self.general_flags) flags.update(self.input_dict[step]) if step == 'scf': if xc == 'pbe': flags.update(self.input_dict[xc]) calc = Vasp2(self.atoms,directory=directory,kpts=self.struct_info['kgrid_'+xc],gamma=True,**flags) calc.write_input(self.atoms) if str(self.atoms.symbols) in ['Ni2O2']: mom_list = {'Ni':2,'Mn':5,'Co':3,'Fe':4} s = str(self.atoms.symbols[0]) incar_scf = Incar.from_file(directory+'/INCAR') incar_scf['MAGMOM'] = '%s -%s 0 0' %(mom_list[s],mom_list[s]) incar_scf.write_file(directory+'/INCAR') self.modify_poscar(path=directory) elif step == 'band': flags.update(self.input_dict[xc]) calc = Vasp2(self.atoms,directory=directory,gamma=True,**flags) calc.write_input(self.atoms) self.modify_poscar(path=directory) if xc == 'pbe': self.kpt4pbeband(directory, import_kpath) elif xc == 'hse': print(directory) self.kpt4hseband(directory, import_kpath)
def run_task(self, fw_spec): chgcar_start = False # read the VaspInput from the previous run poscar = Poscar.from_file(zpath('POSCAR')) incar = Incar.from_file(zpath('INCAR')) # figure out what GGA+U values to use and override them # LDAU values to use mpvis = MPVaspInputSet() ggau_incar = mpvis.get_incar(poscar.structure).as_dict() incar_updates = {k: ggau_incar[k] for k in ggau_incar.keys() if 'LDAU' in k} for k in ggau_incar: # update any parameters not set explicitly in previous INCAR if k not in incar and k in ggau_incar: incar_updates[k] = ggau_incar[k] incar.update(incar_updates) # override the +U keys # start from the CHGCAR of previous run if os.path.exists('CHGCAR'): incar['ICHARG'] = 1 chgcar_start = True # write back the new INCAR to the current directory incar.write_file('INCAR') return FWAction(stored_data={'chgcar_start': chgcar_start})
def test_aliasing_incar(self): os.chdir(os.path.join(test_dir, "aliasing")) shutil.copy("INCAR", "INCAR.orig") h = AliasingErrorHandler("vasp.aliasing_incar") h.check() d = h.correct() self.assertEqual(d["errors"], ['aliasing_incar']) self.assertEqual(d["actions"], [{'action': {'_unset': {'NGY':1, 'NGZ': 1}}, 'dict': 'INCAR'}, {"file": "CHGCAR", "action": {"_file_delete": {'mode': "actual"}}}, {"file": "WAVECAR", "action": {"_file_delete": {'mode': "actual"}}}]) incar = Incar.from_file('INCAR.orig') incar["ICHARG"] = 10 incar.write_file("INCAR") d = h.correct() self.assertEqual(d["errors"], ['aliasing_incar']) self.assertEqual(d["actions"], [{'action': {'_unset': {'NGY': 1, 'NGZ': 1}}, 'dict': 'INCAR'}]) shutil.move("INCAR.orig", "INCAR") clean_dir() os.chdir(test_dir)
def postprocess(self): """ Postprocessing includes renaming and gzipping where necessary. Also copies the magmom to the incar if necessary """ for f in VASP_OUTPUT_FILES + [self.output_file]: if os.path.exists(f): if self.final and self.suffix != "": shutil.move(f, "{}{}".format(f, self.suffix)) elif self.suffix != "": shutil.copy(f, "{}{}".format(f, self.suffix)) if self.copy_magmom and not self.final: try: outcar = Outcar("OUTCAR") magmom = [m["tot"] for m in outcar.magnetization] incar = Incar.from_file("INCAR") incar["MAGMOM"] = magmom incar.write_file("INCAR") except Exception: logger.error("MAGMOM copy from OUTCAR to INCAR failed") # Remove continuation so if a subsequent job is run in # the same directory, will not restart this job. if os.path.exists("continue.json"): os.remove("continue.json")
def test_check(self): shutil.copy("INCAR", "INCAR.orig") h = DriftErrorHandler(max_drift=0.05, to_average=11) self.assertFalse(h.check()) h = DriftErrorHandler(max_drift=0.05) self.assertFalse(h.check()) h = DriftErrorHandler(max_drift=0.0001) self.assertFalse(h.check()) incar = Incar.from_file("INCAR") incar["EDIFFG"] = -0.01 incar.write_file("INCAR") h = DriftErrorHandler(max_drift=0.0001) self.assertTrue(h.check()) h = DriftErrorHandler() h.check() self.assertEqual(h.max_drift, 0.01) clean_dir() shutil.move("INCAR.orig", "INCAR")
def test_check_correct_scan_metal(self): h = ScanMetalHandler() self.assertTrue(h.check()) d = h.correct() self.assertEqual(d["errors"], ["ScanMetal"]) self.assertEqual(Incar.from_file("INCAR")["KSPACING"], 0.22) os.remove("vasprun.xml")
def driver(): pwd = os.getcwd() num_jobs_in_workflow = check_num_jobs_in_workflow(pwd) with open(os.path.join(pwd, 'WORKFLOW_CONVERGENCE'), 'w') as f: f.write('WORKFLOW_CONVERGED = False') f.close() if num_jobs_in_workflow > 1: if check_path_exists(os.path.join(pwd, 'WORKFLOW_NAME')): workflow_file = Incar.from_file(os.path.join(pwd, 'WORKFLOW_NAME')) workflow_name = workflow_file['NAME'] else: print('\n#---------------------------------#\n') workflow_name = input("Please enter a name for this workflow: ") print('\n#---------------------------------#\n') with open(os.path.join(pwd, 'WORKFLOW_NAME'), 'w') as f: writeline = 'NAME = ' + str(workflow_name) f.write(writeline) f.close() else: workflow_name = get_single_job_name(pwd) # need dependencies for vasp_run_main computed_entries = vasp_run_main(pwd) if computed_entries is None: pass else: with open(os.path.join(pwd, str(workflow_name) + '_converged.json'), 'w') as f: json.dump(computed_entries, f)
def setup(self): """ setup static jobs for all the calibrate objects copies CONTCAR to POSCAR sets NSW = 0 """ for cal in self.cal_objs: for i, jdir in enumerate(cal.old_job_dir_list): job_dir = self.job_dir + os.sep \ + jdir.replace(os.sep, '_').replace('.', '_') \ + os.sep + 'STATIC' logger.info('setting up job in {}'.format(job_dir)) cal.incar = Incar.from_file(jdir + os.sep + 'INCAR') cal.incar['EDIFF'] = '1E-6' cal.incar['NSW'] = 0 cal.potcar = Potcar.from_file(jdir + os.sep + 'POTCAR') cal.kpoints = Kpoints.from_file(jdir + os.sep + 'KPOINTS') contcar_file = jdir + os.sep + 'CONTCAR' if os.path.isfile(contcar_file): logger.info('setting poscar file from {}' .format(contcar_file)) cal.poscar = Poscar.from_file(contcar_file) cal.add_job(job_dir=job_dir) else: logger.critical("""CONTCAR doesnt exist. Setting up job using input set in the old calibration directory""") cal.poscar = Poscar.from_file(jdir + os.sep + 'POSCAR') cal.add_job(job_dir=job_dir)
def test_point_group_vasp6(self): # the error message is formatted differently in VASP6 compared to VASP5 h = VaspErrorHandler("vasp6.point_group") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["point_group"]) i = Incar.from_file("INCAR") self.assertEqual(i["ISYM"], 0)
def test_inv_rot_matrix_vasp6(self): # the error message is formatted differently in VASP6 compared to VASP5 h = VaspErrorHandler("vasp6.inv_rot_mat") self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["inv_rot_mat"]) i = Incar.from_file("INCAR") self.assertEqual(i["SYMPREC"], 1e-08)
def check(self): incar = Incar.from_file(self.incar) nelm = incar.get("NELM", 60) unconverged_line = f":{nelm:4d}" with open(self.oszicar, "r") as fr: return any(unconverged_line in line for line in fr)
def test_aliasing_incar(self): os.chdir(os.path.join(test_dir, "aliasing")) shutil.copy("INCAR", "INCAR.orig") h = AliasingErrorHandler("vasp.aliasing_incar") h.check() d = h.correct() self.assertEqual(d["errors"], ["aliasing_incar"]) self.assertEqual( d["actions"], [ { "action": { "_unset": { "NGY": 1, "NGZ": 1 } }, "dict": "INCAR" }, { "file": "CHGCAR", "action": { "_file_delete": { "mode": "actual" } } }, { "file": "WAVECAR", "action": { "_file_delete": { "mode": "actual" } } }, ], ) incar = Incar.from_file("INCAR.orig") incar["ICHARG"] = 10 incar.write_file("INCAR") d = h.correct() self.assertEqual(d["errors"], ["aliasing_incar"]) self.assertEqual( d["actions"], [{ "action": { "_unset": { "NGY": 1, "NGZ": 1 } }, "dict": "INCAR" }], ) shutil.move("INCAR.orig", "INCAR") clean_dir() os.chdir(test_dir)
def setup(self): """ setup static jobs for all the calibrate objects copies CONTCAR to POSCAR sets NSW = 0 """ for cal in self.cal_objs: for i, jdir in enumerate(cal.old_job_dir_list): job_dir = self.job_dir + os.sep \ + jdir.replace(os.sep, '_').replace('.', '_') \ + os.sep + 'STATIC' logger.info('setting up job in {}'.format(job_dir)) cal.incar = Incar.from_file(jdir + os.sep + 'INCAR') cal.incar['EDIFF'] = '1E-6' cal.incar['NSW'] = 0 cal.potcar = Potcar.from_file(jdir + os.sep + 'POTCAR') cal.kpoints = Kpoints.from_file(jdir + os.sep + 'KPOINTS') contcar_file = jdir + os.sep + 'CONTCAR' if os.path.isfile(contcar_file): logger.info( 'setting poscar file from {}'.format(contcar_file)) cal.poscar = Poscar.from_file(contcar_file) cal.add_job(job_dir=job_dir) else: logger.critical("""CONTCAR doesnt exist. Setting up job using input set in the old calibration directory""") cal.poscar = Poscar.from_file(jdir + os.sep + 'POSCAR') cal.add_job(job_dir=job_dir)
def _find_irr_k_points(directory): """ Determine the number of irreducible k-points based on the VASP input files in a directory. Args: directory (str): Path to the directory that contains the VASP input files. Returns: int: Number of irreducible k-points. """ # TODO Still fails for many calculations. warnings.warn("Currently, the _find_irr_k_points method still fails regularly " "to find the same number of irreducible k-points as VASP. Use " "with care.") directory = os.path.abspath(directory) structure = Structure.from_file(os.path.join(directory, "POSCAR")) incar = Incar.from_file(os.path.join(directory, "INCAR")) if incar.get("MAGMOM", None) is not None: structure.add_site_property("magmom", incar.get("MAGMOM", None)) structure.add_oxidation_state_by_site( [round(magmom, 3) for magmom in structure.site_properties["magmom"]] ) kpoints = Kpoints.from_file(os.path.join(directory, "KPOINTS")) spg = SpacegroupAnalyzer(structure, symprec=1e-5) return len(spg.get_ir_reciprocal_mesh(kpoints.kpts))
def run_task(self, fw_spec): directory = self.get("directory", os.getcwd()) multiplier = self.get("multiplier", 3) os.chdir(directory) nelect_written = False try: with open("OUTCAR", "r") as file: if "NELECT" in file.read(): nelect_written = True except FileNotFoundError: pass if not nelect_written: # Do a trial run to figure out the number of standard bands stdout_file = "temp.out" stderr_file = "temp.out" vasp_cmd = fw_spec["_fw_env"]["vasp_cmd"].split(" ") with open(stdout_file, 'w') as f_std, \ open(stderr_file, "w", buffering=1) as f_err: p = subprocess.Popen(vasp_cmd, stdout=f_std, stderr=f_err, preexec_fn=os.setsid) while not nelect_written: try: with open("OUTCAR", "r") as file: if "NELECT" in file.read(): nelect_written = True except FileNotFoundError: pass time.sleep(1) os.killpg(os.getpgid(p.pid), signal.SIGTERM) time.sleep(3) os.remove(os.path.join(directory, "temp.out")) outcar = Outcar("OUTCAR") incar = Incar.from_file("INCAR") pattern = r"\s+NELECT\s=\s+(\d+).\d+\s+total\snumber\sof\selectrons" outcar.read_pattern({"nelect": pattern}) nions = len(Structure.from_file("POSCAR")) nelect = int(outcar.data["nelect"][0][0]) ispin = int(incar.get("ISPIN", 1)) if ispin == 1: nbands = int(round(nelect / 2 + nions / 2)) * multiplier elif ispin == 2: nbands = int(nelect * 3 / 5 + nions) * multiplier else: raise ValueError("ISPIN Value is not set to 1 or 2!") incar.update({"NBANDS": nbands}) incar.write_file("INCAR")
def calc_charge_state(args): poscar = Poscar.from_file(args.dir / "POSCAR") potcar = Potcar.from_file(args.dir / "POTCAR") incar = Incar.from_file(args.dir / "INCAR") charge_state = get_defect_charge_state(poscar, potcar, incar) logger.info(f"Charge state in {args.dir} is {charge_state}.") return charge_state
def test_check_correct_large_sigma(self): h = LargeSigmaHandler() self.assertTrue(h.check()) d = h.correct() self.assertEqual(d["errors"], ["LargeSigma"]) self.assertEqual(Incar.from_file("INCAR")["SIGMA"], 1.44) os.remove("vasprun.xml")
def test_nicht_konv(self): h = VaspErrorHandler("vasp.nicht_konvergent") h.natoms_large_cell = 5 self.assertEqual(h.check(), True) self.assertEqual(h.correct()["errors"], ["nicht_konv"]) i = Incar.from_file("INCAR") self.assertEqual(i["LREAL"], True)
def get_inputs(self, sync=False): """ Read inputs from Job directory """ if sync: self.sync_from_hpc() inputs = {} structures = [] path = op.abspath(self.path) dirs = [d[0] for d in os.walk(path)] for d in dirs: image_name = op.relpath(d, start=path) if all( c.isdigit() for c in list(image_name) ): #check if folder is image (all characters in folder rel path need to be numbers) image_path = d structure = Poscar.from_file(op.join(image_path, 'POSCAR')).structure structures.append(structure) inputs['structures'] = structures inputs['INCAR'] = Incar.from_file(op.join(path, 'INCAR')) inputs['KPOINTS'] = Kpoints.from_file(op.join(path, 'KPOINTS')) inputs['POTCAR'] = Potcar.from_file(op.join(path, 'POTCAR')) self.inputs = inputs return
def write_wannier_input_file(S, spin_polarized=True, write_incar=True): string = """Begin Projections random End Projections guiding_centres=true bands_plot = true begin kpoint_path\n""" string += get_kpoints_wannier(S) + '\n' string += 'end kpoint_path\n' if spin_polarized: string += 'spinors=true\n' w = open('wannier90.win', 'w') w.write(string) w.close() #write INCAR if write_incar: incar = Incar.from_string("""ISMEAR = -5 # usefull energy range for density of states ALGO = None ; NELM = 1 # exact diagonalization one step suffices NBANDS = 96 # need for a lot of bands in GW LORBIT = 11 LWRITE_MMN_AMN = TRUE LWANNIER90_RUN = .TRUE.""") try: NBANDS = Incar.from_file('../../step1/INCAR')['NBANDS'] except: NBANDS = Incar.from_file('../INCAR')['NBANDS'] if spin_polarized: if os.path.exists('POSCAR'): incar.update({ 'LORBIT': 11, 'ISPIN': 2, 'MAGMOM': get_magmom_string(Structure.from_file('POSCAR')) }) else: raise IOError('No POSCAR found at ' + os.getcwd()) incar.update({'NBANDS': NBANDS}) incar.write_file('INCAR')
def setup(self): """ Performs initial setup for VaspNEBJob, including overriding any settings and backing up. """ neb_dirs = self.neb_dirs if self.backup: # Back up KPOINTS, INCAR, POTCAR for f in VASP_NEB_INPUT_FILES: shutil.copy(f, "{}.orig".format(f)) # Back up POSCARs for path in neb_dirs: poscar = os.path.join(path, "POSCAR") shutil.copy(poscar, "{}.orig".format(poscar)) if self.half_kpts and os.path.exists("KPOINTS"): kpts = Kpoints.from_file("KPOINTS") kpts.kpts = np.maximum(np.array(kpts.kpts) / 2, 1) kpts.kpts = kpts.kpts.astype(int).tolist() if tuple(kpts.kpts[0]) == (1, 1, 1): kpt_dic = kpts.as_dict() kpt_dic["generation_style"] = "Gamma" kpts = Kpoints.from_dict(kpt_dic) kpts.write_file("KPOINTS") if self.auto_npar: try: incar = Incar.from_file("INCAR") import multiprocessing # Try sge environment variable first # (since multiprocessing counts cores on the current # machine only) ncores = os.environ.get( "NSLOTS") or multiprocessing.cpu_count() ncores = int(ncores) for npar in range(int(math.sqrt(ncores)), ncores): if ncores % npar == 0: incar["NPAR"] = npar break incar.write_file("INCAR") except Exception: pass if self.auto_continue and os.path.exists("STOPCAR") and not os.access( "STOPCAR", os.W_OK): # Remove STOPCAR os.chmod("STOPCAR", 0o644) os.remove("STOPCAR") # Copy CONTCAR to POSCAR for path in self.neb_sub: contcar = os.path.join(path, "CONTCAR") poscar = os.path.join(path, "POSCAR") shutil.copy(contcar, poscar) if self.settings_override is not None: VaspModder().apply_actions(self.settings_override)
def test_optics(self): self.mpopticsparamset = MPOpticsNonSCFVaspInputSet.from_previous_vasp_run( '{}/static_silicon'.format(test_dir), output_dir='optics_test_dir', nedos=1145) self.assertTrue(os.path.exists('optics_test_dir/CHGCAR')) incar = Incar.from_file('optics_test_dir/INCAR') self.assertTrue(incar['LOPTICS']) self.assertEqual(incar['NEDOS'], 1145) #Remove the directory in which the inputs have been created shutil.rmtree('optics_test_dir')
def setUp(self): filepath = self.TEST_FILES_DIR / 'INCAR' incar = Incar.from_file(filepath) filepath = self.TEST_FILES_DIR / 'POSCAR' poscar = Poscar.from_file(filepath,check_for_POTCAR=False) if "PMG_VASP_PSP_DIR" not in os.environ: os.environ["PMG_VASP_PSP_DIR"] = str(self.TEST_FILES_DIR) filepath = self.TEST_FILES_DIR / 'POTCAR' potcar = Potcar.from_file(filepath) filepath = self.TEST_FILES_DIR / 'KPOINTS.auto' kpoints = Kpoints.from_file(filepath) self.vinput = VaspInput(incar, kpoints, poscar, potcar)
def test_write(self): tmp_dir = "VaspInput.testing" self.vinput.write_input(tmp_dir) filepath = os.path.join(tmp_dir, "INCAR") incar = Incar.from_file(filepath) self.assertEqual(incar["NSW"], 99) for name in ("INCAR", "POSCAR", "POTCAR", "KPOINTS"): os.remove(os.path.join(tmp_dir, name)) os.rmdir(tmp_dir)
def test_write(self): tmp_dir = Path("VaspInput.testing") self.vinput.write_input(tmp_dir) filepath = tmp_dir / "INCAR" incar = Incar.from_file(filepath) self.assertEqual(incar["NSW"], 99) for name in ("INCAR", "POSCAR", "POTCAR", "KPOINTS"): (tmp_dir / name).unlink() tmp_dir.rmdir()
def run_hse_prep_calculation(dim=2, submit=True): """ Submits a quick static calculation to calculate the IBZKPT file using a smaller number of k-points (200/atom instead of 1000/atom). The other outputs from this calculation are essentially useless. Args: dim (int): 2 for relaxing a 2D material, 3 for a 3D material. submit (bool): Whether or not to submit the job. """ if not os.path.isdir('hse_prep'): os.mkdir('hse_prep') os.chdir('hse_prep') os.system('cp ../CONTCAR ./POSCAR') if os.path.isfile('../POTCAR'): os.system('cp POTCAR .') relax(dim=2, submit=False) incar_dict = Incar.from_file('INCAR').as_dict() incar_dict.update({'NSW': 0, 'NELM': 1, 'LWAVE': False, 'LCHARG': False, 'LAECHG': False}) Incar.from_dict(incar_dict).write_file('INCAR') Kpoints.automatic_density( Structure.from_file('POSCAR'), 200 ).write_file('KPOINTS') if dim == 2: kpts_lines = open('KPOINTS').readlines() with open('KPOINTS', 'w') as kpts: for line in kpts_lines[:3]: kpts.write(line) kpts.write(kpts_lines[3].split()[0] + ' ' + kpts_lines[3].split()[1] + ' 1') if QUEUE == 'pbs': write_pbs_runjob('{}_prep'.format( os.getcwd().split('/')[-2]), 1, 16, '800mb', '6:00:00', VASP) submission_command = 'qsub runjob' elif QUEUE == 'slurm': write_slurm_runjob('{}_prep'.format( os.getcwd().split('/')[-2]), 16, '800mb', '6:00:00', VASP) submission_command = 'sbatch runjob' if submit: os.system(submission_command) os.chdir('../')
def test_write_inputset(self): name = 'Test' incar= Incar.from_file(TEST_STEP1+os.sep+'INCAR') kpoints = Kpoints.from_file(TEST_STEP1+os.sep+'KPOINTS') poscar = Poscar.from_file(TEST_STEP1+os.sep+'POSCAR') potcar = TEST_STEP1+os.sep+'DUMMY_POTSPEC' #potcar = #Potcar.from_dict({'@class': 'Potcar', 'functional': 'PBE',\ # 'symbols': ['Al'], '@module': 'pymatgen.io.vasp.inputs'}) reuse_path = [TEST_STEP1 + os.sep + 'COPY_FILE'] print (reuse_path) mvis = MPINTVaspInputSet(name,incar,poscar,potcar,kpoints,reuse_path=reuse_path,test=True) mvis.write_input(job_dir=TEST_STEP2) self.assertCountEqual(os.listdir(TEST_STEP2), ['INCAR','KPOINTS','POSCAR','COPY_FILE']) cleanup = [os.remove(TEST_STEP2+os.sep+f) for f in os.listdir(TEST_STEP2)]
def setUp(self): filepath = os.path.join(test_dir, 'INCAR') incar = Incar.from_file(filepath) filepath = os.path.join(test_dir, 'POSCAR') poscar = Poscar.from_file(filepath,check_for_POTCAR=False) if "PMG_VASP_PSP_DIR" not in os.environ: test_potcar_dir = os.path.abspath( os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "test_files")) os.environ["PMG_VASP_PSP_DIR"] = test_potcar_dir filepath = os.path.join(test_dir, 'POTCAR') potcar = Potcar.from_file(filepath) filepath = os.path.join(test_dir, 'KPOINTS.auto') kpoints = Kpoints.from_file(filepath) self.vinput = VaspInput(incar, kpoints, poscar, potcar)
def setUp(self): filepath = os.path.join(test_dir, "INCAR") incar = Incar.from_file(filepath) filepath = os.path.join(test_dir, "POSCAR") poscar = Poscar.from_file(filepath) if "VASP_PSP_DIR" not in os.environ: test_potcar_dir = os.path.abspath( os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "test_files") ) os.environ["VASP_PSP_DIR"] = test_potcar_dir filepath = os.path.join(test_dir, "POTCAR") potcar = Potcar.from_file(filepath) filepath = os.path.join(test_dir, "KPOINTS.auto") kpoints = Kpoints.from_file(filepath) self.vinput = VaspInput(incar, kpoints, poscar, potcar)
def setup(self): """ setup solvation jobs for the calibrate objects copies WAVECAR and sets the solvation params in the incar file also dumps system.json file in each directory for the database crawler mind: works only for cal objects that does only single calculations """ for cal in self.cal_objs: jdir = cal.old_job_dir_list[0] cal.poscar = Poscar.from_file(jdir + os.sep + 'POSCAR') cal.potcar = Potcar.from_file(jdir + os.sep + 'POTCAR') cal.kpoints = Kpoints.from_file(jdir + os.sep + 'KPOINTS') cal.incar = Incar.from_file(jdir + os.sep + 'INCAR') cal.incar['LSOL'] = '.TRUE.' syms = [site.specie.symbol for site in cal.poscar.structure] zvals = {p.symbol: p.nelectrons for p in cal.potcar} nelectrons = sum([zvals[a[0]] * len(tuple(a[1])) for a in itertools.groupby(syms)]) keys = [k for k in self.sol_params.keys() if self.sol_params[k]] prod_list = [self.sol_params.get(k) for k in keys] for params in itertools.product(*tuple(prod_list)): job_dir = self.job_dir + os.sep \ + cal.old_job_dir_list[0].replace(os.sep, '_').replace('.', '_') \ + os.sep + 'SOL' for i, k in enumerate(keys): if k == 'NELECT': cal.incar[k] = params[i] + nelectrons else: cal.incar[k] = params[i] job_dir = job_dir + os.sep + k + os.sep + str( cal.incar[k]).replace('.', '_') if not os.path.exists(job_dir): os.makedirs(job_dir) with open(job_dir + os.sep + 'system.json', 'w') as f: json.dump(dict(list(zip(keys, params))), f) wavecar_file = cal.old_job_dir_list[0] + os.sep + 'WAVECAR' if os.path.isfile(wavecar_file): shutil.copy(wavecar_file, job_dir + os.sep + 'WAVECAR') cal.add_job(job_dir=job_dir) else: logger.critical('WAVECAR doesnt exist. Aborting ...') sys.exit(0)
def plot_density_of_states(xlim=(-10, 5), ylim=(-1.5, 1.5), fmt='pdf'): """ Plots the density of states from the DOSCAR in the cwd. Plots spin up in red, down in green, and the sum in black. Efermi = 0. Args: xlim (tuple): minimum and maximum energies for the plot's x-axis. ylim (tuple): minimum and maximum for the plot's y-axis. fmt (str): matplotlib format style. Check the matplotlib docs for options. """ efermi = Vasprun('vasprun.xml').efermi dos_lines = open ('DOSCAR').readlines() x, up, down = [], [], [] nedos = Incar.from_file('INCAR').as_dict()['NEDOS'] - 1 for line in dos_lines[6:6+nedos]: split_line = line.split() x.append(float(split_line[0]) - efermi) up.append(float(split_line[1])) down.append(-float(split_line[2])) x, up, down = np.array(x), np.array(up), np.array(down) sum = up + down ax = plt.figure().gca() ax.set_xlim(xlim[0], xlim[1]) ax.set_ylim(ylim[0], ylim[1]) ax.set_xlabel(r'$\mathrm{E\/(eV)}$') ax.set_ylabel(r'$\mathrm{Density\/of\/States$') ax.set_xticklabels([r'$\mathrm{%s}$' % t for t in ax.get_xticklabels()]) ax.set_yticklabels([r'$\mathrm{%s}$' % t for t in ax.get_yticklabels()]) ax.plot(x, up, color='red' ) ax.plot(x, down, color='green') ax.plot(x, sum, color='black' ) if fmt is not None: plt.savefig('density_of_states.{}'.format(fmt)) else: return ax plt.close()
def setup(self): """ setup static jobs for the calibrate objects copies CONTCAR to POSCAR sets NSW = 0 write system.json file for database crawler """ d = {} for cal in self.cal_objs: for i, jdir in enumerate(cal.old_job_dir_list): job_dir = self.job_dir + os.sep \ + jdir.replace(os.sep, '_').replace('.', '_') + \ os.sep + 'STATIC' cal.incar = Incar.from_file(jdir + os.sep + 'INCAR') cal.incar['EDIFF'] = '1E-6' cal.incar['NSW'] = 0 cal.potcar = Potcar.from_file(jdir + os.sep + 'POTCAR') cal.kpoints = Kpoints.from_file(jdir + os.sep + 'KPOINTS') contcar_file = jdir + os.sep + 'CONTCAR' if os.path.isfile(contcar_file): cal.poscar = Poscar.from_file(contcar_file) if cal in self.cal_slabs or cal in self.cal_interfaces: try: d['hkl'] = cal.system['hkl'] except: logger.critical("""the calibrate object doesnt have a system set for calibrating""") if cal in self.cal_interfaces: try: d['ligand'] = cal.system['ligand']['name'] except: logger.critical("""the calibrate object doesnt have a system set for calibrating""") if not os.path.exists(job_dir): os.makedirs(job_dir) if d: with open(job_dir + os.sep + 'system.json', 'w') as f: json.dump(d, f) cal.add_job(job_dir=job_dir) else: logger.critical("""CONTCAR doesnt exist. Setting up job using input set in the old calibration directory""") cal.poscar = Poscar.from_file(jdir + os.sep + 'POSCAR') cal.add_job(job_dir=job_dir)
def test_init(self): prev_run = os.path.join(test_dir, "relaxation") vis = MPNonSCFSet.from_prev_calc( prev_calc_dir=prev_run, mode="Line", copy_chgcar=False) self.assertEqual(vis.incar["NSW"], 0) # Check that the ENCUT has been inherited. self.assertEqual(vis.incar["ENCUT"], 600) self.assertEqual(vis.kpoints.style, Kpoints.supported_modes.Reciprocal) # Check as from dict. vis = MPNonSCFSet.from_dict(vis.as_dict()) self.assertEqual(vis.incar["NSW"], 0) # Check that the ENCUT has been inherited. self.assertEqual(vis.incar["ENCUT"], 600) self.assertEqual(vis.kpoints.style, Kpoints.supported_modes.Reciprocal) vis.write_input(self.tmp) self.assertFalse(os.path.exists(os.path.join(self.tmp, "CHGCAR"))) vis = MPNonSCFSet.from_prev_calc(prev_calc_dir=prev_run, mode="Line", copy_chgcar=True) vis.write_input(self.tmp) self.assertTrue(os.path.exists(os.path.join(self.tmp, "CHGCAR"))) # Code below is just to make sure that the parameters are the same # between the old MPStaticVaspInputSet and the new MPStaticSet. # TODO: Delete code below in future. MPNonSCFVaspInputSet.from_previous_vasp_run( previous_vasp_dir=prev_run, output_dir=self.tmp, mode="Line") incar = Incar.from_file(os.path.join(self.tmp, "INCAR")) for k, v1 in vis.incar.items(): v2 = incar.get(k) try: v1 = v1.upper() v2 = v2.upper() except: # Convert strings to upper case for comparison. Ignore other # types. pass self.assertEqual(v1, v2, str(v1)+str(v2)) kpoints = Kpoints.from_file(os.path.join(self.tmp, "KPOINTS")) self.assertEqual(kpoints.style, vis.kpoints.style) self.assertArrayAlmostEqual(kpoints.kpts, vis.kpoints.kpts)
def plot_density_of_states(fmt="pdf"): """ Plots the density of states from the DOSCAR in the cwd. Plots spin up in red, down in green, and the sum in black. Efermi = 0. Args: fmt (str): matplotlib format style. Check the matplotlib docs for options. """ efermi = Vasprun("vasprun.xml").efermi ticks = [-10, -5, -3, -2, -1, 0, 1, 2, 3, 5] dos_lines = open("DOSCAR").readlines() x, up, down = np.array(), np.array(), np.array() nedos = Incar.from_file("INCAR").as_dict()["NEDOS"] - 1 for line in dos_lines[6 : 6 + nedos]: split_line = line.split() x.append(float(split_line[0]) - efermi) up.append(float(split_line[1])) down.append(-float(split_line[2])) sum = up + down ax = plt.figure().gca() ax.set_xlim(-10, 5) ax.set_ylim(-1.5, 1.5) ax.set_xlabel("E (eV)") ax.set_ylabel("Density of States") ax.set_xticks(ticks) ax.plot(x, up, color="red") ax.plot(x, down, color="green") ax.plot(x, sum, color="black") plt.savefig("density_of_states.{}".format(fmt)) plt.close()
def check_incar(task_type): errors = [] incar = Incar.from_file("INCAR") if 'deformed' in task_type: if incar['ISIF'] != 2: errors.append("Deformed optimization requires ISIF = 2") if 'static' in task_type or 'Uniform' in task_type or 'band structure' in task_type: if incar["IBRION"] != -1: errors.append("IBRION should be -1 for non structure optimization runs") if "NSW" in incar and incar["NSW"] != 0: errors.append("NSW must be 0 for non structure optimization runs") if 'static' in task_type and not incar["LCHARG"]: errors.append("LCHARG must be True for static runs") if 'Uniform' in task_type and incar["ICHARG"]!=11: errors.append("ICHARG must be 11 for Uniform runs") if 'band structure' in task_type and incar["ICHARG"]!=11: errors.append("ICHARG must be 11 for band structure runs") if 'GGA+U' in task_type: # check LDAU if not incar["LDAU"]: errors.append("GGA+U requires LDAU parameter") if not incar["LMAXMIX"] >= 4: errors.append("GGA+U requires LMAXMIX >= 4") if not sum(incar["LDAUU"]) > 0: errors.append("GGA+U requires sum(LDAUU)>0") return errors
def run_task(self, fw_spec): incar = Incar.from_file(zpath("INCAR")) incar.update({"ISIF": 2}) incar.write_file("INCAR") return FWAction()
def run_gamma_calculations(submit=True, step_size=0.5): """ Setup a 2D grid of static energy calculations to plot the Gamma surface between two layers of the 2D material. These calculations are run and stored in subdirectories under 'friction/lateral'. Args: submit (bool): Whether or not to submit the jobs. step_size (float): the distance between grid points in Angstroms. """ if not os.path.isdir('friction'): os.mkdir('friction') os.chdir('friction') if not os.path.isdir('lateral'): os.mkdir('lateral') os.chdir('lateral') os.system('cp ../../CONTCAR POSCAR') # Pad the bottom layer with 20 Angstroms of vacuum. utl.ensure_vacuum(Structure.from_file('POSCAR'), 20) structure = Structure.from_file('POSCAR') n_sites_per_layer = structure.num_sites n_divs_x = int(math.ceil(structure.lattice.a / step_size)) n_divs_y = int(math.ceil(structure.lattice.b / step_size)) # Get the thickness of the material. max_height = max([site.coords[2] for site in structure.sites]) min_height = min([site.coords[2] for site in structure.sites]) thickness = max_height - min_height # Make a new layer. species, coords = [], [] for site in structure.sites: # Original site species.append(site.specie) coords.append(site.coords) # New layer site species.append(site.specie) coords.append([site.coords[0], site.coords[1], site.coords[2] + thickness + 3.5]) Structure(structure.lattice, species, coords, coords_are_cartesian=True).to('POSCAR', 'POSCAR') for x in range(n_divs_x): for y in range(n_divs_y): dir = '{}x{}'.format(x, y) if not os.path.isdir(dir): os.mkdir(dir) # Copy input files os.chdir(dir) os.system('cp ../../../INCAR .') os.system('cp ../../../KPOINTS .') os.system('cp ../POSCAR .') if VDW_KERNEL: os.system('cp {} .'.format(VDW_KERNEL)) # Shift the top layer structure = Structure.from_file("POSCAR") all_z_coords = [s.coords[2] for s in structure.sites] top_layer = [s for s in structure.sites if s.coords[2] > np.mean(all_z_coords)] structure.remove_sites([i for i, s in enumerate(structure.sites) if s in top_layer]) for site in top_layer: structure.append( site.specie, [site.coords[0]+float(x)/float(n_divs_x), site.coords[1]+float(y)/float(n_divs_y), site.coords[2]], coords_are_cartesian=True ) structure = structure.get_sorted_structure() structure.to("POSCAR", "POSCAR") utl.write_potcar() incar_dict = Incar.from_file('INCAR').as_dict() incar_dict.update({'NSW': 0, 'LAECHG': False, 'LCHARG': False, 'LWAVE': False, 'LVTOT': False, 'MAGMOM': utl.get_magmom_string(structure)}) incar_dict.pop('NPAR', None) Incar.from_dict(incar_dict).write_file('INCAR') if QUEUE_SYSTEM == 'pbs': utl.write_pbs_runjob(dir, 1, 8, '1000mb', '2:00:00', VASP_STD_BIN) submission_command = 'qsub runjob' elif QUEUE_SYSTEM == 'slurm': utl.write_slurm_runjob(dir, 8, '1000mb', '2:00:00', VASP_STD_BIN) submission_command = 'sbatch runjob' if submit: os.system(submission_command) os.chdir('../') os.chdir('../../')
def run_normal_force_calculations(basin_and_saddle_dirs, spacings=np.arange(1.5, 4.25, 0.25), submit=True): """ Set up and run static calculations of the basin directory and saddle directory at specified interlayer spacings to get f_N and f_F. Args: basin_and_saddle_dirs (tuple): Can be obtained by the get_basin_and_peak_locations() function under friction.analysis. For example, run_normal_force_calculations(('0x0', '3x6')) or run_normal_force_calculations(get_basin_and_peak_locations()) will both work. spacings (tuple): list of interlayer spacings (in Angstroms, as floats) at which to run the calculations. submit (bool): Whether or not to submit the jobs. """ spacings = [str(spc) for spc in spacings] os.chdir('friction') if not os.path.isdir('normal'): os.mkdir('normal') os.chdir('normal') for spacing in spacings: if not os.path.isdir(spacing): os.mkdir(spacing) for subdirectory in basin_and_saddle_dirs: os.system('cp -r ../lateral/{} {}/'.format(subdirectory, spacing)) os.chdir('{}/{}'.format(spacing, subdirectory)) structure = Structure.from_file('POSCAR') n_sites = len(structure.sites) all_z_coords = [s.coords[2] for s in structure.sites] top_layer = [s for s in structure.sites if s.coords[2] > np.mean(all_z_coords)] bottom_of_top_layer = min([site.coords[2] for site in top_layer]) remove_indices = [i for i, s in enumerate(structure.sites) if s in top_layer] structure.remove_sites(remove_indices) top_of_bottom_layer = max( [site.coords[2] for site in structure.sites] ) for site in top_layer: structure.append( site.specie, [site.coords[0], site.coords[1], site.coords[2] - bottom_of_top_layer + top_of_bottom_layer + float(spacing)], coords_are_cartesian=True) structure = structure.get_sorted_structure() structure.to('POSCAR', 'POSCAR') utl.write_potcar() incar_dict = Incar.from_file('INCAR').as_dict() incar_dict.update({"MAGMOM": utl.get_magmom_string(structure)}) Incar.from_dict(incar_dict).write_file("INCAR") if QUEUE_SYSTEM == 'pbs': utl.write_pbs_runjob('{}_{}'.format( subdirectory, spacing), 1, 8, '1000mb', '2:00:00', VASP_STD_BIN) submission_command = 'qsub runjob' elif QUEUE_SYSTEM == 'slurm': utl.write_slurm_runjob('{}_{}'.format( subdirectory, spacing), 8, '1000mb', '2:00:00', VASP_STD_BIN) submission_command = 'sbatch runjob' if submit: os.system(submission_command) os.chdir('../../') os.chdir('../../')
def test_diff(self): incar = self.incar filepath1 = os.path.join(test_dir, 'INCAR') incar1 = Incar.from_file(filepath1) filepath2 = os.path.join(test_dir, 'INCAR.2') incar2 = Incar.from_file(filepath2) filepath3 = os.path.join(test_dir, 'INCAR.3') incar3 = Incar.from_file(filepath2) self.assertEqual( incar1.diff(incar2), {'Different': { 'NELM': {'INCAR1': None, 'INCAR2': 100}, 'ISPIND': {'INCAR1': 2, 'INCAR2': None}, 'LWAVE': {'INCAR1': True, 'INCAR2': False}, 'LDAUPRINT': {'INCAR1': None, 'INCAR2': 1}, 'MAGMOM': {'INCAR1': [6, -6, -6, 6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6], 'INCAR2': None}, 'NELMIN': {'INCAR1': None, 'INCAR2': 3}, 'ENCUTFOCK': {'INCAR1': 0.0, 'INCAR2': None}, 'HFSCREEN': {'INCAR1': 0.207, 'INCAR2': None}, 'LSCALU': {'INCAR1': False, 'INCAR2': None}, 'ENCUT': {'INCAR1': 500, 'INCAR2': None}, 'NSIM': {'INCAR1': 1, 'INCAR2': None}, 'ICHARG': {'INCAR1': None, 'INCAR2': 1}, 'NSW': {'INCAR1': 99, 'INCAR2': 51}, 'NKRED': {'INCAR1': 2, 'INCAR2': None}, 'NUPDOWN': {'INCAR1': 0, 'INCAR2': None}, 'LCHARG': {'INCAR1': True, 'INCAR2': None}, 'LPLANE': {'INCAR1': True, 'INCAR2': None}, 'ISMEAR': {'INCAR1': 0, 'INCAR2': -5}, 'NPAR': {'INCAR1': 8, 'INCAR2': 1}, 'SYSTEM': { 'INCAR1': 'Id=[0] dblock_code=[97763-icsd] formula=[li mn (p o4)] sg_name=[p n m a]', 'INCAR2': 'Id=[91090] dblock_code=[20070929235612linio-59.53134651-vasp] formula=[li3 ni3 o6] sg_name=[r-3m]'}, 'ALGO': {'INCAR1': 'Damped', 'INCAR2': 'Fast'}, 'LHFCALC': {'INCAR1': True, 'INCAR2': None}, 'TIME': {'INCAR1': 0.4, 'INCAR2': None}}, 'Same': {'IBRION': 2, 'PREC': 'Accurate', 'ISIF': 3, 'LMAXMIX': 4, 'LREAL': 'Auto', 'ISPIN': 2, 'EDIFF': 0.0001, 'LORBIT': 11, 'SIGMA': 0.05}}) self.assertEqual( incar1.diff(incar3), {'Different': { 'NELM': {'INCAR1': None, 'INCAR2': 100}, 'ISPIND': {'INCAR1': 2, 'INCAR2': None}, 'LWAVE': {'INCAR1': True, 'INCAR2': False}, 'LDAUPRINT': {'INCAR1': None, 'INCAR2': 1}, 'MAGMOM': {'INCAR1': [6, -6, -6, 6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6], 'INCAR2': None}, 'NELMIN': {'INCAR1': None, 'INCAR2': 3}, 'ENCUTFOCK': {'INCAR1': 0.0, 'INCAR2': None}, 'HFSCREEN': {'INCAR1': 0.207, 'INCAR2': None}, 'LSCALU': {'INCAR1': False, 'INCAR2': None}, 'ENCUT': {'INCAR1': 500, 'INCAR2': None}, 'NSIM': {'INCAR1': 1, 'INCAR2': None}, 'ICHARG': {'INCAR1': None, 'INCAR2': 1}, 'NSW': {'INCAR1': 99, 'INCAR2': 51}, 'NKRED': {'INCAR1': 2, 'INCAR2': None}, 'NUPDOWN': {'INCAR1': 0, 'INCAR2': None}, 'LCHARG': {'INCAR1': True, 'INCAR2': None}, 'LPLANE': {'INCAR1': True, 'INCAR2': None}, 'ISMEAR': {'INCAR1': 0, 'INCAR2': -5}, 'NPAR': {'INCAR1': 8, 'INCAR2': 1}, 'SYSTEM': { 'INCAR1': 'Id=[0] dblock_code=[97763-icsd] formula=[li mn (p o4)] sg_name=[p n m a]', 'INCAR2': 'Id=[91090] dblock_code=[20070929235612linio-59.53134651-vasp] formula=[li3 ni3 o6] sg_name=[r-3m]'}, 'ALGO': {'INCAR1': 'Damped', 'INCAR2': 'Fast'}, 'LHFCALC': {'INCAR1': True, 'INCAR2': None}, 'TIME': {'INCAR1': 0.4, 'INCAR2': None}}, 'Same': {'IBRION': 2, 'PREC': 'Accurate', 'ISIF': 3, 'LMAXMIX': 4, 'LREAL': 'Auto', 'ISPIN': 2, 'EDIFF': 0.0001, 'LORBIT': 11, 'SIGMA': 0.05}})
def test_write(self): tempfname = "INCAR.testing" self.incar.write_file(tempfname) i = Incar.from_file(tempfname) self.assertEqual(i, self.incar) os.remove(tempfname)
def assimilate(self, path): files = os.listdir(path) ciffilepath = None if any("relax1" in s for s in files) and any("relax2" in s for s in files): filepath = glob.glob(os.path.join(path, "vasprun.xml.relax2*"))[0] try: incarfilepath = glob.glob(os.path.join(path,'INCAR.relax1*'))[0] except: print path #Get cif from directory # if glob.glob(os.path.join(path,'*cif')): # ciffilepath = glob.glob(os.path.join(path,'*cif'))[0] contcarfile = glob.glob(os.path.join(path,"CONTCAR.relax2*"))[0] else: vasprun_files = glob.glob(os.path.join(path, "vasprun.xml*")) try: incarfilepath = glob.glob(os.path.join(path,"INCAR*"))[0] except: print path #Get cif from directory # if glob.glob(os.path.join(path,'*cif')): # ciffilepath = glob.glob(os.path.join(path,'*cif'))[0] contcarfile = glob.glob(os.path.join(path,"CONTCAR*"))[0] filepath = None if len(vasprun_files) == 1: filepath = vasprun_files[0] logging.debug(filepath) elif len(vasprun_files) > 1: """ This is a bit confusing, since there maybe be multi-steps. By default, assimilate will try to find a file simply named vasprun.xml, vasprun.xml.bz2, or vasprun.xml.gz. Failing which it will try to get a relax2 from an aflow style run if possible. Or else, a randomly chosen file containing vasprun.xml is chosen. """ for fname in vasprun_files: if os.path.basename(fname) in ["vasprun.xml", "vasprun.xml.gz", "vasprun.xml.bz2"]: filepath = fname break if re.search("relax2", fname): filepath = fname break filepath = fname try: vasprun = Vasprun(filepath) except Exception as ex: logger.debug("error in {}: {}".format(filepath, ex)) return None logging.debug('Done entry if') entry = vasprun.get_computed_entry(self._inc_structure, parameters=self._parameters, data=self._data) logging.debug(entry) entry.parameters["history"] = _get_transformation_history(path) incar = Incar.from_file(incarfilepath) try: entry.data['NUPDOWN'] = incar['NUPDOWN'] entry.data['ISMEAR'] = incar['ISMEAR'] except: pass logging.debug('Return Entry step') entry.data['CONTCAR_Structure'] = Structure.from_file(contcarfile,primitive=False) # if ciffilepath: # entry.data['Cif_Structure'] = Structure.from_file(ciffilepath,primitive=False) return entry
def setUp(self): file_name = os.path.join(test_dir, 'INCAR') self.incar = Incar.from_file(file_name)
def setup_poscar_jobs(self, scale_list=None, poscar_list=None): """ for scaling the latice vectors of the original structure, scale_list is volume scaling factor list """ if scale_list: for scale in scale_list: self.set_poscar(scale=scale) self.set_potcar() if not self.is_matrix: job_dir = self.job_dir + os.sep + 'POS' + \ os.sep + 'VOLUME_' + str(scale) self.add_job(name=job_dir, job_dir=job_dir) elif poscar_list: for pos in poscar_list: # if it is a twod_database run or any general standard database run, # the incar, kpoints and potcar follow a standard input set # which will be activated by the twod_database tag set to true # NOTE: this implementation means that the first turn_knobs tag # needs to be the poscar objects list # the database tag will be set to the name of the yaml file with the # standard input deck definition for that database # this incar dict provided as the init can be general format # based on the chosen functional, cutoff # so self.incar is a vdW incar for re-relaxation in vdW, gga for every # other calculation or LDA+U for LSDA+U calculations incar_dict = self.incar.as_dict() if self.reuse: # if this is a true list minimally, ['CONTCAR'] # it is to be ensured that the poscar list is a # list of paths as opposed to list of poscar objects by the turn knobs # values # Here pos is the path and r in each self.reuse is the name of the file(s) # to be reused # in a reuse calculation the following are possible: # update incar (Solvation calculations) or reset incar (HSE calculations) # reset kpoints file with IBZKPT # copy a CHGCAR or WAVECAR or both perhaps try: # first setup of POSCAR initial, INCAR, KPOINTS poscar = Poscar.from_file(pos + os.sep + 'CONTCAR') self.logger.info('Read previous relaxed CONTCAR file from {}'. format(pos)) # check if it is KPOINTS altering job like HSE if self.Grid_type == 'hse_bands_2D_prep': # HSE prep calcualtions # reset the INCAR file with a magmom only if exists try: incar_dict = { 'MAGMOM': get_magmom_string(poscar)} except: incar_dict = {} incar_dict = get_2D_incar_hse_prep(incar_dict) self.set_kpoints(poscar=poscar) self.logger.info( 'updated input set for HSE 2D prep calcaultion') elif self.Grid_type == 'hse_bands_2D': # HSE calculation # reset the incar and kpoints file builds # on the preceding calculations (prep calculation) # IBZKPT try: incar_dict = { 'MAGMOM': get_magmom_string(poscar)} except: incar_dict = {} incar_dict = get_2D_incar_hse(incar_dict) self.set_kpoints(poscar=poscar, ibzkpth=pos + os.sep + 'IBZKPT') self.logger.info('updated input set for HSE calcaultion\ using IBZKPT from {0}'.format(pos + os.sep + 'IBZKPT')) elif self.Grid_type == 'hse_bands': # general HSE bands pass elif self.Grid_type == 'Finer_G_Mesh': self.logger.info('updating to Finer G Mesh') kpoint = Kpoints.from_file(pos+os.sep+'KPOINTS') self.set_kpoints(kpoint=kpoint.kpts[0]) else: # use the same kpoints file and build from the old # incar self.kpoints = Kpoints.from_file( pos + os.sep + 'KPOINTS') # decide on how to use incar, use same one or # update or afresh if self.reuse_incar == 'old': incar_dict = Incar.from_file( pos + os.sep + 'INCAR').as_dict() elif self.reuse_incar == 'update': # way to go for cutoff updates, convergence, etc. # but retain the old functional incar_dict.update(Incar.from_file(pos + os.sep + 'INCAR'). as_dict()) else: # use a fresh incar as specified by the init # way to go for example for LDAU or other # major removals done to INCAR # but always retain the MAGMOM if present old_incar_dict = Incar.from_file( pos + os.sep + 'INCAR').as_dict() if 'MAGMOM' in old_incar_dict.keys(): incar_dict['MAGMOM'] = old_incar_dict[ 'MAGMOM'] else: incar_dict = incar_dict if isinstance(self.reuse, list): reuse_paths = [ pos + os.sep + r for r in self.reuse] self.reuse_paths = reuse_paths # Magnetism use cases, updates to be made to the INCAR (MAE) # and poscar (AFM) # MAE and AFM if self.magnetism == 'MAE': # remove vdW tags for MAE calculations vdW_tags = ('GGA', 'AGGAC', 'LUSE_VDW', 'PARAM1', 'PARAM2') for key in vdW_tags: if key in incar_dict: del incar_dict[key] self.logger.info( 'updating input set for MAE calculation') self.mag_init = Outcar( pos + os.sep + 'OUTCAR').total_mag nbands = 2 * \ Vasprun(pos + os.sep + 'vasprun.xml').parameters['NBANDS'] # u_value = Vasprun(pos+os.sep+'vasprun.xml').incar['LDAUU'] # u_value = 4.0 self.logger.info( "updating mag mom with value {0}".format(self.mag_init)) self.logger.info( "updating NBANDS with {0}".format(nbands)) incar_dict.update({'NBANDS': nbands, 'LSORBIT': True, 'EDIFF': 1e-08, 'ICHARG': 11, 'LMAXMIX': 4, 'LCHARG': False, 'ISYM': 0, 'NSW': 0, 'ISPIN': 2, 'IBRION': -1, 'LORBIT': 11, 'MAGMOM': get_magmom_mae(poscar, self.mag_init) }) # incar_dict.update({'LDAUU': u_value}) elif self.magnetism == 'AFM': self.logger.info( 'updating INCAR and POSCAR for AFM calculation') afm, poscar = get_magmom_afm(poscar, self.database) incar_dict.update({'MAGMOM': afm}) except: # check what to do if the previous calculation being reused is not # actuall done .. system exit or adopt a user override # with POSCAR self.logger.warn( 'Empty relaxed CONTCAR file .. Probably job not done') if not self.reuse_override: self.logger.warn( 'You can set reuse_override to continue with POSCAR file, exiting now ..') sys.exit(0) else: self.logger.info('Using old Poscar for rerun') poscar = Poscar.from_file(pos + os.sep + 'POSCAR') # case for non - reuse else: poscar = pos # temporary: magnetism only set if twod flag is activated if self.database == 'twod': incar_dict.update( {'MAGMOM': get_magmom_string(poscar)}) self.set_kpoints(poscar=poscar) self.incar = Incar.from_dict(incar_dict) self.set_poscar(poscar=poscar) self.set_potcar() if not self.is_matrix: job_dir = self.job_dir + os.sep + 'POS' + \ os.sep + self.val_to_name(poscar) self.add_job(name=job_dir, job_dir=job_dir)
def assimilate(self, path): files = os.listdir(path) try: files_to_parse = {} if "relax1" in files and "relax2" in files: for filename in ("INCAR", "POTCAR", "POSCAR"): search_str = os.path.join(path, "relax1", filename + "*") files_to_parse[filename] = glob.glob(search_str)[0] for filename in ("CONTCAR", "OSZICAR"): search_str = os.path.join(path, "relax2", filename + "*") files_to_parse[filename] = glob.glob(search_str)[-1] else: for filename in ( "INCAR", "POTCAR", "CONTCAR", "OSZICAR", "POSCAR", "DYNMAT" ): files = glob.glob(os.path.join(path, filename + "*")) if len(files) < 1: continue if len(files) == 1 or filename == "INCAR" or \ filename == "POTCAR" or filename == "DYNMAT": files_to_parse[filename] = files[-1]\ if filename == "POTCAR" else files[0] elif len(files) > 1: """ This is a bit confusing, since there maybe be multiple steps. By default, assimilate will try to find a file simply named filename, filename.bz2, or filename.gz. Failing which it will try to get a relax2 from a custodian double relaxation style run if possible. Or else, a random file is chosen. """ for fname in files: if fnmatch.fnmatch(os.path.basename(fname), "{}(\.gz|\.bz2)*" .format(filename)): files_to_parse[filename] = fname break if fname == "POSCAR" and \ re.search("relax1", fname): files_to_parse[filename] = fname break if (fname in ("CONTCAR", "OSZICAR") and re.search("relax2", fname)): files_to_parse[filename] = fname break files_to_parse[filename] = fname poscar, contcar, incar, potcar, oszicar, dynmat = [None]*6 if 'POSCAR' in files_to_parse: poscar = Poscar.from_file(files_to_parse["POSCAR"]) if 'CONTCAR' in files_to_parse: contcar = Poscar.from_file(files_to_parse["CONTCAR"]) if 'INCAR' in files_to_parse: incar = Incar.from_file(files_to_parse["INCAR"]) if 'POTCAR' in files_to_parse: potcar = Potcar.from_file(files_to_parse["POTCAR"]) if 'OSZICAR' in files_to_parse: oszicar = Oszicar(files_to_parse["OSZICAR"]) if 'DYNMAT' in files_to_parse: dynmat = Dynmat(files_to_parse["DYNMAT"]) param = {"hubbards":{}} if poscar is not None and incar is not None and "LDAUU" in incar: param["hubbards"] = dict(zip(poscar.site_symbols, incar["LDAUU"])) param["is_hubbard"] = ( incar.get("LDAU", False) and sum(param["hubbards"].values()) > 0 ) if incar is not None else False param["run_type"] = None if incar is not None: param["run_type"] = "GGA+U" if param["is_hubbard"] else "GGA" param["history"] = _get_transformation_history(path) param["potcar_spec"] = potcar.spec if potcar is not None else None energy = oszicar.final_energy if oszicar is not None else 1e10 structure = contcar.structure if contcar is not None\ else poscar.structure initial_vol = poscar.structure.volume if poscar is not None else \ None final_vol = contcar.structure.volume if contcar is not None else \ None delta_volume = None if initial_vol is not None and final_vol is not None: delta_volume = (final_vol / initial_vol - 1) data = {"filename": path, "delta_volume": delta_volume} if dynmat is not None: data['phonon_frequencies'] = dynmat.get_phonon_frequencies() if self._inc_structure: entry = ComputedStructureEntry( structure, energy, parameters=param, data=data ) else: entry = ComputedEntry( structure.composition, energy, parameters=param, data=data ) return entry except Exception as ex: logger.debug("error in {}: {}".format(path, ex)) return None
def run_gamma_calculations(submit=True, step_size=0.5): """ Setup a 2D grid of static energy calculations to plot the Gamma surface between two layers of the 2D material. These calculations are run and stored in subdirectories under 'friction/lateral'. Args: submit (bool): Whether or not to submit the jobs. step_size (float): the distance between grid points in Angstroms. """ if not os.path.isdir('friction'): os.mkdir('friction') os.chdir('friction') if not os.path.isdir('lateral'): os.mkdir('lateral') os.chdir('lateral') os.system('cp ../../CONTCAR POSCAR') # Pad the bottom layer with 20 Angstroms of vacuum. utl.add_vacuum(20 - utl.get_spacing(), 0.8) structure = Structure.from_file('POSCAR') n_sites_per_layer = structure.num_sites n_divs_x = int(math.ceil(structure.lattice.a / step_size)) n_divs_y = int(math.ceil(structure.lattice.b / step_size)) # Get the thickness of the material. max_height = max([site.coords[2] for site in structure.sites]) min_height = min([site.coords[2] for site in structure.sites]) thickness = max_height - min_height # Make a new layer. new_sites = [] for site in structure.sites: new_sites.append((site.specie, [site.coords[0], site.coords[1], site.coords[2] + thickness + 3.5])) for site in new_sites: structure.append(site[0], site[1], coords_are_cartesian=True) #structure.get_sorted_structure().to('POSCAR', 'POSCAR') structure.to('POSCAR', 'POSCAR') for x in range(n_divs_x): for y in range(n_divs_y): dir = '{}x{}'.format(x, y) if not os.path.isdir(dir): os.mkdir(dir) # Copy input files os.chdir(dir) os.system('cp ../../../INCAR .') os.system('cp ../../../KPOINTS .') os.system('cp ../POSCAR .') if VDW_KERNEL != '/path/to/vdw_kernel.bindat': os.system('cp {} .'.format(VDW_KERNEL)) utl.write_potcar() incar_dict = Incar.from_file('INCAR').as_dict() incar_dict.update({'NSW': 0, 'LAECHG': False, 'LCHARG': False, 'LWAVE': False, 'MAGMOM': utl.get_magmom_string()}) incar_dict.pop('NPAR', None) Incar.from_dict(incar_dict).write_file('INCAR') # Shift the top layer poscar_lines = open('POSCAR').readlines() with open('POSCAR', 'w') as poscar: for line in poscar_lines[:8 + n_sites_per_layer]: poscar.write(line) for line in poscar_lines[8 + n_sites_per_layer:]: split_line = line.split() new_coords = [ float(split_line[0]) + float(x)/float(n_divs_x), float(split_line[1]) + float(y)/float(n_divs_y), float(split_line[2])] poscar.write(' '.join([str(i) for i in new_coords]) + '\n') if QUEUE == 'pbs': utl.write_pbs_runjob(dir, 1, 4, '800mb', '1:00:00', VASP) submission_command = 'qsub runjob' elif QUEUE == 'slurm': utl.write_slurm_runjob(dir, 4, '800mb', '1:00:00', VASP) submission_command = 'sbatch runjob' if submit: os.system(submission_command) os.chdir('../') os.chdir('../../')
def assimilate(self, path): files = os.listdir(path) try: files_to_parse = {} if "relax1" in files and "relax2" in files: for filename in ("INCAR", "POTCAR", "POSCAR"): search_str = os.path.join(path, "relax1", filename + "*") files_to_parse[filename] = glob.glob(search_str)[0] for filename in ("CONTCAR", "OSZICAR"): search_str = os.path.join(path, "relax2", filename + "*") files_to_parse[filename] = glob.glob(search_str)[-1] else: for filename in ( "INCAR", "POTCAR", "CONTCAR", "OSZICAR", "POSCAR", "DYNMAT" ): files = sorted(glob.glob(os.path.join(path, filename + "*"))) if len(files) < 1: continue if len(files) == 1 or filename == "INCAR" or \ filename == "POTCAR" or filename == "DYNMAT": files_to_parse[filename] = files[-1]\ if filename == "POTCAR" else files[0] elif len(files) > 1: # Since multiple files are ambiguous, we will always # use the first one for POSCAR and the last one # alphabetically for CONTCAR and OSZICAR. if filename == "POSCAR": files_to_parse[filename] = files[0] else: files_to_parse[filename] = files[-1] warnings.warn( "%d files found. %s is being parsed." % (len(files), files_to_parse[filename])) poscar, contcar, incar, potcar, oszicar, dynmat = [None]*6 if 'POSCAR' in files_to_parse: poscar = Poscar.from_file(files_to_parse["POSCAR"]) if 'CONTCAR' in files_to_parse: contcar = Poscar.from_file(files_to_parse["CONTCAR"]) if 'INCAR' in files_to_parse: incar = Incar.from_file(files_to_parse["INCAR"]) if 'POTCAR' in files_to_parse: potcar = Potcar.from_file(files_to_parse["POTCAR"]) if 'OSZICAR' in files_to_parse: oszicar = Oszicar(files_to_parse["OSZICAR"]) if 'DYNMAT' in files_to_parse: dynmat = Dynmat(files_to_parse["DYNMAT"]) param = {"hubbards":{}} if poscar is not None and incar is not None and "LDAUU" in incar: param["hubbards"] = dict(zip(poscar.site_symbols, incar["LDAUU"])) param["is_hubbard"] = ( incar.get("LDAU", False) and sum(param["hubbards"].values()) > 0 ) if incar is not None else False param["run_type"] = None if incar is not None: param["run_type"] = "GGA+U" if param["is_hubbard"] else "GGA" # param["history"] = _get_transformation_history(path) param["potcar_spec"] = potcar.spec if potcar is not None else None energy = oszicar.final_energy if oszicar is not None else 1e10 structure = contcar.structure if contcar is not None\ else poscar.structure initial_vol = poscar.structure.volume if poscar is not None else \ None final_vol = contcar.structure.volume if contcar is not None else \ None delta_volume = None if initial_vol is not None and final_vol is not None: delta_volume = (final_vol / initial_vol - 1) data = {"filename": path, "delta_volume": delta_volume} if dynmat is not None: data['phonon_frequencies'] = dynmat.get_phonon_frequencies() if self._inc_structure: entry = ComputedStructureEntry( structure, energy, parameters=param, data=data ) else: entry = ComputedEntry( structure.composition, energy, parameters=param, data=data ) return entry except Exception as ex: logger.debug("error in {}: {}".format(path, ex)) return None
def test_write(self): tempfname = Path("INCAR.testing") self.incar.write_file(tempfname) i = Incar.from_file(tempfname) self.assertEqual(i, self.incar) tempfname.unlink()
def setUp(self): file_name = self.TEST_FILES_DIR / 'INCAR' self.incar = Incar.from_file(file_name)
def test_diff(self): incar = self.incar filepath1 = os.path.join(test_dir, "INCAR") incar1 = Incar.from_file(filepath1) filepath2 = os.path.join(test_dir, "INCAR.2") incar2 = Incar.from_file(filepath2) filepath3 = os.path.join(test_dir, "INCAR.3") incar3 = Incar.from_file(filepath2) self.assertEqual( incar1.diff(incar2), { "Different": { "NELM": {"INCAR1": None, "INCAR2": 100}, "ISPIND": {"INCAR1": 2, "INCAR2": None}, "LWAVE": {"INCAR1": True, "INCAR2": False}, "LDAUPRINT": {"INCAR1": None, "INCAR2": 1}, "MAGMOM": { "INCAR1": [ 6, -6, -6, 6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, ], "INCAR2": None, }, "NELMIN": {"INCAR1": None, "INCAR2": 3}, "ENCUTFOCK": {"INCAR1": 0.0, "INCAR2": None}, "HFSCREEN": {"INCAR1": 0.207, "INCAR2": None}, "LSCALU": {"INCAR1": False, "INCAR2": None}, "ENCUT": {"INCAR1": 500, "INCAR2": None}, "NSIM": {"INCAR1": 1, "INCAR2": None}, "ICHARG": {"INCAR1": None, "INCAR2": 1}, "NSW": {"INCAR1": 99, "INCAR2": 51}, "NKRED": {"INCAR1": 2, "INCAR2": None}, "NUPDOWN": {"INCAR1": 0, "INCAR2": None}, "LCHARG": {"INCAR1": True, "INCAR2": None}, "LPLANE": {"INCAR1": True, "INCAR2": None}, "ISMEAR": {"INCAR1": 0, "INCAR2": -5}, "NPAR": {"INCAR1": 8, "INCAR2": 1}, "SYSTEM": { "INCAR1": "Id=[0] dblock_code=[97763-icsd] formula=[li mn (p o4)] sg_name=[p n m a]", "INCAR2": "Id=[91090] dblock_code=[20070929235612linio-59.53134651-vasp] formula=[li3 ni3 o6] sg_name=[r-3m]", }, "ALGO": {"INCAR1": "Damped", "INCAR2": "Fast"}, "LHFCALC": {"INCAR1": True, "INCAR2": None}, "TIME": {"INCAR1": 0.4, "INCAR2": None}, }, "Same": { "IBRION": 2, "PREC": "Accurate", "ISIF": 3, "LMAXMIX": 4, "LREAL": "Auto", "ISPIN": 2, "EDIFF": 0.0001, "LORBIT": 11, "SIGMA": 0.05, }, }, ) self.assertEqual( incar1.diff(incar3), { "Different": { "NELM": {"INCAR1": None, "INCAR2": 100}, "ISPIND": {"INCAR1": 2, "INCAR2": None}, "LWAVE": {"INCAR1": True, "INCAR2": False}, "LDAUPRINT": {"INCAR1": None, "INCAR2": 1}, "MAGMOM": { "INCAR1": [ 6, -6, -6, 6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, ], "INCAR2": None, }, "NELMIN": {"INCAR1": None, "INCAR2": 3}, "ENCUTFOCK": {"INCAR1": 0.0, "INCAR2": None}, "HFSCREEN": {"INCAR1": 0.207, "INCAR2": None}, "LSCALU": {"INCAR1": False, "INCAR2": None}, "ENCUT": {"INCAR1": 500, "INCAR2": None}, "NSIM": {"INCAR1": 1, "INCAR2": None}, "ICHARG": {"INCAR1": None, "INCAR2": 1}, "NSW": {"INCAR1": 99, "INCAR2": 51}, "NKRED": {"INCAR1": 2, "INCAR2": None}, "NUPDOWN": {"INCAR1": 0, "INCAR2": None}, "LCHARG": {"INCAR1": True, "INCAR2": None}, "LPLANE": {"INCAR1": True, "INCAR2": None}, "ISMEAR": {"INCAR1": 0, "INCAR2": -5}, "NPAR": {"INCAR1": 8, "INCAR2": 1}, "SYSTEM": { "INCAR1": "Id=[0] dblock_code=[97763-icsd] formula=[li mn (p o4)] sg_name=[p n m a]", "INCAR2": "Id=[91090] dblock_code=[20070929235612linio-59.53134651-vasp] formula=[li3 ni3 o6] sg_name=[r-3m]", }, "ALGO": {"INCAR1": "Damped", "INCAR2": "Fast"}, "LHFCALC": {"INCAR1": True, "INCAR2": None}, "TIME": {"INCAR1": 0.4, "INCAR2": None}, }, "Same": { "IBRION": 2, "PREC": "Accurate", "ISIF": 3, "LMAXMIX": 4, "LREAL": "Auto", "ISPIN": 2, "EDIFF": 0.0001, "LORBIT": 11, "SIGMA": 0.05, }, }, )