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 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)
class VasprunBSLoaderTest(unittest.TestCase): def setUp(self): self.loader = VasprunBSLoader(vrun) self.assertIsNotNone(self.loader) self.loader = VasprunBSLoader(bs, vrun.final_structure) self.assertIsNotNone(self.loader) self.loader = VasprunBSLoader.from_file(vrunfile) self.assertIsNotNone(self.loader) warnings.simplefilter("ignore") self.loader_sp = VasprunBSLoader(vrun_sp) self.assertIsNotNone(self.loader_sp) self.loader_sp = VasprunBSLoader(bs_sp, vrun_sp.final_structure) self.assertIsNotNone(self.loader_sp) self.loader_sp = VasprunBSLoader.from_file(vrunfile_sp) self.assertIsNotNone(self.loader_sp) warnings.simplefilter("ignore") def tearDown(self): warnings.simplefilter("default") def test_properties(self): self.assertEqual(self.loader.is_spin_polarized, False) self.assertAlmostEqual(self.loader.fermi, 0.185266535678, 5) self.assertAlmostEqual(self.loader.structure.lattice.a, 4.64303565932548, 5) self.assertEqual(self.loader.nelect_all, 20.0) self.assertEqual(self.loader_sp.nelect_all, 10.0) self.assertTupleEqual(self.loader.ebands_all.shape, (20, 120)) self.assertAlmostEqual(self.loader.ebands_all[10, 100], 0.2708057, 5) self.assertEqual(len(self.loader.proj_all), 1) self.assertTupleEqual(self.loader.proj_all[Spin.up].shape, (120, 20, 2, 9)) self.assertEqual(self.loader_sp.is_spin_polarized, True) self.assertTupleEqual(self.loader_sp.ebands_all.shape, (24, 198)) self.assertAlmostEqual(self.loader_sp.ebands_all[10, 100], 0.2543788, 4) self.assertAlmostEqual(self.loader_sp.ebands_all[22, 100], 0.2494617, 4) self.assertEqual(len(self.loader_sp.proj_all), 2) self.assertTupleEqual(self.loader_sp.proj_all[Spin.down].shape, (198, 12, 2, 9)) def test_get_volume(self): self.assertAlmostEqual(self.loader.get_volume(), 477.6256714925874, 5)
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 = VasprunBSLoader(vrun) self.assertIsNotNone(self.loader) self.loader = VasprunBSLoader(bs, vrun.final_structure) self.assertIsNotNone(self.loader) self.loader = VasprunBSLoader.from_file(vrunfile) self.assertIsNotNone(self.loader) warnings.simplefilter("ignore") self.loader_sp = VasprunBSLoader(vrun_sp) self.assertIsNotNone(self.loader_sp) self.loader_sp = VasprunBSLoader(bs_sp, vrun_sp.final_structure) self.assertIsNotNone(self.loader_sp) self.loader_sp = VasprunBSLoader.from_file(vrunfile_sp) self.assertIsNotNone(self.loader_sp) warnings.simplefilter("ignore")
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