xarpes 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

xarpes/__init__.py

@@ -1,6 +1,6 @@
-__version__ = '0.3.4'
+__version__ = '0.4.0'
 
 from .spectral import *
 from .distributions import *
 from .functions import *
-from .plotting import *
+from .plotting import *

xarpes/plotting.py

@@ -12,14 +12,19 @@
 """Functions related to plotting."""
 
 from functools import wraps
+from IPython import get_ipython
 import matplotlib.pyplot as plt
 import matplotlib as mpl
 
-def plot_settings(name='default'):
+
+def plot_settings(name='default', register_pre_run=True):
+    """Configure default plotting style for xARPES."""
+
     mpl.rc('xtick', labelsize=10, direction='in')
     mpl.rc('ytick', labelsize=10, direction='in')
     plt.rcParams['legend.frameon'] = False
     lw = dict(default=2.0, large=4.0)[name]
+
     mpl.rcParams.update({
         'lines.linewidth': lw,
         'lines.markersize': 3,
@@ -30,6 +35,31 @@ def plot_settings(name='default'):
         'axes.ymargin': 0.15,
     })
 
+    if register_pre_run:
+        _maybe_register_pre_run_close_all()
+
+
+def _maybe_register_pre_run_close_all():
+    """Register a pre_run_cell hook once, and only inside Jupyter."""
+
+    # Create the function attribute on first call
+    if not hasattr(_maybe_register_pre_run_close_all, "_registered"):
+        _maybe_register_pre_run_close_all._registered = False
+
+    if _maybe_register_pre_run_close_all._registered:
+        return
+
+    ip = get_ipython()
+    if ip is None or ip.__class__.__name__ != "ZMQInteractiveShell":
+        return
+
+    def _close_all(_info):
+        plt.close('all')
+
+    ip.events.register('pre_run_cell', _close_all)
+    _maybe_register_pre_run_close_all._registered = True
+
+
 def get_ax_fig_plt(ax=None, **kwargs):
     r"""Helper function used in plot functions supporting an optional `Axes`
     argument.

xarpes/spectral.py

@@ -346,20 +346,41 @@ class BandMap:
         return mdcs, angle_range_out, self.angle_resolution, \
         enel_range_out, self.hnuminphi
 
-
     @add_fig_kwargs
     def plot(self, abscissa='momentum', ordinate='electron_energy',
-             self_energies=None, ax=None, markersize=None, **kwargs):
+             self_energies=None, ax=None, markersize=None,
+             plot_dispersions='none', **kwargs):
         r"""
-        Plot the band map. Optionally attach a collection of self-energies,
+        Plot the band map. Optionally overlay a collection of self-energies,
         e.g. a CreateSelfEnergies instance or any iterable of self-energy
-        objects. They are stored on `self` for later overlay plotting.
+        objects. Self-energies are *not* stored internally; they are used
+        only for this plotting call.
 
         When self-energies are present and ``abscissa='momentum'``, their
         MDC maxima are overlaid with 95 % confidence intervals.
+
+        The `plot_dispersions` argument controls bare-band plotting:
+
+        - "full"   : use the full momentum range of the map (default)
+        - "none"   : do not plot bare dispersions
+        - "kink"   : for each self-energy, use the min/max of its own
+          momentum range (typically its MDC maxima), with
+          `len(self.angles)` points.
+        - "domain" : for SpectralQuadratic, use only the left or right
+          domain relative to `center_wavevector`, based on the self-energy
+          attribute `side` ("left" / "right"); for other cases this behaves
+          as "full".
         """
         import warnings
 
+        plot_disp_mode = plot_dispersions
+        valid_disp_modes = ('full', 'none', 'kink', 'domain')
+        if plot_disp_mode not in valid_disp_modes:
+            raise ValueError(
+                f"Invalid plot_dispersions '{plot_disp_mode}'. "
+                f"Valid options: {valid_disp_modes}."
+            )
+
         valid_abscissa = ('angle', 'momentum')
         valid_ordinate = ('kinetic_energy', 'electron_energy')
 
@@ -374,114 +395,247 @@ class BandMap:
                 f"Valid options: {valid_ordinate}"
             )
 
-        # Optionally store self-energies on the instance
         if self_energies is not None:
 
             # MDC maxima are defined in momentum space, not angle space
-            if abscissa == 'angle' and isinstance(
-                self_energies, (list, tuple, CreateSelfEnergies)
-            ):
-                raise ValueError( "MDC maxima cannot be plotted against "
-                "angles; they are defined in momentum space. Use " \
-                "abscissa='momentum' when passing a list of self-energies.")
-
-            if not isinstance(self_energies, CreateSelfEnergies):
-                self_energies = CreateSelfEnergies(self_energies)
-
-            self._self_energies = self_energies
-        elif not hasattr(self, "_self_energies"):
-            self._self_energies = None
+            if abscissa == 'angle':
+                raise ValueError(
+                    "MDC maxima cannot be plotted against angles; they are "
+                    "defined in momentum space. Use abscissa='momentum' "
+                    "when passing self-energies."
+                )
 
         ax, fig, plt = get_ax_fig_plt(ax=ax)
-        # Below, **kwargs is 
 
         Angl, Ekin = np.meshgrid(self.angles, self.ekin)
-        
+
         if abscissa == 'angle':
             ax.set_xlabel('Angle ($\\degree$)')
             if ordinate == 'kinetic_energy':
-                mesh = ax.pcolormesh(Angl, Ekin, self.intensities, 
-                    shading='auto', cmap=plt.get_cmap('bone').reversed(), 
-                        **kwargs)
+                mesh = ax.pcolormesh(
+                    Angl, Ekin, self.intensities,
+                    shading='auto',
+                    cmap=plt.get_cmap('bone').reversed())
                 ax.set_ylabel('$E_{\\mathrm{kin}}$ (eV)')
             elif ordinate == 'electron_energy':
                 Enel = Ekin - self.hnuminphi
-                mesh = ax.pcolormesh(Angl, Enel, self.intensities, 
-                    shading='auto', cmap=plt.get_cmap('bone').reversed(), 
-                        **kwargs)
+                mesh = ax.pcolormesh(
+                    Angl, Enel, self.intensities,
+                    shading='auto',
+                    cmap=plt.get_cmap('bone').reversed())
                 ax.set_ylabel('$E-\\mu$ (eV)')
 
         elif abscissa == 'momentum':
             ax.set_xlabel(r'$k_{//}$ ($\mathrm{\AA}^{-1}$)')
 
             with warnings.catch_warnings(record=True) as wlist:
-                warnings.filterwarnings("always",
-                    message=("The input coordinates to pcolormesh are "
+                warnings.filterwarnings(
+                    "always",
+                    message=(
+                        "The input coordinates to pcolormesh are "
                         "interpreted as cell centers, but are not "
-                        "monotonically increasing or decreasing."),
-                    category=UserWarning)
+                        "monotonically increasing or decreasing."
+                    ),
+                    category=UserWarning,
+                )
 
                 Mome = np.sqrt(Ekin / pref) * np.sin(Angl * dtor)
+                mome_min = np.min(Mome)
+                mome_max = np.max(Mome)
+                full_disp_momenta = np.linspace(
+                    mome_min, mome_max, len(self.angles)
+                )
 
                 if ordinate == 'kinetic_energy':
-                    mesh = ax.pcolormesh(Mome, Ekin, self.intensities,
-                        shading='auto', cmap=plt.get_cmap('bone').reversed(), 
-                        **kwargs)
+                    mesh = ax.pcolormesh(
+                        Mome, Ekin, self.intensities,
+                        shading='auto',
+                        cmap=plt.get_cmap('bone').reversed())
                     ax.set_ylabel('$E_{\\mathrm{kin}}$ (eV)')
-
                 elif ordinate == 'electron_energy':
                     Enel = Ekin - self.hnuminphi
-                    mesh = ax.pcolormesh(Mome, Enel, self.intensities, 
-                        shading='auto', cmap=plt.get_cmap('bone').reversed(), 
-                        **kwargs)
+                    mesh = ax.pcolormesh(
+                        Mome, Enel, self.intensities,
+                        shading='auto',
+                        cmap=plt.get_cmap('bone').reversed())
                     ax.set_ylabel('$E-\\mu$ (eV)')
 
+                y_lims = ax.get_ylim()
+
             if any("cell centers" in str(w.message) for w in wlist):
-                warnings.warn("Conversion from angle to momenta causes warping "
-                              "of the cell centers. \n Cell edges of the "
-                              "mesh plot may look irregular.", UserWarning, 
-                              stacklevel=2)
+                warnings.warn(
+                    "Conversion from angle to momenta causes warping of the "
+                    "cell centers. \n Cell edges of the mesh plot may look "
+                    "irregular.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+
+        if abscissa == 'momentum' and self_energies is not None:
+            for self_energy in self_energies:
 
-        if abscissa == 'momentum' and self._self_energies is not None:
-            for self_energy in self._self_energies:
                 mdc_maxima = getattr(self_energy, "mdc_maxima", None)
 
-                # If this self-energy doesn't contain maxima, don't plot them
+                # If this self-energy doesn't contain maxima, don't plot
                 if mdc_maxima is None:
                     continue
 
-                peak_sigma = getattr(self_energy, "peak_positions_sigma",
-                    None)
+                # Reserve a colour from the axes cycle for this self-energy,
+                # and use it consistently for MDC maxima and dispersion.
+                line_color = ax._get_lines.get_next_color()
+
+                peak_sigma = getattr(
+                    self_energy, "peak_positions_sigma", None
+                )
                 xerr = stdv * peak_sigma if peak_sigma is not None else None
 
                 if ordinate == 'kinetic_energy':
                     y_vals = self_energy.ekin_range
-                else:  # electron energy
+                else:
                     y_vals = self_energy.enel_range
 
                 x_vals = mdc_maxima
                 label = getattr(self_energy, "label", None)
 
+                # First plot the MDC maxima, using the reserved colour
                 if xerr is not None:
-                    ax.errorbar(x_vals, y_vals, xerr=xerr, fmt='o',
-                                linestyle='', label=label,
-                                markersize=markersize)
+                    ax.errorbar(
+                        x_vals, y_vals, xerr=xerr, fmt='o',
+                        linestyle='', label=label,
+                        markersize=markersize,
+                        color=line_color, ecolor=line_color,
+                    )
                 else:
-                    ax.plot(x_vals, y_vals, linestyle='', marker='o',
-                            label=label, markersize=markersize)
+                    ax.plot(
+                        x_vals, y_vals, linestyle='',
+                        marker='o', label=label,
+                        markersize=markersize,
+                        color=line_color,
+                    )
 
-            handles, labels = ax.get_legend_handles_labels()
-            if any(labels):
-                ax.legend()
+                # Bare-band dispersion for SpectralLinear / SpectralQuadratic
+                spec_class = getattr(
+                    self_energy, "_class",
+                    self_energy.__class__.__name__,
+                )
+
+                if (plot_disp_mode != 'none'
+                        and spec_class in ("SpectralLinear",
+                                           "SpectralQuadratic")):
+
+                    # Determine momentum grid for the dispersion
+                    if plot_disp_mode == 'kink':
+                        x_arr = np.asarray(x_vals)
+                        mask = np.isfinite(x_arr)
+                        if not np.any(mask):
+                            # No valid k-points to define a range
+                            continue
+                        k_min = np.min(x_arr[mask])
+                        k_max = np.max(x_arr[mask])
+                        disp_momenta = np.linspace(
+                            k_min, k_max, len(self.angles)
+                        )
+                    elif (plot_disp_mode == 'domain'
+                          and spec_class == "SpectralQuadratic"):
+                        side = getattr(self_energy, "side", None)
+                        if side == 'left':
+                            disp_momenta = np.linspace(
+                                mome_min, self_energy.center_wavevector,
+                                len(self.angles)
+                            )
+                        elif side == 'right':
+                            disp_momenta = np.linspace(
+                                self_energy.center_wavevector, mome_max,
+                                len(self.angles)
+                            )
+                        else:
+                            # Fallback: no valid side, use full range
+                            disp_momenta = full_disp_momenta
+                    else:
+                        # 'full' or 'domain' for SpectralLinear
+                        disp_momenta = full_disp_momenta
+
+                    # --- Robust parameter checks before computing base_disp ---
+                    if spec_class == "SpectralLinear":
+                        fermi_vel = getattr(
+                            self_energy, "fermi_velocity", None
+                        )
+                        fermi_k = getattr(
+                            self_energy, "fermi_wavevector", None
+                        )
+                        if fermi_vel is None or fermi_k is None:
+                            missing = []
+                            if fermi_vel is None:
+                                missing.append("fermi_velocity")
+                            if fermi_k is None:
+                                missing.append("fermi_wavevector")
+                            raise TypeError(
+                                "Cannot plot bare dispersion for "
+                                "SpectralLinear: "
+                                f"{', '.join(missing)} is None."
+                            )
+
+                        base_disp = (
+                            fermi_vel * (disp_momenta - fermi_k)
+                        )
+
+                    else:  # SpectralQuadratic
+                        bare_mass = getattr(
+                            self_energy, "bare_mass", None
+                        )
+                        center_k = getattr(
+                            self_energy, "center_wavevector", None
+                        )
+                        fermi_k = getattr(
+                            self_energy, "fermi_wavevector", None
+                        )
+
+                        missing = []
+                        if bare_mass is None:
+                            missing.append("bare_mass")
+                        if center_k is None:
+                            missing.append("center_wavevector")
+                        if fermi_k is None:
+                            missing.append("fermi_wavevector")
+
+                        if missing:
+                            raise TypeError(
+                                "Cannot plot bare dispersion for "
+                                "SpectralQuadratic: "
+                                f"{', '.join(missing)} is None."
+                            )
+
+                        dk = disp_momenta - center_k
+                        base_disp = (
+                            pref * (dk ** 2 - fermi_k ** 2) / bare_mass
+                        )
+                    # --- end parameter checks and base_disp construction ---
+
+                    if ordinate == 'electron_energy':
+                        disp_vals = base_disp
+                    else:  # kinetic energy
+                        disp_vals = base_disp + self.hnuminphi
+
+                    band_label = getattr(self_energy, "label", None)
+                    if band_label is not None:
+                        band_label = f"{band_label} (bare)"
+
+                    ax.plot(
+                        disp_momenta, disp_vals,
+                        label=band_label,
+                        linestyle='--',
+                        color=line_color,
+                    )
 
             handles, labels = ax.get_legend_handles_labels()
             if any(labels):
                 ax.legend()
 
+            ax.set_ylim(y_lims)
+
         plt.colorbar(mesh, ax=ax, label='counts (-)')
         return fig
-
-
+    
     @add_fig_kwargs
     def fit_fermi_edge(self, hnuminphi_guess, background_guess=0.0,
                        integrated_weight_guess=1.0, angle_min=-np.inf,
@@ -2094,6 +2248,154 @@ class SelfEnergy:
                 )
 
         return self._mdc_maxima
+    
+    def _se_legend_labels(self):
+        """Return (real_label, imag_label) for legend with safe subscripts."""
+        se_label = getattr(self, "label", None)
+
+        if se_label is None:
+            real_label = r"$\Sigma'(E)$"
+            imag_label = r"$-\Sigma''(E)$"
+            return real_label, imag_label
+
+        safe_label = str(se_label).replace("_", r"\_")
+
+        # If the label is empty after conversion, fall back
+        if safe_label == "":
+            real_label = r"$\Sigma'(E)$"
+            imag_label = r"$-\Sigma''(E)$"
+            return real_label, imag_label
+
+        real_label = rf"$\Sigma_{{\mathrm{{{safe_label}}}}}'(E)$"
+        imag_label = rf"$-\Sigma_{{\mathrm{{{safe_label}}}}}''(E)$"
+
+        return real_label, imag_label
+
+    @add_fig_kwargs
+    def plot_real(self, ax=None, **kwargs):
+        r"""Plot the real part Σ' of the self-energy as a function of E-μ.
+
+        Parameters
+        ----------
+        ax : Matplotlib-Axes or None
+            Axis to plot on. Created if not provided by the user.
+        **kwargs :
+            Additional keyword arguments passed to ``ax.errorbar``.
+
+        Returns
+        -------
+        fig : Matplotlib-Figure
+            Figure containing the Σ'(E) plot.
+        """
+
+        ax, fig, plt = get_ax_fig_plt(ax=ax)
+
+        x = self.enel_range
+        y = self.real
+        y_sigma = self.real_sigma
+
+        real_label, _ = self._se_legend_labels()
+        kwargs.setdefault("label", real_label)
+
+        if y_sigma is not None:
+            if np.isnan(y_sigma).any():
+                print(
+                    "Warning: some Σ'(E) uncertainty values are missing. "
+                    "Error bars omitted at those energies."
+                )
+            kwargs.setdefault("yerr", stdv * y_sigma)
+
+        ax.errorbar(x, y, **kwargs)
+        ax.set_xlabel(r"$E-\mu$ (eV)")
+        ax.set_ylabel(r"$\Sigma'(E)$ (eV)")
+        ax.legend()
+
+        return fig
+
+    @add_fig_kwargs
+    def plot_imag(self, ax=None, **kwargs):
+        r"""Plot the imaginary part -Σ'' of the self-energy vs. E-μ.
+
+        Parameters
+        ----------
+        ax : Matplotlib-Axes or None
+            Axis to plot on. Created if not provided by the user.
+        **kwargs :
+            Additional keyword arguments passed to ``ax.errorbar``.
+
+        Returns
+        -------
+        fig : Matplotlib-Figure
+            Figure containing the -Σ''(E) plot.
+        """
+
+        ax, fig, plt = get_ax_fig_plt(ax=ax)
+
+        x = self.enel_range
+        y = self.imag
+        y_sigma = self.imag_sigma
+
+        _, imag_label = self._se_legend_labels()
+        kwargs.setdefault("label", imag_label)
+
+        if y_sigma is not None:
+            if np.isnan(y_sigma).any():
+                print(
+                    "Warning: some -Σ''(E) uncertainty values are missing. "
+                    "Error bars omitted at those energies."
+                )
+            kwargs.setdefault("yerr", stdv * y_sigma)
+
+        ax.errorbar(x, y, **kwargs)
+        ax.set_xlabel(r"$E-\mu$ (eV)")
+        ax.set_ylabel(r"$-\Sigma''(E)$ (eV)")
+        ax.legend()
+
+        return fig
+
+    @add_fig_kwargs
+    def plot_both(self, ax=None, **kwargs):
+        r"""Plot Σ'(E) and -Σ''(E) vs. E-μ on the same axis."""
+
+        ax, fig, plt = get_ax_fig_plt(ax=ax)
+
+        x = self.enel_range
+        real = self.real
+        imag = self.imag
+        real_sigma = self.real_sigma
+        imag_sigma = self.imag_sigma
+
+        real_label, imag_label = self._se_legend_labels()
+
+        # --- plot Σ'
+        kw_real = dict(kwargs)
+        if real_sigma is not None:
+            if np.isnan(real_sigma).any():
+                print(
+                    "Warning: some Σ'(E) uncertainty values are missing. "
+                    "Error bars omitted at those energies."
+                )
+            kw_real.setdefault("yerr", stdv * real_sigma)
+        kw_real.setdefault("label", real_label)
+        ax.errorbar(x, real, **kw_real)
+
+        # --- plot -Σ''
+        kw_imag = dict(kwargs)
+        if imag_sigma is not None:
+            if np.isnan(imag_sigma).any():
+                print(
+                    "Warning: some -Σ''(E) uncertainty values are missing. "
+                    "Error bars omitted at those energies."
+                )
+            kw_imag.setdefault("yerr", stdv * imag_sigma)
+        kw_imag.setdefault("label", imag_label)
+        ax.errorbar(x, imag, **kw_imag)
+
+        ax.set_xlabel(r"$E-\mu$ (eV)")
+        ax.set_ylabel(r"$\Sigma'(E),\ -\Sigma''(E)$ (eV)")
+        ax.legend()
+
+        return fig
 
 
 class CreateSelfEnergies:
@@ -2171,5 +2473,4 @@ class CreateSelfEnergies:
         r"""
         Return a {label: self_energy} dictionary for convenient access.
         """
-        return {se.label: se for se in self.self_energies}
-    
+        return {se.label: se for se in self.self_energies}

{xarpes-0.3.4.dist-info → xarpes-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xarpes
-Version: 0.3.4
+Version: 0.4.0
 Summary: Extraction from angle resolved photoemission spectra
 Author: xARPES Developers
 Requires-Python: >=3.7.0
@@ -88,10 +88,10 @@ Example for Linux:
 
 Answer `y` to questions. Create and activate a new environment:
 
-    conda create -n <my_env> -c defaults -c conda-forge  
+    conda create -n <my_env> -c conda-forge  
     conda activate <my_env>
 
-Where `<my_env>` must be replaced by your desired name.
+Where `<my_env>` must be replaced by your desired name. Package compatibility ssues may arise if conda installs from different channels. This can be prevented by appending `--strict-channel-priority` to the creation command.
 
 ### Installing xARPES
 

xarpes-0.4.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+xarpes/__init__.py,sha256=c_dJwE9MtE67k6ms-2ljYZxPwTHEHDUDtOiI_g6s9QE,125
+xarpes/constants.py,sha256=vQxxFeCdGIxMpdh5XGbeRbn7-HF1d5snWkR09d8spGc,587
+xarpes/distributions.py,sha256=svzhvf994_5gndJA1M04SW4MVfHEVwiAumbhO5Jj22s,23434
+xarpes/functions.py,sha256=4s2atkWyPUb1ipJApRDVMsow_47kt25wvSwLtfqD2fs,14261
+xarpes/plotting.py,sha256=3nwq-6q3i3hUG_tMv6y-62v2FceB2LuayDeE_fSdUr0,6499
+xarpes/spectral.py,sha256=2AmqiyAk3xYJpUj1zPwbdA1Q62mGAVvXJAWmyiGHb6s,93908
+xarpes-0.4.0.dist-info/entry_points.txt,sha256=917UR-cqFTMMI_vMqIbk7boYSuFX_zHwQlXKcj9vlCE,79
+xarpes-0.4.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+xarpes-0.4.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+xarpes-0.4.0.dist-info/METADATA,sha256=cBUTzdc-CF8QCIag1q7kgSISydC2o1Mo4ZlAHMe87n0,6526
+xarpes-0.4.0.dist-info/RECORD,,

xarpes-0.3.4.dist-info/RECORD

@@ -1,11 +0,0 @@
-xarpes/__init__.py,sha256=WAZKbz4gEW1H7Yb24GVBAryDrMsQiAn0UNmeJwEM_no,124
-xarpes/constants.py,sha256=vQxxFeCdGIxMpdh5XGbeRbn7-HF1d5snWkR09d8spGc,587
-xarpes/distributions.py,sha256=svzhvf994_5gndJA1M04SW4MVfHEVwiAumbhO5Jj22s,23434
-xarpes/functions.py,sha256=4s2atkWyPUb1ipJApRDVMsow_47kt25wvSwLtfqD2fs,14261
-xarpes/plotting.py,sha256=W-5WaKjBtg8PIxTypqja2R29mgWkQ844lgRWci0nhn0,5679
-xarpes/spectral.py,sha256=GT_1GUMy9Md4X8W7UM0l8ir_WRaPAaUbgvS5Ep0uSY8,82863
-xarpes-0.3.4.dist-info/entry_points.txt,sha256=917UR-cqFTMMI_vMqIbk7boYSuFX_zHwQlXKcj9vlCE,79
-xarpes-0.3.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-xarpes-0.3.4.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-xarpes-0.3.4.dist-info/METADATA,sha256=FLClCjMjfV2D_MYH3o9o3PlFG2KsDJLZLyNUzwD2FG4,6369
-xarpes-0.3.4.dist-info/RECORD,,