def setUp(self): self.loader = VasprunLoader(vrun) self.assertTupleEqual(self.loader.proj.shape, (120, 20, 2, 9)) self.bztInterp = BztInterpolator(self.loader, lpfac=2) self.assertIsNotNone(self.bztInterp) warnings.simplefilter("ignore") bs_sp = loadfn(os.path.join(test_dir, "N2_bandstructure.json")) loader_sp_up = BandstructureLoader(bs_sp, vrun_sp.structures[-1], spin=1) loader_sp_dn = BandstructureLoader(bs_sp, vrun_sp.structures[-1], spin=-1) min_bnd = min(loader_sp_up.ebands.min(), loader_sp_dn.ebands.min()) max_bnd = max(loader_sp_up.ebands.max(), loader_sp_dn.ebands.max()) loader_sp_up.set_upper_lower_bands(min_bnd, max_bnd) loader_sp_dn.set_upper_lower_bands(min_bnd, max_bnd) self.bztI_up = BztInterpolator(loader_sp_up, lpfac=2, energy_range=np.inf, curvature=False) self.bztI_dn = BztInterpolator(loader_sp_dn, lpfac=2, energy_range=np.inf, curvature=False)
def spin_boltz(vrunfile="", spin=1, k_latt=1.0, write_json=True): fname = vrunfile.replace("vasprun.xml", "boltz2data.json") if not os.path.isfile(fname): kp = vrunfile.replace("vasprun.xml", "KPOINTS") v = Vasprun(vrunfile) nelect = v.parameters["NELECT"] bs = v.get_band_structure(kp, line_mode=False) # doping=10.**np.arange(20,22) temp_r = np.array([300, 400, 500, 600, 700, 800]) doping = np.array([0, 10**18, 10**19, 10**20, 10**21, 10**22]) loader = BandstructureLoader(bs, v.structures[-1], spin=spin, nelect=nelect) bztInterp = BztInterpolator(loader, lpfac=2, curvature=True) bztTransp = BztTransportProperties(bztInterp, doping=doping, temp_r=temp_r) xx = bztTransp.compute_properties_doping(doping=doping) # 4 temps, 2 doping Conductivity_doping = bztTransp.Conductivity_doping Seebeck_doping = bztTransp.Seebeck_doping Kappa_doping = bztTransp.Kappa_doping Effective_mass_doping = bztTransp.Effective_mass_doping Power_Factor_doping = bztTransp.Power_Factor_doping mu_r_eV = bztTransp.mu_r_eV info = {} info["mu_r_eV"] = mu_r_eV info["temp_r"] = temp_r info["doping"] = doping info["Conductivity_doping"] = Conductivity_doping info["Seebeck_doping"] = Seebeck_doping info["Kappa_doping"] = Kappa_doping info["Effective_mass_doping"] = Effective_mass_doping info["Power_Factor_doping"] = Power_Factor_doping info["Conductivity_mu"] = bztTransp.Conductivity_mu info["Seebeck_mu"] = bztTransp.Seebeck_mu info["Kappa_mu"] = bztTransp.Kappa_mu info["Power_Factor_mu"] = bztTransp.Power_Factor_mu info["Effective_mass_mu"] = bztTransp.Effective_mass_mu info[ "Hall_carrier_conc_trace_mu"] = bztTransp.Hall_carrier_conc_trace_mu zt = [] temp_zt = [] for i, ii in enumerate(info["temp_r"]): for j, k in zip(info["Power_Factor_mu"][i], info["Kappa_mu"][i]): temp_zt.append(0.001 * j * ii / (k + k_latt)) zt.append(temp_zt) temp_zt = [] zt = np.array(zt) info["zt_mu"] = zt if write_json == True: f = open(fname, "w") f.write(json.dumps(info, cls=MontyEncoder)) f.close() return info else: print("File exists")
def setUp(self): loader = VasprunLoader(vrun) bztInterp = BztInterpolator(loader, lpfac=2) self.bztTransp = BztTransportProperties(bztInterp, temp_r=np.arange( 300, 600, 100)) self.assertIsNotNone(self.bztTransp) warnings.simplefilter("ignore")
def dos_from_boltztrap(bs_dict, energy_grid=0.005, avoid_projections=False): """ Function to just interpolate a DOS from a bandstructure using BoltzTrap Args: bs_dict(dict): A MSONable dictionary for a bandstructure object energy_grid(float): the energy_grid spacing for the DOS in eV avoid_projections(bool): don't interpolate projections even if present """ bs = BandStructure.from_dict(bs_dict) st = bs.structure energy_grid = energy_grid * units.eV projections = True if bs.projections and not avoid_projections else False if bs.is_spin_polarized: data_up = BandstructureLoader(bs, st, spin=1) data_dn = BandstructureLoader(bs, st, spin=-1) min_bnd = min(data_up.ebands.min(), data_dn.ebands.min()) max_bnd = max(data_up.ebands.max(), data_dn.ebands.max()) data_up.set_upper_lower_bands(min_bnd, max_bnd) data_dn.set_upper_lower_bands(min_bnd, max_bnd) bztI_up = BztInterpolator(data_up, energy_range=np.inf, curvature=False) bztI_dn = BztInterpolator(data_dn, energy_range=np.inf, curvature=False) npts_mu = int((max_bnd - min_bnd) / energy_grid) dos_up = bztI_up.get_dos(partial_dos=projections, npts_mu=npts_mu) dos_dn = bztI_dn.get_dos(partial_dos=projections, npts_mu=npts_mu) cdos = merge_up_down_doses(dos_up, dos_dn) else: data = BandstructureLoader(bs, st) min_bnd = min(data.ebands.min(), data.ebands.min()) max_bnd = max(data.ebands.max(), data.ebands.max()) npts_mu = int((max_bnd - min_bnd) / energy_grid) bztI = BztInterpolator(data, energy_range=np.inf, curvature=False) cdos = bztI.get_dos(partial_dos=projections, npts_mu=npts_mu) return cdos.as_dict()
def nonspin_boltz(vrunfile="", k_latt=1.0, write_json=False): fname = vrunfile.replace("vasprun.xml", "boltz2data.json") if not os.path.isfile(fname): vrun = Vasprun(vrunfile, parse_projected_eigen=True) loader = VasprunLoader().from_file(vrunfile) temp_r = np.array([300, 400, 500, 600, 700, 800]) doping = np.array([0, 10**18, 10**19, 10**20, 10**21, 10**22]) bztInterp = BztInterpolator(loader, lpfac=2) bztTransp = BztTransportProperties(bztInterp, temp_r=temp_r, doping=doping) xx = bztTransp.compute_properties_doping(doping=doping) # 4 temps, 2 doping Conductivity_doping = bztTransp.Conductivity_doping Seebeck_doping = bztTransp.Seebeck_doping Kappa_doping = bztTransp.Kappa_doping Effective_mass_doping = bztTransp.Effective_mass_doping Power_Factor_doping = bztTransp.Power_Factor_doping mu_r_eV = bztTransp.mu_r_eV info = {} info["mu_r_eV"] = mu_r_eV info["temp_r"] = temp_r info["doping"] = doping info["Conductivity_doping"] = Conductivity_doping info["Seebeck_doping"] = Seebeck_doping info["Kappa_doping"] = Kappa_doping info["Effective_mass_doping"] = Effective_mass_doping info["Power_Factor_doping"] = Power_Factor_doping info["Conductivity_mu"] = bztTransp.Conductivity_mu info["Seebeck_mu"] = bztTransp.Seebeck_mu info["Kappa_mu"] = bztTransp.Kappa_mu info["Power_Factor_mu"] = bztTransp.Power_Factor_mu info["Effective_mass_mu"] = bztTransp.Effective_mass_mu info[ "Hall_carrier_conc_trace_mu"] = bztTransp.Hall_carrier_conc_trace_mu zt = [] temp_zt = [] for i, ii in enumerate(info["temp_r"]): for j, k in zip(info["Power_Factor_mu"][i], info["Kappa_mu"][i]): temp_zt.append(0.001 * j * ii / (k + k_latt)) zt.append(temp_zt) temp_zt = [] zt = np.array(zt) info["zt_mu"] = zt if write_json == True: f = open(fname, "w") f.write(json.dumps(info, cls=MontyEncoder)) f.close() return info else: print("File exists")
def test_plot(self): loader = VasprunBSLoader(vrun) bztInterp = BztInterpolator(loader, lpfac=2) bztTransp = BztTransportProperties(bztInterp, temp_r=np.arange(300, 600, 100)) self.bztPlotter = BztPlotter(bztTransp, bztInterp) self.assertIsNotNone(self.bztPlotter) fig = self.bztPlotter.plot_props("S", "mu", "temp", temps=[300, 500]) self.assertIsNotNone(fig) fig = self.bztPlotter.plot_bands() self.assertIsNotNone(fig) fig = self.bztPlotter.plot_dos() self.assertIsNotNone(fig)
def setUp(self): self.loader = VasprunBSLoader(vrun) self.bztInterp = BztInterpolator(self.loader, lpfac=2) self.assertIsNotNone(self.bztInterp) self.bztInterp = BztInterpolator(self.loader, lpfac=2, save_coeffs=True, fname=bztinterp_fn) self.assertIsNotNone(self.bztInterp) self.bztInterp = BztInterpolator(self.loader, load_bztinterp=True, fname=bztinterp_fn) self.assertIsNotNone(self.bztInterp) warnings.simplefilter("ignore") self.loader_sp = VasprunBSLoader(vrun_sp) self.bztInterp_sp = BztInterpolator(self.loader_sp, lpfac=2) self.assertIsNotNone(self.bztInterp_sp) self.bztInterp_sp = BztInterpolator(self.loader_sp, lpfac=2, save_coeffs=True, fname=bztinterp_fn) self.assertIsNotNone(self.bztInterp_sp) self.bztInterp_sp = BztInterpolator(self.loader_sp, lpfac=2, load_bztinterp=True, fname=bztinterp_fn) self.assertIsNotNone(self.bztInterp_sp) warnings.simplefilter("ignore")
def setUp(self): loader = VasprunBSLoader(vrun) bztInterp = BztInterpolator(loader, lpfac=2) self.bztTransp = BztTransportProperties(bztInterp, temp_r=np.arange( 300, 600, 100)) self.assertIsNotNone(self.bztTransp) warnings.simplefilter("ignore") self.bztTransp = BztTransportProperties(bztInterp, doping=10.0**np.arange(20, 22), temp_r=np.arange( 300, 600, 100)) self.assertIsNotNone(self.bztTransp) self.assertEqual(self.bztTransp.contain_props_doping, True) warnings.simplefilter("ignore") bztInterp = BztInterpolator(loader, lpfac=2) self.bztTransp = BztTransportProperties( bztInterp, temp_r=np.arange(300, 600, 100), save_bztTranspProps=True, fname=bzttransp_fn, ) self.assertIsNotNone(self.bztTransp) warnings.simplefilter("ignore") bztInterp = BztInterpolator(loader, lpfac=2) self.bztTransp = BztTransportProperties(bztInterp, load_bztTranspProps=True, fname=bzttransp_fn) self.assertIsNotNone(self.bztTransp) warnings.simplefilter("ignore") loader_sp = VasprunBSLoader(vrun_sp) bztInterp_sp = BztInterpolator(loader_sp, lpfac=2) self.bztTransp_sp = BztTransportProperties(bztInterp_sp, temp_r=np.arange( 300, 600, 100)) self.assertIsNotNone(self.bztTransp_sp) warnings.simplefilter("ignore") bztInterp_sp = BztInterpolator(loader_sp, lpfac=2) self.bztTransp_sp = BztTransportProperties( bztInterp_sp, temp_r=np.arange(300, 600, 100), save_bztTranspProps=True, fname=bzttransp_fn, ) self.assertIsNotNone(self.bztTransp_sp) warnings.simplefilter("ignore") bztInterp_sp = BztInterpolator(loader_sp, lpfac=2) self.bztTransp_sp = BztTransportProperties(bztInterp_sp, load_bztTranspProps=True, fname=bzttransp_fn) self.assertIsNotNone(self.bztTransp_sp) warnings.simplefilter("ignore")
def make_effective_mass(vasprun, temp, concentrations, band_gap): try: from pymatgen.electronic_structure.boltztrap2 import VasprunBSLoader, \ BztInterpolator, BztTransportProperties except BoltztrapError: raise ImportError('Calculating effective mass requires BoltzTrap2') vl = VasprunBSLoader(vasprun) energy_range = band_gap / 2 + 2.0 bi = BztInterpolator(vl, energy_range=energy_range) btp = BztTransportProperties(bi, temp_r=np.array([temp])) btp.compute_properties_doping(concentrations) return EffectiveMass(p=btp.Effective_mass_doping["p"].tolist()[0], n=btp.Effective_mass_doping["n"].tolist()[0], temperature=temp, concentrations=concentrations)
def setUp(self): self.loader = VasprunLoader(vrun) self.assertTupleEqual(self.loader.proj.shape, (120, 20, 2, 9)) self.bztInterp = BztInterpolator(self.loader, lpfac=2) self.assertIsNotNone(self.bztInterp) warnings.simplefilter("ignore")
def setUp(self): loader = VasprunLoader().from_file(vrunfile) self.bztInterp = BztInterpolator(loader) self.assertIsNotNone(self.bztInterp) warnings.simplefilter("ignore")
def setUp(self): loader = VasprunLoader().from_file(vrunfile) bztInterp = BztInterpolator(loader) bztTransp = BztTransportProperties(bztInterp,temp_r = np.arange(300,600,100)) self.bztPlotter = BztPlotter(bztTransp,bztInterp) self.assertIsNotNone(self.bztPlotter)
def bandplot_func( filenames=None, code='vasp', prefix=None, directory=None, vbm_cbm_marker=False, projection_selection=None, mode='rgb', pred=None, interpolate_factor=4, circle_size=150, dos_file=None, cart_coords=False, scissor=None, ylabel='Energy (eV)', dos_label=None, elements=None, lm_orbitals=None, atoms=None, spin=None, total_only=False, plot_total=True, legend_cutoff=3, gaussian=None, height=None, width=None, ymin=-6., ymax=6., colours=None, yscale=1, style=None, no_base_style=False, image_format='pdf', dpi=400, plt=None, fonts=None, boltz={ "ifinter": "T", "lpfac": "10", "energy_range": "50", "curvature": "", "load": "T", 'ismetaltolerance': '0.01' }, nelec=0): if not filenames: filenames = find_vasprun_files() elif isinstance(filenames, str): filenames = [filenames] # only load the orbital projects if we definitely need them parse_projected = True if projection_selection else False # now load all the band structure data and combine using the # get_reconstructed_band_structure function from pymatgen bandstructures = [] if code == 'vasp': for vr_file in filenames: vr = BSVasprun(vr_file, parse_projected_eigen=parse_projected) print("BSVasprun", type(vr), vr) print("vr.eigenvalues.keys()", type(vr.eigenvalues.keys()), vr.eigenvalues.keys()) if pred.any(): # Fill in Model prediction model = BSVasprun(vr_file, parse_projected_eigen=parse_projected) print("pred", type(pred), pred.shape) pred = np.expand_dims(pred, axis=-1) for key in model.eigenvalues.keys(): key_last = key print("model.eigenvalues[key][:, :, :].shape[0]", key, type(model.eigenvalues[key][:, :, :]), model.eigenvalues[key][:, :, :].shape, pred[:, :, :].shape) bands = min(model.eigenvalues[key][:, :, :].shape[1], pred.shape[1]) print( "bands", bands, "attention! max: ", max(model.eigenvalues[key][:, :, :].shape[1], pred.shape[1])) print( "equel False?", np.sum(model.eigenvalues[key][:, :bands, :] - pred[:, :bands, :])) model.eigenvalues[key][:, :bands, :] = pred[:, :bands, :] print( "equel True?", np.sum(model.eigenvalues[key][:, :bands, :] - pred[:, :bands, :])) print( "equel model vr?", np.sum(model.eigenvalues[key][:, :bands, :] - vr.eigenvalues[key][:, :bands, :])) # spin = 1 # for only plotting spin up oder down 1, -1 # model.eigenvalues[key_last][:, :bands, :] = pred[:, :bands, :] #boltztrap={'ifinter':False,'lpfac':10,'energy_range':50,'curvature':False}): if bool(boltz['ifinter']): b_data = VasprunBSLoader(vr) model_data = VasprunBSLoader(model) print("BSVasprunLoader", type(b_data), b_data) b_inter = BztInterpolator(b_data, lpfac=int(boltz['lpfac']), energy_range=float( boltz['energy_range']), curvature=bool(boltz['curvature']), save_bztInterp=True, load_bztInterp=bool(boltz['load'])) model_inter = BztInterpolator( model_data, lpfac=int(boltz['lpfac']), energy_range=float(boltz['energy_range']), curvature=bool(boltz['curvature']), save_bztInterp=True, load_bztInterp=bool(boltz['load'])) try: kpath = json.load(open('./kpath', 'r')) kpaths = kpath['path'] kpoints_lbls_dict = {} for i in range(len(kpaths)): for j in [0, 1]: if 'GAMMA' == kpaths[i][j]: kpaths[i][j] = '\Gamma' for k, v in kpath['kpoints_rel'].items(): if k == 'GAMMA': k = '\Gamma' kpoints_lbls_dict[k] = v except: kpaths = None kpoints_lbls_dict = None print(kpaths, kpoints_lbls_dict) bs = b_inter.get_band_structure( kpaths=kpaths, kpoints_lbls_dict=kpoints_lbls_dict) model_bs = model_inter.get_band_structure( kpaths=kpaths, kpoints_lbls_dict=kpoints_lbls_dict) #bs_uniform = b_inter.get_band_structure() gap = bs.get_band_gap() nvb = int(np.ceil(nelec / (int(bs.is_spin_polarized) + 1))) vbm = -100 print("WHC interpolated gap: %s" % gap) for spin, v in bs.bands.items(): vbm = max(vbm, max(v[nvb - 1])) print( 'WHC WARNNING vasp fermi %s interpolation vbm %s nelec %s nvb %s' % (bs.efermi, vbm, nelec, nvb)) if vbm < bs.efermi: bs.efermi = vbm print("if vbm <") if vbm < model_bs.efermi: model_bs.efermi = vbm print("if vbm <") print(bs.bands.keys()) band_keys = list(bs.bands.keys()) print("Band shapes", bs.bands[band_keys[0]].shape, model_bs.bands[band_keys[0]].shape) print( "equel bands?", np.sum((bs.bands[band_keys[0]] - bs.efermi) - model_bs.bands[band_keys[0]])) bs.bands[band_keys[0]] = ( bs.bands[band_keys[0]] - bs.efermi ) # why?????????????????????????????????????????????????? # bs.bands[band_keys[1]] = (bs.bands[band_keys[1]] - bs.efermi) # why?????????????????????????????????????????????????? print( "equel bands fermi shifted?", np.sum((bs.bands[band_keys[0]] - bs.efermi) - model_bs.bands[band_keys[0]])) # bandstructures.append(bs) # bandstructures.append(model_bs) bs = get_reconstructed_band_structure([bs]) model_bs = get_reconstructed_band_structure([model_bs]) if bool(boltz['ifinter']): bs.nvb = nvb bs.ismetaltolerance = float(boltz['ismetaltolerance']) model_bs.nvb = nvb model_bs.ismetaltolerance = float(boltz['ismetaltolerance']) print("dft bands", bs.bands[band_keys[0]]) print("dft ktps", len(bs.kpoints), kpts.shape) print("dft labels", bs.labels_dict) for key in bs.labels_dict.keys(): print(bs.labels_dict[key].label, bs.labels_dict[key].as_dict(), bs.labels_dict[key].a, bs.labels_dict[key].b, bs.labels_dict[key].c, bs.labels_dict[key].frac_coords) labels = [] for i in range(len(bs.kpoints)): # print(i, bs.kpoints[i]) for key in bs.labels_dict.keys(): if bs.labels_dict[key].label == bs.kpoints[ i].label and bs.labels_dict[ key].label != bs.kpoints[i - 1].label: # print("Labels!!!!!", i, bs.labels_dict[key].label) labels.append([i, bs.labels_dict[key].label]) print(labels) print("dft efermi", bs.efermi) print("dft lattice_rec", bs.lattice_rec) print("dft structure", bs.structure) print("model bands", model_bs.bands[band_keys[0]]) print("model ktps", len(model_bs.kpoints), kpts.shape) print("model labels", model_bs.labels_dict) print("model efermi", model_bs.efermi) print("model lattice_rec", model_bs.lattice_rec) print("model structure", model_bs.structure) return bs.bands[band_keys[0]], model_bs.bands[band_keys[0]], labels save_files = False if plt else True dos_plotter = None dos_opts = None if dos_file: dos, pdos = load_dos(dos_file, elements, lm_orbitals, atoms, gaussian, total_only) dos_plotter = SDOSPlotter(dos, pdos) dos_opts = { 'plot_total': plot_total, 'legend_cutoff': legend_cutoff, 'colours': colours, 'yscale': yscale } model_and_dft_bs = [bs, model_bs] plotter = SBSPlotter(model_bs) print("spin", spin) if len(vr.eigenvalues.keys()) == 1: spin = None print("spin", spin) plt = plotter.get_plot(zero_to_efermi=True, ymin=ymin, ymax=ymax, height=height, width=width, vbm_cbm_marker=vbm_cbm_marker, ylabel=ylabel, plt=plt, dos_plotter=dos_plotter, dos_options=dos_opts, dos_label=dos_label, fonts=fonts, style=style, no_base_style=no_base_style, spin=spin) # don't save if pyplot object provided save_files = False if plt else True if save_files: basename = 'band.{}'.format(image_format) filename = '{}_{}'.format(prefix, basename) if prefix else basename if directory: filename = os.path.join(directory, filename) plt.savefig(filename, format=image_format, dpi=dpi, bbox_inches='tight') written = [filename] written += save_data_files(bs, prefix=prefix, directory=directory) return written else: return plt