def test_inputs(): p = Poscar.from_file(pos) print(p) td = p.to_dict() print("td is:", td) fd = Poscar.from_dict(td) new_file, filename = tempfile.mkstemp() p.write_file(filename) i = Incar.from_file(inc) i.update({"ENCUT": 1000}) assert (round(p.atoms.density, 2), i.to_dict()["ISIF"]) == (2.25, "3") f = open(pos, "r") lines = f.read() f.close() p = Poscar.from_string(lines) assert (round(p.atoms.density, 2), i.to_dict()["ISIF"]) == (2.25, "3") d = i.to_dict() ii = Incar.from_dict(d) pot = os.path.join( os.path.dirname(__file__), "POT_GGA_PAW_PBE", "Xe", "POTCAR", ) potc = IndividualPotcarData.from_file(pot) print(potc) os.environ["JARVIS_VASP_PSP_DIR"] = os.path.join(os.path.dirname(__file__)) new_file, filename = tempfile.mkstemp() pot = Potcar(elements=["Xe"]) td = pot.to_dict() fd = Potcar.from_dict(td) print(pot) pot.write_file(filename)
def test_cal(): box = [[2.715, 2.715, 0], [0, 2.715, 2.715], [2.715, 0, 2.715]] coords = [[0, 0, 0], [0.25, 0.2, 0.25]] elements = ["Si", "Si"] atoms = Atoms(lattice_mat=box, coords=coords, elements=elements) decorated_atoms, hall_number, wsymbols = get_selective_dyn_decorated_atoms( atoms) print(decorated_atoms) p = Poscar(decorated_atoms) p.write_file('POSCAR') #p2 = Poscar.from_file('POSCAR') #print (p2) assert (wsymbols, hall_number) == (["i", "i"], 63)
def get_wann_electron(jid="JVASP-816"): """Download electron WTBH if available.""" w = "" ef = "" fls = data("raw_files") for i in fls["WANN"]: if i["name"].split(".zip")[0] == jid: r = requests.get(i["download_url"]) z = zipfile.ZipFile(io.BytesIO(r.content)) wdat = z.read("wannier90_hr.dat").decode("utf-8") js_file = jid + ".json" js = z.read(js_file).decode("utf-8") fd, path = tempfile.mkstemp() with os.fdopen(fd, "w") as tmp: tmp.write(wdat) w = WannierHam(path) fd, path = tempfile.mkstemp() with os.fdopen(fd, "w") as tmp: tmp.write(js) d = loadjson(path) ef = d["info_mesh"]["efermi"] fd, path = tempfile.mkstemp() pos = z.read("POSCAR").decode("utf-8") with os.fdopen(fd, "w") as tmp: tmp.write(pos) atoms = Poscar.from_file(path).atoms return w, ef, atoms
def elastic( self, mat=None, encut=None, nbands=None, potim=0.015, npar=None, length=20, ): """ Use for elastic property calculations using IBRION = 6. Enforces conventional standard structure. Args: mat : Poscar object encut : Plane-wave cut-off, 1.3 times will be used nbands : number of bands, generally high-value recommended npar : NPAR tag, see VASP manual, set it as number of cores length : K-points in length unit """ incar = self.use_incar_dict cvn = Spacegroup3D(mat.atoms).conventional_standard_structure comment = mat.comment p = Poscar(cvn, comment=comment) if npar is not None: incar.update({"NPAR": npar}) if nbands is not None: nbands = int(nbands * 3) incar.update({"NBANDS": nbands}) data = { "ENCUT": 1.3 * float(encut), "NEDOS": 5000, "ISIF": 3, "POTIM": potim, "ISPIN": 2, "IBRION": 6, "LCHARG": ".FALSE.", } incar.update(data) kpoints = Kpoints().automatic_length_mesh( lattice_mat=p.atoms.lattice_mat, length=length) # Auto_Kpoints(mat=mat, length=length) en, contcar = VaspJob( poscar=p, incar=incar, pot_type=self.pot_type, kpoints=kpoints, jobname=str("MAIN-ELASTIC-") + str(p.comment.split()[0]), ).runjob() return en, contcar
def test_input(): p = Poscar.from_file(pos).atoms wtin = WTin(wtin=wtin_file, atoms=p, wannierout=wout).write_wt_in() wtc = WTin(wtin=wtin_file, atoms=p, wannierout=wout) td = wtc.to_dict() fd = WTin.from_dict(td) assert (os.path.isfile(wtin_file)) == (True) os.remove(wtin_file)
def from_dict(self, d={}): """Load from dictionary.""" job = JobFactory( use_incar_dict=d["use_incar_dict"], pot_type=d["pot_type"], vasp_cmd=d["vasp_cmd"], copy_files=d["copy_files"], attempts=d["attempts"], stderr_file=d["stderr_file"], output_file=d["output_file"], poscar=Poscar.from_dict(d["poscar"]), ) return job
def test_2d_interface(): jids = [ "JVASP-649", "JVASP-652", "JVASP-658", "JVASP-664", "JVASP-688", "JVASP-6841", "JVASP-5983", "JVASP-60244", "JVASP-60389", "JVASP-76195", ] # jids = ["JVASP-652", "JVASP-664"] jids = ["JVASP-76195", "JVASP-5983"] jids = ["JVASP-76195", "JVASP-60389"] # jids = ["JVASP-76195", "JVASP-60244"] jids = ["JVASP-688", "JVASP-664"] jids = ["JVASP-652", "JVASP-646"] jids = ["JVASP-652", "JVASP-658"] # WS2,WSe2 count = 0 for i in jids: for j in jids: if count < 100 and i != j: # try: intf = get_2d_hetero_jids(jid1=i, jid2=j) if intf.num_atoms < 200: count = count + 1 print(i, j) p = Poscar(intf) filename = "POSCAR-" + str(i) + "_" + str(j) + ".vasp" p.comment = "Surf@" + str(i) + "_" + str(j) print(p) # p.write_file(filename) print() print() print()
def from_dict(self, info={}): """Load the class from a dictionary.""" return VaspJob( poscar=Poscar.from_dict(info["poscar"]), kpoints=Kpoints.from_dict(info["kpoints"]), incar=Incar.from_dict(info["incar"]), potcar=Potcar.from_dict(info["potcar"]), vasp_cmd=info["vasp_cmd"], copy_files=info["copy_files"], attempts=info["attempts"], output_file=info["output_file"], stderr_file=info["stderr_file"], jobname=info["jobname"], )
def workflow(self, generic_incar=""): """ Use for functional based high-throughput calculations. This will converge k-points, cut-offs, and then carry several property calculations. Args: mat : Poscar object """ job = JobFactory( use_incar_dict=generic_incar.incar, pot_type=generic_incar.pot_type, vasp_cmd=self.vasp_cmd, copy_files=self.copy_files, attempts=self.attempts, stderr_file=self.stderr_file, output_file=self.output_file, poscar=self.mat, ) encut = job.converg_encut(mat=self.mat) length = job.converg_kpoint(mat=self.mat) energy, contcar_path = job.optimize_geometry(mat=self.mat, encut=encut, length=length) optimized_mat = Poscar.from_file(contcar_path) vrun = Vasprun(contcar_path.replace("CONTCAR", "vasprun.xml")) chg_path = contcar_path.replace("CONTCAR", "CHGCAR") nbands = int(vrun.all_input_parameters["NBANDS"]) enB, contcB = job.band_structure( mat=optimized_mat, encut=encut, line_density=20, nbands=2 * nbands, copy_prev_chgcar=chg_path, ) enL, contcL = job.loptics(mat=optimized_mat, encut=encut, nbands=2 * nbands, length=length) enM, contcM = job.mbj_loptics(mat=optimized_mat, encut=encut, nbands=2 * nbands, length=length) enE, contcE = job.elastic(mat=optimized_mat, encut=encut, nbands=2 * nbands, length=length)
def all_optb88vdw_props(self, mat=None): """ Use for OptB88vdW functional based high-throughput calculations. This will converge k-points, cut-offs, and then carry several property calculations. Args: mat : Poscar object """ optb88 = GenericIncars().optb88vdw() job = JobFactory(use_incar_dict=optb88.incar, pot_type=optb88.pot_type) encut = job.converg_encut(mat=mat) length = job.converg_kpoint(mat=mat) energy, contcar_path = job.optimize_geometry(mat=mat, encut=encut, length=length) optimized_mat = Poscar.from_file(contcar_path) vrun = Vasprun(contcar_path.replace("CONTCAR", "vasprun.xml")) chg_path = contcar_path.replace("CONTCAR", "CHGCAR") nbands = int(vrun.all_input_parameters["NBANDS"]) enB, contcB = job.band_structure( mat=optimized_mat, encut=encut, line_density=20, nbands=2 * nbands, copy_prev_chgcar=chg_path, ) enL, contcL = job.loptics(mat=optimized_mat, encut=encut, nbands=2 * nbands, length=length) enM, contcM = job.mbj_loptics(mat=optimized_mat, encut=encut, nbands=2 * nbands, length=length) enE, contcE = job.elastic(mat=optimized_mat, encut=encut, nbands=2 * nbands, length=length)
def read_file(self): """Read CHGCAR.""" f = open(self.filename, "r") lines = f.read() f.close() self.atoms = Poscar.from_string(lines).atoms volume = self.atoms.volume text = lines.splitlines() ng_line = text[self.atoms.num_atoms + 9] ng = [int(j) for j in ng_line.split()] self.dim = np.array(ng) found = self.atoms.num_atoms + 8 nsets = 0 for i in text: if "augmentation occupancies 1 " in i: nsets = nsets + 1 self.nsets = nsets if self.is_spin_orbit(): ValueError("Not implemeted for spin-orbit calculations yet") # print ('nsets=',nsets) start = found + 2 ngs = int(ng[0] * ng[1] * ng[2]) if ngs % 5 == 0: nlines = int(ngs / 5.0) else: nlines = int(ngs / 5.0) + 1 end = nlines + start # +1 for ii, i in enumerate(text): if text[ii] == ng_line: start = ii + 1 end = start + nlines chg = self.chg_set(text, start, end, volume, ng) self.chg.append(chg) self.chg = np.array(self.chg)
def runjob(self): """Provide main function for running a generic VASP calculation.""" # poscar=self.poscar # incar=self.incar # kpoints=self.kpoints # copy_files=self.copy_files # cwd = str(os.getcwd()) if self.jobname == "": jobname = str(self.poscar.comment) # job_dir = str(self.jobname) run_file = (str(os.getcwd()) + str("/") + str(self.jobname) + str(".json")) run_dir = str(os.getcwd()) + str("/") + str(self.jobname) if self.poscar.comment.startswith("Surf"): [a, b, c] = self.kpoints.kpts[0] # self.kpoints.kpts = [[a, b, 1]] self.kpoints = Kpoints3D(kpoints=[[a, b, 1]]) try: pol = self.poscar.atoms.check_polar if pol: COM = self.poscar.atoms.get_center_of_mass() print("COM=", COM) print("Found polar surface,setting dipole corrections") self.incar.update({ "LDIPOL": ".TRUE.", "IDIPOL": 3, "ISYM": 0, "DIPOL": str(COM[0]) + str(" ") + str(COM[2]) + str(" ") + str(COM[2]), }) print( "Polar surface encountered in run_job", self.poscar.comment, ) except Exception: pass wait = False json_file = str(self.jobname) + str(".json") print( "json should be here=", str(os.getcwd()) + str("/") + str(json_file), ) print("json should be=", json_file, run_file, os.getcwd()) if os.path.exists(str(os.getcwd()) + str("/") + str(json_file)): try: data_cal = loadjson( str(os.getcwd()) + str("/") + str(json_file)) tmp_outcar = (str(os.getcwd()) + str("/") + str(json_file.split(".json")[0]) + str("/OUTCAR")) print("outcar is", tmp_outcar) wait = Outcar(tmp_outcar).converged # True print("outcar status", wait) if wait: f_energy = data_cal[0]["final_energy"] contcar = (str(os.getcwd()) + str("/") + str(json_file.split(".json")[0]) + str("/CONTCAR")) return f_energy, contcar except Exception: pass attempt = 0 while not wait: attempt = attempt + 1 if attempt == self.attempts: wait = True # print("Setting up POTCAR") # if self.potcar is None: # new_symb = list(set(self.poscar.atoms.elements)) # self.potcar = Potcar(elements=new_symb, pot_type=self.pot_type) if not os.path.exists(run_dir): print("Starting new job") os.makedirs(run_dir) os.chdir(run_dir) self.poscar.write_file("POSCAR") else: os.chdir(run_dir) if os.path.isfile("OUTCAR"): try: wait = Outcar( "OUTCAR" ).converged # Vasprun("vasprun.xml").converged # wait=Vasprun("vasprun.xml").converged except Exception: pass try: self.potcar.write_file("POTCAR") print("FOUND OLD CONTCAR in", os.getcwd()) copy_cmd = str("cp CONTCAR POSCAR") self.poscar.write_file("POSCAR") # pos = Poscar.from_file("CONTCAR") print("copy_cmd=", copy_cmd) if ("ELAST" not in jobname and "LEPSILON" not in jobname): # Because in ELASTIC calculations # structures are deformed os.system(copy_cmd) # time.sleep(3) except Exception: pass self.incar.write_file("INCAR") self.potcar.write_file("POTCAR") self.kpoints.write_file("KPOINTS") for i in self.copy_files: print("copying", i) shutil.copy2(i, "./") self.run() # .wait() print("Queue 1") if os.path.isfile("OUTCAR"): try: wait = Outcar( "OUTCAR").converged # Vasprun("vasprun.xml").converged except Exception: pass print("End of the first loop", os.getcwd(), wait) f_energy = "na" # enp = "na" contcar = str(os.getcwd()) + str("/") + str("CONTCAR") final_str = Poscar.from_file(contcar).atoms vrun = Vasprun("vasprun.xml") f_energy = float(vrun.final_energy) # enp = float(f_energy) / float(final_str.num_atoms) # natoms = final_str.num_atoms os.chdir("../") if wait: data_cal = [] data_cal.append({ "jobname": self.jobname, "poscar": self.poscar.atoms.to_dict(), "incar": self.incar.to_dict(), "kpoints": self.kpoints.to_dict(), "final_energy": (f_energy), "contcar": final_str.to_dict(), }) json_file = str(self.jobname) + str(".json") f_json = open(json_file, "w") f_json.write(json.dumps(data_cal)) f_json.close() print("Wrote json file", f_energy) return f_energy, contcar
from jarvis.io.wannier.inputs import Wannier90win from jarvis.core.atoms import Atoms import os from jarvis.io.vasp.inputs import Poscar win = os.path.join(os.path.dirname(__file__), "win.input") s1 = Poscar.from_file( os.path.join( os.path.dirname(__file__), "..", "..", "analysis", "structure", "POSCAR", )).atoms s2 = Poscar.from_file( os.path.join( os.path.dirname(__file__), "..", "..", "analysis", "structure", "POSCAR-Cmcm", )).atoms s3 = Poscar.from_file( os.path.join( os.path.dirname(__file__), "..", "..", "analysis",
def test_form_en(): atoms = Poscar.from_file(p).atoms total_energy = -9.974648 fen = form_enp(atoms=atoms, total_energy=total_energy) assert fen == -0.40429
def phonons(self, atoms=None, lammps_cmd="", enforce_c_size=15.0, parameters={}): """Make Phonon calculation setup.""" from phonopy import Phonopy from phonopy.file_IO import ( # parse_FORCE_CONSTANTS, write_FORCE_CONSTANTS, ) bulk = atoms.phonopy_converter() dim = get_supercell_dims(atoms, enforce_c_size=enforce_c_size) atoms = atoms.make_supercell([dim[0], dim[1], dim[2]]) Poscar(atoms).write_file("POSCAR") atoms = atoms.make_supercell_matrix([dim[0], dim[1], dim[2]]) Poscar(atoms).write_file("POSCAR-Super.vasp") phonon = Phonopy(bulk, [[dim[0], 0, 0], [0, dim[1], 0], [0, 0, dim[2]]]) print("[Phonopy] Atomic displacements1:", bulk) print("[Phonopy] Atomic displacements2:", phonon, dim[0], dim[1], dim[2]) phonon.generate_displacements(distance=0.03) disps = phonon.get_displacements() print("[Phonopy] Atomic displacements3:", disps) for d in disps: print("[Phonopy]", d[0], d[1:]) supercells = phonon.get_supercells_with_displacements() # Force calculations by calculator set_of_forces = [] disp = 0 from ase import Atoms as AseAtoms for scell in supercells: ase_atoms = AseAtoms( symbols=scell.get_chemical_symbols(), scaled_positions=scell.get_scaled_positions(), cell=scell.get_cell(), pbc=True, ) j_atoms = ase_to_atoms(ase_atoms) disp = disp + 1 parameters["control_file"] = "run0.mod" a, b, forces = LammpsJob( atoms=j_atoms, lammps_cmd=lammps_cmd, parameters=parameters, jobname="disp-" + str(disp), ).runjob() print("forces=", forces) drift_force = forces.sum(axis=0) print("drift forces=", drift_force) # Simple translational invariance for force in forces: force -= drift_force / forces.shape[0] set_of_forces.append(forces) phonon.produce_force_constants(forces=set_of_forces) write_FORCE_CONSTANTS(phonon.get_force_constants(), filename="FORCE_CONSTANTS") print() print("[Phonopy] Phonon frequencies at Gamma:")
from jarvis.analysis.structure.spacegroup import ( Spacegroup3D, symmetrically_distinct_miller_indices, get_wyckoff_position_operators, ) from jarvis.core.atoms import Atoms from jarvis.io.vasp.inputs import Poscar import os from collections import defaultdict from jarvis.db.jsonutils import loadjson s1 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "..", "defects", "POSCAR-667.vasp")).atoms s2 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "..", "..", "io", "wannier", "POSCAR")).atoms s3 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "POSCAR-tetragonal")).atoms s4 = Poscar.from_file(os.path.join(os.path.dirname(__file__), "POSCAR-Cmcm")).atoms s5 = Poscar.from_file(os.path.join(os.path.dirname(__file__), "POSCAR-Aem2")).atoms s6 = Poscar.from_file(os.path.join(os.path.dirname(__file__), "POSCAR-C2m")).atoms s7 = Poscar.from_file(os.path.join(os.path.dirname(__file__), "POSCAR-Pc")).atoms s8 = Poscar.from_file(os.path.join(os.path.dirname(__file__), "POSCAR-P-1")).atoms s9 = Poscar.from_file(os.path.join(os.path.dirname(__file__), "POSCAR-P21m")).atoms
get_orbitals, ) import os import tempfile from jarvis.core.kpoints import generate_kgrid from jarvis.io.vasp.inputs import Poscar import matplotlib.pyplot as plt plt.switch_backend("agg") new_file, filename = tempfile.mkstemp() atoms = Poscar.from_file( os.path.join( os.path.dirname(__file__), "..", "..", "analysis", "structure", "POSCAR", )).atoms wann_soc_win_hr = os.path.join(os.path.dirname(__file__), "wannier90_hr.dat") wann_wout = os.path.join(os.path.dirname(__file__), "wannier90.wout") soc_scfband_vrun = os.path.join(os.path.dirname(__file__), "vasprun.xml") # for JVASP-1067 def test_outputs_bi2se3(): pp = get_projectors_for_formula(formula_dict={"Cr": 1, "I": 3})[0] orb = get_orbitals()[0] x = get_orbitals( projection_info=[["Cr", 4, ["s", "d"]], ["I", 3, ["s", "p"]]],
import os from jarvis.tasks.vasp.vasp import JobFactory, write_jobfact_optb88vdw from jarvis.db.figshare import get_jid_data tmp_dict = get_jid_data(jid="JVASP-816", dataset="dft_3d")["atoms"] atoms = Atoms.from_dict(tmp_dict) vasp_cmd = "mpirun /users/knc6/VASP/vasp54/src/vasp.5.4.1DobbySOC2/bin/vasp_std" copy_files = ["/users/knc6/bin/vdw_kernel.bindat"] submit_cmd = ["qsub", "submit_job"] jids = ["JVASP-1002", "JVASP-1067"] for jid in jids: d = get_jid_data(jid=jid, dataset="dft_3d") atoms = Atoms.from_dict(d["atoms"]).get_primitive_atoms mat = Poscar(atoms) mat.comment = "bulk@" + str(jid) cwd_home = os.getcwd() dir_name = d["jid"] + "_" + str("PBEBO") if not os.path.exists(dir_name): os.makedirs(dir_name) os.chdir(dir_name) job = JobFactory( vasp_cmd=vasp_cmd, poscar=mat, copy_files=copy_files, ) dumpjson(data=job.to_dict(), filename="job_fact.json") write_jobfact_optb88vdw(pyname="job_fact.py", job_json="job_fact.json") # Example job commands, need to change based on your cluster
def test_2d(): p = Poscar.from_file(C).atoms vacs = Vacancy(atoms=p).generate_defects(enforce_c_size=10.0, extend=1) # print (vacs[0]._defect_structure) assert (Atoms.from_dict( vacs[0].to_dict()["defect_structure"]).num_atoms == 49)
def write_poscar(self, filename="POSCAR"): """Write POSCAR format file from Atoms object.""" from jarvis.io.vasp.inputs import Poscar pos = Poscar(self) pos.write_file(filename)
def from_poscar(self, filename="POSCAR"): """Read POSCAR/CONTCAR file from to make Atoms object.""" from jarvis.io.vasp.inputs import Poscar return Poscar.from_file(filename).atoms
from jarvis.core.kpoints import ( Kpoints3D, generate_kpath, generate_kgrid, HighSymmetryKpoint3DFactory, ) from jarvis.analysis.structure.spacegroup import Spacegroup3D from jarvis.core.atoms import Atoms from jarvis.io.vasp.inputs import Poscar import os import tempfile s1 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "..", "analysis", "structure", "POSCAR")).atoms s2 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "..", "analysis", "structure", "POSCAR-Aem2")).atoms s3 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "..", "analysis", "structure", "POSCAR-C2m")).atoms s4 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "..", "analysis", "structure", "POSCAR-Cmcm")).atoms s5 = Poscar.from_file( os.path.join(os.path.dirname(__file__), "..", "analysis", "structure", "POSCAR-P-1")).atoms s6 = Poscar.from_file( os.path.join( os.path.dirname(__file__), "..",