xarpes 0.6.4__py3-none-any.whl → 0.6.5__py3-none-any.whl

xarpes/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.4"
+__version__ = "0.6.5"
 
 from importlib import import_module
 

xarpes/functions.py

@@ -236,7 +236,6 @@ def fit_least_squares(p0, xdata, ydata, function, resolution=None, yerr=None,
     return pfit, pcov, success
 
 
-
 def download_examples():
     """Downloads the examples folder from the main xARPES repository only if it
     does not already exist in the current directory. Prints executed steps and a
@@ -625,4 +624,168 @@ def chi2kink_logistic(x, a, b, c, d):
         expz = np.exp(z[mneg])
         phi[mneg] = a + b * expz / (1.0 + expz)
 
-    return phi
+    return phi
+
+def _in_ipython():
+    try:
+        from IPython import get_ipython
+    except Exception:
+        return False
+    return get_ipython() is not None
+
+
+class _LineBuffer:
+    """Capture text as lines, keeping only head + tail and total count."""
+    def __init__(self, head=10, tail=10):
+        from collections import deque
+        self.head = int(head)
+        self.tail = int(tail)
+        self._head_lines = []
+        self._tail_lines = deque(maxlen=self.tail)
+        self._partial = ""
+        self._n_lines = 0
+
+    def feed(self, text):
+        if not text:
+            return
+
+        # Normalize carriage returns (progress bars etc.)
+        text = str(text).replace("\r", "\n")
+
+        # Prepend any partial line from previous write.
+        text = self._partial + text
+        parts = text.split("\n")
+
+        # If text does not end with '\n', last part is partial.
+        self._partial = parts.pop()  # may be "" if ended with newline
+
+        for line in parts:
+            # Record completed line
+            self._n_lines += 1
+            if len(self._head_lines) < self.head:
+                self._head_lines.append(line)
+            else:
+                if self.tail > 0:
+                    self._tail_lines.append(line)
+
+    def finalize(self):
+        # If there is an unfinished line, treat it as a line.
+        if self._partial.strip() != "":
+            self.feed("\n")  # forces it into completed lines
+        self._partial = ""
+
+    def summary(self):
+        self.finalize()
+
+        n = self._n_lines
+        if n == 0:
+            return ""
+
+        # If total small, reconstruct from head + tail if possible
+        if n <= self.head + self.tail:
+            # We didn't keep all middle lines, but if n <= head+tail we kept all.
+            # For n <= head, tail may be empty; for n > head, tail contains rest.
+            out = list(self._head_lines)
+            if n > len(self._head_lines):
+                out.extend(list(self._tail_lines))
+            return "\n".join(out)
+
+        omitted = n - self.head - self.tail
+        head_txt = "\n".join(self._head_lines)
+        tail_txt = "\n".join(list(self._tail_lines))
+        return (
+            f"{head_txt}\n"
+            f"... ({omitted} lines omitted) ...\n"
+            f"{tail_txt}"
+        )
+
+
+def trim_notebook_output(print_lines=10, *, enabled=True, clear=True,
+                         capture_stderr=True, sleep_s=0.05):
+    """Context manager: show live prints, then keep only head/tail in notebooks.
+
+    In plain scripts (no IPython), this is a no-op.
+    """
+    from contextlib import contextmanager
+
+    @contextmanager
+    def _ctx():
+        if (not enabled) or (print_lines is None):
+            yield
+            return
+
+        n = int(print_lines)
+        if n <= 0:
+            yield
+            return
+
+        # Only do this in IPython environments; scripts should print normally.
+        if not _in_ipython():
+            yield
+            return
+
+        import sys
+        import time
+
+        buf = _LineBuffer(head=n, tail=n)
+
+        stdout_orig = sys.stdout
+        stderr_orig = sys.stderr
+
+        class _TeeStream:
+            def __init__(self, real_stream, buffer):
+                self._real = real_stream
+                self._buf = buffer
+
+            def write(self, text):
+                # Live output
+                try:
+                    self._real.write(text)
+                    self._real.flush()
+                except Exception:
+                    pass
+                # Capture
+                self._buf.feed(text)
+
+            def flush(self):
+                try:
+                    self._real.flush()
+                except Exception:
+                    pass
+
+            # Some libraries ask for these:
+            def isatty(self):
+                return False
+
+            @property
+            def encoding(self):
+                return getattr(self._real, "encoding", "utf-8")
+
+        sys.stdout = _TeeStream(stdout_orig, buf)
+        if capture_stderr:
+            sys.stderr = _TeeStream(stderr_orig, buf)
+
+        try:
+            yield
+        finally:
+            # Restore streams first.
+            sys.stdout = stdout_orig
+            sys.stderr = stderr_orig
+
+            # Let Jupyter finish rendering any queued output.
+            if sleep_s:
+                time.sleep(float(sleep_s))
+
+            # Clear cell output and print summary.
+            summary = buf.summary()
+            if clear:
+                try:
+                    from IPython.display import clear_output
+                    clear_output(wait=True)
+                except Exception:
+                    pass
+
+            if summary:
+                print(summary)
+
+    return _ctx()

xarpes/selfenergies.py

@@ -1175,52 +1175,47 @@ class SelfEnergy:
         return fig, spectrum, model, omega_range, alpha_select
     
 
-    def bayesian_loop(self, *, omega_min, omega_max, omega_num, omega_I, omega_M,
-                    fermi_velocity=None, fermi_wavevector=None, bare_mass=None,
-                    vary=(), opt_method="Nelder-Mead", opt_options=None,
-                    mem=None, loop=None, print_lines=None, **mem_kwargs):
+    def bayesian_loop(self, *, omega_min, omega_max, omega_num, omega_I, 
+                    omega_M, fermi_velocity=None, 
+                    fermi_wavevector=None, bare_mass=None, vary=(),
+                    opt_method="Nelder-Mead", opt_options=None,
+                    mem=None, loop=None, **mem_kwargs):
         r"""
         Bayesian outer loop calling `_cost_function()`.
 
+        If `vary` is non-empty, runs a SciPy optimization over the selected
+        parameters in `vary`.
+
+        Supported entries in `vary` depend on `self._class`:
+
+        - Common: "fermi_wavevector", "impurity_magnitude", "lambda_el", "h_n"
+        - SpectralLinear: additionally "fermi_velocity"
+        - SpectralQuadratic: additionally "bare_mass"
+
+        Notes
+        -----
+        **Convergence behaviour**
+
+        By default, convergence is controlled by a *custom patience criterion*:
+        the optimization terminates when the absolute difference between the
+        current cost and the best cost seen so far is smaller than `tole` for
+        `converge_iters` consecutive iterations.
+
+        To instead rely on SciPy's native convergence criteria (e.g. Nelder–Mead
+        `xatol` / `fatol`), disable the custom criterion by setting
+        `converge_iters=0` or `tole=None`. In that case, SciPy termination options
+        supplied via `opt_options` are used.
+
         Parameters
         ----------
-        print_lines : int or None, optional
-            If an integer, prints the first/last `print_lines` iteration lines.
-            If None, prints all lines as usual.
+        opt_options : dict, optional
+            Options passed directly to `scipy.optimize.minimize`. These are only
+            used for convergence if the custom criterion is disabled (see Notes).
         """
-        return self._bayesian_loop_core(
-            omega_min=omega_min,
-            omega_max=omega_max,
-            omega_num=omega_num,
-            omega_I=omega_I,
-            omega_M=omega_M,
-            fermi_velocity=fermi_velocity,
-            fermi_wavevector=fermi_wavevector,
-            bare_mass=bare_mass,
-            vary=vary,
-            opt_method=opt_method,
-            opt_options=opt_options,
-            mem=mem,
-            loop=loop,
-            print_lines=print_lines,
-            **mem_kwargs,
-        )
-    
 
-    def _bayesian_loop_core(self, *, omega_min, omega_max, omega_num, omega_I,
-                            omega_M, fermi_velocity=None, fermi_wavevector=None,
-                            bare_mass=None, vary=(), opt_method="Nelder-Mead",
-                            opt_options=None, mem=None, loop=None,
-                            print_lines=None, **mem_kwargs):
-        r"""
-        Core implementation of `bayesian_loop` (prints controlled by print_lines).
-
-        See `bayesian_loop` for API documentation.
-        """
         fermi_velocity, fermi_wavevector, bare_mass = self._prepare_bare(
-            fermi_velocity, fermi_wavevector, bare_mass
-        )
-
+            fermi_velocity, fermi_wavevector, bare_mass)
+        
         vary = tuple(vary) if vary is not None else ()
 
         allowed = {"fermi_wavevector", "impurity_magnitude", "lambda_el", "h_n"}
@@ -1231,17 +1226,16 @@ class SelfEnergy:
             allowed.add("bare_mass")
         else:
             raise NotImplementedError(
-                "bayesian_loop does not support spectral class "
-                f"'{self._class}'."
+                f"bayesian_loop does not support spectral class '{self._class}'."
             )
-
+        
         unknown = set(vary).difference(allowed)
         if unknown:
             raise ValueError(
                 f"Unsupported entries in vary: {sorted(unknown)}. "
                 f"Allowed: {sorted(allowed)}."
             )
-
+                        
         omega_num = int(omega_num)
         if omega_num < 2:
             raise ValueError("omega_num must be an integer >= 2.")
@@ -1307,15 +1301,21 @@ class SelfEnergy:
                 f"Initial h_n ({h_n0:g}) must be >= h_n_min ({h_n_min:g})."
             )
         if kF0 is None:
-            raise ValueError("bayesian_loop requires an initial fermi_wavevector.")
+            raise ValueError(
+                "bayesian_loop requires an initial fermi_wavevector."
+                )
         if self._class == "SpectralLinear" and vF0 is None:
-            raise ValueError("bayesian_loop requires an initial fermi_velocity.")
+            raise ValueError(
+                "bayesian_loop requires an initial fermi_velocity."
+                )
         if self._class == "SpectralQuadratic" and mb0 is None:
             raise ValueError("bayesian_loop requires an initial bare_mass.")
-
+        
         from scipy.optimize import minimize
-        from collections import deque
         from . import create_kernel_function, singular_value_decomposition
+          
+        ecut_left = float(mem_cfg["ecut_left"])
+        ecut_right = mem_cfg["ecut_right"]
 
         ecut_left_eV = ecut_left / KILO
         if ecut_right is None:
@@ -1346,14 +1346,10 @@ class SelfEnergy:
             kernel_used = np.concatenate((np.real(kernel_raw), -np.imag(kernel_raw)))
         elif parts == "real":
             kernel_used = np.real(kernel_raw)
-        else:
+        else:  # parts == "imag"
             kernel_used = -np.imag(kernel_raw)
 
-        # Try to silence SVD diagnostics during trimmed-output runs, if supported.
-        svd_verbose = (print_lines is None)
-        V_Sigma, U, uvec0 = singular_value_decomposition(
-            kernel_used, sigma_svd
-            )
+        V_Sigma, U, uvec0 = singular_value_decomposition(kernel_used, sigma_svd)
 
         _precomp = {
             "omega_range": omega_range,
@@ -1365,47 +1361,43 @@ class SelfEnergy:
             "ecut_left": ecut_left,
             "ecut_right": ecut_right,
         }
-
+        
         def _reflect_min(xi, p0, p_min, scale):
             """Map R -> [p_min, +inf) using linear reflection around p_min."""
             return p_min + np.abs((float(p0) - p_min) + scale * float(xi))
 
         def _unpack_params(x):
             params = {}
+
             i = 0
             for name in vary:
                 xi = float(x[i])
 
                 if name == "fermi_velocity":
                     if vF0 is None:
-                        raise ValueError(
-                            "Cannot vary fermi_velocity: no initial vF provided."
-                        )
+                        raise ValueError("Cannot vary fermi_velocity: no "
+                        "initial vF provided.")
                     params["fermi_velocity"] = vF0 + scale_vF * xi
 
                 elif name == "bare_mass":
                     if mb0 is None:
-                        raise ValueError(
-                            "Cannot vary bare_mass: no initial bare_mass provided."
-                        )
+                        raise ValueError("Cannot vary bare_mass: no initial "
+                        "bare_mass provided.")
                     params["bare_mass"] = mb0 + scale_mb * xi
 
                 elif name == "fermi_wavevector":
                     if kF0 is None:
                         raise ValueError(
-                            "Cannot vary fermi_wavevector: no initial kF provided."
+                            "Cannot vary fermi_wavevector: no initial kF "
+                            "provided."
                         )
                     params["fermi_wavevector"] = kF0 + scale_kF * xi
-
+                    
                 elif name == "impurity_magnitude":
-                    params["impurity_magnitude"] = _reflect_min(
-                        xi, imp0, 0.0, scale_imp
-                    )
+                    params["impurity_magnitude"] = _reflect_min(xi, imp0, 0.0, scale_imp)
 
                 elif name == "lambda_el":
-                    params["lambda_el"] = _reflect_min(
-                        xi, lae0, 0.0, scale_lambda_el
-                    )
+                    params["lambda_el"] = _reflect_min(xi, lae0, 0.0, scale_lambda_el)
 
                 elif name == "h_n":
                     params["h_n"] = _reflect_min(xi, h_n0, h_n_min, scale_hn)
@@ -1443,14 +1435,14 @@ class SelfEnergy:
 
             return self._cost_function(
                 optimisation_parameters=optimisation_parameters,
-                omega_min=omega_min,
-                omega_max=omega_max,
-                omega_num=omega_num,
-                omega_I=omega_I,
-                omega_M=omega_M,
-                mem_cfg=mem_cfg,
-                _precomp=_precomp,
-            )
+                omega_min=omega_min, omega_max=omega_max, omega_num=omega_num,
+                omega_I=omega_I, omega_M=omega_M, mem_cfg=mem_cfg, 
+                _precomp=_precomp
+                )
+
+        last = {"cost": None, "spectrum": None, "model": None, "alpha": None}
+
+        iter_counter = {"n": 0}
 
         class ConvergenceException(RuntimeError):
             """Raised when optimisation has converged successfully."""
@@ -1469,6 +1461,7 @@ class SelfEnergy:
         if converge_iters < 0:
             raise ValueError("converge_iters must be >= 0.")
 
+        # Track best solution seen across all obj calls (not just last).
         best_global = {
             "x": None,
             "params": None,
@@ -1479,53 +1472,25 @@ class SelfEnergy:
         }
 
         history = []
+
+        # Cache most recent evaluation so the callback can read a cost without
+        # forcing an extra objective evaluation.
+        last_x = {"x": None}
         last_cost = {"cost": None}
         initial_cost = {"cost": None}
+
         iter_counter = {"n": 0}
 
         def _clean_params(params):
             """Convert NumPy scalar values to plain Python scalars."""
             out = {}
             for key, val in params.items():
-                out[key] = float(val) if isinstance(val, np.generic) else val
+                if isinstance(val, np.generic):
+                    out[key] = float(val)
+                else:
+                    out[key] = val
             return out
 
-        # --- Deterministic iteration printing (bulletproof) ---
-        if print_lines is None:
-            n_print = None
-        else:
-            n_print = int(print_lines)
-            if n_print < 0:
-                raise ValueError("print_lines must be >= 0 or None.")
-
-        tail_buf = deque(maxlen=0 if n_print is None else n_print)
-        omitted = {"n": 0}
-
-        def _emit_iter_line(line):
-            if n_print is None:
-                print(line)
-                return
-            if n_print == 0:
-                return
-            if iter_counter["n"] <= n_print:
-                print(line)
-            else:
-                tail_buf.append(line)
-                omitted["n"] += 1
-
-        def _flush_tail(clear=True):
-            if n_print is None or n_print == 0:
-                return
-
-            if omitted["n"] > 0:
-                print(f"... ({omitted['n']} lines omitted) ...")
-            for line in tail_buf:
-                print(line)
-
-            if clear:
-                tail_buf.clear()
-                omitted["n"] = 0
-
         def obj(x):
             import warnings
 
@@ -1538,10 +1503,7 @@ class SelfEnergy:
                 try:
                     cost, spectrum, model, alpha_select = _evaluate_cost(params)
                 except RuntimeWarning as exc:
-                    raise ValueError(
-                        f"RuntimeWarning during cost eval: {exc}"
-                    ) from exc
-
+                    raise ValueError(f"RuntimeWarning during cost eval: {exc}") from exc
             cost_f = float(cost)
 
             history.append(
@@ -1555,7 +1517,14 @@ class SelfEnergy:
                 }
             )
 
+            last["cost"] = cost_f
+            last["spectrum"] = spectrum
+            last["model"] = model
+            last["alpha"] = float(alpha_select)
+
+            last_x["x"] = np.array(x, dtype=float, copy=True)
             last_cost["cost"] = cost_f
+
             if initial_cost["cost"] is None:
                 initial_cost["cost"] = cost_f
 
@@ -1570,15 +1539,18 @@ class SelfEnergy:
             msg = [f"Iter {iter_counter['n']:4d} | cost = {cost: .4e}"]
             for key in sorted(params):
                 msg.append(f"{key}={params[key]:.8g}")
-            _emit_iter_line(" | ".join(msg))
+            print(" | ".join(msg))
 
             return cost_f
-
+        
         class TerminationCallback:
-            def __init__(self, tole, converge_iters, min_steps_for_regression):
+            def __init__(self, tole, converge_iters,
+                         min_steps_for_regression):
                 self.tole = None if tole is None else float(tole)
                 self.converge_iters = int(converge_iters)
-                self.min_steps_for_regression = int(min_steps_for_regression)
+                self.min_steps_for_regression = int(
+                    min_steps_for_regression
+                )
                 self.iter_count = 0
                 self.call_count = 0
 
@@ -1594,7 +1566,7 @@ class SelfEnergy:
 
                 best_cost = float(best_global["cost"])
                 if np.isfinite(best_cost):
-                    if abs(float(current) - best_cost) < self.tole:
+                    if abs(current - best_cost) < self.tole:
                         self.iter_count += 1
                     else:
                         self.iter_count = 0
@@ -1602,10 +1574,11 @@ class SelfEnergy:
                 if self.iter_count >= self.converge_iters:
                     raise ConvergenceException(
                         "Converged: |cost-best| < "
-                        f"{self.tole:g} for {self.converge_iters} iterations."
+                        f"{self.tole:g} for "
+                        f"{self.converge_iters} iterations."
                     )
 
-                if self.call_count < min_steps_for_regression:
+                if self.call_count < self.min_steps_for_regression:
                     return
 
                 init_cost = initial_cost["cost"]
@@ -1618,7 +1591,10 @@ class SelfEnergy:
                 if not np.isfinite(best_cost):
                     return
 
-                if abs(current - init_cost) * relative_best < abs(current - best_cost):
+                if (
+                    abs(current - init_cost) * relative_best
+                    < abs(current - best_cost)
+                ):
                     raise RegressionException(
                         "Regression toward initial guess detected."
                     )
@@ -1648,12 +1624,19 @@ class SelfEnergy:
         res = None
 
         while retry_count <= max_retries:
+            best = {
+                "x": None,
+                "params": None,
+                "cost": np.inf,
+                "spectrum": None,
+                "model": None,
+                "alpha": None,
+            }
+            last_x["x"] = None
             last_cost["cost"] = None
             initial_cost["cost"] = None
             iter_counter["n"] = 0
             history.clear()
-            tail_buf.clear()
-            omitted["n"] = 0
 
             callback = TerminationCallback(
                 tole=tole,
@@ -1677,7 +1660,6 @@ class SelfEnergy:
                 break
 
             except RegressionException as exc:
-                _flush_tail()
                 print(f"{exc} Rolling back {rollback_steps} steps.")
                 retry_count += 1
 
@@ -1689,7 +1671,6 @@ class SelfEnergy:
                 continue
 
             except ValueError as exc:
-                _flush_tail()
                 print(f"ValueError encountered: {exc}. Rolling back.")
                 retry_count += 1
 
@@ -1700,8 +1681,6 @@ class SelfEnergy:
                 x0 = np.array(history[-back]["x"], dtype=float, copy=True)
                 continue
 
-        _flush_tail()
-
         if retry_count > max_retries:
             print("Max retries reached. Parameters may not be optimal.")
 
@@ -1723,13 +1702,14 @@ class SelfEnergy:
         print("Optimised parameters:")
         print(args)
 
+        # store inside class methods
         self._a2f_spectrum = spectrum
         self._a2f_model = model
         self._a2f_omega_range = omega_range
         self._a2f_alpha_select = alpha_select
         self._a2f_cost = cost
 
-        return spectrum, model, omega_range, alpha_select, cost, params  
+        return spectrum, model, omega_range, alpha_select, cost, params
 
 
     @staticmethod

{xarpes-0.6.4.dist-info → xarpes-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xarpes
-Version: 0.6.4
+Version: 0.6.5
 Summary: Extraction from angle resolved photoemission spectra
 Author: xARPES Developers
 Requires-Python: >=3.7.0

{xarpes-0.6.4.dist-info → xarpes-0.6.5.dist-info}/RECORD

@@ -1,15 +1,15 @@
-xarpes/__init__.py,sha256=vXNdJ2VWNYVMLPB6MXlUskWnyEgsJOEsLMea57P7DXE,756
+xarpes/__init__.py,sha256=DFt2W5mUNCCXIJt4Q_h3xsCQn0U9nqO_3C1bEguzLnw,756
 xarpes/bandmap.py,sha256=1B5GbRXFdBPqnmeKPJW0mzlz-IUoLD-28rxrThpp4co,34664
 xarpes/constants.py,sha256=XOdgSzyrmHr5xocHZfmcFHHoVAa1G05a305hm3XOTtY,504
 xarpes/distributions.py,sha256=pC8V5MlZDNFdooMonFREEASiN5QodHiyKc2ehnxMKvQ,23498
-xarpes/functions.py,sha256=ibWoSa7_yXD9XsIEif0kbbbHidIozBivvaAEui9f64A,20675
+xarpes/functions.py,sha256=oVAdNY0g44h7h6bXI8IYCiNbXfrLvBk7xD79ZQnbhno,25404
 xarpes/mdcs.py,sha256=WRKSfGlRVKBssJp9FIHcAFsINVunPkmW9fBnFjqBHYI,42844
 xarpes/plotting.py,sha256=lGCReHcXhYLQXR5ns3EHFjCQjJ9Sc-HifV7n4BnWby4,5189
-xarpes/selfenergies.py,sha256=40mgFGZUWZIYywmyT1PTazP7elb4DKzcrrXzwtvkaMo,84534
+xarpes/selfenergies.py,sha256=stbKhpDt49F8QTancIpOhgpTrdRvTvCBhvH770p0y-U,84176
 xarpes/settings_parameters.py,sha256=yOYvgEiDeDiLzzLkvysCTiVwqg6fKIkN48B-WSad728,1912
 xarpes/settings_plots.py,sha256=X-qteB2fIbBKOAcLMvMYDfQ8QdlUeA5xYQqF_Nyb4uA,1562
-xarpes-0.6.4.dist-info/entry_points.txt,sha256=917UR-cqFTMMI_vMqIbk7boYSuFX_zHwQlXKcj9vlCE,79
-xarpes-0.6.4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-xarpes-0.6.4.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81
-xarpes-0.6.4.dist-info/METADATA,sha256=erfAZH4Hn-z2-RiJThNjStBw_7UbFKGM9ExzxY_36GA,7154
-xarpes-0.6.4.dist-info/RECORD,,
+xarpes-0.6.5.dist-info/entry_points.txt,sha256=917UR-cqFTMMI_vMqIbk7boYSuFX_zHwQlXKcj9vlCE,79
+xarpes-0.6.5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+xarpes-0.6.5.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81
+xarpes-0.6.5.dist-info/METADATA,sha256=sgr0wwth6Z-sAC4JaIlDXV_PCg9jFX8_F6ZracOhZO4,7154
+xarpes-0.6.5.dist-info/RECORD,,