gridstate 2.8.0__tar.gz → 2.9.0__tar.gz

{gridstate-2.8.0 → gridstate-2.9.0}/.gitignore

@@ -100,3 +100,6 @@ tests/test_data/**/*.log
 
 # Local-only specs / extracted material
 .specs/
+
+# Library: no lock file in the repository
+uv.lock

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

@@ -9,6 +9,30 @@ 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.9.0 (2026-10-18)
+
+### Feat
+
+- `pseudo_voltage_scope` (`add_pseudo_measurements(voltage_scope=...)`): the
+  nodes whose pseudo-V prior keeps its σ. `"all"` (default) keeps the current
+  behavior. `"generation"` keeps it only at the slack and the nodes with
+  generation (`exist_gen` or an active generator); elsewhere the prior variance
+  is multiplied by `v_out_of_scope_loose_factor` (default 1e4, σ × 100) and the
+  prior stays for observability only. A prior at the nominal V on a load node
+  without a V measurement pulls its estimate down, and the solver makes up the
+  difference with the load Q. `"none"` loosens every pseudo-V prior, the slack
+  and the generation nodes included: V is then held by the network, the
+  measurements and the voltage limits (meant for `ipm` / `ipm_pd`). The step
+  reports `v_priors_loose` in both modes.
+
+### Fix
+
+- The UI manifest showed the IPM settings (balance modes, balance weights and
+  the BUS-equivalent prior) only for `algorithm="ipm"`, although `ipm_pd` uses
+  them too. Their `depends` is now `{"algorithm": ["ipm", "ipm_pd"]}`: a list
+  value in `depends` means "one of". `ipm_trust_region_scope` acts in the
+  primal solver only and keeps `{"algorithm": "ipm"}`.
+
 ## v2.8.0 (2026-10-18)
 
 ### Behavior changes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridstate
-Version: 2.8.0
+Version: 2.9.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.8.0 → gridstate-2.9.0}/gridstate/_version.py

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

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

@@ -10,7 +10,9 @@ the UI manifest (:func:`gridstate.pipeline.manifest`):
 * ``help``: hint text;
 * ``control``: UI control hint (``"switch"`` / ``"number"`` / ``"select"``);
 * ``min`` / ``max``: bounds (numbers); ``choices``: allowed values (select);
-* ``depends``: show only when another field equals a value (e.g. ``algorithm=ipm``).
+* ``depends``: show only when every named field matches: a scalar value means
+  equality, a list means one of its values (e.g. ``algorithm`` in
+  ``["ipm", "ipm_pd"]``).
 
 ``choices`` / ``min`` / ``max`` are enforced: :meth:`PipelineConfig.validate`
 runs on construction and at the start of a run.
@@ -79,6 +81,8 @@ _G_MODE = "Режим (нагрузка/генерация)"
 _G_CASCADE = "Каскад и статусы"
 _G_PSEUDO = "Псевдо-измерения"
 _G_EST = "Оценка состояния"
+# Algorithms that read the IPM settings (``depends`` of the IPM group).
+_IPM_SOLVERS = ["ipm", "ipm_pd"]
 _G_IPM = "IPM"
 _G_POST = "Пост-обработка"
 
@@ -313,6 +317,24 @@ class PipelineConfig:
             "measurements."
         ),
     )
+    pseudo_voltage_scope: Literal["all", "generation", "none"] = _param(
+        "all",
+        group=_G_PSEUDO,
+        label="Узлы с псевдо-U",
+        control="select",
+        choices=["all", "generation", "none"],
+        depends={"add_pseudo": True},
+        help="Nodes without a V measurement whose pseudo-V prior keeps its σ. "
+        "all — every node (default); generation — only the slack and the nodes "
+        "with generation (exist_gen or an active generator), which can hold their "
+        "voltage. Elsewhere the prior is loosened (σ × 100) and stays for "
+        "observability only: a prior at the nominal V on a load node pulls its "
+        "estimate down and the solver makes up the difference with the load Q. "
+        "none — every pseudo-V prior is loosened, the slack and the generation "
+        "nodes included: V is held by the network, the measurements and the "
+        "voltage limits. Meant for ipm/ipm_pd (their barrier keeps V within the "
+        "limits); with WLS V of an unmeasured area rests on the loosened prior.",
+    )
     unobservable_v_sigma_frac: float = _param(
         0.02,
         group=_G_PSEUDO,
@@ -502,7 +524,7 @@ class PipelineConfig:
         control="number",
         min=1e-4,
         max=1e6,
-        depends={"algorithm": "ipm"},
+        depends={"algorithm": _IPM_SOLVERS},
         help="Меньше → balance мягче. default 0.1. Soft balance only (ipm_balance_mode=soft).",
     )
     ipm_balance_mode: str = _param(
@@ -511,7 +533,7 @@ class PipelineConfig:
         label="Balance mode",
         control="select",
         choices=["soft", "hard"],
-        depends={"algorithm": "ipm"},
+        depends={"algorithm": _IPM_SOLVERS},
         help="soft — the nodal P/Q balance is a weighted pseudo-measurement "
         "(ipm_balance_weight_factor); hard — an equality constraint enforced with "
         "Lagrange multipliers (ipm: method of multipliers; ipm_pd: regularised KKT) "
@@ -603,7 +625,7 @@ class PipelineConfig:
         control="number",
         min=0.0,
         max=1e6,
-        depends={"algorithm": "ipm"},
+        depends={"algorithm": _IPM_SOLVERS},
         help="Nodes whose injection range is fully set by their generation/load boxes get a "
         "balance row with variance median(σ²_data) / factor. The box carries the node's "
         "freedom; a loose balance only hides data conflicts as an imbalance. 0 — off.",
@@ -615,7 +637,7 @@ class PipelineConfig:
         control="number",
         min=0.0,
         max=1e6,
-        depends={"algorithm": "ipm"},
+        depends={"algorithm": _IPM_SOLVERS},
         help="Transit nodes (no exist_gen/exist_load) get a balance row with variance "
         "median(σ²_data) / factor. Their injection is known to be zero; a loose balance "
         "turns data conflicts into a fictitious injection. 0 — off.",
@@ -626,7 +648,7 @@ class PipelineConfig:
         label="Balance mode of transit nodes",
         control="select",
         choices=["soft", "hard"],
-        depends={"algorithm": "ipm"},
+        depends={"algorithm": _IPM_SOLVERS},
         help="soft — the balance of a transit node (no exist_gen/exist_load) is a "
         "weighted row like the others (ipm_transit_balance_weight_factor); hard — an "
         "equality constraint to ipm_transit_balance_tol_p_mw / _q_mvar, the other "
@@ -659,7 +681,7 @@ class PipelineConfig:
         control="number",
         min=0.0,
         max=10.0,
-        depends={"algorithm": "ipm"},
+        depends={"algorithm": _IPM_SOLVERS},
         help="default 0.01 p.u.².",
     )
     ipm_trust_region_scope: str = _param(
@@ -669,7 +691,8 @@ class PipelineConfig:
         control="select",
         choices=["all", "state"],
         depends={"algorithm": "ipm"},
-        help="Coordinates whose Newton step is bounded by the trust region (0.5 p.u.). "
+        help="Primal ipm only (with ipm_pd: its fallback solve). "
+        "Coordinates whose Newton step is bounded by the trust region (0.5 p.u.). "
         "all — the whole state vector, generation/load box variables included "
         "(the previous default); state (default) — V and δ only: a box variable "
         "that has to move far no longer shrinks the V/δ step (boxes stay protected "

{gridstate-2.8.0 → gridstate-2.9.0}/gridstate/pipeline/manifest.py

@@ -26,6 +26,11 @@ def manifest(config: PipelineConfig | type[PipelineConfig] | None = None) -> dic
     toggle list), grouped by ``group``. It takes the defaults from here instead
     of hard-coding them.
 
+    ``depends`` maps field names to the values under which the control is shown;
+    every entry must match. A scalar value matches by equality, a list matches
+    any of its values: ``{"algorithm": ["ipm", "ipm_pd"]}`` shows the control
+    for both IPM solvers.
+
     ``config`` selects the source of defaults and of the iterated fields:
 
     * ``None`` (default) -- ``PipelineConfig()``, the library defaults;

{gridstate-2.8.0 → gridstate-2.9.0}/gridstate/pipeline/preparation.py

@@ -236,6 +236,7 @@ def _s_add_pseudo(ctx: _Ctx) -> dict:
             unmeasured_gen_p_nodes=ctx.released_injections.get("P", frozenset()),
             unmeasured_gen_q_nodes=ctx.released_injections.get("Q", frozenset()),
             loosen_unknown_load=ctx.cfg.loosen_unknown_load_pseudo,
+            voltage_scope=ctx.cfg.pseudo_voltage_scope,
         )
         or {}
     )

{gridstate-2.8.0 → gridstate-2.9.0}/gridstate/preprocessing/pseudo_measurements.py

@@ -5,7 +5,10 @@ unobservable, so the gain matrix becomes singular. To avoid this, for every
 active node without a `V/P_inj/Q_inj` measurement we add a weak prior:
 
 * `V ≈ V_nominal` (either `V_magnitude` from the loaded model, or `vzd`
-  for a PV node) with σ=10% of Vnom (slack 0.1%, PV 5%).
+  for a PV node) with σ=10% of Vnom (slack 0.1%, PV 5%). With
+  ``voltage_scope="generation"`` the V prior of a node that cannot hold its
+  voltage (no generation, not the slack) is loosened to an observability prior;
+  with ``voltage_scope="none"`` every V prior is.
 * `P_inj = pg - pn`, `Q_inj = qg - qn` from the node table (for transit
   nodes this gives 0). σ depends on the node type and empty-model detection.
 """
@@ -13,7 +16,7 @@ active node without a `V/P_inj/Q_inj` measurement we add a weak prior:
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 
@@ -70,6 +73,11 @@ class PseudoMeasConfig:
     # Loosen the P/Q injection prior of a node with load but no load data (no
     # box, nothing materialized) when the injection is fixed by measurements.
     loosen_unknown_load: bool = False
+    # Nodes whose V prior keeps its σ (generation and slack nodes, or none);
+    # ``None`` = every node. Outside it the V prior variance is multiplied by
+    # ``v_out_of_scope_loose_factor``.
+    v_scope_nodes: frozenset[int] | None = None
+    v_out_of_scope_loose_factor: float = 1e4
 
 
 def _generation_range_variance(row: np.void, lo_col: str, hi_col: str, fallback: float) -> float:
@@ -216,6 +224,7 @@ def _build_pseudo_rows(
     n_zinj_added = 0
     n_unobs_v = 0
     n_unknown_load = 0
+    n_v_loose = 0
 
     new_rows: list[dict] = []
     for row in nodes_arr:
@@ -261,6 +270,11 @@ def _build_pseudo_rows(
                 # nodes (degree=1, empty-model P_inj σ=100) 10% allowed the SE
                 # to drag V down to 0.3-0.5 p.u.: the pseudo-V did not hold the anchor.
                 sigma = (0.05 * vn) ** 2
+            if config.v_scope_nodes is not None and nid not in config.v_scope_nodes:
+                # Outside the scope a prior at the nominal or input V would pull
+                # the estimate there; keep it for observability only.
+                sigma *= config.v_out_of_scope_loose_factor
+                n_v_loose += 1
             new_rows.append(
                 pseudo_node_measurement(ids.next(), nid, KIND_VOLTAGE, v_prior_value, float(sigma))
             )
@@ -335,6 +349,8 @@ def _build_pseudo_rows(
         "unobservable_v_tight": n_unobs_v,
         "unknown_load_loose": n_unknown_load,
     }
+    if config.v_scope_nodes is not None:
+        stats["v_priors_loose"] = n_v_loose
     return new_rows, stats
 
 
@@ -411,6 +427,8 @@ def add_pseudo_measurements(
     unmeasured_gen_p_nodes: frozenset[int] = frozenset(),
     unmeasured_gen_q_nodes: frozenset[int] = frozenset(),
     loosen_unknown_load: bool = False,
+    voltage_scope: Literal["all", "generation", "none"] = "all",
+    v_out_of_scope_loose_factor: float = 1e4,
 ) -> dict:
     """Augment the model with pseudo-measurements to remove under-observability.
 
@@ -480,10 +498,26 @@ def add_pseudo_measurements(
             at both ends of every incident branch) that prior's variance is
             multiplied by ``boundary_inj_loose_factor``. Typical nodes: cut ends of
             lines leaving the model and substations of neighbouring systems.
+        voltage_scope: nodes whose V prior keeps its σ. ``"all"`` (default):
+            every node. ``"generation"``: only the nodes that can hold their
+            voltage, i.e. the slack and the nodes with generation (``exist_gen``
+            or an active generator); elsewhere the V prior variance is multiplied
+            by ``v_out_of_scope_loose_factor``. A V prior at the nominal (or
+            input) V on a load node without a V measurement pulls the estimate
+            there, and the solver makes up the difference with the load Q.
+            ``"none"``: every V prior is loosened, the slack and the generation
+            nodes included; V is then held by the network, the measurements and
+            the voltage limits. Meant for ``ipm`` / ``ipm_pd``, whose barrier
+            keeps V within the limits; WLS has no such bound, and V of a node seen
+            by no measurement rests on the loosened prior alone.
+        v_out_of_scope_loose_factor: variance multiplier of the V prior outside
+            ``voltage_scope``. Default 1e4 (σ × 100) keeps the prior in the
+            system only for observability.
 
     Returns:
         ``{"v_priors_added": N, "zero_inj_added": N, "unobservable_v_tight": N,
-        "unknown_load_loose": N}`` — counters.
+        "unknown_load_loose": N}`` — counters, plus ``"v_priors_loose": N`` with
+        ``voltage_scope`` other than ``"all"``.
     """
     nodes_arr = model.nodes.to_numpy()
     meas_arr = model.measurements.to_numpy()
@@ -496,6 +530,21 @@ def add_pseudo_measurements(
     ):
         node_load_props = extract_node_load_props_from_model(model)
 
+    if voltage_scope not in ("all", "generation", "none"):
+        raise ValueError(
+            f"voltage_scope={voltage_scope!r} is not one of ['all', 'generation', 'none']"
+        )
+    v_scope_nodes: frozenset[int] | None = None
+    if voltage_scope == "generation":
+        gen = model.generators.to_numpy()
+        holds_v = nodes_arr["exist_gen"].astype(bool)
+        holds_v |= nodes_arr["node_type"] == int(NodeType.SLACK)
+        v_scope_nodes = frozenset(
+            nodes_arr["id"][holds_v].tolist() + gen["node_id"][gen["status"].astype(bool)].tolist()
+        )
+    elif voltage_scope == "none":
+        v_scope_nodes = frozenset()
+
     config = PseudoMeasConfig(
         add_zero_injections=add_zero_injections,
         slack_voltage_sigma_frac=slack_voltage_sigma_frac,
@@ -510,6 +559,8 @@ def add_pseudo_measurements(
         unmeasured_gen_p_nodes=frozenset(unmeasured_gen_p_nodes),
         unmeasured_gen_q_nodes=frozenset(unmeasured_gen_q_nodes),
         loosen_unknown_load=loosen_unknown_load,
+        v_scope_nodes=v_scope_nodes,
+        v_out_of_scope_loose_factor=v_out_of_scope_loose_factor,
     )
 
     new_rows, stats = _add_pseudo_measurements_on_arrays(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridstate
-Version: 2.8.0
+Version: 2.9.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.8.0 → gridstate-2.9.0}/gridstate.egg-info/SOURCES.txt

@@ -169,6 +169,7 @@ tests/test_post_processing.py
 tests/test_preparation_steps.py
 tests/test_prepare_network.py
 tests/test_pseudo_unknown_load.py
+tests/test_pseudo_v_scope.py
 tests/test_pseudo_v_unobservable.py
 tests/test_quality_summary_paths.py
 tests/test_reconcile_balance.py

{gridstate-2.8.0 → gridstate-2.9.0}/gridstate.egg-info/scm_file_list.json

@@ -181,6 +181,7 @@
     "tests/test_preparation_steps.py",
     "tests/test_prepare_network.py",
     "tests/test_pseudo_unknown_load.py",
+    "tests/test_pseudo_v_scope.py",
     "tests/test_pseudo_v_unobservable.py",
     "tests/test_quality_summary_paths.py",
     "tests/test_reconcile_balance.py",

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

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

{gridstate-2.8.0 → gridstate-2.9.0}/tests/test_pipeline.py

@@ -49,6 +49,30 @@ def test_manifest_params_have_required_fields():
         assert p["type"] in {"bool", "int", "float", "str"}
 
 
+def test_manifest_depends_reference_real_fields_and_values():
+    params = {p["name"]: p for p in P.manifest()["params"]}
+    for p in params.values():
+        for name, value in p.get("depends", {}).items():
+            assert name in params, f"{p['name']}: depends on unknown field {name}"
+            values = value if isinstance(value, list) else [value]
+            assert values, f"{p['name']}: empty depends list for {name}"
+            choices = params[name].get("choices")
+            if choices is not None:
+                assert set(values) <= set(choices), f"{p['name']}: {values} not in {choices}"
+
+
+def test_manifest_ipm_group_is_shown_for_ipm_pd():
+    # Primal-only: the trust region scope acts in solve_ipm (the ipm_pd fallback).
+    primal_only = {"ipm_trust_region_scope"}
+    for p in P.manifest()["params"]:
+        algo = p.get("depends", {}).get("algorithm")
+        if algo is None:
+            continue
+        values = algo if isinstance(algo, list) else [algo]
+        assert "ipm" in values, p["name"]
+        assert ("ipm_pd" in values) == (p["name"] not in primal_only), p["name"]
+
+
 def test_every_step_toggle_references_real_config_field():
     cfg_fields = {f.name for f in fields(P.PipelineConfig)}
     for step in P.STEPS:

gridstate-2.9.0/tests/test_pseudo_v_scope.py

@@ -0,0 +1,196 @@
+"""Tests of the pseudo-V scope.
+
+``add_pseudo_measurements(voltage_scope="generation")`` keeps the σ of the V
+prior only at the slack and the nodes with generation (``exist_gen`` or an
+active generator); elsewhere the prior is loosened by
+``v_out_of_scope_loose_factor``. ``"all"`` (default) leaves every prior as is.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from gridstate.constants import BranchType, NodeType
+from gridstate.pipeline import PipelineConfig, manifest
+from gridstate.pipeline import run as pipeline_run
+from gridstate.preprocessing import add_pseudo_measurements
+from gridstate.working import Working
+from gridstate.z_vector import KIND_POWER_P, KIND_VOLTAGE, OBJ_BRANCH, OBJ_NODE
+
+
+VN = 110.0
+
+
+def _build_model() -> Working:
+    """6 nodes on a chain, no V measurement except at node 6.
+
+    * 1 slack;
+    * 2 ``exist_gen``;
+    * 3 load (``exist_load``);
+    * 4 transit with an inactive generator;
+    * 5 an active generator, ``exist_gen`` unset;
+    * 6 load with a real V measurement.
+    """
+    m = Working.empty()
+    spec = [
+        (1, NodeType.SLACK, False, False),
+        (2, NodeType.PQ, True, False),
+        (3, NodeType.PQ, False, True),
+        (4, NodeType.PQ, False, False),
+        (5, NodeType.PQ, False, False),
+        (6, NodeType.PQ, False, True),
+    ]
+    for nid, ntype, gen, load in spec:
+        m.nodes.add(
+            {
+                "id": nid,
+                "voltage_nominal": VN,
+                "voltage_magnitude": VN,
+                "voltage_angle": 0.0,
+                "status": True,
+                "node_type": int(ntype),
+                "exist_gen": gen,
+                "exist_load": load,
+                "generation_p": 20.0 if gen else 0.0,
+                "load_p": 10.0 if load else 0.0,
+                "load_q": 3.0 if load else 0.0,
+            }
+        )
+    for bid, (fr, to) in enumerate(((1, 2), (2, 3), (3, 4), (4, 5), (5, 6)), start=100):
+        m.branches.add(
+            {
+                "id": bid,
+                "from_node": fr,
+                "to_node": to,
+                "resistance": 2.0,
+                "reactance": 10.0,
+                "tap_ratio": 1.0,
+                "status": True,
+                "branch_type": int(BranchType.LINE),
+            }
+        )
+    for gid, nid, on in ((40, 4, False), (50, 5, True)):
+        m.generators.add(
+            {
+                "id": gid,
+                "node_id": nid,
+                "power_output": 5.0,
+                "reactive_output": 0.0,
+                "status": on,
+            }
+        )
+    next_id = 1
+    for bid in range(100, 105):
+        m.measurements.add(
+            {
+                "id": next_id,
+                "object_type": OBJ_BRANCH,
+                "object_id": bid,
+                "measurement_type": KIND_POWER_P,
+                "value": 5.0,
+                "variance": 1.0,
+                "status": True,
+                "is_pseudo": False,
+            }
+        )
+        next_id += 1
+    m.measurements.add(
+        {
+            "id": next_id,
+            "object_type": OBJ_NODE,
+            "object_id": 6,
+            "measurement_type": KIND_VOLTAGE,
+            "value": 116.0,
+            "variance": 1.0,
+            "status": True,
+            "is_pseudo": False,
+        }
+    )
+    return m
+
+
+def _pseudo_v_sigma_frac(model: Working) -> dict[int, float]:
+    """``node id → σ / Vnom`` of its pseudo-V prior."""
+    m = model.measurements.to_numpy()
+    sel = m["is_pseudo"].astype(bool) & (m["object_type"] == OBJ_NODE)
+    sel &= m["measurement_type"] == KIND_VOLTAGE
+    return {
+        int(nid): float(np.sqrt(var)) / VN
+        for nid, var in zip(m["object_id"][sel], m["variance"][sel], strict=True)
+    }
+
+
+def test_all_is_the_default():
+    a, b = _build_model(), _build_model()
+    stats_default = add_pseudo_measurements(a)
+    stats_all = add_pseudo_measurements(b, voltage_scope="all")
+    assert stats_all == stats_default
+    assert "v_priors_loose" not in stats_all
+    ma, mb = a.measurements.to_numpy(), b.measurements.to_numpy()
+    assert ma.tobytes() == mb.tobytes()
+
+
+def test_generation_loosens_the_nodes_without_generation():
+    m = _build_model()
+    stats = add_pseudo_measurements(m, voltage_scope="generation")
+    sigma = _pseudo_v_sigma_frac(m)
+    assert sigma[1] == pytest.approx(0.001)  # slack
+    assert sigma[2] == pytest.approx(0.05)  # exist_gen
+    assert sigma[5] == pytest.approx(0.05)  # active generator
+    assert sigma[3] == pytest.approx(5.0)  # load: σ × 100
+    assert sigma[4] == pytest.approx(5.0)  # transit, its generator is off
+    assert 6 not in sigma  # real V measurement
+    assert stats["v_priors_loose"] == 2
+
+
+def test_generation_loose_factor():
+    m = _build_model()
+    add_pseudo_measurements(m, voltage_scope="generation", v_out_of_scope_loose_factor=4.0)
+    sigma = _pseudo_v_sigma_frac(m)
+    assert sigma[3] == pytest.approx(0.1)
+    assert sigma[2] == pytest.approx(0.05)
+
+
+def test_none_loosens_every_v_prior():
+    m = _build_model()
+    stats = add_pseudo_measurements(m, voltage_scope="none")
+    sigma = _pseudo_v_sigma_frac(m)
+    assert sigma[1] == pytest.approx(0.1)  # slack: 0.001 × 100
+    for nid in (2, 3, 4, 5):
+        assert sigma[nid] == pytest.approx(5.0)
+    assert 6 not in sigma
+    assert stats["v_priors_loose"] == 5
+
+
+def test_unknown_scope_raises():
+    with pytest.raises(ValueError, match="voltage_scope"):
+        add_pseudo_measurements(_build_model(), voltage_scope="load")  # type: ignore[arg-type]
+
+
+def test_pipeline_field_and_manifest():
+    assert PipelineConfig().pseudo_voltage_scope == "all"
+    with pytest.raises(ValueError):
+        PipelineConfig(pseudo_voltage_scope="load")  # type: ignore[arg-type]
+    entry = next(p for p in manifest()["params"] if p["name"] == "pseudo_voltage_scope")
+    assert entry["choices"] == ["all", "generation", "none"]
+    assert entry["depends"] == {"add_pseudo": True}
+
+
+def test_pipeline_runs_with_generation_scope():
+    model = _build_model()
+    base = pipeline_run(model, config=PipelineConfig())
+    same = pipeline_run(model, config=PipelineConfig(pseudo_voltage_scope="all"))
+    assert np.array_equal(base.v_pu, same.v_pu, equal_nan=True)
+    gen = pipeline_run(model, config=PipelineConfig(pseudo_voltage_scope="generation"))
+    assert gen.success
+    assert np.all(np.isfinite(gen.v_pu))
+
+
+def test_ipm_pd_converges_without_v_priors():
+    out = pipeline_run(
+        _build_model(), config=PipelineConfig(algorithm="ipm_pd", pseudo_voltage_scope="none")
+    )
+    assert out.success
+    assert np.all(np.isfinite(out.v_pu))
+    assert np.all((out.v_pu > 0.7) & (out.v_pu < 1.5))