freealg 0.7.11__py3-none-any.whl → 0.7.14__py3-none-any.whl

freealg/_algebraic_form/_decompress.py

@@ -12,7 +12,6 @@
 # =======
 
 import numpy
-from ._continuation_algebraic import powers
 
 __all__ = ['build_time_grid', 'decompress_newton_old', 'decompress_newton']
 
@@ -21,11 +20,11 @@ __all__ = ['build_time_grid', 'decompress_newton_old', 'decompress_newton']
 # build time grid
 # ===============
 
-def build_time_grid(sizes, n0, min_n_time=0):
+def build_time_grid(sizes, n0, min_n_times=0):
     """
     sizes: list/array of requested matrix sizes (e.g. [2000,3000,4000,8000])
     n0:    initial size (self.n)
-    min_n_time: minimum number of time points to run Newton sweep on
+    min_n_times: minimum number of time points to run Newton sweep on
 
     Returns
     -------
@@ -43,7 +42,7 @@ def build_time_grid(sizes, n0, min_n_time=0):
     t_all = numpy.sort(base)
 
     # Add points only if needed: split largest gaps
-    N = int(min_n_time) if min_n_time is not None else 0
+    N = int(min_n_times) if min_n_times is not None else 0
     while t_all.size < N and t_all.size >= 2:
         gaps = numpy.diff(t_all)
         k = int(numpy.argmax(gaps))
@@ -60,121 +59,8 @@ def build_time_grid(sizes, n0, min_n_time=0):
     return t_all, idx_req
 
 
-# ===============
-# eval P partials
-# ===============
-
-def eval_P_partials(z, m, a_coeffs):
-    """
-    Evaluate P(z,m) and its partial derivatives dP/dz and dP/dm.
-
-    This assumes P is represented by `a_coeffs` in the monomial basis
-
-        P(z, m) = sum_{j=0..s} a_j(z) * m^j,
-        a_j(z) = sum_{i=0..deg_z} a_coeffs[i, j] * z^i.
-
-    The function returns P, dP/dz, dP/dm with broadcasting over z and m.
-
-    Parameters
-    ----------
-    z : complex or array_like of complex
-        First argument to P.
-    m : complex or array_like of complex
-        Second argument to P. Must be broadcast-compatible with `z`.
-    a_coeffs : ndarray, shape (deg_z+1, s+1)
-        Coefficient matrix for P in the monomial basis.
-
-    Returns
-    -------
-    P : complex or ndarray of complex
-        Value P(z,m).
-    Pz : complex or ndarray of complex
-        Partial derivative dP/dz evaluated at (z,m).
-    Pm : complex or ndarray of complex
-        Partial derivative dP/dm evaluated at (z,m).
-
-    Notes
-    -----
-    For scalar (z,m), this uses Horner evaluation for a_j(z) and then Horner
-    in m. For array inputs, it uses precomputed power tables via `_powers` for
-    simplicity.
-
-    Examples
-    --------
-    .. code-block:: python
-
-        P, Pz, Pm = eval_P_partials(1.0 + 1j, 0.2 + 0.3j, a_coeffs)
-    """
 
-    z = numpy.asarray(z, dtype=complex)
-    m = numpy.asarray(m, dtype=complex)
 
-    deg_z = int(a_coeffs.shape[0] - 1)
-    s = int(a_coeffs.shape[1] - 1)
-
-    if (z.ndim == 0) and (m.ndim == 0):
-        zz = complex(z)
-        mm = complex(m)
-
-        a = numpy.empty(s + 1, dtype=complex)
-        ap = numpy.empty(s + 1, dtype=complex)
-
-        for j in range(s + 1):
-            c = a_coeffs[:, j]
-
-            val = 0.0 + 0.0j
-            for i in range(deg_z, -1, -1):
-                val = val * zz + c[i]
-            a[j] = val
-
-            dval = 0.0 + 0.0j
-            for i in range(deg_z, 0, -1):
-                dval = dval * zz + (i * c[i])
-            ap[j] = dval
-
-        p = a[s]
-        pm = 0.0 + 0.0j
-        for j in range(s - 1, -1, -1):
-            pm = pm * mm + p
-            p = p * mm + a[j]
-
-        pz = ap[s]
-        for j in range(s - 1, -1, -1):
-            pz = pz * mm + ap[j]
-
-        return p, pz, pm
-
-    shp = numpy.broadcast(z, m).shape
-    zz = numpy.broadcast_to(z, shp).ravel()
-    mm = numpy.broadcast_to(m, shp).ravel()
-
-    zp = powers(zz, deg_z)
-    mp = powers(mm, s)
-
-    dzp = numpy.zeros_like(zp)
-    for i in range(1, deg_z + 1):
-        dzp[:, i] = i * zp[:, i - 1]
-
-    P = numpy.zeros(zz.size, dtype=complex)
-    Pz = numpy.zeros(zz.size, dtype=complex)
-    Pm = numpy.zeros(zz.size, dtype=complex)
-
-    for j in range(s + 1):
-        aj = zp @ a_coeffs[:, j]
-        P += aj * mp[:, j]
-
-        ajp = dzp @ a_coeffs[:, j]
-        Pz += ajp * mp[:, j]
-
-        if j >= 1:
-            Pm += (j * aj) * mp[:, j - 1]
-
-    return P.reshape(shp), Pz.reshape(shp), Pm.reshape(shp)
-
-
-# ==========
-# fd solve w
-# ==========
 
 def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
                armijo=1e-4, min_lam=1e-6, w_min=1e-14):
@@ -245,256 +131,140 @@ def fd_solve_w(z, t, a_coeffs, w_init, max_iter=50, tol=1e-12,
     want_pos_imag = (z.imag > 0.0)
 
     for _ in range(max_iter):
-        if not numpy.isfinite(w.real) or not numpy.isfinite(w.imag):
-            return w, False
-        if abs(w) < w_min:
-            return w, False
-        if want_pos_imag and (w.imag <= 0.0):
-            return w, False
-
-        zeta = z + alpha / w
-        y = tau * w
-
-        F, Pz, Py = eval_P_partials(zeta, y, a_coeffs)
-        F = complex(F)
-        Pz = complex(Pz)
-        Py = complex(Py)
 
-        if abs(F) <= tol:
-            return w, True
-
-        dF = (-alpha / (w * w)) * Pz + tau * Py
-        if dF == 0.0:
+        a = numpy.asarray(a_coeffs, dtype=numpy.complex128)
+        deg_z = a.shape[0] - 1
+        deg_m = a.shape[1] - 1
+
+        beta = tau - 1.0
+
+        # poly_y[p] stores coeff of y^p after clearing denominators
+        poly_y = numpy.zeros(deg_z + deg_m + 1, dtype=numpy.complex128)
+
+        # Build polynomial: sum_{i,j} a[i,j] (z + beta/y)^i y^j * y^{deg_z}
+        # Expand (z + beta/y)^i = sum_{k=0}^i C(i,k) z^{i-k} (beta/y)^k
+        # Term contributes to power p = deg_z + j - k.
+        from math import comb
+        for i in range(deg_z + 1):
+            for j in range(deg_m + 1):
+                aij = a[i, j]
+                if aij == 0:
+                    continue
+                for k in range(i + 1):
+                    p = deg_z + j - k
+                    poly_y[p] += aij * comb(i, k) * (z ** (i - k)) * (beta ** k)
+
+        # numpy.roots expects highest degree first
+        coeffs = poly_y[::-1]
+
+        # If leading coefficients are ~0, trim (rare but safe)
+        nz_lead = numpy.flatnonzero(numpy.abs(coeffs) > 0)
+        if nz_lead.size == 0:
             return w, False
+        coeffs = coeffs[nz_lead[0]:]
 
-        step = -F / dF
+        roots_y = numpy.roots(coeffs)
 
-        lam = 1.0
-        F_abs = abs(F)
-        ok = False
+        # Pick root with Im(w)>0 (if z in upper half-plane), closest to time seed
+        y_seed = tau * w_init
+        best = None
+        best_score = None
 
-        while lam >= min_lam:
-            w_new = w + lam * step
-            if abs(w_new) < w_min:
-                lam *= 0.5
-                continue
-            if want_pos_imag and (w_new.imag <= 0.0):
-                lam *= 0.5
+        for y in roots_y:
+            if not numpy.isfinite(y.real) or not numpy.isfinite(y.imag):
                 continue
 
-            zeta_new = z + alpha / w_new
-            y_new = tau * w_new
+            w_cand = y / tau
 
-            F_new = eval_P_partials(zeta_new, y_new, a_coeffs)[0]
-            F_new = complex(F_new)
+            if want_pos_imag and (w_cand.imag <= 0.0):
+                continue
 
-            if abs(F_new) <= (1.0 - armijo * lam) * F_abs:
-                w = w_new
-                ok = True
-                break
+            if abs(w_cand) < w_min:
+                continue
+
+            # score: stick to time continuation
+            score = abs(y - y_seed)
 
-            lam *= 0.5
+            if (best_score is None) or (score < best_score):
+                best = w_cand
+                best_score = score
 
-        if not ok:
+        if best is None:
             return w, False
 
-    F_end = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
-    return w, (abs(F_end) <= 10.0 * tol)
+        w = complex(best)
 
+        # final residual check
+        F_end = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
+        return w, (abs(F_end) <= 1e3 * tol)
 
-# =====================
-# decompress newton old
-# =====================
+    # -------------------
 
-def decompress_newton_old(z_list, t_grid, a_coeffs, w0_list=None,
-                          dt_max=0.1, sweep=True, time_rel_tol=5.0,
-                          max_iter=50, tol=1e-12, armijo=1e-4,
-                          min_lam=1e-6, w_min=1e-14):
-    """
-    Evolve w = m(t,z) on a fixed z grid and time grid using FD.
 
-    Parameters
-    ----------
-    z_list : array_like of complex
-        Query points z (typically x + 1j*eta with eta > 0).
-    t_grid : array_like of float
-        Strictly increasing time grid.
-    a_coeffs : ndarray
-        Coefficients defining P(zeta,y) in the monomial basis used by eval_P.
-    w0_list : array_like of complex
-        Initial values at t_grid[0] (typically m0(z_list) on the physical
-        branch).
-    dt_max : float, optional
-        Maximum internal time step. Larger dt is handled by substepping.
-    sweep : bool, optional
-        If True, use spatial continuation (neighbor seeding) plus a
-        time-consistency check to prevent branch collapse. If False, solve
-        each z independently from the previous-time seed (faster but may
-        branch-switch for small eta).
-    time_rel_tol : float, optional
-        When sweep=True, if the neighbor-seeded solution differs from the
-        previous-time value w_prev by more than time_rel_tol*(1+|w_prev|), we
-        also solve using the previous-time seed and select the closer one.
-    max_iter : int, optional
-        Maximum Newton iterations in fd_solve_w.
-    tol : float, optional
-        Residual tolerance in fd_solve_w.
-    armijo : float, optional
-        Armijo parameter for backtracking in fd_solve_w.
-    min_lam : float, optional
-        Minimum damping factor in fd_solve_w backtracking.
-    w_min : float, optional
-        Minimum |w| allowed to avoid singularity.
-
-    Returns
-    -------
-    W : ndarray, shape (len(t_grid), len(z_list))
-        Evolved values w(t,z).
-    ok : ndarray of bool, same shape as W
-        Convergence flags from the final accepted solve at each point.
-
-    Notes
-    -----
-    For very small eta, the implicit FD equation can have multiple roots in the
-    upper half-plane. The sweep option is a branch-selection mechanism. The
-    time-consistency check is critical at large t to avoid propagating a
-    nearly-real spurious root across x.
+    F_end = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
+    return w, (abs(F_end) <= 10.0 * tol)
 
-    Examples
-    --------
-    .. code-block:: python
 
-        x = numpy.linspace(-0.5, 2.5, 2000)
-        eta = 1e-6
-        z_query = x + 1j*eta
-        w0_list = m1_fn(z_query)
+# ============
+# NEW FUNCTION
+# ============
 
-        t_grid = numpy.linspace(0.0, 4.0, 2)
-        W, ok = fd_evolve_on_grid(
-            z_query, t_grid, a_coeffs, w0_list=w0_list,
-            dt_max=0.1, sweep=True, time_rel_tol=5.0,
-            max_iter=50, tol=1e-12, armijo=1e-4, min_lam=1e-6, w_min=1e-14
-        )
-        rho = W.imag / numpy.pi
+def fd_candidates_w(z, t, a_coeffs, w_min=1e-14):
     """
-    z_list = numpy.asarray(z_list, dtype=complex).ravel()
-    t_grid = numpy.asarray(t_grid, dtype=float).ravel()
-    nt = t_grid.size
-    nz = z_list.size
-
-    W = numpy.empty((nt, nz), dtype=complex)
-    ok = numpy.zeros((nt, nz), dtype=bool)
-
-    if w0_list is None:
-        raise ValueError(
-            "w0_list must be provided (e.g. m1_fn(z_list) at t=0).")
-    w_prev = numpy.asarray(w0_list, dtype=complex).ravel()
-    if w_prev.size != nz:
-        raise ValueError("w0_list must have same size as z_list.")
-
-    W[0, :] = w_prev
-    ok[0, :] = True
-
-    sweep = bool(sweep)
-    time_rel_tol = float(time_rel_tol)
-
-    for it in range(1, nt):
-        t0 = float(t_grid[it - 1])
-        t1 = float(t_grid[it])
-        dt = t1 - t0
-        if dt <= 0.0:
-            raise ValueError("t_grid must be strictly increasing.")
+    Return candidate roots w solving P(z + alpha/w, tau*w)=0 with Im(w)>0 (if Im(z)>0).
+    """
+    z = complex(z)
+    tau = float(numpy.exp(t))
+    alpha = 1.0 - 1.0 / tau
+    want_pos_imag = (z.imag > 0.0)
 
-        # Internal substepping makes time-continuity a strong selector.
-        n_sub = int(numpy.ceil(dt / float(dt_max)))
-        if n_sub < 1:
-            n_sub = 1
+    a = numpy.asarray(a_coeffs, dtype=numpy.complex128)
+    deg_z = a.shape[0] - 1
+    deg_m = a.shape[1] - 1
 
-        for ks in range(1, n_sub + 1):
-            t = t0 + dt * (ks / float(n_sub))
+    beta = tau - 1.0  # since alpha/w = (tau-1)/(tau*w) = beta / y with y=tau*w
 
-            w_row = numpy.empty(nz, dtype=complex)
-            ok_row = numpy.zeros(nz, dtype=bool)
+    poly_y = numpy.zeros(deg_z + deg_m + 1, dtype=numpy.complex128)
 
-            if not sweep:
-                # Independent solves: each point uses previous-time seed only.
-                for iz in range(nz):
-                    w, success = fd_solve_w(
-                        z_list[iz], t, a_coeffs, w_prev[iz],
-                        max_iter=max_iter, tol=tol, armijo=armijo,
-                        min_lam=min_lam, w_min=w_min
-                    )
-                    w_row[iz] = w
-                    ok_row[iz] = success
-
-                w_prev = w_row
+    from math import comb
+    for i in range(deg_z + 1):
+        for j in range(deg_m + 1):
+            aij = a[i, j]
+            if aij == 0:
                 continue
+            for k in range(i + 1):
+                p = deg_z + j - k
+                poly_y[p] += aij * comb(i, k) * (z ** (i - k)) * (beta ** k)
+
+    coeffs = poly_y[::-1]
+    nz_lead = numpy.flatnonzero(numpy.abs(coeffs) > 0)
+    if nz_lead.size == 0:
+        return []
+
+    coeffs = coeffs[nz_lead[0]:]
+    roots_y = numpy.roots(coeffs)
+
+    cands = []
+    for y in roots_y:
+        if not numpy.isfinite(y.real) or not numpy.isfinite(y.imag):
+            continue
+        w = y / tau
+        if abs(w) < w_min:
+            continue
+        if want_pos_imag and (w.imag <= 0.0):
+            continue
+        # residual filter (optional but helps)
+        # -------------
+        # TEST
+        # F = eval_P_partials(z + alpha / w, tau * w, a_coeffs)[0]
+        # if abs(F) < 1e-6:
+        #     cands.append(complex(w))
+        # ---------------
+        # TEST
+        cands.append(complex(w))
+        # ------------------
 
-            # Center-out sweep seed: pick where previous-time Im is largest.
-            i0 = int(numpy.argmax(numpy.abs(numpy.imag(w_prev))))
-
-            w0, ok0 = fd_solve_w(
-                z_list[i0], t, a_coeffs, w_prev[i0],
-                max_iter=max_iter, tol=tol, armijo=armijo,
-                min_lam=min_lam, w_min=w_min
-            )
-            w_row[i0] = w0
-            ok_row[i0] = ok0
-
-            def solve_with_choice(iz, w_neighbor):
-                # First try neighbor-seeded Newton (spatial continuity).
-                w_a, ok_a = fd_solve_w(
-                    z_list[iz], t, a_coeffs, w_neighbor,
-                    max_iter=max_iter, tol=tol, armijo=armijo,
-                    min_lam=min_lam, w_min=w_min
-                )
-
-                # Always keep a time-consistent fallback candidate.
-                w_b, ok_b = fd_solve_w(
-                    z_list[iz], t, a_coeffs, w_prev[iz],
-                    max_iter=max_iter, tol=tol, armijo=armijo,
-                    min_lam=min_lam, w_min=w_min
-                )
-
-                if ok_a and ok_b:
-                    # Prefer the root closer to previous-time value (time
-                    # continuation).
-                    da = abs(w_a - w_prev[iz])
-                    db = abs(w_b - w_prev[iz])
-
-                    # If neighbor result is wildly off, reject it.
-                    if da > time_rel_tol * (1.0 + abs(w_prev[iz])):
-                        return w_b, True
-
-                    return (w_a, True) if (da <= db) else (w_b, True)
-
-                if ok_a:
-                    # If only neighbor succeeded, still guard against extreme
-                    # drift.
-                    da = abs(w_a - w_prev[iz])
-                    if da > time_rel_tol * (1.0 + abs(w_prev[iz])) and ok_b:
-                        return w_b, True
-                    return w_a, True
-
-                if ok_b:
-                    return w_b, True
-
-                return w_a, False
-
-            # Sweep right
-            for iz in range(i0 + 1, nz):
-                w_row[iz], ok_row[iz] = solve_with_choice(iz, w_row[iz - 1])
-
-            # Sweep left
-            for iz in range(i0 - 1, -1, -1):
-                w_row[iz], ok_row[iz] = solve_with_choice(iz, w_row[iz + 1])
-
-            w_prev = w_row
-
-        W[it, :] = w_prev
-        ok[it, :] = ok_row
-
-    return W, ok
+    return cands
 
 
 # =================
@@ -505,7 +275,7 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
                       dt_max=0.1, sweep=True, time_rel_tol=5.0,
                       active_imag_eps=None, sweep_pad=20,
                       max_iter=50, tol=1e-12, armijo=1e-4,
-                      min_lam=1e-6, w_min=1e-14):
+                      min_lam=1e-6, w_min=1e-14, min_n_time=None):
     """
     Evolve w = m(t,z) on a fixed z grid and time grid using FD.
 
@@ -576,41 +346,88 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
         active_imag_eps = 50.0 * eta0 if eta0 > 0.0 else 1e-10
     active_imag_eps = float(active_imag_eps)
 
+    # --------------------------------------
+    # TEST
+    # def solve_with_choice(iz, w_seed):
+    #     # Neighbor-seeded candidate (spatial continuity)
+    #     w_a, ok_a = fd_solve_w(
+    #         z_list[iz], t, a_coeffs, w_seed,
+    #         max_iter=max_iter, tol=tol, armijo=armijo,
+    #         min_lam=min_lam, w_min=w_min
+    #     )
+    #
+    #     # Time-seeded candidate (time continuation)
+    #     w_b, ok_b = fd_solve_w(
+    #         z_list[iz], t, a_coeffs, w_prev[iz],
+    #         max_iter=max_iter, tol=tol, armijo=armijo,
+    #         min_lam=min_lam, w_min=w_min
+    #     )
+    #
+    #     if ok_a and ok_b:
+    #         da = abs(w_a - w_prev[iz])
+    #         db = abs(w_b - w_prev[iz])
+    #
+    #         # Reject neighbor result if it drifted too far in one step
+    #         if da > time_rel_tol * (1.0 + abs(w_prev[iz])):
+    #             return w_b, True
+    #
+    #         return (w_a, True) if (da <= db) else (w_b, True)
+    #
+    #     if ok_a:
+    #         da = abs(w_a - w_prev[iz])
+    #         if da > time_rel_tol * (1.0 + abs(w_prev[iz])) and ok_b:
+    #             return w_b, True
+    #         return w_a, True
+    #
+    #     if ok_b:
+    #         return w_b, True
+    #
+    #     return w_a, False
+    # ----------------------------------------
+    # TEST
     def solve_with_choice(iz, w_seed):
-        # Neighbor-seeded candidate (spatial continuity)
-        w_a, ok_a = fd_solve_w(
-            z_list[iz], t, a_coeffs, w_seed,
-            max_iter=max_iter, tol=tol, armijo=armijo,
-            min_lam=min_lam, w_min=w_min
-        )
-
-        # Time-seeded candidate (time continuation)
-        w_b, ok_b = fd_solve_w(
-            z_list[iz], t, a_coeffs, w_prev[iz],
-            max_iter=max_iter, tol=tol, armijo=armijo,
-            min_lam=min_lam, w_min=w_min
-        )
-
-        if ok_a and ok_b:
-            da = abs(w_a - w_prev[iz])
-            db = abs(w_b - w_prev[iz])
-
-            # Reject neighbor result if it drifted too far in one step
-            if da > time_rel_tol * (1.0 + abs(w_prev[iz])):
-                return w_b, True
+        # candidate roots at this (t,z)
+        cands = fd_candidates_w(z_list[iz], t, a_coeffs, w_min=w_min)
+
+        # ---------------------
+        # TEST
+        if iz in (0, nz//2, nz-1):
+            ims = [float(w.imag) for w in cands]
+            print(f"      iz={iz} ncand={len(cands)} Im(cands) min/med/max="
+                  f"{(min(ims) if ims else None)}/"
+                  f"{(numpy.median(ims) if ims else None)}/"
+                  f"{(max(ims) if ims else None)}")
+        # ---------------------
+
+        if len(cands) == 0:
+            # fallback to your existing single-root solver
+            w, success = fd_solve_w(
+                z_list[iz], t, a_coeffs, w_prev[iz],
+                max_iter=max_iter, tol=tol, armijo=armijo,
+                min_lam=min_lam, w_min=w_min
+            )
+            return w, success
 
-            return (w_a, True) if (da <= db) else (w_b, True)
+        # cost = spatial continuity + time continuity (tune weights if needed)
+        w_time = w_prev[iz]
+        w_space = w_seed
+        best = None
+        best_cost = None
 
-        if ok_a:
-            da = abs(w_a - w_prev[iz])
-            if da > time_rel_tol * (1.0 + abs(w_prev[iz])) and ok_b:
-                return w_b, True
-            return w_a, True
+        for w in cands:
+            # TEST
+            # cost = abs(w - w_space) + 0.25 * abs(w - w_time)
+            # TEST
+            # prefer continuity, but also prefer larger Im(w) to stay on the bulk branch
+            cost = abs(w - w_space) + 0.25 * abs(w - w_time) - 5.0 * w.imag
+            # --------------
 
-        if ok_b:
-            return w_b, True
+            if (best_cost is None) or (cost < best_cost):
+                best = w
+                best_cost = cost
 
-        return w_a, False
+        return best, True
+    # ----------------------------------------
 
     for it in range(1, nt):
         t0 = float(t_grid[it - 1])
@@ -648,15 +465,107 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
             # Define "active" region from previous time: inside bulks
             # Im(w_prev) is O(1), outside bulks Im(w_prev) is ~O(eta). Dilate
             # by sweep_pad to allow edges to move.
+
+            # ------------------------------
+            # TEST
+            # active = (numpy.abs(numpy.imag(w_prev)) > active_imag_eps)
+            # active_pad = active.copy()
+            # if sweep_pad > 0 and numpy.any(active):
+            #     idx = numpy.flatnonzero(active)
+            #     for i in idx:
+            #         lo = 0 if (i - sweep_pad) < 0 else (i - sweep_pad)
+            #         hi = \
+            #             nz if (i + sweep_pad + 1) > nz else (i + sweep_pad + 1)
+            #         active_pad[lo:hi] = True
+            # ------------------------------
+            # TEST
             active = (numpy.abs(numpy.imag(w_prev)) > active_imag_eps)
-            active_pad = active.copy()
-            if sweep_pad > 0 and numpy.any(active):
-                idx = numpy.flatnonzero(active)
-                for i in idx:
-                    lo = 0 if (i - sweep_pad) < 0 else (i - sweep_pad)
-                    hi = \
-                        nz if (i + sweep_pad + 1) > nz else (i + sweep_pad + 1)
-                    active_pad[lo:hi] = True
+
+            # Split active indices into contiguous blocks (bulks)
+            pad_label = -numpy.ones(nz, dtype=numpy.int64)   # bulk id per index
+            active_pad = numpy.zeros(nz, dtype=bool)
+
+            idx = numpy.flatnonzero(active)
+            if idx.size > 0:
+                cuts = numpy.where(numpy.diff(idx) > 1)[0]
+                blocks = numpy.split(idx, cuts + 1)
+
+                # Build padded intervals + centers
+                centers = []
+                pads = []
+                for b in blocks:
+                    centers.append(int((b[0] + b[-1]) // 2))
+                    lo = int(max(0, b[0] - sweep_pad))
+                    hi = int(min(nz - 1, b[-1] + sweep_pad))
+                    pads.append((lo, hi))
+
+                # Union of padded regions
+                for lo, hi in pads:
+                    active_pad[lo:hi + 1] = True
+
+                # Assign each padded index to the nearest bulk center (no overlap label)
+                idx_u = numpy.flatnonzero(active_pad)
+                c = numpy.asarray(centers, dtype=numpy.int64)
+                dist = numpy.abs(idx_u[:, None] - c[None, :])
+                winner = numpy.argmin(dist, axis=1).astype(numpy.int64)
+                pad_label[idx_u] = winner
+            # ------------------------------
+
+            # ------------------------------
+            # TEST
+            def _ranges(idxs):
+                if idxs.size == 0:
+                    return []
+                cuts = numpy.where(numpy.diff(idxs) > 1)[0]
+                blocks = numpy.split(idxs, cuts + 1)
+                return [(int(b[0]), int(b[-1])) for b in blocks]
+
+            print("    pad_label>=0 ranges:", _ranges(numpy.flatnonzero(pad_label >= 0)))
+            print("    overlap(-2) ranges:", _ranges(numpy.flatnonzero(pad_label == -2)))
+            # ------------------------------
+
+
+
+            # ----------------------------------------------
+
+            # TEST
+            # eta = float(abs(z_list[0].imag))
+            #
+            # # Barrier: points that look like "gap" (tiny Im(w_prev))
+            # barrier_eps = 10.0 * eta   # try 5*eta or 10*eta
+            # barrier = (numpy.abs(numpy.imag(w_prev)) <= barrier_eps)
+
+
+
+            # TEST
+            # -------------------------
+            # --- diagnostics ---
+            active = (numpy.abs(numpy.imag(w_prev)) > active_imag_eps)
+            idx_active = numpy.flatnonzero(active)
+            idx_pad = numpy.flatnonzero(active_pad)
+
+            def _ranges(idxs):
+                if idxs.size == 0:
+                    return []
+                cuts = numpy.where(numpy.diff(idxs) > 1)[0]
+                blocks = numpy.split(idxs, cuts + 1)
+                return [(b[0], b[-1]) for b in blocks]
+
+            print(f"[t={t:.6g}] eta={z_list[0].imag:.2e} active_eps={active_imag_eps:.2e} "
+                  f"active_n={idx_active.size}/{nz} pad_n={idx_pad.size}/{nz} "
+                  f"active_ranges={_ranges(idx_active)} pad_ranges={_ranges(idx_pad)}")
+
+            # Track the physical “gap” region around between bulks by looking at low Im(w_prev)
+            gap = numpy.abs(numpy.imag(w_prev)) <= 5.0 * z_list[0].imag
+            ig = numpy.flatnonzero(gap)
+            if ig.size > 0:
+                print(f"    gap_ranges(Im<=5eta)={_ranges(ig)} "
+                      f"Im(w) min/med/max = {numpy.min(w_prev.imag):.3e}/"
+                      f"{numpy.median(w_prev.imag):.3e}/{numpy.max(w_prev.imag):.3e}")
+
+            # ------------------
+
+
 
             # Left-to-right: use neighbor seed only within padded active
             # regions, so we don't propagate a branch across the gap between
@@ -665,16 +574,51 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
                 if iz == 0:
                     w_seed = w_prev[iz]
                 else:
-                    if active_pad[iz] and active_pad[iz - 1]:
+                    # TEST
+                    # if active_pad[iz] and active_pad[iz - 1]:
+                    #     w_seed = w_row[iz - 1]
+                    # else:
+                    #     w_seed = w_prev[iz]
+                    # TEST
+                    # if (active_pad[iz] and active_pad[iz - 1] and
+                    #         (not barrier[iz]) and (not barrier[iz - 1])):
+                    #     w_seed = w_row[iz - 1]
+                    # else:
+                    #     w_seed = w_prev[iz]
+                    # ----------------------
+                    # TEST
+                    # if (active_pad[iz] and active_pad[iz - 1] and
+                    #         (pad_label[iz] == pad_label[iz - 1]) and
+                    #         (pad_label[iz] >= 0)):
+                    # -----------------
+                    # TEST
+                    if (active_pad[iz] and active_pad[iz - 1] and
+                        (pad_label[iz] == pad_label[iz - 1]) and
+                        (pad_label[iz] >= 0)):
                         w_seed = w_row[iz - 1]
                     else:
                         w_seed = w_prev[iz]
+                    # ----------------------
+
 
                 w_row[iz], ok_row[iz] = solve_with_choice(iz, w_seed)
 
             # Right-to-left refinement: helps stabilize left edges of bulks.
             for iz in range(nz - 2, -1, -1):
-                if active_pad[iz] and active_pad[iz + 1]:
+                # TEST
+                # if active_pad[iz] and active_pad[iz + 1]:
+                # TEST
+                # if (active_pad[iz] and active_pad[iz + 1] and
+                #         (not barrier[iz]) and (not barrier[iz + 1])):
+                # TEST
+                # if (active_pad[iz] and active_pad[iz + 1] and
+                #         (pad_label[iz] == pad_label[iz + 1]) and
+                #         (pad_label[iz] >= 0)):
+                # TEST
+                if (active_pad[iz] and active_pad[iz + 1] and
+                        (pad_label[iz] == pad_label[iz + 1]) and
+                        (pad_label[iz] >= 0)):
+
                     w_seed = w_row[iz + 1]
                     w_new, ok_new = solve_with_choice(iz, w_seed)
                     if ok_new:
@@ -684,6 +628,11 @@ def decompress_newton(z_list, t_grid, a_coeffs, w0_list=None,
                             w_row[iz] = w_new
                             ok_row[iz] = True
 
+
+
+            # TEST
+            print(f'solved_ok={ok_row.sum()}/{nz}  (this substep)')
+
             w_prev = w_row
 
         W[it, :] = w_prev