PyAntiGen 1.0.11__tar.gz → 1.0.13__tar.gz

{pyantigen-1.0.11 → pyantigen-1.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.11
+Version: 1.0.13
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

{pyantigen-1.0.11 → pyantigen-1.0.13}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.11
+Version: 1.0.13
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

pyantigen-1.0.13/PyAntiGen.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.13",
+  "distance": 0,
+  "node": "ga5c2cee6bb58358aeefd1f48b50c73b952bfa343",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-17"
+}

{pyantigen-1.0.11 → pyantigen-1.0.13}/framework/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.11'
-__version_tuple__ = version_tuple = (1, 0, 11)
+__version__ = version = '1.0.13'
+__version_tuple__ = version_tuple = (1, 0, 13)
 
-__commit_id__ = commit_id = 'gdaaaf88e9'
+__commit_id__ = commit_id = 'ga5c2cee6b'

{pyantigen-1.0.11 → pyantigen-1.0.13}/framework/template/Example/Engine/Evaluator.py

@@ -131,6 +131,17 @@ class EvalSpec:
     # in the parent, which runs the invariance check once; a worker must never
     # make that call on its own, or 40 of them would each re-derive it.
     preequil_cache: bool = False
+    # Modules.utils.noise_floor.export_cache() snapshot, taken in the parent
+    # AFTER its own calibration (see Engine.Optimize.run_optimization_from_groups,
+    # clear_cache() + the post-optimum re-evaluation). Workers seed their own
+    # (otherwise empty, since spawn shares no memory) floor cache from this in
+    # _init_worker, so every worker scores every floored observable against
+    # the SAME calibrated sigma the parent settled on, rather than each one
+    # independently calibrating against whatever parameter vector it happens
+    # to be handed first -- an arbitrary profile-grid point or Sobol sample,
+    # not the converged optimum. Same reasoning as fixed_sigmas above, one
+    # mechanism down: compute once where it's meaningful, ship the answer.
+    floor_cache: dict = field(default_factory=dict)
     # Reserved for future use by the profile grid (Stage 2).
     meta: dict = field(default_factory=dict)
 
@@ -149,8 +160,16 @@ def _init_worker(spec_blob):
     from framework.TelluriumGen import TelluriumGen
     from Engine.Event_times import attach_event_times
     from Engine.Optimize import OptRoadRunnerProxy
+    from Modules.utils.noise_floor import seed_cache
 
     spec = _serializer.loads(spec_blob)
+    # Before any task runs: this worker's own Modules.utils.noise_floor
+    # module was just re-imported fresh (spawn shares no memory with the
+    # parent), so its floor cache starts empty. Seed it from the parent's
+    # already-calibrated snapshot so every worker agrees with the parent --
+    # and with each other -- on every floored observable's sigma, instead of
+    # each recalibrating independently against whichever task it draws first.
+    seed_cache(spec.floor_cache)
     models = {}
     t0 = time.time()
     for sim_name, replicate in spec.replicates.items():
@@ -189,7 +208,7 @@ def _init_worker(spec_blob):
           f"{time.time() - t0:.1f}s", flush=True)
 
 
-def _worker_nll(x):
+def _worker_nll(x, frozen_sigmas=None):
     """The joint NLL, evaluated with this worker's own compiled models."""
     from Engine.Optimize import evaluate_nll_fixed
 
@@ -202,17 +221,18 @@ def _worker_nll(x):
         events_dynamic=spec.events_dynamic, failure_value=FAILURE_VALUE,
         for_inference=getattr(spec, "for_inference", True),
         concentrated=getattr(spec, "concentrated", True),
+        frozen_sigmas=frozen_sigmas,
     )
 
 
-def _eval_task(x):
+def _eval_task(x, frozen_sigmas=None):
     """Evaluate one parameter vector. Never raises across the pool boundary."""
     if _WORKER["spec"] is None:
         return (FAILURE_VALUE, "worker-not-initialized", 0.0)
 
     t0 = time.time()
     try:
-        val = _worker_nll(x)
+        val = _worker_nll(x, frozen_sigmas=frozen_sigmas)
         _WORKER["n_evals"] += 1
         status = "ok" if np.isfinite(val) and val < FAILURE_VALUE else "sentinel"
         return (float(val), status, time.time() - t0)
@@ -503,7 +523,17 @@ def _profile_task(job):
         cache = {}
         cache_order = []
 
-        raw_objective = _make_nuisance_objective(_worker_nll, param_idx, n_params)
+        # Every profile point pins each floored block at its own sigma_used
+        # from the fit rather than letting it re-concentrate (see
+        # Engine.Optimize._freeze_floor) -- stamped onto the job by
+        # profile_batch's frozen_sigmas, not decided here, so the caller
+        # controls it per batch.
+        frozen = job.get("frozen_sigmas")
+
+        def _pinned_nll(x_full):
+            return _worker_nll(x_full, frozen_sigmas=frozen)
+
+        raw_objective = _make_nuisance_objective(_pinned_nll, param_idx, n_params)
 
         def nuisance_objective(x_nuisance, fixed_val):
             x_arr = np.asarray(x_nuisance, dtype=float)
@@ -858,32 +888,50 @@ class ParallelEvaluator:
 
     # -- evaluation --------------------------------------------------------
 
-    def evaluate_batch(self, xs, label=None):
-        """Evaluate every parameter vector in *xs*; return losses in input order."""
+    def evaluate_batch(self, xs, label=None, heartbeat_s=_HEARTBEAT_SECONDS,
+                       frozen_sigmas=None):
+        """Evaluate every parameter vector in *xs*; return losses in input order.
+
+        Uses submit/wait, not map -- see profile_batch's docstring for the
+        general reasoning. map() (the previous implementation here) returns
+        nothing until the WHOLE batch is done, so one slow straggler among
+        many fast points -- a slice-screen point far from the optimum landing
+        in a stiff numerical regime, say -- makes the entire batch silent for
+        as long as that one point takes, indistinguishable from a hang. A
+        heartbeat every heartbeat_s while nothing has landed answers that
+        directly: it says how many are done, how many are still in flight, and
+        an ETA once at least one has finished.
+
+        chunk_size no longer applies to this method: submitting one task per
+        vector is what makes the heartbeat and per-point completion visibility
+        possible at all, and no caller in this codebase sets chunk_size to
+        anything but the default anyway.
+
+        Still returns losses in INPUT order, not completion order -- unlike
+        profile_batch, whose callers key off fields in each job/result dict,
+        callers here (the slice screen especially) index into the return value
+        positionally.
+        """
         xs = [np.asarray(x, dtype=float) for x in xs]
-        if not xs:
+        n = len(xs)
+        if n == 0:
             return []
         if self._pool is None:
             self.start()
 
-        chunk = self.chunk_size
-        if chunk is None:
-            # Enough chunks to keep every worker fed, few enough to avoid
-            # per-task overhead dominating.
-            chunk = max(1, len(xs) // (self.n_workers * 4) or 1)
+        from concurrent.futures import wait, FIRST_COMPLETED
 
         t0 = time.time()
+        tag = f" [{label}]" if label else ""
         if self.verbose:
-            # map() returns nothing until the whole batch is done, so this line
-            # is the only warning the caller gets that the next stretch of
-            # silence is expected. Individual points are reported by
-            # profile_batch; this path deliberately trades that for chunking.
-            tag = f" [{label}]" if label else ""
-            print(f"[pool]{tag} {len(xs)} evaluation(s) submitted to "
-                  f"{self.n_workers} worker(s) in chunks of {chunk}; "
-                  f"no output until the batch completes.", flush=True)
+            print(f"[pool]{tag} {n} evaluation(s) submitted to "
+                  f"{self.n_workers} worker(s); progress every "
+                  f"{_fmt_dur(heartbeat_s)} until results start landing.",
+                  flush=True)
+
         try:
-            out = list(self._pool.map(_eval_task, xs, chunksize=chunk))
+            futures = {self._pool.submit(_eval_task, x, frozen_sigmas): i
+                      for i, x in enumerate(xs)}
         except RuntimeError as exc:
             if "bootstrapping phase" in str(exc):
                 # spawn re-imports the __main__ module in every worker. If the
@@ -903,15 +951,46 @@ class ParallelEvaluator:
                 ) from exc
             raise
 
-        losses = []
+        pending = set(futures)
+        out = [None] * n
+        work = 0.0
+        done = 0
         failures = []
-        for i, (val, status, secs) in enumerate(out):
-            losses.append(val)
-            self.total_worker_seconds += secs
-            if status != "ok":
-                failures.append((i, status))
 
-        self.n_evals += len(xs)
+        while pending:
+            finished, pending = wait(pending, timeout=heartbeat_s,
+                                     return_when=FIRST_COMPLETED)
+
+            if not finished:
+                if self.verbose:
+                    now = time.time()
+                    msg = (f"  [pool{tag}] {done}/{n} done, "
+                           f"{len(pending)} in flight, "
+                           f"{_fmt_dur(now - t0)} elapsed")
+                    if done:
+                        rate = done / max(now - t0, 1e-9)
+                        msg += f", ~{_fmt_dur((n - done) / rate)} remaining"
+                    else:
+                        msg += " (no point has finished yet, so no estimate)"
+                    print(msg, flush=True)
+                continue
+
+            for fut in finished:
+                i = futures[fut]
+                try:
+                    val, status, secs = fut.result()
+                except Exception as exc:
+                    val = FAILURE_VALUE
+                    status = f"error: {type(exc).__name__}: {exc}"
+                    secs = 0.0
+                out[i] = val
+                work += secs
+                self.total_worker_seconds += secs
+                if status != "ok":
+                    failures.append((i, status))
+                done += 1
+
+        self.n_evals += n
         self.n_failures += len(failures)
 
         if self.verbose:
@@ -920,22 +999,31 @@ class ParallelEvaluator:
             # wall time is the speedup actually realized. On the first batch it
             # includes worker startup, so it understates steady-state throughput
             # -- report both numbers rather than one flattering one.
-            work = sum(o[2] for o in out)
-            tag = f" [{label}]" if label else ""
-            print(f"[pool]{tag} {len(xs)} evals in {elapsed:.1f}s wall "
+            print(f"[pool]{tag} {n} evals in {elapsed:.1f}s wall "
                   f"({work:.1f}s of work, {work / elapsed:.1f}x, "
-                  f"{len(xs) / elapsed:.1f} eval/s)", flush=True)
+                  f"{n / elapsed:.1f} eval/s)", flush=True)
             if failures:
                 shown = "; ".join(f"#{i}: {s}" for i, s in failures[:3])
                 more = f" (+{len(failures) - 3} more)" if len(failures) > 3 else ""
                 print(f"[pool]{tag} {len(failures)} failed — {shown}{more}", flush=True)
 
-        return losses
+        return out
 
     def profile_batch(self, jobs, on_result=None, label=None,
-                      heartbeat_s=_HEARTBEAT_SECONDS, budget=None):
+                      heartbeat_s=_HEARTBEAT_SECONDS, budget=None,
+                      frozen_sigmas=None):
         """Run profile-likelihood points in parallel, within a wall budget.
 
+        ``frozen_sigmas``, stamped onto every job here rather than left to
+        each caller's job-building code, is a ``{(block_key_or_exp_id,
+        obs_label): sigma_used}`` lookup (see ``Engine.Optimize.
+        block_sigmas``) pinning each data-floored block found in it at its own
+        resolved sigma for the point's whole nuisance re-optimization, instead
+        of letting it re-concentrate as the nuisance vector moves -- see
+        ``Engine.Optimize._freeze_floor``. Every profile pass submitted
+        through one ``batch()`` closure gets it uniformly this way, with no
+        change needed at the individual job-building sites.
+
         Unlike ``evaluate_batch`` this uses submit/wait rather than map, because
         each job is minutes to hours long and results must be checkpointed *as
         they land* -- the whole point of checkpointing is that killing the run
@@ -975,7 +1063,10 @@ class ParallelEvaluator:
 
         t0 = time.time()
         results = []
-        backlog = list(jobs)
+        # Stamped once here, not per admitted job: unlike deadline/sec_per_eval
+        # this does not depend on the clock, so every job in the batch gets it
+        # up front.
+        backlog = [dict(j, frozen_sigmas=frozen_sigmas) for j in jobs]
         futures = {}
         pending = set()
         n_jobs = len(jobs)
@@ -1125,6 +1216,7 @@ def build_eval_spec(
 ):
     """Convenience constructor mirroring the spec-route local variables."""
     from Engine.Event_times import without_event_times
+    from Modules.utils.noise_floor import export_cache
 
     return EvalSpec(
         model_text=model_text,
@@ -1150,6 +1242,12 @@ def build_eval_spec(
         for_inference=bool(for_inference),
         concentrated=bool(concentrated),
         preequil_cache=bool(preequil_cache),
+        # Captured HERE, at spec-build time -- called in the parent after its
+        # own clear_cache()-and-recalibrate pass (see run_optimization_from_
+        # groups), so this snapshot is the same calibration the parent's own
+        # subsequent diagnostics use, not whatever was cached earlier in the
+        # run (e.g. during the live optimize()).
+        floor_cache=export_cache(),
     )
 
 

{pyantigen-1.0.11 → pyantigen-1.0.13}/framework/template/Example/Engine/Fast_profile.py

@@ -281,13 +281,27 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
                      n_rounds=DEFAULT_ROUNDS,
                      near_zero_frac=DEFAULT_NEAR_ZERO_FRAC,
                      span_decades=SPAN_DECADES,
-                     min_reach_decades=MIN_REACH_DECADES, verbose=True):
+                     min_reach_decades=MIN_REACH_DECADES, verbose=True,
+                     nll_at_optimum_profile=None):
     """Screen, then one capped profile point per crossed side, in rounds.
 
     *batch* has the profile_batch signature: ``batch(jobs, on_result, label)``.
     *nll_batch* evaluates a list of full parameter vectors, for the screen.
     Returns the report dict; :func:`print_fast_profile_report` renders it and
     :func:`fast_profile_summary` shrinks it for the results snapshot.
+
+    *nll_at_optimum* anchors the screen, which goes through *nll_batch* and so
+    is never sigma-frozen (see ``Engine.Optimize._freeze_floor``).
+    *nll_at_optimum_profile* anchors the profile points that come back through
+    *batch*, which the caller submits with each floored block's sigma pinned
+    at its own ``sigma_used`` from the fit (``frozen_sigmas=sigma_by_block``,
+    not the raw floor -- see ``Engine.Optimize._freeze_floor``). Reusing the
+    unfrozen anchor for a frozen point's dNLL would compare two different
+    objectives, and if freezing were done at the raw floor instead of the
+    block's own resolved sigma that mismatch could run to hundreds of nats
+    even a fraction of a Wald SE from the optimum, since most floored blocks
+    are not binding at a good fit. Defaults to *nll_at_optimum* when not
+    given, which is correct whenever the caller submits unfrozen points too.
     """
     from Engine.Optimize import _cold_simplex, _param_bounds
 
@@ -295,6 +309,8 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
     n = len(param_names)
     scales = list(scales) if scales is not None else ["lin"] * n
     t_start = time.time()
+    if nll_at_optimum_profile is None:
+        nll_at_optimum_profile = nll_at_optimum
 
     # ── The screen, reused when this fit already has one ──────────────────
     screen = load_screen(ckpt_dir, param_names, res_x, threshold,
@@ -411,7 +427,7 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
         nll = res.get("nll")
         ok = (res.get("status") == "ok" and nll is not None
               and np.isfinite(nll) and nll < FAILURE_VALUE)
-        d = float(nll) - float(nll_at_optimum) if ok else None
+        d = float(nll) - float(nll_at_optimum_profile) if ok else None
         prev = side["dnll"]
         side["status"] = res.get("status")
         side["rounds"].append({
@@ -525,7 +541,10 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
 
     report = {
         "threshold": float(threshold),
-        "anchor": float(nll_at_optimum),
+        # The anchor every dNLL in this report was actually measured against
+        # -- the frozen one, since every round's points come back through
+        # batch(). Not the same number as the screen's own anchor above.
+        "anchor": float(nll_at_optimum_profile),
         "res_x": [float(v) for v in res_x],
         "param_names": list(param_names),
         "round_evals": int(round_evals),

{pyantigen-1.0.11 → pyantigen-1.0.13}/framework/template/Example/Engine/Identifiability.py

@@ -133,6 +133,17 @@ class UnidentifiableParameters(RuntimeError):
         )
 
 
+def _is_usable(p):
+    """Whether a slice point carries real information rather than a failure
+    sentinel. Shared by :func:`_verdict` (to find the true furthest usable
+    point) and :func:`run_slice_screen` (to decide whether a ladder's
+    outermost rung already settles a side) so the two never disagree about
+    what counts as a real crossing. ``nll < FAILURE_VALUE`` matters because
+    the sentinel is a large *finite* number, not inf or nan -- a failed
+    integration must not read as "crossed"."""
+    return np.isfinite(p["dnll"]) and p["nll"] < FAILURE_VALUE
+
+
 def _se_for(wald_se, param_idx):
     """The Wald SE for one parameter in optimizer space, or None.
 
@@ -313,14 +324,11 @@ def _verdict(points, bound, threshold, p_opt, sign, is_log,
     to be spent there. It is recorded rather than consumed: wiring it into the
     profile's opening grid is a separate change.
     """
-    def _usable(p):
-        return np.isfinite(p["dnll"]) and p["nll"] < FAILURE_VALUE
-
-    finite = [p for p in points if _usable(p)]
+    finite = [p for p in points if _is_usable(p)]
 
     inner = None
     for p in points:                       # points are ordered outward
-        if not _usable(p) or p["dnll"] > threshold:
+        if not _is_usable(p) or p["dnll"] > threshold:
             break
         inner = p["x_linear"]
 
@@ -389,25 +397,46 @@ def run_slice_screen(nll_batch, res_x, nll_at_optimum, param_names, bounds,
                      max_points=6, growth=2.0, range_factor=2.0,
                      span_decades=SPAN_DECADES,
                      min_reach_decades=MIN_REACH_DECADES, verbose=True):
-    """Evaluate every parameter's slice out across decades, as one batch.
-
-    A slice point has no dependency on any other, so all of them go out
-    together: this is the cheapest possible use of the pool, one evaluation per
-    point with no optimizer wrapped around it.
-
-    That shape has a second use. If evaluations far from the fitted values are
-    pathologically slow -- the region where the integrator struggles and
-    ``safe_simulate`` enters its retry ladder -- this finds out in minutes, and
-    says so plainly, instead of the run discovering it hours into a profile
-    batch where every stuck evaluation is buried inside a nuisance
-    minimization.
+    """Evaluate every parameter's slice out across decades, stopping each side
+    the moment it crosses.
+
+    The screen's job is to hand the profile a starting point, not to walk
+    every side all the way out. So the candidate ladder for each side --
+    :func:`screen_values`, unchanged -- is submitted one round at a time: round
+    *r* asks the pool for every side's *r*-th candidate, all still-active
+    sides together in one batch, which keeps this as parallel as the old
+    single-batch version was. A side is retired the instant one of its points
+    reads ``dnll > threshold`` and never contributes another evaluation --
+    :func:`_verdict` reads a side's state from whichever point is furthest out
+    among those actually evaluated, so nothing is lost by stopping there. A
+    side that never crosses keeps going, round after round, all the way to its
+    candidate list's last point -- the declared bound or ``span_decades`` out,
+    whichever is further, see :func:`screen_target` -- exactly as before,
+    because that is the one thing this screen has to be able to prove.
+
+    Why stopping matters now and did not always: once a block's sigma is
+    capped at a data-derived floor (``sigma_floor_from_data``), a point far
+    outside the fitted region can return a genuinely enormous NLL rather than
+    a merely large one -- the self-forgiving log(sigma) term that used to
+    compress a bad far-out fit is exactly what the floor removes -- and that
+    region is also where the integrator is slowest. A declared bound is a
+    user-supplied number with no guaranteed relationship to anything physical,
+    so nothing about it -- not "it is inside the box", not "it is only one
+    point" -- is safe to evaluate unconditionally. The only bound that is safe
+    is not asking for a point once its side has already answered the question.
+
+    The one thing round-by-round stopping gives up: a slice that crosses early
+    and then dips back below threshold at a point it never reaches would have
+    been read as "open" by a full evaluation, and reads "crossed" here
+    instead. That trades a slower profile on a rare, specific slice shape for
+    never paying an unbounded evaluation on the common one.
     """
     from Engine.Optimize import _param_bounds
 
     res_x = np.asarray(res_x, dtype=float)
     scales = list(scales) if scales is not None else ["lin"] * len(param_names)
 
-    plan, xs = [], []
+    plan = []
     for i, name in enumerate(param_names):
         is_log = scales[i] == "log10"
         lb, ub = _param_bounds(bounds, i)
@@ -418,21 +447,48 @@ def run_slice_screen(nll_batch, res_x, nll_at_optimum, param_names, bounds,
                                  range_factor=range_factor,
                                  span_decades=span_decades)
             plan.append({"index": i, "name": name, "side": side, "sign": sign,
-                         "is_log": is_log, "values": vals,
-                         "p_opt": float(res_x[i]),
-                         "bound": (lb if sign < 0 else ub)})
-            for v in vals:
-                x = res_x.copy()
-                x[i] = v
-                xs.append(x)
+                        "is_log": is_log, "values": vals, "points": [],
+                        "settled": False,
+                        "p_opt": float(res_x[i]),
+                        "bound": (lb if sign < 0 else ub)})
 
+    n_candidates = sum(len(e["values"]) for e in plan)
+    max_rounds = max((len(e["values"]) for e in plan), default=0)
     if verbose:
         print(f"\n[screen] slice screen: {len(param_names)} parameter(s) x 2 "
-              f"side(s) = {len(xs)} evaluation(s), submitted as one batch. "
-              f"No nuisance optimization: each point is an upper bound on the "
-              f"profile, which is all the screen needs.", flush=True)
-
-    values = list(nll_batch(xs, label="slice-screen")) if xs else []
+              f"side(s); up to {n_candidates} evaluation(s) across at most "
+              f"{max_rounds} round(s), one round per pool submission. A side "
+              f"stops the round it first crosses dNLL={threshold:g}; only "
+              f"sides still undecided pay for the next, further-out point. "
+              f"No nuisance optimization: each point is an upper bound on "
+              f"the profile, which is all the screen needs.", flush=True)
+
+    n_evaluations = 0
+    for r in range(max_rounds):
+        round_xs, round_owner = [], []
+        for entry in plan:
+            if entry["settled"] or r >= len(entry["values"]):
+                continue
+            v = entry["values"][r]
+            x = res_x.copy()
+            x[entry["index"]] = v
+            round_xs.append(x)
+            round_owner.append((entry, v))
+        if not round_xs:
+            break
+        if verbose:
+            print(f"[screen] round {r + 1}: {len(round_xs)} side(s) still "
+                  f"undecided.", flush=True)
+        n_evaluations += len(round_xs)
+        nlls = nll_batch(round_xs, label=f"slice-screen-r{r + 1}")
+        for (entry, v), nll in zip(round_owner, nlls):
+            nll = float(nll)
+            point = {"x": float(v),
+                    "x_linear": float(10.0 ** v if entry["is_log"] else v),
+                    "nll": nll, "dnll": float(nll - nll_at_optimum)}
+            entry["points"].append(point)
+            if _is_usable(point) and point["dnll"] > threshold:
+                entry["settled"] = True
 
     report = {"threshold": float(threshold),
               "anchor": float(nll_at_optimum),
@@ -440,25 +496,17 @@ def run_slice_screen(nll_batch, res_x, nll_at_optimum, param_names, bounds,
               "param_names": list(param_names),
               "span_decades": float(span_decades),
               "min_reach_decades": float(min_reach_decades),
-              "n_evaluations": len(xs),
+              "n_evaluations": n_evaluations,
+              "n_candidates": n_candidates,
               "parameters": {}}
 
-    pos = 0
     for entry in plan:
-        pts = []
-        for v in entry["values"]:
-            nll = float(values[pos])
-            pos += 1
-            pts.append({
-                "x": float(v),
-                "x_linear": float(10.0 ** v if entry["is_log"] else v),
-                "nll": nll,
-                "dnll": float(nll - nll_at_optimum),
-            })
-        side = _verdict(pts, entry["bound"], threshold, entry["p_opt"],
-                        entry["sign"], entry["is_log"],
+        side = _verdict(entry["points"], entry["bound"], threshold,
+                        entry["p_opt"], entry["sign"], entry["is_log"],
                         min_reach_decades=min_reach_decades)
         side["is_log"] = entry["is_log"]
+        side["stopped_early"] = bool(entry["settled"]
+                                     and len(entry["points"]) < len(entry["values"]))
         report["parameters"].setdefault(entry["name"], {})[entry["side"]] = side
 
     states = [s["state"] for sides in report["parameters"].values()