gridstate 2.7.0__tar.gz → 2.8.0__tar.gz

{gridstate-2.7.0 → gridstate-2.8.0}/CHANGELOG.md

@@ -9,6 +9,38 @@ types of the merged pull requests; breaking and behavior-changing items are
 listed separately under "Breaking changes" and "Behavior changes". A release is
 cut by tagging the merged main commit; the version is derived from that tag.
 
+## v2.8.0 (2026-10-18)
+
+### Behavior changes
+
+- `init="flat"` starts V consistent with the transformer ratios instead of
+  1 p.u. everywhere: `log V` from a least squares over the branches
+  (`log V_to − log V_from = −log k`, weight `1/|z|`, `log V_slack = 0`). A node
+  whose nominal voltage does not match its transformer ratio (or an off-nominal
+  tap on a low-impedance branch) no longer starts with a mismatch of hundreds
+  of p.u. Applies to every algorithm; without off-nominal ratios the start is
+  unchanged. WLS on an ill-conditioned model may converge to a neighbouring
+  solution (on the test models p95 |ΔV| against the reference within 0.05 kV).
+- `ipm_pd` voltage guard on by default (`ipm_voltage_guard` /
+  `voltage_guard`, ignored by other algorithms): every node V is kept within a
+  box from its `voltage_min` / `voltage_max` (unset or implausible limits fall
+  back to 0.55 / 1.8 p.u., 0.7–1.5 p.u. with neither set) and one step changes
+  V by at most 20 %, an angle by at most 0.6 rad and a branch angle difference
+  by at most 0.35 rad. Where a node limit is active the estimate sits on it.
+
+### Fix
+
+- `ipm_pd` with the global hard balance no longer collapses a generator node
+  into the low-voltage power-flow branch from a flat start (V → 0, the node
+  angle undetermined, a formally converged V ≈ 0.2 p.u.).
+
+### Feat
+
+- `solve_ipm_pd`: `state_box_*` (barrier boxes on state coordinates that stay
+  under the trust region and the stopping test, without box damping) and the
+  `step_rel_*` / `step_abs_*` / `step_diff_*` step limits.
+- `gridstate.state.tap_consistent_voltages`.
+
 ## v2.7.0 (2026-10-18)
 
 ### Behavior changes

{gridstate-2.7.0 → gridstate-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridstate
-Version: 2.7.0
+Version: 2.8.0
 Summary: Power system State Estimation: pure-Python WLS/IPM on numpy/scipy, input via a versioned file contract (npz).
 Author-email: Evgeny Istomin <gena@alpisto.eu>
 License: MIT

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.7.0'
-__version_tuple__ = version_tuple = (2, 7, 0)
+__version__ = version = '2.8.0'
+__version_tuple__ = version_tuple = (2, 8, 0)
 
-__commit_id__ = commit_id = 'g9810ca9e9'
+__commit_id__ = commit_id = 'g89cfd10b4'

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate/algorithms/ipm_pd.py

@@ -172,6 +172,37 @@ class _Linearization:
         return dx, ds_l, ds_u, dy_l, dy_u, dlam
 
 
+def _step_cap(
+    dx: np.ndarray,
+    x: np.ndarray,
+    rel_idx: np.ndarray,
+    rel_max: float,
+    abs_idx: np.ndarray,
+    abs_max: float,
+    pair_i: np.ndarray,
+    pair_j: np.ndarray,
+    diff_max: float,
+) -> float:
+    """Largest primal step length allowed by the per-coordinate step limits."""
+    cap = math.inf
+    if rel_max > 0.0 and rel_idx.size:
+        d = np.abs(dx[rel_idx])
+        lim = rel_max * np.abs(x[rel_idx])
+        k = d > 0.0
+        if k.any():
+            cap = min(cap, float(np.min(lim[k] / d[k])))
+    if abs_max > 0.0 and abs_idx.size:
+        d_max = float(np.max(np.abs(dx[abs_idx])))
+        if d_max > 0.0:
+            cap = min(cap, abs_max / d_max)
+    if diff_max > 0.0 and pair_i.size:
+        dz = np.append(dx, 0.0)
+        d_max = float(np.max(np.abs(dz[pair_i] - dz[pair_j])))
+        if d_max > 0.0:
+            cap = min(cap, diff_max / d_max)
+    return cap
+
+
 @dataclass
 class _Merit:
     """The merit ``φ`` of one iteration (see the module docstring); ``mu`` is the target ``σμ``."""
@@ -249,6 +280,15 @@ def solve_ipm_pd(
     eq_prox: float = 1e-9,
     box_prox: float = 1e-6,
     box_prox_max: float = 1e-2,
+    state_box_idx: np.ndarray | None = None,
+    state_box_lo: np.ndarray | None = None,
+    state_box_hi: np.ndarray | None = None,
+    step_rel_idx: np.ndarray | None = None,
+    step_rel_max: float = 0.0,
+    step_abs_idx: np.ndarray | None = None,
+    step_abs_max: float = 0.0,
+    step_diff_pairs: tuple[np.ndarray, np.ndarray] | None = None,
+    step_diff_max: float = 0.0,
 ) -> IPMResult:
     """Mehrotra predictor-corrector IPM (see the module docstring).
 
@@ -297,6 +337,17 @@ def solve_ipm_pd(
             conflicts into the residuals and make this markedly worse. ``0``
             reweights to the end.
         kkt_solver: Newton-system solver (``None`` — scipy).
+        state_box_idx, state_box_lo, state_box_hi: barrier boxes on state
+            coordinates (e.g. V). Unlike ``box_idx`` they stay under the trust
+            region and the stopping test and get no box damping: the box only
+            keeps the iteration away from an inadmissible region (V → 0, where
+            the node angle is undetermined).
+        step_rel_idx, step_rel_max: ``|αp·Δx_i| ≤ step_rel_max·|x_i|`` on these
+            coordinates (``0`` — off).
+        step_abs_idx, step_abs_max: ``|αp·Δx_i| ≤ step_abs_max`` (``0`` — off).
+        step_diff_pairs, step_diff_max: ``|αp·(Δx_i − Δx_j)| ≤ step_diff_max`` for
+            each pair ``(i, j)``; an index ``-1`` stands for a fixed zero (the
+            slack angle). ``0`` — off.
         eq_prox: with equality rows, a proximal term ``eq_prox·max(ρ)`` on the
             diagonal of the box coordinates. A hard balance fixes only the net
             injection of a node, so the common level of its generation and load
@@ -335,6 +386,28 @@ def solve_ipm_pd(
             raise ValueError("box_lo/box_hi contain pairs with lo >= hi")
     else:
         b_lo = b_hi = np.zeros(0)
+    n_var_box = box_idx.size
+    if state_box_idx is not None and np.size(state_box_idx):
+        if state_box_lo is None or state_box_hi is None:
+            raise ValueError("state_box_lo and state_box_hi are required with state_box_idx")
+        sb_lo = np.asarray(state_box_lo, dtype=np.float64)
+        sb_hi = np.asarray(state_box_hi, dtype=np.float64)
+        if np.any(sb_lo >= sb_hi):
+            raise ValueError("state_box_lo/state_box_hi contain pairs with lo >= hi")
+        box_idx = np.concatenate([box_idx, np.asarray(state_box_idx, dtype=np.int64)])
+        b_lo = np.concatenate([b_lo, sb_lo])
+        b_hi = np.concatenate([b_hi, sb_hi])
+    var_box_idx = box_idx[:n_var_box]
+    rel_idx = np.asarray(step_rel_idx if step_rel_idx is not None else [], dtype=np.int64)
+    abs_idx = np.asarray(step_abs_idx if step_abs_idx is not None else [], dtype=np.int64)
+    if step_diff_pairs is not None:
+        # -1 -> the appended zero coordinate.
+        pair_i = np.asarray(step_diff_pairs[0], dtype=np.int64)
+        pair_j = np.asarray(step_diff_pairs[1], dtype=np.int64)
+        pair_i = np.where(pair_i < 0, n, pair_i)
+        pair_j = np.where(pair_j < 0, n, pair_j)
+    else:
+        pair_i = pair_j = np.zeros(0, dtype=np.int64)
     mb_rows = np.asarray(meas_box_rows if meas_box_rows is not None else [], dtype=np.int64)
     if mb_rows.size:
         if meas_box_lo is None or meas_box_hi is None:
@@ -386,7 +459,8 @@ def solve_ipm_pd(
     )
 
     tr_mask = np.ones(n, dtype=bool)
-    tr_mask[box_idx] = False
+    tr_mask[var_box_idx] = False
+    prox_on = np.arange(nb) < n_var_box
     tr_pos = np.flatnonzero(tr_mask)
     limiters: dict[int, int] = {}
     limiting_rows: dict[int, int] = {}
@@ -456,7 +530,9 @@ def solve_ipm_pd(
         w_mat[eq_rows] = rho
         w_mat[mb_rows] += d_k[nb:]
         diag = np.zeros(n)
-        diag[box_idx] = d_k[:nb] + max(eq_prox_abs, box_scale * w_median)
+        diag[box_idx] = d_k[:nb] + np.where(
+            prox_on, max(eq_prox_abs, box_scale * w_median), eq_prox_abs
+        )
         # Stationarity residual of the current point (for reporting).
         y_dual = np.zeros(nb + mb_rows.size)
         y_dual[il] += y_l
@@ -568,6 +644,14 @@ def solve_ipm_pd(
         # The stopping test measures the Newton step, not how far the search cut it.
         step_inf = a_p * free_inf
         fit_inf = a_p * float(np.max(np.sqrt(w_data) * np.abs(hdx))) if m else 0.0
+        # The step limits shorten the step like the search below, after
+        # step_inf has measured the Newton step.
+        a_p = min(
+            a_p,
+            _step_cap(
+                dx, x, rel_idx, step_rel_max, abs_idx, step_abs_max, pair_i, pair_j, step_diff_max
+            ),
+        )
         a_full = a_p
         r_new = None
         # A direction that does not descend (inconsistent slacks of a nonlinear

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate/api.py

@@ -55,6 +55,7 @@ from gridstate.state import (
     flat_start,
     flat_start_with_box,
     pack,
+    tap_consistent_voltages,
     unpack,
     unpack_full,
 )
@@ -120,7 +121,9 @@ def estimate(
             ``"ipm_pd"`` (the same problem by the primal-dual Mehrotra
             predictor-corrector, :mod:`gridstate.algorithms.ipm_pd`).
         init: initial guess strategy:
-            - ``"flat"`` — V=1 p.u., δ=0 for all nodes;
+            - ``"flat"`` — δ=0 for all nodes, V consistent with the
+              transformer ratios (:func:`gridstate.state.tap_consistent_voltages`;
+              1 p.u. without off-nominal ratios);
             - ``"results"`` — take the current ``voltage_magnitude``/``voltage_angle``
               from ``model``;
             - ``"slack"`` — V=V_slack for all nodes, δ=0.
@@ -651,7 +654,9 @@ def _initial_state_from_mode(
 ) -> np.ndarray:
     """``e_init`` of the ``init`` strategy alone."""
     if init == "flat":
-        return flat_start(layout)
+        e = flat_start(layout)
+        e[layout.offset_v : layout.offset_v + layout.n_bus] = tap_consistent_voltages(network_pu)
+        return e
 
     if init == "results":
         nodes_arr = model.nodes.to_numpy()
@@ -684,6 +689,66 @@ def _initial_state_from_mode(
     raise ValueError(f"Unknown init mode init={init!r}")
 
 
+# Voltage guard of ipm_pd (``voltage_guard=True``): node V box in p.u. of the
+# nominal voltage and the per-iteration step limits.
+_VG_LO_MIN = 0.5  # voltage_min below this share of nominal is ignored ...
+_VG_LO_FALLBACK = 0.55  # ... and replaced by this
+_VG_HI_MAX = 2.0  # voltage_max above this share of nominal is ignored ...
+_VG_HI_FALLBACK = 1.8  # ... and replaced by this
+_VG_BOTH_UNSET = (0.7, 1.5)  # neither limit set
+_VG_V_STEP_REL = 0.2  # |αp·ΔV| ≤ 0.2·V
+_VG_DELTA_STEP = 0.6  # |αp·Δδ| ≤ 0.6 rad
+_VG_BRANCH_DELTA_STEP = 0.35  # |αp·(Δδ_i − Δδ_j)| ≤ 0.35 rad over a branch
+
+
+def _voltage_guard_kwargs(
+    model: Working, network_pu: NetworkPU, layout: StateLayout
+) -> dict[str, Any]:
+    """``solve_ipm_pd`` kwargs of the voltage guard: V boxes and step limits.
+
+    The box of a node comes from its ``voltage_min`` / ``voltage_max`` (kV): a
+    limit that is unset (0) or implausible (below half / above twice the
+    nominal) falls back to 0.55 / 1.8 p.u.; with neither limit set the box is
+    0.7…1.5 p.u. It keeps the iteration out of the collapsed region (V → 0,
+    where the node angle is undetermined); the step limits keep one Newton
+    step from crossing into it.
+    """
+    nodes = model.nodes.to_numpy()
+    id_to_pos = id_to_pos_map(network_pu.bus_ids)
+    n = network_pu.n_bus
+    umin = np.zeros(n)
+    umax = np.zeros(n)
+    for row in nodes[nodes["status"]]:
+        pos = id_to_pos.get(int(row["id"]))
+        if pos is not None:
+            umin[pos] = float(row["voltage_min"])
+            umax[pos] = float(row["voltage_max"])
+    vn = np.asarray(network_pu.bus_vn_kv, dtype=np.float64)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        lo_pu = np.where(vn > 0, umin / vn, 0.0)
+        hi_pu = np.where(vn > 0, umax / vn, 0.0)
+    lo = np.where((umin > 0) & (lo_pu >= _VG_LO_MIN), lo_pu, _VG_LO_FALLBACK)
+    hi = np.where((umax > 0) & (hi_pu <= _VG_HI_MAX), hi_pu, _VG_HI_FALLBACK)
+    unset = (umin <= 0) & (umax <= 0)
+    lo[unset], hi[unset] = _VG_BOTH_UNSET
+    bad = lo >= hi
+    lo[bad], hi[bad] = _VG_LO_FALLBACK, _VG_HI_FALLBACK
+    v_idx = np.arange(layout.offset_v, layout.offset_v + n, dtype=np.int64)
+    delta_of = np.full(n, -1, dtype=np.int64)
+    delta_of[layout.non_slack_idx] = layout.offset_delta + np.arange(n - 1)
+    return {
+        "state_box_idx": v_idx,
+        "state_box_lo": lo,
+        "state_box_hi": hi,
+        "step_rel_idx": v_idx,
+        "step_rel_max": _VG_V_STEP_REL,
+        "step_abs_idx": delta_of[layout.non_slack_idx],
+        "step_abs_max": _VG_DELTA_STEP,
+        "step_diff_pairs": (delta_of[network_pu.from_idx], delta_of[network_pu.to_idx]),
+        "step_diff_max": _VG_BRANCH_DELTA_STEP,
+    }
+
+
 def _run_ipm(
     model: Working,
     network_pu: NetworkPU,
@@ -712,6 +777,7 @@ def _run_ipm(
     role_estimates: dict[int, float] | None = None,
     hint_iterations: int = 100,
     huber_threshold: str = "fixed",
+    voltage_guard: bool = True,
     **ipm_kwargs: Any,
 ) -> IPMResult:
     """IPM mode: extends the state vector with box-vars and solves the primal log-barrier WLS.
@@ -751,6 +817,10 @@ def _run_ipm(
     than ``hint_iterations`` iterations (``0`` — no iteration trigger) logs a
     WARNING with convergence hints (:mod:`gridstate.ipm_hints`).
 
+    ``voltage_guard`` (``"ipm_pd"`` only, ignored by ``"ipm"``): node V boxes
+    from ``voltage_min`` / ``voltage_max`` and per-step limits on V/δ (see
+    :func:`_voltage_guard_kwargs`).
+
     ``huber_threshold`` (``"ipm_pd"`` only): ``"fixed"`` keeps the Huber
     threshold at ``huber_c``; ``"adaptive"`` raises it to ``k·median|r/σ|``,
     recomputed every iteration, so the estimate follows the solver path. The
@@ -866,6 +936,7 @@ def _run_ipm(
             huber_warmup_iters=2,
             huber_adaptive_k=0.0 if huber_threshold == "fixed" else 2.0,
             kkt_solver=kkt,
+            **(_voltage_guard_kwargs(model, network_pu, layout_ipm) if voltage_guard else {}),
         )
         pd_result = result
         if result.solve_status is not SolveStatus.KKT:

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate/pipeline/config.py

@@ -552,6 +552,16 @@ class PipelineConfig:
         "min_value/max_value set is kept within [min_value, max_value] as an "
         "inequality of the interior-point problem. Default OFF.",
     )
+    ipm_voltage_guard: bool = _toggle(
+        True,
+        group=_G_IPM,
+        label="Voltage guard (ipm_pd)",
+        help="ipm_pd only (ignored otherwise): every node V is kept within a box "
+        "from its voltage_min/voltage_max (unset or implausible limits fall back "
+        "to 0.55/1.8 p.u. of nominal, 0.7..1.5 with neither set), and one step "
+        "changes V by at most 20 %, an angle by at most 0.6 rad and a branch "
+        "angle difference by at most 0.35 rad. Default ON.",
+    )
     ipm_injection_roles: bool = _toggle(
         False,
         group=_G_IPM,

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate/pipeline/passes.py

@@ -61,6 +61,7 @@ def _ipm_kwargs(cfg: PipelineConfig) -> dict:
         "balance_tol_q_mvar": cfg.ipm_balance_tol_q_mvar,
         "fixed_injection_from_input": cfg.ipm_fixed_injection_from_input,
         "measurement_bounds": cfg.ipm_measurement_bounds,
+        "voltage_guard": cfg.ipm_voltage_guard,
         "injection_roles": cfg.ipm_injection_roles,
         "hint_iterations": cfg.ipm_hint_iterations,
         "huber_threshold": cfg.ipm_huber_threshold,

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate/state.py

@@ -24,9 +24,20 @@ The layout to/from a flat array is handled by ``pack`` / ``unpack``.
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
+import scipy.sparse as sp
+from scipy.sparse.linalg import spsolve
+
+
+if TYPE_CHECKING:
+    from gridstate.units import NetworkPU
+
+
+# Impedance floor of the tap-consistent start weights: breakers (|z| ≈ 0) bind
+# their ends without making the system singular.
+_TAP_START_Z_FLOOR = 1e-4
 
 
 def _empty_int64() -> np.ndarray:
@@ -254,6 +265,46 @@ def flat_start(layout: StateLayout) -> np.ndarray:
     return e
 
 
+def tap_consistent_voltages(network_pu: NetworkPU) -> np.ndarray:
+    """Flat-start magnitudes consistent with the transformer ratios (p.u.).
+
+    ``V = 1`` everywhere contradicts every branch whose ratio in p.u. is not 1
+    (an off-nominal tap, or a node whose ``voltage_nominal`` does not match the
+    ratio of its transformer): on a low-impedance branch the flat start then
+    carries a circulating flow of hundreds of p.u. Instead ``log V`` solves the
+    least squares ``log V_to − log V_from = −log k`` over all branches, weighted
+    by ``1/|z|``, with ``log V_slack = 0``. On a radial transformer chain this
+    propagates the ratios exactly, in a meshed network it averages them.
+    A component without the slack is centred on 1.0.
+    """
+    n = network_pu.n_bus
+    f = np.asarray(network_pu.from_idx, dtype=np.int64)
+    t = np.asarray(network_pu.to_idx, dtype=np.int64)
+    if f.size == 0:
+        return np.ones(n, dtype=np.float64)
+    k = np.asarray(network_pu.tap_ratio, dtype=np.float64)
+    k = np.where(np.isfinite(k) & (k > 0), k, 1.0)
+    z = np.hypot(network_pu.branch_r, network_pu.branch_x)
+    w = 1.0 / np.maximum(z, _TAP_START_Z_FLOOR)
+    rows = np.arange(f.size)
+    a = sp.csr_matrix(
+        (np.r_[np.ones(f.size), -np.ones(f.size)], (np.r_[rows, rows], np.r_[t, f])),
+        shape=(f.size, n),
+    )
+    # A vanishing pull to log V = 0 keeps nodes outside the slack's component
+    # determined without moving the connected ones.
+    lap = (a.T @ sp.diags(w) @ a + sp.identity(n) * (1e-9 * float(w.mean()))).tolil()
+    rhs = a.T @ (-w * np.log(k))
+    s = network_pu.slack_idx
+    lap[s, :] = 0.0
+    lap[s, s] = 1.0
+    rhs[s] = 0.0
+    log_v = np.asarray(spsolve(lap.tocsc(), rhs), dtype=np.float64)
+    if not np.all(np.isfinite(log_v)):
+        return np.ones(n, dtype=np.float64)
+    return np.exp(log_v)
+
+
 def unpack_full(
     e: np.ndarray,
     layout: StateLayout,

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridstate
-Version: 2.7.0
+Version: 2.8.0
 Summary: Power system State Estimation: pure-Python WLS/IPM on numpy/scipy, input via a versioned file contract (npz).
 Author-email: Evgeny Istomin <gena@alpisto.eu>
 License: MIT

{gridstate-2.7.0 → gridstate-2.8.0}/gridstate.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "2.7.0",
+  "tag": "2.8.0",
   "distance": 0,
-  "node": "g9810ca9e90847ed818258672eb84ba159fa60ea2",
+  "node": "g89cfd10b4b3ddbc5a57cc8c2c174af3419272c8b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-18"

{gridstate-2.7.0 → gridstate-2.8.0}/tests/test_data/golden/case118.json

@@ -4,11 +4,11 @@
   "scalars": {
    "success": true,
    "iterations": 3,
-   "objective_value": 845.3285893926766,
+   "objective_value": 845.3285898461884,
    "algorithm": "wls",
    "convergence_status": "converged",
    "chi2": {
-    "value": 845.3285893926765,
+    "value": 845.3285898461886,
     "dof": 863,
     "threshold": 932.4536984554023,
     "passes": true
@@ -267,9 +267,9 @@
      "algorithm": "wls",
      "success": true,
      "iterations": 3,
-     "objective_value": 845.3285893926766,
+     "objective_value": 845.3285898461884,
      "solve_status": "kkt",
-     "objective_wls": 845.3285893926765
+     "objective_wls": 845.3285898461886
     }
    },
    {
@@ -323,11 +323,11 @@
   "scalars": {
    "success": true,
    "iterations": 9,
-   "objective_value": 395.29708505775994,
+   "objective_value": 395.297085057761,
    "algorithm": "ipm",
    "convergence_status": "kkt",
    "chi2": {
-    "value": 789.2957682480255,
+    "value": 789.2957682480284,
     "dof": 863,
     "threshold": 932.4536984554023,
     "passes": true
@@ -587,9 +587,9 @@
      "algorithm": "ipm",
      "success": true,
      "iterations": 9,
-     "objective_value": 300.2204080576151,
+     "objective_value": 300.22040484190455,
      "solve_status": "mu_schedule_done",
-     "objective_wls": 601.3973592538798
+     "objective_wls": 601.3973601055147
     }
    },
    {
@@ -652,7 +652,7 @@
      "success": true,
      "iterations": 9,
      "solve_status": "kkt",
-     "objective_wls": 789.2957682480255
+     "objective_wls": 789.2957682480284
     }
    },
    {
@@ -676,11 +676,11 @@
   "scalars": {
    "success": true,
    "iterations": 9,
-   "objective_value": 395.29708505775994,
+   "objective_value": 395.297085057761,
    "algorithm": "ipm",
    "convergence_status": "kkt",
    "chi2": {
-    "value": 789.2957682480255,
+    "value": 789.2957682480284,
     "dof": 863,
     "threshold": 932.4536984554023,
     "passes": true
@@ -940,9 +940,9 @@
      "algorithm": "ipm",
      "success": true,
      "iterations": 9,
-     "objective_value": 300.2204080576151,
+     "objective_value": 300.22040484190455,
      "solve_status": "mu_schedule_done",
-     "objective_wls": 601.3973592538798
+     "objective_wls": 601.3973601055147
     }
    },
    {
@@ -970,7 +970,7 @@
      "success": true,
      "iterations": 9,
      "solve_status": "kkt",
-     "objective_wls": 789.2957682480255
+     "objective_wls": 789.2957682480284
     }
    },
    {
@@ -1022,11 +1022,11 @@
   "scalars": {
    "success": true,
    "iterations": 9,
-   "objective_value": 395.29708505775994,
+   "objective_value": 395.297085057761,
    "algorithm": "ipm",
    "convergence_status": "kkt",
    "chi2": {
-    "value": 789.2957682480255,
+    "value": 789.2957682480284,
     "dof": 863,
     "threshold": 932.4536984554023,
     "passes": true
@@ -1286,9 +1286,9 @@
      "algorithm": "ipm",
      "success": true,
      "iterations": 9,
-     "objective_value": 300.2204080576151,
+     "objective_value": 300.22040484190455,
      "solve_status": "mu_schedule_done",
-     "objective_wls": 601.3973592538798
+     "objective_wls": 601.3973601055147
     }
    },
    {
@@ -1351,7 +1351,7 @@
      "success": true,
      "iterations": 9,
      "solve_status": "kkt",
-     "objective_wls": 789.2957682480255
+     "objective_wls": 789.2957682480284
     }
    },
    {
@@ -1385,11 +1385,11 @@
   "scalars": {
    "success": true,
    "iterations": 9,
-   "objective_value": 395.29708505775994,
+   "objective_value": 395.297085057761,
    "algorithm": "ipm",
    "convergence_status": "kkt",
    "chi2": {
-    "value": 789.2957682480255,
+    "value": 789.2957682480284,
     "dof": 863,
     "threshold": 932.4536984554023,
     "passes": true
@@ -1649,9 +1649,9 @@
      "algorithm": "ipm",
      "success": true,
      "iterations": 9,
-     "objective_value": 300.2204080576151,
+     "objective_value": 300.22040484190455,
      "solve_status": "mu_schedule_done",
-     "objective_wls": 601.3973592538798
+     "objective_wls": 601.3973601055147
     }
    },
    {
@@ -1714,7 +1714,7 @@
      "success": true,
      "iterations": 9,
      "solve_status": "kkt",
-     "objective_wls": 789.2957682480255
+     "objective_wls": 789.2957682480284
     }
    },
    {
@@ -1747,11 +1747,11 @@
   "scalars": {
    "success": true,
    "iterations": 9,
-   "objective_value": 395.2970850577641,
+   "objective_value": 395.29708505776426,
    "algorithm": "ipm",
    "convergence_status": "kkt",
    "chi2": {
-    "value": 789.2957682440815,
+    "value": 789.2957682440822,
     "dof": 863,
     "threshold": 932.4536984554023,
     "passes": true
@@ -2015,9 +2015,9 @@
      "algorithm": "ipm",
      "success": true,
      "iterations": 9,
-     "objective_value": 301.3328623053176,
+     "objective_value": 301.3328623053196,
      "solve_status": "kkt",
-     "objective_wls": 601.3742571933722
+     "objective_wls": 601.3742571933731
     }
    },
    {
@@ -2080,7 +2080,7 @@
      "success": true,
      "iterations": 9,
      "solve_status": "kkt",
-     "objective_wls": 789.2957682440815
+     "objective_wls": 789.2957682440822
     }
    },
    {