diff --git a/docs/examples/example_mgo.md b/docs/examples/example_mgo.md index 949812d..28ba4f4 100644 --- a/docs/examples/example_mgo.md +++ b/docs/examples/example_mgo.md @@ -108,3 +108,58 @@ Unfolded MgO band structure with atomic projections plotted separately. There are _many_ customisation options available for the plotting functions in `easyunfold`. See `easyunfold plot -h` or `easyunfold unfold plot-projections -h` for more details! ::: + + +The command `easyunfold unfold effective-mass` can be used to find the effective masses of the unfolded band structure. + +The example output is shown below: + +``` +Loaded data from easyunfold.json +Band extrema data: + Kpoint index Kind Sub-kpoint index Band indices +-------------- ------ ------------------ -------------- + 0 cbm 0 16 + 47 cbm 0 16 + 0 vbm 0 15 + 47 vbm 0 15 + +Electron effective masses: + index Kind Effective mass Band index from to +------- ------ ---------------- ------------ ------------------------ ------------------- + 0 m_e 0.373553 16 [0.0, 0.0, 0.0] (\Gamma) [0.5, 0.5, 0.5] (L) + 1 m_e 0.367203 16 [0.0, 0.0, 0.0] (\Gamma) [0.5, 0.0, 0.5] (X) + +Hole effective masses: + index Kind Effective mass Band index from to +------- ------ ---------------- ------------ ------------------------ ------------------- + 0 m_h -3.44604 15 [0.0, 0.0, 0.0] (\Gamma) [0.5, 0.5, 0.5] (L) + 1 m_h -2.13525 15 [0.0, 0.0, 0.0] (\Gamma) [0.5, 0.0, 0.5] (X) +Unfolded band structure can be ambiguous, please cross-check with the spectral function plot. +``` + +If detected band extrema are not consistent with the band structure, one should adjust the `--intensity-tol` and `--extrema-detect-tol`. +Increasing the value of `--intensity-tol` will filter away bands with very small spectral weights. +On the other hand, increasing `--extrema-detect-tol` will increase the energy window with respect +to the VBM or CBM to assign extrema points. +One can also inspect if the detected bands makes sense by using the `--plot` option. +A Jupyter Notebook example can be found [here](../../examples/MgO/effective-mass.ipynb). + + +```{figure} ../../examples/MgO/unfold-effective-mass.png +:width: 800 px +:alt: Effective bands extracted + +Extracted bands at CBM and VBM for an unfolded MgO band structure. +``` + + +:::{warning} +Make sure the band extrema data tabulated is correct and consistent before using any of the reported values. +The results can unreliable for systems with little or no band gaps and those with complex unfolded band structures. +::: + + +:::{tip} +For complex systems where the detection is difficult, one can manually pass the kpoint and the band indices using the `--manual-extrema` option. +::: diff --git a/docs/index.md b/docs/index.md index 952fb35..0454dbc 100644 --- a/docs/index.md +++ b/docs/index.md @@ -21,7 +21,7 @@ package. For the methodology of supercell band unfolding, see [here](https://link.aps.org/doi/10.1103/PhysRevB.85.085201). -### Example Outputs +## Example Outputs | [Cs₂(Sn/Ti)Br₆ Vacancy-Ordered Perovskite Alloys](https://doi.org/10.1021/acs.jpcc.3c05204) | Oxygen Vacancy (*V*ₒ⁰) in MgO | |:-------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------:| | | | diff --git a/docs/theory.md b/docs/theory.md index 3b88471..d00ca7a 100644 --- a/docs/theory.md +++ b/docs/theory.md @@ -74,5 +74,40 @@ cell, followed by a reduction using the symmetry of the supercell. The spectral is then a weighted combination of that set of $\vec{k_s^\prime}$ points that are inequivalent under the symmetry of the supercell. + +## Cell and Transformation Matrix convention + +The cell matrix may be consisted of column or row lattice vectors. In this package we use the **row vector** +convention as commonly found in many post-processing tools and DFT codes. The cell matrix is defined as: + +$$ +\mathbf{C} = \begin{pmatrix} +x_a & y_a & z_a \\ +x_b & y_b & z_b \\ +x_c & y_c & z_c +\end{pmatrix} +$$ + +where $x_a$, $y_a$, $z_a$ are components of the lattice vector $\mathbf{a}$. + +The cell matrix of the supercell $\mathbf{C_s}$ is obtained by (left) multiplying the original unit cell $\mathbf{C_u}$ by the transformation matrix $\mathbf{M}$: + + +$$ +\mathbf{C_{s}} = \mathbf{M} \, \mathbf{C_u} +$$ + +:::{note} +Sometimes the cell matrix is defined by **column** vectors of the lattice parameters, e.g. $\mathbf{C_u^c} = \mathbf{C_u^T}$, and the relationship becomes: +$$ +\mathbf{C_u^c} = \mathbf{C_u^T} \, \mathbf{M^T} +$$ + +Hence, when the column vector convention is used, the transformation matrix is the **transpose** of that used by the row convention. + +One example of code using the column vector convention is [Phonopy](https://phonopy.github.io/phonopy/setting-tags.html#dim). +::: + + [^1]: Popescu, V.; Zunger, A. Effective Band Structure of Random Alloys. Phys. Rev. Lett. 2010, 104 (23), 236403. https://doi.org/10.1103/PhysRevLett.104.236403. [^2]: Popescu, V.; Zunger, A. Extracting $E$ versus $\vec{k}$ Effective Band Structure from Supercell Calculations on Alloys and Impurities. Phys. Rev. B 2012, 85 (8), 085201. https://doi.org/10.1103/PhysRevB.85.085201. \ No newline at end of file diff --git a/easyunfold/cli.py b/easyunfold/cli.py index 841f7c1..f2241a4 100644 --- a/easyunfold/cli.py +++ b/easyunfold/cli.py @@ -51,17 +51,22 @@ def easyunfold(): @click.option('--matrix', '-m', help='Transformation matrix, in the form "x y z" for a diagonal matrix, ' - 'or "x1 y1 z1, x2 y2 z2, x3 y3 z3" for a 3x3 matrix. Automatically guessed if not ' + 'or "x1 y1 z1 x2 y2 z2 x3 y3 z3" for a 3x3 matrix. Automatically guessed if not ' 'provided.') @click.option('--symprec', help='Tolerance for determining the symmetry', type=float, default=1e-5, show_default=True) @click.option('--out-file', '-o', default='easyunfold.json', help='Name of the output file') @click.option('--no-expand', help='Do not expand the kpoints by symmetry', default=False, is_flag=True) @click.option('--nk-per-split', help='Number of band structure kpoints per split.', type=int) +@click.option('--separate-folders/--no-separate-folders', + help='Whether to use separate folders for each split.', + default=False, + show_default=True) @click.option('--scf-kpoints', help='File (IBZKPT) to provide SCF kpoints for self-consistent calculations. Needed for hybrid functional calculations.', type=click.Path(exists=True, dir_okay=False)) @click.option('--yes', '-y', is_flag=True, default=False, help='Skip and confirmation.', hidden=True) # hide help -def generate(pc_file, code, sc_file, matrix, kpoints, time_reversal, out_file, no_expand, symprec, nk_per_split, scf_kpoints, yes): +def generate(pc_file, code, sc_file, matrix, kpoints, time_reversal, out_file, no_expand, symprec, nk_per_split, scf_kpoints, yes, + separate_folders): """ Generate the kpoints for performing supercell calculations. @@ -107,6 +112,7 @@ def generate(pc_file, code, sc_file, matrix, kpoints, time_reversal, out_file, n else: tmp = supercell.cell @ np.linalg.inv(primitive.cell) transform_matrix = np.rint(tmp) + transform_matrix[transform_matrix == 0] = 0 if not np.allclose(tmp, transform_matrix, rtol=2e-2): # 2% mismatch tolerance if np.allclose(transform_matrix @ primitive.cell, supercell.cell, rtol=5e-2): # 2-5% mismatch click.echo(_quantitative_inaccuracy_warning) @@ -154,6 +160,7 @@ def generate(pc_file, code, sc_file, matrix, kpoints, time_reversal, out_file, n out_kpt_name, nk_per_split=nk_per_split, scf_kpoints_and_weights=scf_kpoints_and_weights, + use_separate_folders=separate_folders, source=sc_file, ) @@ -267,19 +274,17 @@ def wrapper(*args, **kwargs): @click.option('--spin', type=int, default=0, help='Index of the spin channel.', show_default=True) @click.option('--npoints', type=int, default=3, help='Number of kpoints used for fitting from the extrema.', show_default=True) @click.option('--extrema-detect-tol', type=float, default=0.01, help='Tolerance for band extrema detection.', show_default=True) -@click.option('--degeneracy-detect-tol', - type=float, - default=0.01, - help='Tolerance for band degeneracy detection at extrema.', - show_default=True) @click.option('--nocc', type=int, help='DEV: Use this band as the extrema at all kpoints.') @click.option('--plot', is_flag=True, default=False) @click.option('--plot-fit', is_flag=True, default=False, help='Generate plots of the band edge and parabolic fits.') @click.option('--fit-label', help='Which branch to use for plot fitting. e.g. electrons:0', default='electrons:0', show_default=True) @click.option('--band-filter', default=None, type=int, help='Only displace information for this band.') @click.option('--out-file', '-o', default='unfold-effective-mass.png', help='Name of the output file.', show_default=True) -def unfold_effective_mass(ctx, intensity_threshold, spin, band_filter, npoints, extrema_detect_tol, degeneracy_detect_tol, nocc, plot, - plot_fit, fit_label, out_file): +@click.option('--emin', type=float, default=-5., help='Minimum energy in eV relative to the reference.', show_default=True) +@click.option('--emax', type=float, default=5., help='Maximum energy in eV relative to the reference.', show_default=True) +@click.option('--manual-extrema', help='Manually specify the extrema to use for fitting, in the form "mode,k_index,band_index"') +def unfold_effective_mass(ctx, intensity_threshold, spin, band_filter, npoints, extrema_detect_tol, nocc, plot, plot_fit, fit_label, + out_file, emin, emax, manual_extrema): """ Compute and print effective masses by tracing the unfolded weights. @@ -293,7 +298,7 @@ def unfold_effective_mass(ctx, intensity_threshold, spin, band_filter, npoints, from easyunfold.unfold import UnfoldKSet from tabulate import tabulate unfoldset: UnfoldKSet = ctx.obj['obj'] - efm = EffectiveMass(unfoldset, intensity_tol=intensity_threshold, extrema_tol=extrema_detect_tol, degeneracy_tol=degeneracy_detect_tol) + efm = EffectiveMass(unfoldset, intensity_tol=intensity_threshold, extrema_tol=extrema_detect_tol) click.echo('Band extrema data:') table = [] @@ -306,12 +311,20 @@ def unfold_effective_mass(ctx, intensity_threshold, spin, band_filter, npoints, if nocc: efm.set_nocc(nocc) - output = efm.get_effective_masses(ispin=spin, npoints=npoints) + if manual_extrema is None: + output = efm.get_effective_masses(ispin=spin, npoints=npoints) + else: + mode, ik, ib = manual_extrema.split(',') + ik = int(ik) + ib = int(ib) + click.echo(f'Using manually passed kpoint and band: {ik},{ib}') + output = efm.get_effective_masses(ispin=spin, npoints=npoints, mode=mode, iks=[ik], iband=[[ib]]) # Filter by band if requested if band_filter is not None: for carrier in ['electrons', 'holes']: - output[carrier] = [entry for entry in output[carrier] if entry['band_index'] == band_filter] + if carrier in output: + output[carrier] = [entry for entry in output[carrier] if entry['band_index'] == band_filter] ## Print data def print_data(entries, tag='me'): @@ -332,19 +345,22 @@ def print_data(entries, tag='me'): click.echo(tabulate(table, headers=['index', 'Kind', 'Effective mass', 'Band index', 'from', 'to'])) click.echo('Electron effective masses:') - print_data(output['electrons'], 'm_e') + print_data(output.get('electrons', []), 'm_e') print('') click.echo('Hole effective masses:') - print_data(output['holes'], 'm_h') + print_data(output.get('holes', []), 'm_h') - click.echo('Unfolded band structure can be ambiguous, please cross-check with the spectral function plot.') + if not plot: + click.echo( + 'NOTE: Unfolded band structure can be ambiguous.' + 'You may want to run the command with `--plot` and check if the detected bands are consistent with the spectral function.') if plot: from easyunfold.plotting import UnfoldPlotter plotter = UnfoldPlotter(unfoldset) - click.echo('Generating spectral function plot for visualising detected branches...') + click.echo('Generating spectral function plot for visualising detected band branches...') engs, sf = unfoldset.get_spectral_function() - plotter.plot_effective_mass(efm, engs, sf, effective_mass_data=output, save=out_file) + plotter.plot_effective_mass(efm, engs, sf, effective_mass_data=output, save=out_file, ylim=(emin, emax)) elif plot_fit: from easyunfold.plotting import UnfoldPlotter diff --git a/easyunfold/effective_mass.py b/easyunfold/effective_mass.py index a2bcaf1..9e1b9ec 100644 --- a/easyunfold/effective_mass.py +++ b/easyunfold/effective_mass.py @@ -8,7 +8,7 @@ from scipy.optimize import curve_fit from .unfold import UnfoldKSet -# pylint: disable=invalid-name +# pylint: disable=invalid-name,too-many-locals eV_to_hartree = physical_constants['electron volt-hartree relationship'][0] bohr_to_m = physical_constants['Bohr radius'][0] @@ -54,21 +54,24 @@ def f(x, alpha, d): # coefficient is currently in eV/Angstrom^2/h_bar^2 # want it in atomic units so Hartree/bohr^2/h_bar^2 eff_mass = (angstrom_to_bohr**2 / eV_to_hartree) / c - return eff_mass + return eff_mass, fit def fitted_band(x: np.ndarray, eff_mass: float) -> np.ndarray: """Return fitted effective mass curve""" c = (angstrom_to_bohr**2 / eV_to_hartree) / eff_mass - x0 = x - x[0] - return x0 + x[0], c / 2 * x0**2 + return c / 2 * x**2 -def points_with_tol(array, value, tol=1e-4): +def points_with_tol(array, value, tol=1e-4, sign=1): """ Return the indices and values of points in an array close to the value with a tolerance """ - idx = np.where(np.abs(array - value) < tol)[0] + if sign == 0: + diff = abs(array - value) + else: + diff = (array - value) * sign + idx = np.where((-1e-3 < diff) & (diff < tol))[0] return idx, array[idx] @@ -80,22 +83,21 @@ def __init__( unfold: UnfoldKSet, intensity_tol: float = 1e-1, extrema_tol: float = 1e-3, - degeneracy_tol: float = 1e-2, parabolic: bool = True, npoints: float = 3, ): """ Instantiate the object - Args: - unfold (UnfoldKSet): The ``UnfoldKSet`` object that holes unfolding data. - intensity_tol (float): Intensity tolerance for detecting band edges. - parabolic (bool): Perform parabolic fit or not. Defaults to True as non-parabolic fit is not working at the moment... + :param unfold: The ``UnfoldKSet`` object that holds unfolding data. + :param intensity_tol: Intensity threshold for detecting band edges. + :param extrema_tol: Distance tolerance for detecting band edges. + :param parabolic: Perform parabolic fit or not. The default is None. + :param npoints: The number of points used for fitting. """ self.unfold: UnfoldKSet = unfold self.intensity_tol = intensity_tol self.extrema_detect_tol = extrema_tol - self.degeneracy_tol = degeneracy_tol self.parabolic = parabolic self.nocc = None # Number of occupied bands if npoints < 3: @@ -108,34 +110,43 @@ def set_nocc(self, nocc): @property def kpoints(self): + """ + The primitive cell k-points used for unfolding. + """ return self.unfold.kpts_pc @property def kpoints_labels(self): + """ + The primitive cell k-points labels set for unfolding. + """ return self.unfold.kpoint_labels - def get_band_extrema(self, mode: str = 'cbm', extrema_tol: float = None, degeneracy_tol: float = None, ispin=0): + def get_band_extrema(self, mode: str = 'cbm', extrema_tol: float = None, ispin=0): """ - Obtain the kpoint idx of band maximum, sub indices in th set and the band indices. - - The search takes two steps, first the kpoints at the band extrema is located by comparing the - band energies with that recorded in supplied *cbm* and *vbm*, based on the `exgtrema_tol`. - Afterwards, the band indices are selected at the these kpoints using `degeneracy_tol`. - - Returns: - A tuple of extrema locations including a list of kpoint indices, sub-indices within - the set and the band indices at each kpoint that is within the `tol` set. + Obtain the kpoint idx of band extrema, sub indices in the set, and the band indices. + + The search takes two steps. First, the kpoints at the band extrema are located by comparing the + band energies with that recorded in the supplied *cbm* and *vbm*, based on the `extrema_tol`. + Afterwards, the band indices are selected at these kpoints using the `tol` set. + + :param mode: The mode to search for band extrema. Can be either 'cbm' (conduction band minimum) or 'vbm' + (valence band maximum). + :param extrema_tol: The tolerance for determining the proximity of band energies to the cbm/vbm. + If not provided, the default tolerance from `self.extrema_detect_tol` is used. + :param ispin: The spin index. Default is 0. + :returns: A tuple of extrema locations including a list of kpoint indices, sub-indices within + the set, and the band indices at each kpoint that is within the `extrema_tol` from the cbm/vbm. + :raises ValueError: If an unknown mode is provided. """ - if extrema_tol is None: - extrema_tol = self.extrema_detect_tol - if degeneracy_tol is None: - degeneracy_tol = self.degeneracy_tol + extrema_tol = self.extrema_detect_tol if extrema_tol is None else extrema_tol intensity_tol = self.intensity_tol if mode not in ['cbm', 'vbm']: raise ValueError(f'Unknown mode {mode}') - cbm = self.unfold.calculated_quantities[mode] + + eref = self.unfold.calculated_quantities[mode] weights = self.unfold.calculated_quantities['spectral_weights_per_set'] # Indices of the kpoint corresponding to the CBM @@ -144,22 +155,20 @@ def get_band_extrema(self, mode: str = 'cbm', extrema_tol: float = None, degener cbm_indices = [] for ik, wset in enumerate(weights): for isubset in range(wset.shape[1]): - if np.any(np.abs(wset[ispin, isubset, :, 0] - cbm) < extrema_tol): - itmp, _ = points_with_tol(wset[ispin, isubset, :, 0], cbm, extrema_tol) - # Check if it has sufficient intensity - if np.max(wset[ispin, isubset, itmp, 1]) < intensity_tol: - continue - # Select this kpoints - k_indicies.append(ik) - # Select all band indices within the tolerance - k_subset_indices.append(isubset) - # Stop looking at other kpoints in the k subset if found - break - - # Go through each case - for ik, iksub in zip(k_indicies, k_subset_indices): - itmp, _ = points_with_tol(weights[ik][ispin, iksub, :, 0], cbm, degeneracy_tol) - cbm_indices.append(itmp) + etmp = wset[ispin, isubset, :, 0] + wtmp = wset[ispin, isubset, :, 1] + # Filter by intensity + mask = wtmp > intensity_tol + midx = np.where(mask)[0] + # Find points close to the reference energy (vbm/cbm) + itmp, _ = points_with_tol(etmp[mask], eref, extrema_tol, 0) + if len(itmp) == 0: + continue + # Reconstruct the valid extrema indices + itmp = midx[itmp] + cbm_indices.append(itmp) + k_indicies.append(ik) + k_subset_indices.append(isubset) return k_indicies, k_subset_indices, cbm_indices @@ -181,6 +190,13 @@ def _get_kpoint_distances(self): def _get_fitting_data(self, kidx: int, iband: int, direction=1, ispin=0, npoints=None): """ Get fitting data for a specific combination of kpoint and band index + + :param kidx: The index of the kpoint + :param iband: The index of the band + :param direction: The direction of the data collection, defaults to 1 + :param ispin: The index of the spin, defaults to 0 + :param npoints: Override for the number of data points to collect + :returns: The normalized kpoint distances, normalized effective energies, and the original kpoint distances and effective energies """ istart = kidx weights = self.unfold.calculated_quantities['spectral_weights_per_set'] @@ -188,9 +204,11 @@ def _get_fitting_data(self, kidx: int, iband: int, direction=1, ispin=0, npoints kdists = [] engs_effective = [] - npoints = self.get_npoints(npoints) + npoints = self.npoints if npoints is None else npoints for i in range(npoints): idx = istart + i * direction + if idx >= len(dists) or idx < 0: + break kdists.append(dists[idx]) # Get the spectral weight array sw = weights[idx] @@ -200,34 +218,57 @@ def _get_fitting_data(self, kidx: int, iband: int, direction=1, ispin=0, npoints # Compute the effective energy weighted by intensity and kpoint weighting eng_effective = np.sum(engs * intensities * kw) / np.sum(intensities * kw) engs_effective.append(eng_effective) - return kdists, engs_effective - def get_npoints(self, override: Union[float, None] = None): - """Get the number of points used for fitting""" - if override is None: - return self.npoints - return override + # Normalise the fitting data + kdists_norm = np.array(kdists) - kdists[0] + engs_norm = np.array(engs_effective) + engs_norm -= engs_norm[0] + + kdists_norm = np.concatenate([-kdists_norm[::-1], kdists_norm]) + engs_norm = np.concatenate([engs_norm[::-1], engs_norm]) + + return kdists_norm, engs_norm, (kdists, engs_effective) - def get_effective_masses(self, npoints: Union[float, None] = None, ispin=0): + def get_effective_masses(self, npoints: Union[float, None] = None, ispin=0, iks=None, iband=None, mode=None): """ - Workout the effective masses based on the unfolded band structure + Obtain the effective masses based on the unfolded band structure + + :param npoints: Number of points to use for fitting. If None, a default value is used. + :param ispin: The index of the spin channel. Default is 0. + :param iks: K-point indices used for manual override. + :param iband: Band indices used for manual override. + :param mode: Calculation mode. If None, effective masses at both conduction band minimum (cbm) + and valence band maximum (vbm) will be calculated. + :returns: A dictionary containing the effective masses for electrons and holes. """ outputs = {} - for mode in ['cbm', 'vbm']: - name = 'electrons' if mode == 'cbm' else 'holes' - outputs[name] = self._get_effective_masses(mode, npoints=npoints, ispin=ispin) + mode = ['cbm', 'vbm'] if mode is None else [mode] + for mname in mode: + name = 'electrons' if mname == 'cbm' else 'holes' + outputs[name] = self._get_effective_masses(mname, npoints=npoints, ispin=ispin, iband=iband, iks=iks) return outputs - def _get_effective_masses(self, mode: str = 'cbm', ispin: int = 0, npoints: Union[None, int] = None): + def _get_effective_masses(self, mode: str = 'cbm', ispin: int = 0, npoints: Union[None, int] = None, iks=None, iband=None): """ Work out the effective masses based on the unfolded band structure for CBM or VBM + + :param mode: The mode to calculate effective masses, either 'cbm' for conduction band minimum + or 'vbm' for valence band maximum. Default is 'cbm'. + :param ispin: The spin index. Default is 0. + :param npoints: The number of points to use for fitting. If None, the default number of points will be used. + :param iks: The indices of the k-points to calculate effective masses. If None, the indices will be + obtained from get_band_extrema method. + :param iband: The indices of the bands to calculate effective masses. If None, the indices will be + obtained from get_band_extrema method. + :returns: A list of dictionaries containing the calculated effective masses and related information. """ - iks, _, iband = self.get_band_extrema(mode=mode) + if iks is None or iband is None: + iks, _, iband = self.get_band_extrema(mode=mode) # Override occupations if self.nocc: iband = [self.nocc for _ in iband] - npoints = self.get_npoints(npoints) + npoints = self.npoints if npoints is None else npoints results = [] label_idx = [x[0] for x in self.kpoints_labels] label_names = [x[1] for x in self.kpoints_labels] @@ -242,9 +283,9 @@ def _get_effective_masses(self, mode: str = 'cbm', ispin: int = 0, npoints: Unio continue # Get fitting data for each (degenerate) band at the extrema for band_id in idxb: - kdists, engs_effective = self._get_fitting_data(idxk, band_id, direction, ispin=ispin, npoints=npoints) + kdists, engs_effective, raw_fit_values = self._get_fitting_data(idxk, band_id, direction, ispin=ispin, npoints=npoints) - me = fit_effective_mass(kdists, engs_effective, parabolic=self.parabolic) + me, fit = fit_effective_mass(kdists, engs_effective, parabolic=self.parabolic) # If the identified edge is not in the list of high symmetry point, ignore it # This mitigate the problem where the CBM can be duplicated.... @@ -262,7 +303,9 @@ def _get_effective_masses(self, mode: str = 'cbm', ispin: int = 0, npoints: Unio 'type': 'electrons' if mode == 'cbm' else 'holes', 'raw_data': { 'kpoint_distances': kdists, - 'effective_energies': engs_effective + 'effective_energies': engs_effective, + 'fit_res': fit, + 'raw_fit_values': raw_fit_values, } }) results.sort(key=lambda x: abs(abs(x['effective_mass']))) @@ -271,7 +314,15 @@ def _get_effective_masses(self, mode: str = 'cbm', ispin: int = 0, npoints: Unio def locate_kpoint_segment(idxk: int, label_idx: list, label_names: list, direction: int): - """Locate the labels and indices of the kpoints defining a segment""" + """ + Locate the labels and indices of the kpoints defining a segment + + :param idxk: The index of the kpoint + :param label_idx: A list of indices corresponding to the labels + :param label_names: A list of label names + :param direction: The direction of the segment (1 for forward, -1 for backward) + :returns: A tuple containing the index of the label, the label name of the starting point, and the label name of the ending point + """ if idxk not in label_idx: pairs = list(zip(label_idx, label_names)) i = 0 diff --git a/easyunfold/plotting.py b/easyunfold/plotting.py index 2822ba0..6bf3ed7 100644 --- a/easyunfold/plotting.py +++ b/easyunfold/plotting.py @@ -40,7 +40,8 @@ def __init__(self, unfold: UnfoldKSet): """ self.unfold = unfold - def plot_dos(self, ax, dos_plotter, dos_label, dos_options, ylim, eref, atoms=None, colours=None, orbitals_subplots=None): + @staticmethod + def plot_dos(ax, dos_plotter, dos_label, dos_options, ylim, eref, atoms=None, colours=None, orbitals_subplots=None): """ Prepare and plot the density of states. """ @@ -410,38 +411,40 @@ def plot_effective_mass(self, kvbm = eff.get_band_extrema(mode='vbm')[0] all_k = sorted(list(set(list(kcbm) + list(kvbm)))) kdist = self.unfold.get_kpoint_distances() - xwidth = 0.2 if eref is None: eref = self.unfold.calculated_quantities['vbm'] - fig, axes = plt.subplots(1, len(all_k)) + fig, axes = plt.subplots(1, len(all_k), figsize=(4 * len(all_k), 3), dpi=300, squeeze=False) if effective_mass_data is None: effective_mass_data = eff.get_effective_masses() # Plot the spectral function - for (ik, ax) in zip(all_k, axes): + xwidth = abs(kdist[1] - kdist[0]) + for (ik, ax) in zip(all_k, axes[0]): self.plot_spectral_function(engs, sf, ax=ax, eref=eref, **kwargs) xk = kdist[ik] xlim = (xk - xwidth / 2, xk + xwidth / 2) ax.set_xlim(xlim) ax.set_title(f'Kpoint: {ik}') - elec = effective_mass_data['electrons'] + elec = effective_mass_data.get('electrons', []) # Plot the detected effective mass fitting data on top for entry in elec: ik = entry['kpoint_index'] iax = all_k.index(ik) - x = entry['raw_data']['kpoint_distances'] - y = entry['raw_data']['effective_energies'] - axes[iax].plot(x, np.asarray(y) - eref, '-o', color='C1') + x = entry['raw_data']['raw_fit_values'][0] + y = entry['raw_data']['raw_fit_values'][1] + axes[0, iax].plot(x, np.asarray(y) - eref, '-o', color='C1') + axes[0, iax].set_xlim(min(x) - xwidth / 2, max(x) + xwidth / 2) - hole = effective_mass_data['holes'] + hole = effective_mass_data.get('holes', []) for entry in hole: ik = entry['kpoint_index'] iax = all_k.index(ik) - x = entry['raw_data']['kpoint_distances'] - y = entry['raw_data']['effective_energies'] - axes[iax].plot(x, np.asarray(y) - eref, '-o', color='C2') + x = entry['raw_data']['raw_fit_values'][0] + y = entry['raw_data']['raw_fit_values'][1] + axes[0, iax].plot(x, np.asarray(y) - eref, '-o', color='C2') + axes[0, iax].set_xlim(min(x) - xwidth / 2, max(x) + xwidth / 2) if save: fig.savefig(save) @@ -793,18 +796,18 @@ def plot_effective_mass_fit(efm: EffectiveMass, :param save: Name of the file used for saveing. :param dpi: DPI of the figure when saving. - :return: A figure with plotted data. + :returns: A figure with plotted data. """ data = efm.get_effective_masses(npoints=npoints)[carrier][idx] x = data['raw_data']['kpoint_distances'] y = data['raw_data']['effective_energies'] me = data['effective_mass'] - x1, y1 = fitted_band(x, me) + y1 = fitted_band(x, me) if ax is None: fig, ax = plt.subplots(1, 1) ax.plot(x, y, 'x-', label='Energy ') - ax.plot(x1, y1 + y[0], label='fitted') + ax.plot(x, y1, label='fitted') ax.legend() if save: fig.savefig(save, dpi=dpi) diff --git a/easyunfold/unfold.py b/easyunfold/unfold.py index 26d038c..42b036d 100644 --- a/easyunfold/unfold.py +++ b/easyunfold/unfold.py @@ -11,6 +11,7 @@ import re import warnings from typing import Union, List, Tuple +from pathlib import Path from packaging import version import numpy as np @@ -332,6 +333,7 @@ def write_sc_kpoints(self, file: str, nk_per_split: Union[None, list] = None, scf_kpoints_and_weights: Union[None, list] = None, + use_separate_folders=False, **kwargs): """ Write the supercell kpoints to a file. @@ -358,12 +360,13 @@ def write_sc_kpoints(self, for i_spilt, kpt in enumerate(splits): if scf_kpoints_and_weights: kpt, weights = concatenate_scf_kpoints(scf_kpoints_and_weights[0], scf_kpoints_and_weights[1], kpt) - write_kpoints(kpt, - f'{file}_{i_spilt + 1:03d}', - f'supercell kpoints split {i_spilt + 1}', - code=self.dft_code, - weights=weights, - **kwargs) + if use_separate_folders: + folder = f'split-{i_spilt+1:03d}' + Path(folder).mkdir(exist_ok=True) + fname = str(folder / file) + else: + fname = f'{file}_{i_spilt + 1:03d}' + write_kpoints(kpt, fname, f'supercell kpoints split {i_spilt + 1}', code=self.dft_code, weights=weights, **kwargs) def write_pc_kpoints(self, file: str, expanded: bool = False, **kwargs): """Write the primitive cell kpoints""" diff --git a/easyunfold/utils.py b/easyunfold/utils.py index aef159a..aedaf49 100644 --- a/easyunfold/utils.py +++ b/easyunfold/utils.py @@ -219,7 +219,7 @@ def find_unique(seq: np.ndarray, func=None): Find unique slices along the first dimension of an np.array. This function is not optimised for high performance and has a O(N^2) scaling. - :return: A tuple of (unique, unique_idx, inv_mapping) + :returns: A tuple of (unique, unique_idx, inv_mapping) """ if func is None: # Use equality condition diff --git a/examples/MgO/effective-mass.ipynb b/examples/MgO/effective-mass.ipynb new file mode 100644 index 0000000..f49de47 --- /dev/null +++ b/examples/MgO/effective-mass.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bd103ffa-b802-4669-8c30-5eaf25ee8dcd", + "metadata": {}, + "source": [ + "## Effective mass fitting example\n", + "\n", + "Fitting effective mass using the unfolded band structure can be complex and not always reliable.\n", + "Here, we demonstrate how it is done via the python API. \n", + "For complex systems, a bit more tinkering will be needed." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "99956272-bf80-4eb5-8578-c163e7d199cf", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-11T16:21:36.171804Z", + "start_time": "2024-01-11T16:21:34.662797Z" + } + }, + "outputs": [], + "source": [ + "from easyunfold.unfold import UnfoldKSet\n", + "from easyunfold.plotting import UnfoldPlotter\n", + "from easyunfold.effective_mass import EffectiveMass, fitted_band\n", + "from monty.serialization import loadfn" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e0aff163-a9e8-46dc-9c6b-4f8cc1d292cd", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-11T16:21:36.184140Z", + "start_time": "2024-01-11T16:21:36.172966Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The data file was generated with easyunfold 0.1.3, current 0.3.4.\n" + ] + } + ], + "source": [ + "unfold = loadfn(\"easyunfold.json\")\n", + "eff = EffectiveMass(unfold)\n", + "plotter = UnfoldPlotter(unfold)" + ] + }, + { + "cell_type": "markdown", + "id": "441c596d-00cf-4599-bc2f-9a08983388dd", + "metadata": {}, + "source": [ + "Let's plot the effective band structure first" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d3978a55-fb61-4e54-8c68-21e866951a53", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-11T16:21:39.547992Z", + "start_time": "2024-01-11T16:21:39.171120Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotter.plot_spectral_function(*unfold.get_spectral_function(sigma=0.02),dpi=150);" + ] + }, + { + "cell_type": "markdown", + "id": "4785d5f4-0137-49b2-8c0b-d148ac0fe2f7", + "metadata": {}, + "source": [ + "Effective mass is sensitive to the details at the CBM/VBM. It can be useful to plot the spectral weights directly. \n", + "In fact, the bands are extracted from the spectral weight rather than the spectral function." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fd8c7942-9eaf-4c67-a88e-be8c7d3dc2bb", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-11T16:21:43.865489Z", + "start_time": "2024-01-11T16:21:43.763430Z" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotter.plot_spectral_weights(ylim=(-2, 10), factor=10);" + ] + }, + { + "cell_type": "markdown", + "id": "720bebeb-261c-4942-8e6e-fe398d1f705d", + "metadata": {}, + "source": [ + "**The effective mass data includes the raw data used for fitting - we can plot and see how good the fit is.**\n", + "To do this, we plot the electronic band energies (normalised) versus the kpoint distances: " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fd56e1f8-075d-408f-9d8d-8567485ab879", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-11T16:21:53.183464Z", + "start_time": "2024-01-11T16:21:53.088461Z" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kpoints: [0, 47] \n", + "sub points: [0, 0] \n", + "bands: [array([16]), array([16])]\n", + "Effective mass: 0.367 me\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_fit(np, data='electrons', ax=None):\n", + " \"\"\"\n", + " Fit and plot effective mass\n", + " \n", + " np: number of points to use for fitting\n", + " data: 'electrons' or 'holes'\n", + " ax: matplotlib axis to plot on \n", + " \"\"\"\n", + " eff = EffectiveMass(unfold, npoints=np, extrema_tol=0.1)\n", + " ik, isubk, iband = eff.get_band_extrema()\n", + " print('kpoints: ', ik, '\\nsub points: ', isubk, '\\nbands: ', iband) \n", + " data = eff.get_effective_masses(npoints=np)[data][1]\n", + " # Checking the quality of the fit\n", + " x = data['raw_data']['kpoint_distances']\n", + " y = data['raw_data']['effective_energies']\n", + " fit = data['raw_data']['fit_res']\n", + " eff = data['effective_mass']\n", + " print(f'Effective mass: {eff:.3f} me')\n", + " y1 = fitted_band(x, eff)\n", + " if ax is None:\n", + " fig, ax = plt.subplots(1,1)\n", + " ax.plot(x, y, 'x-', label='Energy ')\n", + " ax.plot(x, y1, label='fitted')\n", + " ax.legend()\n", + "plot_fit(3)" + ] + }, + { + "cell_type": "markdown", + "id": "1e396968-b75c-4bb0-a7bf-c126515427a1", + "metadata": {}, + "source": [ + "We can also check for holes.\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "db2863ae-0abb-4303-b825-e3f5d8bfbb9d", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-11T16:24:06.708219Z", + "start_time": "2024-01-11T16:24:06.640763Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kpoints: [0, 47] \n", + "sub points: [0, 0] \n", + "bands: [array([16]), array([16])]\n", + "Effective mass: -3.772 me\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_fit(4, 'holes')" + ] + }, + { + "cell_type": "markdown", + "id": "ed77527b-b031-41ef-a7db-ecfe236b9b64", + "metadata": {}, + "source": [ + "Fits for the holes are not as good as the electrons - those bands are much flatter and not so parabolic. \n", + "We can also investigate how the number of fitting points affect the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b9472b9c-1aed-4311-8b21-b012e8ccfc0b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kpoints: [0, 47] \n", + "sub points: [0, 0] \n", + "bands: [array([16]), array([16])]\n", + "Effective mass: 0.367 me\n", + "kpoints: [0, 47] \n", + "sub points: [0, 0] \n", + "bands: [array([16]), array([16])]\n", + "Effective mass: 0.400 me\n", + "kpoints: [0, 47] \n", + "sub points: [0, 0] \n", + "bands: [array([16]), array([16])]\n", + "Effective mass: 0.439 me\n", + "kpoints: [0, 47] \n", + "sub points: [0, 0] \n", + "bands: [array([16]), array([16])]\n", + "Effective mass: 0.484 me\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(8, 6), dpi=100)\n", + "for ax, np in zip(axs.ravel(), [3, 4, 5, 6]): # test different npoints choices\n", + " plot_fit(np, 'electrons', ax)\n", + " ax.set_title(f'Points: {np}')\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "c3dfa1e6-0677-4c50-86bb-640bf2d941ff", + "metadata": {}, + "source": [ + "The effective masses increase as we increase the number of points, and it can be seen that the fit quality becomes worse.\n", + "This is because the included _k_-points are no longer close to the CBM.\n", + "\n", + "To improve the reliability of the effective masses extracted, one may want to use a _k_-point path with smaller step distance. Only the vicinity of the CBM/VBM needs to be included, so this should not increase the computational cost.\n", + "\n", + "For a path with sufficiently small step distance, one should be able to include more fitting points (perhaps more than 4) while having the calculated effective mass unchanged." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/MgO/unfold-effective-mass.png b/examples/MgO/unfold-effective-mass.png new file mode 100644 index 0000000..5a9a23e Binary files /dev/null and b/examples/MgO/unfold-effective-mass.png differ diff --git a/tests/test_cli.py b/tests/test_cli.py index d106d01..7e3a18b 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -100,7 +100,7 @@ def test_generate_agsbte2(agsbte2_project_dir): 'Warning: There is a lattice parameter mismatch in the range 2-5% between the primitive (multiplied by the ' 'transformation matrix) and the supercell. This will lead to some quantitative inaccuracies in the ' 'Brillouin Zone spacing (and thus effective masses) of the unfolded band structures.', - '(Guessed) Transform matrix:\n[[1.0, -0.0, 0.0], [1.0, -3.0, 1.0], [1.0, 1.0, -3.0]]', + '(Guessed) Transform matrix:\n[[1.0, 0.0, 0.0], [1.0, -3.0, 1.0], [1.0, 1.0, -3.0]]', ], output, ) @@ -217,7 +217,7 @@ def test_unfold(si_project_dir, tag): if tag == '': output = runner.invoke(easyunfold, ['unfold', '--data-file', 'test.json', 'effective-mass']) assert 'Hole effective masses' in output.stdout - assert (r' 0 m_e -0.938459 8 [0.5, 0.0, 0.5] (X) [0.5, 0.25, 0.75] (W)' in output.stdout) + assert r'0 m_e 0.820036 8 [0.5, 0.0, 0.5] (X)' in output.stdout # Plot effective mass output = runner.invoke( easyunfold, diff --git a/tests/test_effective_mass.py b/tests/test_effective_mass.py index a5f7572..df321d3 100644 --- a/tests/test_effective_mass.py +++ b/tests/test_effective_mass.py @@ -3,6 +3,7 @@ """ from pathlib import Path import pytest +import numpy as np from monty.serialization import loadfn import easyunfold.effective_mass as em @@ -42,16 +43,15 @@ def test_effective_mass(effective_mass_obj): assert len(kdist) == len(effective_mass_obj.kpoints) fdata = effective_mass_obj._get_fitting_data(0, 16, 1, 0, 3) - assert (fdata[0] == kdist[:3]).all() - assert len(fdata[1]) == 3 + assert len(fdata[1]) == 6 assert len(output['electrons']) == 2 assert len(output['holes']) == 2 assert output['electrons'][0]['kpoint_label_from'] == '\\Gamma' assert output['electrons'][0]['kpoint_label_to'] == 'L' - assert output['electrons'][0]['effective_mass'] == pytest.approx(0.39912256690278236) + assert output['electrons'][0]['effective_mass'] == pytest.approx(0.36959097872) assert output['holes'][0]['kpoint_label_from'] == '\\Gamma' assert output['holes'][0]['kpoint_label_to'] == 'L' - assert output['holes'][0]['effective_mass'] == pytest.approx(-5.972424721183893) + assert output['holes'][0]['effective_mass'] == pytest.approx(-3.36071124861)