def test_makebandpath(): atoms = bulk('Au') cell = atoms.cell path0 = bandpath('GXL', cell) print(path0) path1 = bandpath([[0., 0., 0.], [.5, .5, .5]], cell, npoints=50) print(path1) path2 = bandpath([[0., 0., 0.], [.5, .5, .5], [.1, .2, .3]], cell, npoints=50, special_points={'G': [0., 0., 0.]}) print(path2)
def cubic_kpath(npoints=500, name=True): """ return the kpoint path for cubic Parameters: ---------------- npoints: int number of points. Returns: ----------------- kpts: kpoints xs: x cordinates for plot xspecial: x cordinates for special k points """ special_path = special_paths['cubic'] points = special_points['cubic'] paths = parse_path_string(special_path) special_kpts = [points[k] for k in paths[0]] kpts, xs, xspecial = bandpath(special_kpts, cell=np.eye(3), npoints=npoints) if not name: return kpts, xs, xspecial else: return kpts, xs, xspecial, special_path
def plot_phonon_band(self, kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], supercell_matrix=None, npoints=100, color='red', ax=None): if ax is None: fig, ax = plt.subplots() from ase.dft.kpoints import bandpath if supercell_matrix is not None: kvectors = [np.dot(k, supercell_matrix) for k in kvectors] kpts, x, X = bandpath(kvectors, self.get_cell(), npoints) evalues, evecs = self.solve_phonon(kpts) for i in range(3 * self.natoms): ax.plot(x, evalues[:, i], color=color, alpha=1) plt.axhline(0, linestyle='--', color='gray') ax.set_xlabel('q-point') ax.set_ylabel('Frequency (cm$^{-1}$)') #ax.set_ylabel('Energy (eV)') ax.set_xlim(x[0], x[-1]) ax.set_xticks(X) ax.set_xticklabels(knames) for x in X: ax.axvline(x, linewidth=0.6, color='gray') return ax
def cubic_kpath(): special_path = special_paths['cubic'] points = special_points['cubic'] paths = parse_path_string(special_path) special_kpts = [points[k] for k in paths[0]] kpts, xs, xspecial = bandpath(special_kpts, cell=np.eye(3), npoints=500) return kpts, xs, xspecial
def test_makebandpath(): from ase.dft.kpoints import bandpath from ase.build import bulk atoms = bulk('Au') cell = atoms.cell path0 = bandpath('GXL', cell) print(path0) path1 = bandpath([[0., 0., 0.], [.5, .5, .5]], cell, npoints=50) print(path1) path2 = bandpath([[0., 0., 0.], [.5, .5, .5], [.1, .2, .3]], cell, npoints=50, special_points={'G': [0., 0., 0.]}) print(path2)
def plot_band(self, kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], supercell_matrix=None, npoints=100, efermi=None, ax=None): if ax is None: _fig, ax = plt.subplots() if supercell_matrix is not None: kvectors = [np.dot(k, supercell_matrix) for k in kvectors] kpts, x, X = bandpath(kvectors, self.cell, npoints) evalues, _evecs = self.solve_all(kpts=kpts) for i in range(evalues.shape[1]): ax.plot(x, evalues[:, i], color='blue', alpha=1) if efermi is not None: plt.axhline(self.get_fermi_level(), linestyle='--', color='gray') else: try: plt.axhline(self.get_fermi_level(), linestyle='--', color='gray') except: pass ax.set_xlabel('k-point') ax.set_ylabel('Energy (eV)') ax.set_xlim(x[0], x[-1]) ax.set_xticks(X) ax.set_xticklabels(knames) for x in X: ax.axvline(x, linewidth=0.6, color='gray') return ax
def scdmk(self, mu, sigma, nwann, ftype='Gauss', anchor_only=False, anchor_kpoint=[0.0, 0.0, 0.0], kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], supercell_matrix=None, npoints=100, color='red', anchors=None, scols=None, ax=None): from minimulti.scdm.scdmk import SCDMk, occupation_func, Amnk_to_Hk if ax is None: fig, ax = plt.subplots() from ase.dft.kpoints import bandpath if supercell_matrix is not None: kvectors = [np.dot(k, supercell_matrix) for k in kvectors] kpts, x, X = bandpath(kvectors, self.get_cell(), npoints) Hks, evalues, evecs = self.solve_phonon( kpts, ham=True, add_phase=False) scdmk = SCDMk( evals=evalues, wfn=evecs, #positions=self.basis_positions, positions=np.zeros_like(self.basis_positions), kpts=kpts, nwann=nwann, occupation_func=occupation_func(ftype=ftype, mu=mu, sigma=sigma), anchor_kpoint=anchor_kpoint, anchors=anchors, change_basis=evecs[0], scols=scols) Amn = scdmk.get_Amn(anchor_only=anchor_only) self.Hkr = np.zeros_like(Hks) for i, Hk in enumerate(Hks): self.Hkr[i] = rebase_H(Hk, evecs[0]) Hk_prim = Amnk_to_Hk(Amn, evecs, Hks, kpts) evals = [] for ik, k in enumerate(kpts): ev, _ = sl.eigh(Hk_prim[ik], turbo=False) evals.append(ev) evals = np.array(evals) s = np.sign(evals) v = np.sqrt(evals * s) evals = s * v * 15.633302 * 33 for i in range(evals.shape[1]): ax.plot(x, evals[:, i], marker='.', color='blue', alpha=0.2) return ax
def plot_band(model, kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], supercell_matrix=None, npoints=100, efermi=None, erange=None, color='blue', alpha=0.8, marker='', cell=np.eye(3), ax=None): if ax is None: _fig, ax = plt.subplots() if supercell_matrix is None: supercell_matrix = np.eye(3) kvectors = [np.dot(k, supercell_matrix) for k in kvectors] if 'cell' not in model.__dict__: band = bandpath(kvectors, cell @ supercell_matrix, npoints) else: band = bandpath(kvectors, cell @ supercell_matrix, npoints) kpts = band.kpts x, X, _labels = band.get_linear_kpoint_axis() evalues, _evecs = model.solve_all(kpts=kpts) for i in range(evalues.shape[1]): ax.plot(x, evalues[:, i], color=color, alpha=alpha, marker=marker) if efermi is not None: ax.axhline(efermi, linestyle='--', color='gray') else: try: plt.axhline(model.get_fermi_level(), linestyle='--', color='gray') except AttributeError: pass ax.set_ylabel('Energy (eV)') ax.set_xlim(x[0], x[-1]) ax.set_xticks(X) ax.set_xticklabels(knames) if erange is not None: ax.set_ylim(erange) for x in X: ax.axvline(x, linewidth=0.6, color='gray') return ax
def atoms2bandstructure(atoms, parser, args): cell = atoms.get_cell() calc = atoms.calc bzkpts = calc.get_bz_k_points() ibzkpts = calc.get_ibz_k_points() efermi = calc.get_fermi_level() nibz = len(ibzkpts) nspins = 1 + int(calc.get_spin_polarized()) eps = np.array([[calc.get_eigenvalues(kpt=k, spin=s) for k in range(nibz)] for s in range(nspins)]) if not args.quiet: print('Spins, k-points, bands: {}, {}, {}'.format(*eps.shape)) if bzkpts is None: if ibzkpts is None: raise ValueError('Cannot find any k-point data') else: path_kpts = ibzkpts else: try: size, offset = get_monkhorst_pack_size_and_offset(bzkpts) except ValueError: path_kpts = ibzkpts else: if not args.quiet: print('Interpolating from Monkhorst-Pack grid (size, offset):') print(size, offset) if args.path is None: err = 'Please specify a path!' try: cs = crystal_structure_from_cell(cell) except ValueError: err += ('\nASE cannot automatically ' 'recognize this crystal structure') else: from ase.dft.kpoints import special_paths kptpath = special_paths[cs] err += ('\nIt looks like you have a {} crystal structure.' '\nMaybe you want its special path:' ' {}'.format(cs, kptpath)) parser.error(err) bz2ibz = calc.get_bz_to_ibz_map() path_kpts = bandpath(args.path, atoms.cell, args.points).kpts icell = atoms.get_reciprocal_cell() eps = monkhorst_pack_interpolate(path_kpts, eps.transpose(1, 0, 2), icell, bz2ibz, size, offset) eps = eps.transpose(1, 0, 2) special_points = get_special_points(cell) path = BandPath(atoms.cell, kpts=path_kpts, special_points=special_points) return BandStructure(path, eps, reference=efermi)
def plot_magnon_band( self, kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], supercell_matrix=None, npoints=50, color='red', kpath_fname=None, Jq=False, ax=None, ): if ax is None: fig, ax = plt.subplots() kptlist = kvectors if knames is None and kvectors is None: # fully automatic k-path bp = Cell(self.cell).bandpath(npoints=npoints) spk = bp.special_points xlist, kptlist, Xs, knames = group_band_path(bp) elif knames is not None and kvectors is None: # user specified kpath by name bp = Cell(self.cell).bandpath(knames, npoints=npoints) spk = bp.special_points kpts = bp.kpts xlist, kptlist, Xs, knames = group_band_path(bp) else: # user spcified kpath and kvector. kpts, x, Xs = bandpath(kvectors, self.cell, npoints) spk = dict(zip(knames, kvectors)) xlist = [x] kptlist = [kpts] if supercell_matrix is not None: kptlist = [np.dot(k, supercell_matrix) for k in kptlist] print("High symmetry k-points:") for name, k in spk.items(): if name == 'G': name = 'Gamma' print(f"{name}: {k}") for kpts, xs in zip(kptlist, xlist): evals, evecs = self.solve_k(kpts, Jq=Jq) # Plot band structure nbands = evals.shape[1] emin = np.min(evals[:, 0]) for i in range(nbands): ax.plot(xs, (evals[:, i]) / 1.6e-22, color=color) ax.set_ylabel('Energy (meV)') ax.set_xlim(xlist[0][0], xlist[-1][-1]) ax.set_xticks(Xs) knames = [x if x != 'G' else '$\Gamma$' for x in knames] ax.set_xticklabels(knames) for x in Xs: ax.axvline(x, linewidth=0.6, color='gray') return ax
def kpath(): #DDB = abilab.abiopen('out_DDB') #struct = DDB.structure #atoms = DDB.structure.to_ase_atoms() atoms = bulk('Cu', 'fcc') points = get_special_points('fcc', atoms.cell, eps=0.01) GXW = [points[k] for k in 'GXWGL'] kpts, x, X = bandpath(GXW, atoms.cell, 700) names = ['$\Gamma$', 'X', 'W', '$\Gamma$', 'L'] return kpts, x, X, names, GXW
def phonon_run(runID, save_to_db=False, plot_bands=False): print("Running ID %d" % (runID)) db = connect(db_name) atoms = db.get_atoms(id=runID) #view(atoms) #atoms = bulk("Al") #atoms = atoms*(2,1,1) #calc = EAM(potential="/home/davidkl/Documents/EAM/Al-LEA.eam.alloy") calc = EAM(potential="/home/davidkl/Documents/EAM/mg-al-set.eam.alloy") atoms.set_calculator(calc) #calc = gp.GPAW( mode=gp.PW(600), xc="PBE", kpts=(4,4,4), nbands="120%", symmetry="off" ) #atoms.set_calculator(calc) ph = Phonons(atoms, calc, supercell=(3, 3, 3), name=wrk + "/phonon_files/phonon%d" % (runID)) ph.run() #return ph.read(acoustic=True) omega_e, dos_e = ph.dos(kpts=(30, 30, 30), npts=1000, delta=5E-4) if (plot_bands): points = ibz_points['fcc'] G = points['Gamma'] X = points['X'] W = points['W'] K = points['K'] L = points['L'] U = points['U'] point_names = ['$\Gamma$', 'X', 'U', 'L', '$\Gamma$', 'K'] path = [G, X, U, L, G, K] path_kc, q, Q = bandpath(path, atoms.cell, 100) omega_kn = 1000.0 * ph.band_structure(path_kc) figb = plt.figure() axb = figb.add_subplot(1, 1, 1) for n in range(len(omega_kn[0])): omega_n = omega_kn[:, n] axb.plot(q, omega_n) plt.show() if (save_to_db): # Store the results in the database db.update(runID, has_dos=True) manager = cpd.PhononDOS_DB(db_name) # Extract relevant information from the atoms database row = db.get(id=runID) name = row.name atID = row.id manager.save(name=name, atID=atID, omega_e=omega_e, dos_e=dos_e)
def kpts2ndarray(kpts, atoms=None): """Convert kpts keyword to 2-d ndarray of scaled k-points.""" if kpts is None: return np.zeros((1, 3)) if isinstance(kpts, dict): if 'path' in kpts: return bandpath(cell=atoms.cell, **kpts)[0] size, offsets = kpts2sizeandoffsets(atoms=atoms, **kpts) return monkhorst_pack(size) + offsets if isinstance(kpts[0], int): return monkhorst_pack(kpts) return np.array(kpts)
def plot_unfolded_band(self, kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], supercell_matrix=None, npoints=300, color='red', ax=None): """ plot the projection of the band to the basis """ if ax is None: fig, ax = plt.subplots() from ase.dft.kpoints import bandpath kvectors = [np.dot(k, supercell_matrix) for k in kvectors] kpts, x, X = bandpath(kvectors, self.ref_atoms.cell, npoints) kslist = np.array([x] * (self.natoms * 3)) evals, wkslist = self.unfold_phonon( kpts, supercell_matrix) #.T * 0.98 + 0.01 wkslist = wkslist * 0.98 + 0.02 ekslist = evals ax = plot_band_weight( kslist, ekslist.T, wkslist=wkslist.T, efermi=None, yrange=None, output=None, style='alpha', color='blue', axis=ax, width=20, xticks=None) for i in range(3 * self.natom): ax.plot(x, evals[:, i], color='gray', alpha=1, linewidth=0.1) ax.axhline(0.0, linestyle='--', color='gray') ax.set_ylabel('Frequency (THz)') ax.set_xlim(x[0], x[-1]) ax.set_xticks(X) ax.set_xticklabels(knames) for x in X: ax.axvline(x, linewidth=0.6, color='gray') return ax pass
def main(args, parser): atoms = read(args.calculation) cell = atoms.get_cell() calc = atoms.calc bzkpts = calc.get_bz_k_points() ibzkpts = calc.get_ibz_k_points() efermi = calc.get_fermi_level() nibz = len(ibzkpts) nspins = 1 + int(calc.get_spin_polarized()) eps = np.array([[calc.get_eigenvalues(kpt=k, spin=s) for k in range(nibz)] for s in range(nspins)]) if not args.quiet: print('Spins, k-points, bands: {}, {}, {}'.format(*eps.shape)) try: size, offset = get_monkhorst_pack_size_and_offset(bzkpts) except ValueError: path = ibzkpts else: if not args.quiet: print('Interpolating from Monkhorst-Pack grid (size, offset):') print(size, offset) if args.path is None: err = 'Please specify a path!' try: cs = crystal_structure_from_cell(cell) except ValueError: err += ('\nGPAW cannot autimatically ' 'recognize this crystal structure') else: from ase.dft.kpoints import special_paths kptpath = special_paths[cs] err += ('\nIt looks like you have a {} crystal structure.' '\nMaybe you want its special path:' ' {}'.format(cs, kptpath)) parser.error(err) bz2ibz = calc.get_bz_to_ibz_map() path = bandpath(args.path, atoms.cell, args.points)[0] icell = atoms.get_reciprocal_cell() eps = monkhorst_pack_interpolate(path, eps.transpose(1, 0, 2), icell, bz2ibz, size, offset) eps = eps.transpose(1, 0, 2) emin, emax = (float(e) for e in args.range) bs = BandStructure(atoms.cell, path, eps, reference=efermi) bs.plot(emin=emin, emax=emax)
def plot_magnon_band( self, kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], supercell_matrix=None, npoints=100, color='red', kpath_fname=None, Jq=False, ax=None, ): if ax is None: fig, ax = plt.subplots() if knames is None and kvectors is None: bp = Cell(self.cell).bandpath(npoints=npoints) kpts = bp.kpts x, X, knames = bp.get_linear_kpoint_axis() spk = bp.special_points elif knames is not None: bp = Cell(self.cell).bandpath(knames, npoints=npoints) kpts = bp.kpts x, X, knames = bp.get_linear_kpoint_axis() else: kpts, x, X = bandpath(kvectors, self.cell, npoints) spk = dict(zip(knames, kvectors)) if supercell_matrix is not None: kvectors = [np.dot(k, supercell_matrix) for k in kvectors] evals, evecs = self.solve_k(kpts, Jq=Jq) # Plot band structure nbands = evals.shape[1] emin = np.min(evals[:, 0]) for i in range(nbands): ax.plot(x, (evals[:, i]) / 1.6e-22, color=color) ax.set_ylabel('Energy (meV)') ax.set_xlim(x[0], x[-1]) #ax.set_ylim(0) ax.set_xticks(X) knames = [x if x != 'G' else '$\Gamma$' for x in knames] ax.set_xticklabels(knames) for x in X: ax.axvline(x, linewidth=0.6, color='gray') return ax
def plot_unfolded_band( self, kvectors=np.array([[0, 0, 0], [0.5, 0, 0], [0.5, 0.5, 0], [0, 0, 0], [.5, .5, .5]]), knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'], npoints=200, ax=None, ): """ plot the projection of the band to the basis """ if ax is None: fig, ax = plt.subplots() from ase.dft.kpoints import bandpath kvectors = [np.dot(k, self.sc_matrix) for k in kvectors] kpts, x, X = bandpath(kvectors, self.cell, npoints) kslist = [x] * len(self.positions) efermi = 0.0 wkslist=self.unfold(kpts).T * 0.98 +0.01 ekslist = self.evals #wkslist = np.abs(self.get_projection(orb, spin=spin, eigenvecs=evecs)) ax = plot_band_weight( kslist, ekslist, wkslist=wkslist, efermi=None, yrange=None, output=None, style='alpha', color='blue', axis=ax, width=20, xticks=None) for i in range(len(self.positions)): ax.plot(x, self.evals[i, :], color='gray', alpha=1, linewidth=0.1) #ax.axhline(self.get_fermi_level(), linestyle='--', color='gray') ax.set_xlabel('k-point') ax.set_ylabel('Energy (eV)') ax.set_xlim(x[0], x[-1]) ax.set_xticks(X) ax.set_xticklabels(knames) for x in X: ax.axvline(x, linewidth=0.6, color='gray') return ax
def plot_spinwave(ham, qnames=['$\Gamma$', 'X'], qvectors=[(0, 0, 0), (0.5, 0, 0)]): fig = plt.figure() from ase.build import bulk from ase.dft.kpoints import get_special_points from ase.dft.kpoints import bandpath kpts, x, X = bandpath(qvectors, ham.cell, 300) qsolver = QSolver(hamiltonian=ham) evals, evecs = qsolver.solve_all(kpts, eigen_vectors=True) nbands = evals.shape[1] for i in range(nbands): plt.plot(x, evals[:, i] / 1.6e-21) plt.xlabel('Q-point (2$\pi$)') plt.ylabel('Energy (meV)') plt.xlim(x[0], x[-1]) plt.xticks(X, qnames) for x in X: plt.axvline(x, linewidth=0.6, color='gray') plt.show()
def kpts2kpts(kpts, atoms=None): if kpts is None: return KPoints() if hasattr(kpts, 'kpts'): return kpts if isinstance(kpts, dict): if 'kpts' in kpts: return KPoints(kpts['kpts']) if 'path' in kpts: path = bandpath(cell=atoms.cell, **kpts) return path size, offsets = kpts2sizeandoffsets(atoms=atoms, **kpts) return KPoints(monkhorst_pack(size) + offsets) if isinstance(kpts[0], int): return KPoints(monkhorst_pack(kpts)) return KPoints(np.array(kpts))
def construct_kpoint_path(path: str, cell: Cell, bands_point_num: int) -> BandPath: path_lengths = _path_lengths(path, cell, bands_point_num) special_points = cell.bandpath().special_points path_list = path_str_to_list(path, special_points) kpts = [] for start, end, npoints in zip(path_list[:-1], path_list[1:], path_lengths): if start == ',': pass elif end == ',': kpts.append(special_points[start].tolist()) else: bp = bandpath(start + end, cell, npoints + 1) kpts += bp.kpts[:-1].tolist() # Don't forget about the final kpoint kpts.append(bp.kpts[-1].tolist()) if len(kpts) != sum(path_lengths) + 1: raise AssertionError( 'Did not get the expected number of kpoints; this suggests there is a bug in the code') return BandPath(cell=cell, kpts=kpts, path=path, special_points=special_points)
def parse_plotbands(args): """Parse command-line arguments for the plotbands subcommand.""" # Try and load the data from the interpolation step data, equivalences, coeffs, metadata = ( BoltzTraP2.serialization.load_calculation(args.bt2_file)) lattvec = data.get_lattvec() info("sucessfully loaded " + args.bt2_file) # The second position alargument is first interpreted as a Python literal, # and after parsing it is cast to a NumPy array, which must have the right # dimensions. The special value None directs the parser to split the path # in several parts. try: kpaths = ast.literal_eval(args.kpath) except ValueError: lexit("'{}' cannot be parsed as a Python literal".format(kpaths)) if not isinstance(kpaths, list): lexit("'{}' cannot be parsed as a Python list".format(kpaths)) kpaths = [ list(group) for k, group in itertools.groupby( kpaths, key=lambda x: x is not None) if k ] try: kpaths = [np.array(i, dtype=np.float64) for i in kpaths] for i in kpaths: if i.shape[0] < 2 or i.shape[1] != 3: raise ValueError except ValueError: lexit("the path cannot be interpreted as a set of N x 3" " arrays (with N >= 2") plt.figure() ax = plt.gca() ticks = [] dividers = [] offset = 0. for ikpath, kpath in enumerate(kpaths): ax.set_prop_cycle( color=matplotlib.rcParams["axes.prop_cycle"].by_key()["color"]) info("k path #{}".format(i + 1)) # Generate the explicit point list. kp, dkp, dcl = asekp.bandpath(kpath, data.atoms.cell, args.nkpoints) dkp += offset dcl += offset # Compute the band energies. with TimerContext() as timer: egrid = BoltzTraP2.fite.getBands(kp, equivalences, data.get_lattvec(), coeffs)[0] deltat = timer.get_deltat() info("rebuilding the bands took {:.3g} s".format(deltat)) egrid -= data.fermi # Create the plot nbands = egrid.shape[0] for i in range(nbands): plt.plot(dkp, egrid[i, :], lw=2.) ticks += dcl.tolist() dividers += [dcl[0], dcl[-1]] offset = dkp[-1] ax.set_xticks(ticks) ax.set_xticklabels([]) for d in ticks: plt.axvline(x=d, color=PSEUDO_BLACK, ls="--", lw=.5) for d in dividers: plt.axvline(x=d, color=PSEUDO_BLACK, ls="-", lw=2.) plt.axhline(y=0., color=PSEUDO_BLACK, lw=1.) plt.ylabel(r"$\varepsilon - \varepsilon_F\;\left[\mathrm{Ha}\right]$") plt.tight_layout() plt.show()
from ase.dft.kpoints import bandpath import numpy as np print(bandpath('GX,GX', np.eye(3), 6))
from __future__ import print_function from ase.dft.kpoints import bandpath from ase.parallel import paropen from gpaw import GPAW layer = GPAW('WS2_gs.gpw', txt=None).atoms G = [0, 0, 0] K = [1 / 3., 1 / 3., 0] M = [0.5, 0, 0] M_ = [-0.5, 0, 0] K_ = [-1 / 3., -1 / 3., 0] kpts, x, X = bandpath([M, K, G, K_, M_], layer.cell, npoints=1000) calc = GPAW('WS2_gs.gpw', kpts=kpts, symmetry='off') calc.diagonalize_full_hamiltonian(nbands=100) calc.write('WS2_bands.gpw', mode='all') f = paropen('WS2_kpath.dat', 'w') for k in x: print(k, file=f) f.close() f = paropen('WS2_highsym.dat', 'w') for k in X: print(k, file=f) f.close()
from ase.dft.kpoints import bandpath from ase.build import bulk atoms = bulk('Au') cell = atoms.cell path0 = bandpath('GXL', cell) print(path0) path1 = bandpath([[0., 0., 0.], [.5, .5, .5]], cell, npoints=50) print(path1) path2 = bandpath([[0., 0., 0.], [.5, .5, .5], [.1, .2, .3]], cell, npoints=50, special_points={'G': [0., 0., 0.]}) print(path2)
# Read forces and assemble the dynamical matrix ph.read(acoustic=True) # High-symmetry points in the Brillouin zone points = ibz_points['fcc'] G = points['Gamma'] X = points['X'] W = points['W'] K = points['K'] L = points['L'] U = points['U'] point_names = ['$\Gamma$', 'X', 'U', 'L', '$\Gamma$', 'K'] path = [G, X, U, L, G, K] path_kc, q, Q = bandpath(path, atoms.cell, 100) omega_kn = 1000 * ph.band_structure(path_kc) # DOS omega_e, dos_e = ph.dos(kpts=(50, 50, 50), npts=5000, delta=1e-4) omega_e *= 1000 # Plot phonon dispersion plt.figure(1, (8, 6)) plt.axes([.1, .07, .67, .85]) for n in range(len(omega_kn[0])): omega_n = omega_kn[:, n] plt.plot(q, omega_n, 'k-', lw=2) plt.xticks(Q, point_names, fontsize=18) plt.yticks(fontsize=18)
evbm = np.max(eigval[eigval < efermi]) calc.set( nbands=8, # 4 occupied and 4 unoccupied bands fixdensity=True, eigensolver=CG(niter=5), symmetry='off', kpts={ 'path': 'WGKL', 'npoints': 20 }, convergence={'bands': 'all'}, ) calc.get_potential_energy() path = bandpath('WGKL', atoms.get_cell(), npoints=20) bs_dft = get_band_structure(atoms=atoms, calc=calc, path=path, reference=evbm) write_json('bs_dft.json', bs_dft) bs_dft = read_json('bs_dft.json') bs_dft.plot(filename='bs_dft.png', show=False, emax=bs_dft.reference + 10, emin=bs_dft.reference - 20) dpbs = DftbPlusBandStructure(Hamiltonian_SCC='Yes', Hamiltonian_OrbitalResolvedSCC='No', Hamiltonian_MaxAngularMomentum_='',
from __future__ import print_function from ase.dft.kpoints import ibz_points, bandpath from ase.parallel import paropen from gpaw import GPAW layer = GPAW('Fe_gs.gpw', txt=None).atoms points = ibz_points['bcc'] G = points['Gamma'] H = points['H'] P = points['P'] N = points['N'] H_z = [H[0], -H[1], -H[2]] G_yz = [2 * H[0], 0.0, 0.0] kpts, x, X = bandpath([G, H, G_yz], layer.cell, npoints=1000) calc = GPAW('Fe_gs.gpw', kpts=kpts, fixdensity=True, symmetry='off', txt='Fe_bands.txt', parallel={'band': 1}) calc.get_potential_energy() calc.write('Fe_bands.gpw') f = paropen('Fe_kpath.dat', 'w') for k in x: print(k, file=f) f.close()
txt=datapath + 'graphene_bilayer_sc_' + str(RRA) + '.txt', parallel=dict( band=2, # band parallelization augment_grids=True, # use all cores for XC/Poisson sl_auto=True) # enable parallel ScaLAPACK ) grap_bilayer.calc = calc en1 = grap_bilayer.get_potential_energy() parprint('Finished self-consistent calculation.') calc.write(datapath + 'graphene_bilayer_sc_' + str(RRA) + '.gpw') # Build path in BZ for bandstructure calculation. # Temporarily change the cell height to workaround an ASE problem. super_cell[2][2] = v_norm path = bandpath('MKG', super_cell, 50) kpts = path.kpts super_cell[2][2] = vacuum # Compute band path with a sequential approach, one kpt at a time, # to use less memory. parprint('Calculation on', len(kpts), 'k points:') ref, energies = [], [] for i, k in enumerate(kpts): # Restart from ground state and fix potential: calc = GPAW( datapath + 'graphene_bilayer_sc_' + str(RRA) + '.gpw', fixdensity=True, kpts=[k], symmetry='off', txt=datapath + 'graphene_bilayer_bs_' + str(RRA) + '.txt',
from __future__ import print_function from ase.dft.kpoints import bandpath from ase.io import read from ase.parallel import paropen from gpaw import GPAW a = read('gs_Bi2Se3.gpw') G = [0.0, 0.0, 0.0] L = [0.5, 0.0, 0.0] F = [0.5, 0.5, 0.0] Z = [0.5, 0.5, 0.5] kpts, x, X = bandpath([G, Z, F, G, L], a.cell, npoints=200) calc = GPAW('gs_Bi2Se3.gpw', kpts=kpts, symmetry='off', parallel={'band': 16}, txt='Bi2Se3_bands.txt') calc.diagonalize_full_hamiltonian(nbands=48, scalapack=(4, 4, 32)) calc.write('Bi2Se3_bands.gpw', mode='all') with paropen('kpath.dat', 'w') as f: for k in x: print(k, file=f) with paropen('highsym.dat', 'w') as f: for k in X: print(k, file=f)
calc = GPAW(mode='pw', #changed from LCAO with dbz basis set xc='PBE', kpts=(4, 4, 1), occupations=FermiDirac(0.01), txt='gs_3x3_defect.txt') structure.set_calculator(calc) structure.get_potential_energy() calc.write('gs_3x3_defect.gpw', 'all') a = 3.184 PC = mx2(a=a).get_cell(complete=True) path = [special_points['hexagonal'][k] for k in 'MKG'] kpts, x, X = bandpath(path, PC, 48) M = [[3, 0, 0], [0, 3, 0], [0, 0, 1]] Kpts = [] for k in kpts: K = find_K_from_k(k, M)[0] Kpts.append(K) calc_bands = GPAW('gs_3x3_defect.gpw', fixdensity=True, kpts=Kpts, symmetry='off', nbands=220, convergence={'bands': 200})
# Creates: Pt_bands.png import numpy as np import matplotlib.pyplot as plt from gpaw import GPAW from ase.dft.kpoints import bandpath from gpaw.spinorbit import get_spinorbit_eigenvalues calc = GPAW('Pt_bands.gpw', txt=None) ef = GPAW('Pt_gs.gpw').get_fermi_level() kpts, x, X = bandpath('GXWLGKX', calc.atoms.cell, npoints=200) e_kn = np.array([ calc.get_eigenvalues(kpt=k)[:20] for k in range(len(calc.get_ibz_k_points())) ]) e_nk = e_kn.T e_nk -= ef for e_k in e_nk: plt.plot(x, e_k, '--', c='0.5') e_mk = get_spinorbit_eigenvalues(calc) e_mk -= ef plt.xticks(X, [r'$\Gamma$', 'X', 'W', 'L', r'$\Gamma$', 'K', 'X'], size=20) plt.yticks(size=20) for i in range(len(X))[1:-1]: plt.plot(2 * [X[i]], [-11, 13], c='0.5', linewidth=0.5) for e_k in e_mk[::2]:
# Read forces and assemble the dynamical matrix ph.read() # High-symmetry points in the Brillouin zone points = ibz_points['bcc'] G = points['Gamma'] H = points['H'] N = points['N'] P = points['P'] point_names = ['$\Gamma$', 'H', 'P', '$\Gamma$', 'N'] path = [G, H, P, G, N] # Band structure in meV path_kc, q, Q = bandpath(path, atoms.cell, 100) omega_kn = 1000 * ph.band_structure(path_kc) # Calculate phonon DOS omega_e, dos_e = ph.dos(kpts=(50, 50, 50), npts=5000, delta=5e-4) omega_e *= 1000 save_atoms(atoms, q, Q, omega_kn, point_names, dos_e, omega_e) # Plot the band structure and DOS # import matplotlib.pyplot as plt # plt.figure(1, (8, 6)) # plt.axes([.1, .07, .67, .85]) # for n in range(len(omega_kn[0])): # omega_n = omega_kn[:, n] # plt.plot(q, omega_n, 'k-', lw=2) # # plt.xticks(Q, point_names, fontsize=18)