def testDPPotcar(self): refd = { '@module': 'dpgen.database.vasp', '@class': 'DPPotcar', 'symbols': ['Al'], 'elements': ['Al'], 'hashs': '', 'functional': 'PBE' } try: Potcar(['Al']) #ps TITEL = PAW_PBE Al 04Jan2001 refd.update({'hashs': ['9aafba2c552fad8414179cae2e888e67']}) except: pass for f in self.init_path + self.iter_path: fpp = os.path.join(f, 'POTCAR') pp = DPPotcar.from_file(fpp) self.assertEqual(pp.elements, refd['elements']) self.assertEqual(pp.symbols, refd['symbols']) self.assertEqual(pp.hashs, refd['hashs']) self.assertEqual(pp.functional, refd['functional']) self.assertEqual(pp.as_dict(), refd)
def __init__(self, symbols=None, functional="PBE", pp_file=None, pp_lists=None): if pp_lists and pp_file is None: for pp in pp_lists: assert isinstance(pp, PotcarSingle) self.potcars = pp_lists elif pp_file and pp_list is None: self.potcars = Potcar.from_file(pp_file) elif pp_file and pp_list: self.potcars = Potcar.from_file(pp_file) else: try: self.potcars = Potcar(symbols=symbols, functional=functional) except: warnings.warn("""Inproperly configure of POTCAR !""") self.potcars = None if self.potcars is not None: self.symbols = [pp.symbol for pp in self.potcars] self.functional = list(set([pp.functional for pp in self.potcars]))[0] self.hashs = [pp.get_potcar_hash() for pp in self.potcars] else: self.symbols = symbols self.functional = functional self.hashs = '' self.elements = self._get_elements()
def test_gga(self) -> None: xc_task_potcar = XcTaskPotcar.from_options(xc=Xc.pbe, symbol_list=["Mg", "O"]) expected = Potcar(["Mg", "O"], functional="PBE_54").as_dict() self.assertEqual(expected, xc_task_potcar.potcar.as_dict()) self.assertEqual(400.0, xc_task_potcar.max_enmax)
def default_dict(): return {"composition": Composition("HO2"), "symbol_list": ["H", "O"], "num_kpts": 5, "num_kpt_multiplication_factor": 1, "potcar": Potcar(["H", "O"]), "xc": Xc.pbe, "task": Task.structure_opt}
def test_override(self) -> None: xc_task_potcar = \ XcTaskPotcar.from_options(xc=Xc.pbe, symbol_list=["Mg", "O"], override_potcar_set={"O": "O_h"}) expected = Potcar(["Mg", "O_h"], functional="PBE_54").as_dict() self.assertEqual(expected, xc_task_potcar.potcar.as_dict())
def test_mp_relax_set(self) -> None: xc_task_potcar = \ XcTaskPotcar.from_options(xc=Xc.pbe, symbol_list=["Mg", "O"], potcar_set_name="mp_relax_set") expected = Potcar(["Mg_pv", "O"], functional="PBE_54").as_dict() self.assertEqual(expected, xc_task_potcar.potcar.as_dict())
def gen_potcar(dirname, filename): if filename == "POTCAR.spec": fullpath = os.path.join(dirname, filename) f = open(fullpath, "r") elements = f.readlines() f.close() symbols = [el.strip() for el in elements if el.strip() != ""] potcar = Potcar(symbols) potcar.write_file(os.path.join(dirname, "POTCAR"))
def setUp(self) -> None: self.default_kwargs = { "potcar": Potcar(["Mg", "O"]), "composition": Composition({ "Mg": 1, "O": 2 }), "charge": 1 }
def test_ldau_option(default_dict): generator = IncarSettingsGenerator(composition=Composition("Zn"), symbol_list=["Zn"], potcar=Potcar(["Zn"]), num_kpts=5, num_kpt_multiplication_factor=1, xc=Xc.pbe, task=Task.structure_opt, ldau=False) assert "LDAU" not in generator.incar_settings
def test_nbands(): composition = Composition("KH2") potcar = Potcar(symbols=["Mn", "O"]) nelect_mn_pv = 7 nelect_o = 6 unoccupied_band_mn = 9 unoccupied_band_o = 4 expected = (ceil((nelect_mn_pv + nelect_o * 2) / 2) + unoccupied_band_mn + unoccupied_band_o * 2) assert num_bands(composition, potcar) == expected
def generate_potcar(args): if args.recursive: proc_dir(args.spec, gen_potcar) elif args.symbols: try: p = Potcar(args.symbols, functional=args.functional) p.write_file("POTCAR") except Exception as ex: print("An error has occurred: {}".format(str(ex))) else: print("No valid options selected.")
def test_modify_potcar(self): Potcar(["Si"]).write_file("POTCAR") potcar = Potcar.from_file("POTCAR") self.assertFalse("alt" in potcar[0].header) # modify/test ft = ModifyPotcar(potcar_symbols={"Si": "O"}) ft = load_object(ft.to_dict()) # simulate database insertion ft.run_task({}) new_potcar = Potcar.from_file("POTCAR") self.assertEqual(len(new_potcar), 1) self.assertEqual(new_potcar[0].symbol, "O")
def setUp(self) -> None: mgo = self.get_structure_by_name("MgO64atoms") potcar = Potcar(["Mg", "O"], functional="PBE_54") self.defect = TaskIncarSettings.from_options( task=Task.defect, structure=mgo, potcar=potcar, num_kpoints=10, max_enmax=400.0, is_magnetization=False, band_gap=5.0, vbm_cbm=[2.0, 7.0], npar_kpar=False, encut=None, structure_opt_encut_factor=1.3)
def gen_potcar(dirname, filename): """ Generate POTCAR from POTCAR.spec in directories. Args: dirname (str): Directory name. filename (str): Filename in directory. """ if filename == "POTCAR.spec": fullpath = os.path.join(dirname, filename) with open(fullpath, "r") as f: elements = f.readlines() symbols = [el.strip() for el in elements if el.strip() != ""] potcar = Potcar(symbols) potcar.write_file(os.path.join(dirname, "POTCAR"))
def setUp(self) -> None: mgo = self.get_structure_by_name("MgO") self.default_kwargs = { "task": Task.structure_opt, "structure": mgo, "potcar": Potcar(["Mg", "O"]), "num_kpoints": 8, "max_enmax": 400.0, "is_magnetization": False, "vbm_cbm": [3.0, 8.0], "npar_kpar": True, "num_nodes": 1, "encut": None, "structure_opt_encut_factor": 1.3, "dos_step_size": 0.01 }
def generate_potcar(args): """ Generate POTCAR. Args: args (dict): Args from argparse. """ if args.recursive: proc_dir(args.recursive, gen_potcar) elif args.symbols: try: p = Potcar(args.symbols, functional=args.functional) p.write_file("POTCAR") except Exception as ex: print("An error has occurred: {}".format(str(ex))) else: print("No valid options selected.")
def test_hse_structure_opt(default_dict): default_dict.update({ "xc": Xc.hse, "composition": Composition("UO2"), "symbol_list": ["U", "O"], "potcar": Potcar(["U", "O"]), "exchange_ratio": 0.5, "set_hubbard_u": True }) generator = IncarSettingsGenerator(**default_dict) # for k, v in generator.incar_settings.items(): # print(f'\"{k}\": {v}, ') expected = { "ALGO": "Damped", "PREC": "Normal", "LREAL": False, "EDIFF": 1e-07, "ENCUT": 520.0, "LASPH": True, "NELM": 100, "ISIF": 3, "IBRION": 2, "EDIFFG": -0.005, "NSW": 50, "ISMEAR": 0, "SIGMA": 0.1, "LWAVE": True, "LCHARG": False, "LORBIT": 10, "LHFCALC": True, "PRECFOCK": "Fast", "TIME": 0.4, "AEXX": 0.5, "HFSCREEN": 0.208, "LDAU": True, "LDAUTYPE": 2, "LMAXMIX": 6, "LDAUPRINT": 1, "LDAUU": [5, 0], "LDAUL": [3, -1], "KPAR": 1, } assert generator.incar_settings == expected
def from_options(cls, xc: Xc, symbol_list: list, potcar_set_name: str = None, override_potcar_set: dict = None): """ Construct Potcar from xc and some options. Args: See ViseInputSet docstrings Return: XcTaskPotcar class object """ potcar_functional = "LDA" if xc == Xc.lda else "PBE_54" # Currently GW calc is not supported. potcar_set_name = potcar_set_name or "normal" potcar_list = load_potcar_yaml(potcar_set_name, override_potcar_set) potcar_symbols = [potcar_list.get(el, el) for el in symbol_list] potcar = Potcar(potcar_symbols, functional=potcar_functional) max_enmax = max([p.enmax for p in potcar]) return cls(potcar, max_enmax)
def testParsingVasp(self): parsing_vasp(self.cwd, id_prefix=dpgen.SHORT_CMD) try: Potcar(['Al']) ref = os.path.join(self.cwd, 'data/all_data_pp.json') except: ref = os.path.join(self.cwd, 'data/all_data.json') ret = os.path.join(self.cwd, 'dpgen_db.json') retd = loadfn(ret) retd = sorted(retd, key=lambda x: int(x.entry_id.split('_')[-1])) refd = loadfn(ref) refd = sorted(refd, key=lambda x: int(x.entry_id.split('_')[-1])) self.assertEqual(len(retd), len(refd)) for i, j in zip(retd, refd): self.assertEqual(i.entry_id, j.entry_id) self.assertEqual(i.calculator, j.calculator) self.assertEqual(len(i.data), len(j.data)) self.assertEqual(i.number_element, j.number_element) self.assertEqual(i.entry_id, j.entry_id) self.assertEqual(len(i.composition), len(j.composition)) self.assertEqual(len(i.attribute), len(j.attribute)) os.remove(os.path.join(self.cwd, 'dpgen_db.json'))
def setUp(self): self.mgo = self.get_structure_by_name("MgO") self.potcar = Potcar(["Mg", "O"], functional="PBE_54")
def test_lda(self) -> None: xc_task_potcar = XcTaskPotcar.from_options(xc=Xc.lda, symbol_list=["Mg", "O"]) expected = Potcar(["Mg", "O"], functional="LDA").as_dict() self.assertEqual(expected, xc_task_potcar.potcar.as_dict())