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

xarpes/__init__.py

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

xarpes/functions.py

@@ -254,65 +254,119 @@ def download_examples():
     import shutil
     import io
     import jupytext
+    import tempfile
+    import re
 
-    # Main xARPES repo (examples now live in /examples here)
-    repo_url = 'https://github.com/xARPES/xARPES'
-    output_dir = '.'  # Directory from which the function is called
+    # Main xARPES repo (examples live under /examples there)
+    repo_url = "https://github.com/xARPES/xARPES"
+    output_dir = "."  # Directory from which the function is called
 
     # Target 'examples' directory in the user's current location
-    final_examples_path = os.path.join(output_dir, 'examples')
+    final_examples_path = os.path.join(output_dir, "examples")
     if os.path.exists(final_examples_path):
         print("Warning: 'examples' folder already exists. "
               "No download will be performed.")
         return 1  # Exit the function if 'examples' directory exists
 
-    # Proceed with download if 'examples' directory does not exist
-    repo_parts = repo_url.replace('https://github.com/', '').rstrip('/')
-    zip_url = f'https://github.com/{repo_parts}/archive/refs/heads/main.zip'
-
-    # Make the HTTP request to download the zip file
-    print(f'Downloading {zip_url}')
-    response = requests.get(zip_url)
-    if response.status_code == 200:
-        zip_file_bytes = io.BytesIO(response.content)
-
-        with zipfile.ZipFile(zip_file_bytes, 'r') as zip_ref:
-            zip_ref.extractall(output_dir)
-
-        # Path to the extracted main folder (e.g. xARPES-main)
-        main_folder_path = os.path.join(
-            output_dir,
-            repo_parts.split('/')[-1] + '-main'
-        )
-        examples_path = os.path.join(main_folder_path, 'examples')
-
-        # Move the 'examples' directory to the target location
-        if os.path.exists(examples_path):
-            shutil.move(examples_path, final_examples_path)
-            print(f"'examples' subdirectory moved to {final_examples_path}")
-
-            # Convert all .Rmd files in the examples directory to .ipynb
-            # and delete the .Rmd files
-            for dirpath, dirnames, filenames in os.walk(final_examples_path):
-                for filename in filenames:
-                    if filename.endswith('.Rmd'):
-                        full_path = os.path.join(dirpath, filename)
-                        jupytext.write(
-                            jupytext.read(full_path),
-                            full_path.replace('.Rmd', '.ipynb')
-                        )
-                        os.remove(full_path)  # Deletes .Rmd file afterwards
-                        print(f'Converted and deleted {full_path}')
-
-        # Remove the rest of the extracted content
-        shutil.rmtree(main_folder_path)
-        print(f'Cleaned up temporary files in {main_folder_path}')
-        return 0
+    # --- Determine version from xarpes.__init__.__version__ -----------------
+    try:
+        # Import inside the function, avoiding circular imports at import time
+        import xarpes as _xarpes
+        raw_version = getattr(_xarpes, "__version__", None)
+    except Exception as exc:
+        print(f"Warning: could not import xarpes to determine version: {exc}")
+        raw_version = None
+
+    tag_version = None
+    if raw_version is not None:
+        raw_version = str(raw_version)
+        # Strip dev/local suffixes so that '0.3.3.dev1' or '0.3.3+0.gHASH'
+        # maps to the tag 'v0.3.3'. If you use plain '0.3.3' already, this is 
+        # a no-op.
+        m = re.match(r"(\d+\.\d+\.\d+)", raw_version)
+        if m:
+            tag_version = m.group(1)
+        else:
+            tag_version = raw_version
+
+        print(f"Determined xARPES version from __init__: {raw_version} "
+              f"(using tag version '{tag_version}').")
     else:
-        print('Failed to download the repository. Status code: '
-              f'{response.status_code}')
+        print("Warning: xarpes.__version__ is not defined; will skip "
+        "tag-based download and try the main branch only.")
+
+    # --- Build refs and use for–else to try them in order -------------------
+    repo_parts = repo_url.replace("https://github.com/", "").rstrip("/")
+
+    refs_to_try = []
+    if tag_version is not None:
+        refs_to_try.append(f"tags/v{tag_version}")  # version-matched examples
+    refs_to_try.append("heads/main")                # fallback: latest examples
+
+    response = None
+    for ref in refs_to_try:
+        zip_url = f"https://github.com/{repo_parts}/archive/refs/{ref}.zip"
+        print(f"Attempting to download examples from '{ref}':\n  {zip_url}")
+        response = requests.get(zip_url)
+
+        if response.status_code == 200:
+            if ref.startswith("tags/"):
+                print(f"Successfully downloaded examples from tagged release "
+                      f"'v{tag_version}'.")
+            else:
+                print("Tagged release not available; using latest examples "
+                "from the 'main' branch instead.")
+            break
+        else:
+            print("Failed to download from this ref. HTTP status code: "
+                  f"{response.status_code}")
+    else:
+        # for–else: only executed if we never hit 'break'
+        print("Error: could not download examples from any ref "
+              f"(tried: {', '.join(refs_to_try)}).")
         return 1
 
+    # At this point, 'response' holds a successful download
+    zip_file_bytes = io.BytesIO(response.content)
+
+    # --- Extract into a temporary directory to avoid polluting CWD ----------
+    with tempfile.TemporaryDirectory() as tmpdir:
+        with zipfile.ZipFile(zip_file_bytes, "r") as zip_ref:
+            zip_ref.extractall(tmpdir)
+            # First member gives us the top-level directory in the archive,
+            # typically something like 'xARPES-0.3.3/' or 'xARPES-main/'.
+            first_member = zip_ref.namelist()[0]
+
+        top_level_dir = first_member.split("/")[0]
+        main_folder_path = os.path.join(tmpdir, top_level_dir)
+        examples_path = os.path.join(main_folder_path, "examples")
+
+        if not os.path.exists(examples_path):
+            print("Error: downloaded archive does not contain an 'examples' "
+            "directory.")
+            return 1
+
+        # Move the 'examples' directory to the target location in the CWD
+        shutil.move(examples_path, final_examples_path)
+        print(f"'examples' subdirectory moved to {final_examples_path}")
+
+        # Convert all .Rmd files in the examples directory to .ipynb
+        # and delete the .Rmd files
+        for dirpath, dirnames, filenames in os.walk(final_examples_path):
+            for filename in filenames:
+                if filename.endswith(".Rmd"):
+                    full_path = os.path.join(dirpath, filename)
+                    jupytext.write(
+                        jupytext.read(full_path),
+                        full_path.replace(".Rmd", ".ipynb")
+                    )
+                    os.remove(full_path)  # Deletes .Rmd file afterwards
+                    print(f"Converted and deleted {full_path}")
+
+    # Temporary directory is cleaned up automatically
+    print("Cleaned up temporary files.")
+    return 0
+
 
 def set_script_dir():
     r"""This function sets the directory such that the xARPES code can be

xarpes/spectral.py

@@ -16,7 +16,7 @@ from igor2 import binarywave
 from .plotting import get_ax_fig_plt, add_fig_kwargs
 from .functions import fit_leastsq, extend_function
 from .distributions import FermiDirac, Linear
-from .constants import uncr, pref, dtor, kilo
+from .constants import uncr, pref, dtor, kilo, stdv
 
 class BandMap:
     r"""
@@ -349,24 +349,17 @@ class BandMap:
 
     @add_fig_kwargs
     def plot(self, abscissa='momentum', ordinate='electron_energy',
-            self_energies=None, ax=None, **kwargs):
+             self_energies=None, ax=None, markersize=None, **kwargs):
         r"""
         Plot the band map. Optionally attach 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.
-        """
 
-        # Optionally store self-energies on the instance
-        if self_energies is not None:
-            # You can wrap here if you like, e.g.:
-            # from .containers import CreateSelfEnergies
-            # 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
+        When self-energies are present and ``abscissa='momentum'``, their
+        MDC maxima are overlaid with 95 % confidence intervals.
+        """
+        import warnings
 
-        # Validate options early
         valid_abscissa = ('angle', 'momentum')
         valid_ordinate = ('kinetic_energy', 'electron_energy')
 
@@ -381,52 +374,109 @@ 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
+
         ax, fig, plt = get_ax_fig_plt(ax=ax)
+        # Below, **kwargs is 
 
         Angl, Ekin = np.meshgrid(self.angles, self.ekin)
-        mesh = None  # sentinel to detect missing branch
-
+        
         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(), 
+                        **kwargs)
                 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(), 
+                        **kwargs)
                 ax.set_ylabel('$E-\\mu$ (eV)')
 
         elif abscissa == 'momentum':
-            Mome = np.sqrt(Ekin / pref) * np.sin(Angl * dtor)
             ax.set_xlabel(r'$k_{//}$ ($\mathrm{\AA}^{-1}$)')
-            if ordinate == 'kinetic_energy':
-                mesh = ax.pcolormesh(
-                    Mome, Ekin, self.intensities, shading='auto',
-                    cmap=plt.get_cmap('bone').reversed(), **kwargs
-                )
-                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
-                )
-                ax.set_ylabel('$E-\\mu$ (eV)')
 
-        # If no branch set 'mesh', fail with a clear message
-        if mesh is None:
-            raise RuntimeError(
-                "No plot produced for the combination: "
-                f"abscissa='{abscissa}', ordinate='{ordinate}'. "
-                f"Valid abscissa: {valid_abscissa}; "
-                f"valid ordinate: {valid_ordinate}."
-            )
+            with warnings.catch_warnings(record=True) as wlist:
+                warnings.filterwarnings("always",
+                    message=("The input coordinates to pcolormesh are "
+                        "interpreted as cell centers, but are not "
+                        "monotonically increasing or decreasing."),
+                    category=UserWarning)
+
+                Mome = np.sqrt(Ekin / pref) * np.sin(Angl * dtor)
+
+                if ordinate == 'kinetic_energy':
+                    mesh = ax.pcolormesh(Mome, Ekin, self.intensities,
+                        shading='auto', cmap=plt.get_cmap('bone').reversed(), 
+                        **kwargs)
+                    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)
+                    ax.set_ylabel('$E-\\mu$ (eV)')
+
+            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)
+
+        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 mdc_maxima is None:
+                    continue
+
+                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
+                    y_vals = self_energy.enel_range
+
+                x_vals = mdc_maxima
+                label = getattr(self_energy, "label", None)
+
+                if xerr is not None:
+                    ax.errorbar(x_vals, y_vals, xerr=xerr, fmt='o',
+                                linestyle='', label=label,
+                                markersize=markersize)
+                else:
+                    ax.plot(x_vals, y_vals, linestyle='', marker='o',
+                            label=label, markersize=markersize)
+
+            handles, labels = ax.get_legend_handles_labels()
+            if any(labels):
+                ax.legend()
+
+            handles, labels = ax.get_legend_handles_labels()
+            if any(labels):
+                ax.legend()
 
         plt.colorbar(mesh, ax=ax, label='counts (-)')
         return fig
@@ -1233,14 +1283,25 @@ class MDCs:
                 label = getattr(dist, 'label', str(dist))
                 individual_labels.append(label)
 
-                # ---- collect parameters for this distribution 
+                # ---- collect parameters for this distribution
                 # (Aggregated over slices)
                 cls = getattr(dist, 'class_name', None)
                 wanted = param_spec.get(cls, ())
 
                 # ensure dicts exist
                 label_bucket = aggregated_properties.setdefault(label, {})
-                class_bucket = label_bucket.setdefault(cls, {'label': label, '_class': cls})
+                class_bucket = label_bucket.setdefault(
+                    cls, {'label': label, '_class': cls}
+                )
+
+                # store center_wavevector (scalar) for SpectralQuadratic
+                if (
+                    cls == 'SpectralQuadratic'
+                    and hasattr(dist, 'center_wavevector')
+                ):
+                    class_bucket.setdefault(
+                        'center_wavevector', dist.center_wavevector
+                    )
 
                 # ensure keys for both values and sigmas
                 for pname in wanted:
@@ -1560,8 +1621,8 @@ class MDCs:
         return final_result
     
 
-    def expose_parameters(self, select_label, fermi_wavevector=None, 
-                        fermi_velocity=None, bare_mass=None, side=None):
+    def expose_parameters(self, select_label, fermi_wavevector=None,
+                          fermi_velocity=None, bare_mass=None, side=None):
         r"""
         Select and return fitted parameters for a given component label, plus a
         flat export dictionary containing values **and** 1σ uncertainties.
@@ -1575,7 +1636,8 @@ class MDCs:
         fermi_velocity : float, optional
             Optional Fermi velocity to include.
         bare_mass : float, optional
-            Optional bare mass to include (used for SpectralQuadratic dispersions).
+            Optional bare mass to include (used for SpectralQuadratic
+            dispersions).
         side : {'left','right'}, optional
             Optional side selector for SpectralQuadratic dispersions.
 
@@ -1588,30 +1650,41 @@ class MDCs:
         label : str
             Label of the selected distribution.
         selected_properties : dict or list of dict
-            Nested dictionary (or list thereof) containing <param> and 
-            <param>_sigma arrays.
+            Nested dictionary (or list thereof) containing <param> and
+            <param>_sigma arrays. For SpectralQuadratic components, a
+            scalar `center_wavevector` is also present.
         exported_parameters : dict
-            Flat dictionary of parameters and their uncertainties, plus optional
-            Fermi quantities and `side`.
+            Flat dictionary of parameters and their uncertainties, plus
+            optional Fermi quantities and `side`. For SpectralQuadratic
+            components, `center_wavevector` is included and taken directly
+            from the fitted distribution.
         """
 
         if self._ekin_range is None:
-            raise AttributeError("ekin_range not yet set. Run `.fit_selection()` first.")
+            raise AttributeError(
+                "ekin_range not yet set. Run `.fit_selection()` first."
+            )
 
         store = getattr(self, "_individual_properties", None)
         if not store or select_label not in store:
-            all_labels = (sorted(store.keys()) if isinstance(store, dict) else [])
+            all_labels = (sorted(store.keys())
+                          if isinstance(store, dict) else [])
             raise ValueError(
-                f"Label '{select_label}' not found in available labels: {all_labels}"
+                f"Label '{select_label}' not found in available labels: "
+                f"{all_labels}"
             )
 
-        # Convert lists → numpy arrays within the selected label’s classes
+        # Convert lists → numpy arrays within the selected label’s classes.
+        # Keep scalar center_wavevector as a scalar.
         per_class_dicts = []
         for cls, bucket in store[select_label].items():
             dct = {}
             for k, v in bucket.items():
                 if k in ("label", "_class"):
                     dct[k] = v
+                elif k == "center_wavevector":
+                    # keep scalar as-is, do not wrap in np.asarray
+                    dct[k] = v
                 else:
                     dct[k] = np.asarray(v)
             per_class_dicts.append(dct)
@@ -1628,20 +1701,23 @@ class MDCs:
             "side": side,
         }
 
-        # Collect parameters without prefixing by class
+        # Collect parameters without prefixing by class. This will also include
+        # center_wavevector from the fitted SpectralQuadratic class, and since
+        # there is no function argument with that name, it cannot be overridden.
         if isinstance(selected_properties, dict):
             for key, val in selected_properties.items():
                 if key not in ("label", "_class"):
                     exported_parameters[key] = val
         else:
-            # If multiple classes, merge sequentially (last overwrites same-name keys)
+            # If multiple classes, merge sequentially
+            # (last overwrites same-name keys).
             for cls_bucket in selected_properties:
                 for key, val in cls_bucket.items():
                     if key not in ("label", "_class"):
                         exported_parameters[key] = val
 
-        return self._ekin_range, self.hnuminphi, select_label, \
-            selected_properties, exported_parameters
+        return (self._ekin_range, self.hnuminphi, select_label,
+                selected_properties, exported_parameters)
 
 
 class SelfEnergy:
@@ -1697,6 +1773,7 @@ class SelfEnergy:
         self._peak_sigma       = self._properties.get("peak_sigma")
         self._broadening       = self._properties.get("broadening")
         self._broadening_sigma = self._properties.get("broadening_sigma")
+        self._center_wavevector = self._properties.get("center_wavevector")
 
         # lazy caches
         self._peak_positions = None
@@ -1763,6 +1840,7 @@ class SelfEnergy:
         self._peak_positions = None
         self._real = None
         self._real_sigma = None
+        self._mdc_maxima = None
 
     @property
     def fermi_wavevector(self):
@@ -1838,6 +1916,7 @@ class SelfEnergy:
         # invalidate dependent cache
         self._peak_positions = None
         self._real = None
+        self._mdc_maxima = None
 
     @property
     def peak_sigma(self):
@@ -1870,6 +1949,11 @@ class SelfEnergy:
         self._properties["broadening_sigma"] = x
         self._imag_sigma = None
 
+    @property
+    def center_wavevector(self):
+        """Read-only center wavevector (SpectralQuadratic, if present)."""
+        return self._center_wavevector
+    
     # ---------------- derived outputs ----------------
     @property
     def peak_positions(self):
@@ -1888,7 +1972,7 @@ class SelfEnergy:
                     np.sin(np.abs(self._peak) * dtor)
                 self._peak_positions = (-1.0 if self._side == "left" \
                                         else 1.0) * kpar_mag
-            else:  # SpectralLinear
+            else:
                 self._peak_positions = np.sqrt(self._ekin_range / pref) \
                 * np.sin(self._peak * dtor)
         return self._peak_positions
@@ -1900,7 +1984,7 @@ class SelfEnergy:
             if self._peak_sigma is None or self._ekin_range is None:
                 return None
             self._peak_positions_sigma = (np.sqrt(self._ekin_range / pref)
-                                          * np.cos(self._peak * dtor) 
+                                          * np.abs(np.cos(self._peak * dtor))
                                           * self._peak_sigma * dtor)
         return self._peak_positions_sigma
 
@@ -1914,9 +1998,9 @@ class SelfEnergy:
                 if self._fermi_velocity is None:
                     raise AttributeError("Cannot compute `imag` "
                     "(SpectralLinear): set `fermi_velocity` first.")
-                self._imag = self._fermi_velocity * np.sqrt(self._ekin_range \
+                self._imag = np.abs(self._fermi_velocity) * np.sqrt(self._ekin_range \
                      / pref) * self._broadening
-            else:  # SpectralQuadratic
+            else:
                 if self._bare_mass is None:
                     raise AttributeError("Cannot compute `imag` "
                     "(SpectralQuadratic): set `bare_mass` first.")
@@ -1934,9 +2018,9 @@ class SelfEnergy:
                 if self._fermi_velocity is None:
                     raise AttributeError("Cannot compute `imag_sigma` "
                     "(SpectralLinear): set `fermi_velocity` first.")
-                self._imag_sigma = self._fermi_velocity * \
+                self._imag_sigma = np.abs(self._fermi_velocity) * \
                     np.sqrt(self._ekin_range / pref) * self._broadening_sigma
-            else:  # SpectralQuadratic
+            else:
                 if self._bare_mass is None:
                     raise AttributeError("Cannot compute `imag_sigma` "
                     "(SpectralQuadratic): set `bare_mass` first.")
@@ -1957,13 +2041,13 @@ class SelfEnergy:
                     "`fermi_wavevector` first.")
                 self._real = self.enel_range - self._fermi_velocity * \
                     (self.peak_positions - self._fermi_wavevector)
-            else:  # SpectralQuadratic
+            else:
                 if self._bare_mass is None or self._fermi_wavevector is None:
                     raise AttributeError("Cannot compute `real` "
                     "(SpectralQuadratic): set `bare_mass` and " \
                     "`fermi_wavevector` first.")
                 self._real = self.enel_range - (pref / \
-                    np.abs(self._bare_mass)) * (self.peak_positions**2 \
+                    self._bare_mass) * (self.peak_positions**2 \
                     - self._fermi_wavevector**2)
         return self._real
 
@@ -1977,8 +2061,8 @@ class SelfEnergy:
                 if self._fermi_velocity is None:
                     raise AttributeError("Cannot compute `real_sigma` "
                     "(SpectralLinear): set `fermi_velocity` first.")
-                self._real_sigma = self._fermi_velocity * self.peak_positions_sigma
-            else:  # SpectralQuadratic
+                self._real_sigma = np.abs(self._fermi_velocity) * self.peak_positions_sigma
+            else: 
                 if self._bare_mass is None or self._fermi_wavevector is None:
                     raise AttributeError("Cannot compute `real_sigma` "
                     "(SpectralQuadratic): set `bare_mass` and " \
@@ -1987,6 +2071,30 @@ class SelfEnergy:
                     * np.abs(self.peak_positions / self._bare_mass)
         return self._real_sigma
 
+    @property
+    def mdc_maxima(self):
+        """
+        MDC maxima (lazy).
+
+        SpectralLinear:
+            identical to peak_positions
+
+        SpectralQuadratic:
+            peak_positions + center_wavevector
+        """
+        if getattr(self, "_mdc_maxima", None) is None:
+            if self.peak_positions is None:
+                return None
+
+            if self._class == "SpectralLinear":
+                self._mdc_maxima = self.peak_positions
+            elif self._class == "SpectralQuadratic":
+                self._mdc_maxima = (
+                    self.peak_positions + self._center_wavevector
+                )
+
+        return self._mdc_maxima
+
 
 class CreateSelfEnergies:
     r"""

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xarpes
-Version: 0.3.2
+Version: 0.3.4
 Summary: Extraction from angle resolved photoemission spectra
 Author: xARPES Developers
 Requires-Python: >=3.7.0
@@ -16,7 +16,8 @@ Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: lmfit
 Requires-Dist: pyqt5
-Requires-Dist: ipympl
+Requires-Dist: ipympl>=0.9.3
+Requires-Dist: ipywidgets>=8.1.5
 Requires-Dist: ipykernel<6.32.0
 Project-URL: Documentation, https://xarpes.github.io
 
@@ -32,7 +33,7 @@ This project is currently undergoing **beta testing**. Some of the functionaliti
 
 # Contributing
 
-Contributions to the code are most welcome. xARPES is intended to co-develop alongside the increasing complexity of experimental ARPES data sets. Contributions can be made by forking the code and creating a pull request. Importing of file formats from different beamlines is particularly encouraged.
+Contributions to the code are most welcome. xARPES is intended to co-develop alongside the increasing complexity of experimental ARPES data sets. Contributions can be made by forking the code and creating a pull request. Importing of file formats from different beamlines is particularly encouraged. Files useful for developers can be found in `/dev_tools`, such as the `Rmd2py.py` script for the development of examples.
 
 # Installation
 
@@ -41,6 +42,8 @@ xARPES installation can be divided into graphical package manager instructions,
 - via conda-forge, out-of-the-box or editable installation, sourcing the [conda-forge package](https://anaconda.org/conda-forge/xarpes).  
 - via Pip, out-of-the-box or editable installation, sourcing the [PyPI package](https://pypi.org/project/xarpes).
 
+We strongly recommend installing xARPES in a (conda/pip) virtual environment, and to activate the environment each time before activating xARPES.
+
 ## Graphical package manager installation
 
 Most IDEs and scientific Python distributions include a GUI-based package manager.  
@@ -83,11 +86,13 @@ Example for Linux:
     wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  
     bash Miniconda3-latest-Linux-x86_64.sh
 
-Create and activate an environment:
+Answer `y` to questions. Create and activate a new environment:
 
     conda create -n <my_env> -c defaults -c conda-forge  
     conda activate <my_env>
 
+Where `<my_env>` must be replaced by your desired name.
+
 ### Installing xARPES
 
 #### Option A — Out-of-the-box installation (from conda-forge)
@@ -117,8 +122,8 @@ Install venv if necessary:
 
 Create and activate a virtual environment:
 
-    python3 -m venv <my_venv>  
-    source <my_venv>/bin/activate
+    python3 -m venv <my_env>  
+    source <my_env>/bin/activate
 
 Upgrade pip:
 
@@ -147,6 +152,8 @@ After installation of xARPES, the `examples/` folder can be downloaded to the cu
 
     python -c "import xarpes; xarpes.download_examples()"
 
+This attempts to download the examples from the version corresponding encountered in `__init__.py`. If no corresponding tagged version can be downloaded, the code attempts to download the latest examples instead.
+
 # Execution
 
 It is recommended to use JupyterLab to analyse data. JupyterLab is launched using:

xarpes-0.3.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+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,,

xarpes-0.3.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-xarpes/__init__.py,sha256=Wk8mY-vjImFwBLPPzg2ot_LCJ5sA0yrffNQy3Ik-hq8,125
-xarpes/constants.py,sha256=vQxxFeCdGIxMpdh5XGbeRbn7-HF1d5snWkR09d8spGc,587
-xarpes/distributions.py,sha256=svzhvf994_5gndJA1M04SW4MVfHEVwiAumbhO5Jj22s,23434
-xarpes/functions.py,sha256=gE76z-Y9UI1KNUUtADyLziLU1UJ43E1CHLDi_khj0bc,12007
-xarpes/plotting.py,sha256=W-5WaKjBtg8PIxTypqja2R29mgWkQ844lgRWci0nhn0,5679
-xarpes/spectral.py,sha256=qw0qSeYfaCc9C28cGe32QrI3mK64KNcoNTDkS5EplmM,78637
-xarpes-0.3.2.dist-info/entry_points.txt,sha256=917UR-cqFTMMI_vMqIbk7boYSuFX_zHwQlXKcj9vlCE,79
-xarpes-0.3.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-xarpes-0.3.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-xarpes-0.3.2.dist-info/METADATA,sha256=jDXUPvkEx1obDPPHmlSbR32gZ3oTJnd5V6MlPu6HgSk,5763
-xarpes-0.3.2.dist-info/RECORD,,