FLToptim 0.2.0__tar.gz → 0.3.0__tar.gz

{fltoptim-0.2.0 → fltoptim-0.3.0}/FLToptim/__init__.py

@@ -42,4 +42,4 @@ __all__ = [
     "pmax",
 ]
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

{fltoptim-0.2.0 → fltoptim-0.3.0}/FLToptim/csimplex/param_simplex.cpp

@@ -210,6 +210,8 @@ int reopt_and_trace(const double* A, const double* c, const double* lb, const do
     return np;
 }
 
+}  // extern "C" (reopened after the internal core below)
+
 // Voie 2 BATCHED: trace ALL T hourly injection curves for one node in a single call, carrying the
 // basis internally across hours (one HiGHS seed done by the caller). Per hour: update gen caps, dual
 // re-optimise at y=0, trace [lo,0] downward, merge to a Pycplfunction-ready (slopes, breaks) with
@@ -217,12 +219,29 @@ int reopt_and_trace(const double* A, const double* c, const double* lb, const do
 // and ubgen_all[T*G]. Outputs flat: nseg_out[T], phi0_out[T], and slopes_flat/breaks_flat concatenated
 // (offsets = prefix sums of nseg_out). Returns total #segments (>=T), or <0 on error.
 //
-// Efficiency kink (batteries): eff==1 traces the reservoir curve in the storage-control coordinate
-// directly (shift==0). For eff<1 the caller shifts the node base up by `shift` (= max charge power) and
-// widens `lo` to cover the full charge+discharge span, so the single downward trace spans injection
-// contributions u = theta+shift in [-eff*Pdis, +Pcha]; each segment is then reparametrised to the DP
-// control x by the kink map (x=u on charge u>=0, x=u/eff on discharge u<0; slope *= eff on discharge),
-// splitting the segment that straddles u=0. Values are preserved, so phi0 (firstBreakVal) is unchanged.
+// DIRECTION generalisation (batch_core): the RHS is parametrised along an arbitrary direction vector,
+//     b(theta) = b0 + theta * dvec,        phi'(theta) = y . dvec,
+// which the multi-resource engine needs: an H2 storage shifts SEVERAL balance rows in fixed proportion
+// (its own H2 balance by cin/fout, the elec balance by the parasitic charge draw), so its injection-cost
+// curve is the LP objective along a direction, not along one row. The classic single-node trace is the
+// special case dvec = e_node: the direction terms are then bit-identical to the old expressions
+// (th*1.0 == th at the same position in the rhs sum; Binv . e_node == the Binv column; y . e_node ==
+// y[node]), so batch_curves keeps its exact historical output. dvec is used through its nonzero index
+// list (<= 3 entries in practice), so the per-pivot cost is unchanged. NOTE: with conversion columns
+// (coefficients like -1.53) the balance matrix is no longer totally unimodular, so B^-1 is no longer
+// exact-integer -- the rank-1 updates now genuinely accumulate roundoff; the periodic refactor
+// (REFAC=32) and the small-pivot guard in updinv are what keep the trace at ~1e-12 relative accuracy.
+//
+// Efficiency kink (batteries; single-node path only): eff==1 traces the reservoir curve in the
+// storage-control coordinate directly (shift==0). For eff<1 the caller shifts the node base up by
+// `shift` (= max charge power) and widens `lo` to cover the full charge+discharge span, so the single
+// downward trace spans injection contributions u = theta+shift in [-eff*Pdis, +Pcha]; each segment is
+// then reparametrised to the DP control x by the kink map (x=u on charge u>=0, x=u/eff on discharge
+// u<0; slope *= eff on discharge), splitting the segment that straddles u=0. Values are preserved, so
+// phi0 (firstBreakVal) is unchanged. The multi-resource kink changes the DIRECTION itself (parasitic
+// draw on charge only), which no shift can express -- the caller runs TWO half-traces (discharge along
+// d_dis over [lo,0]; charge along -d_cha over [-hi,0], reflected) and stitches them at x=0.
+//
 // nthreads>1 splits [0,T) into contiguous hour-chunks traced concurrently, each re-seeded from the same
 // shared basis `status_io` (the carried basis is only a warmstart -- every hour re-optimises to its own
 // exact optimum -- so chunking is exactness-preserving: nthreads=1 is bit-identical to the serial trace,
@@ -230,12 +249,15 @@ int reopt_and_trace(const double* A, const double* c, const double* lb, const do
 // the seed) is shared; each thread carries its own working simplex state and appends to local buffers that
 // are concatenated in hour order afterwards. status_io writeback is vestigial (the caller re-seeds from
 // HiGHS every node-sweep), so returning the last chunk's basis is fine.
-int batch_curves(const double* A, const double* c, const double* lb, const double* ub_base,
-                 const double* b0_all, const double* ubgen_all, int m, int nx, int G, int T,
-                 int* status_io, int node, double lo, double eff, double shift,
-                 double* slopes_flat, double* breaks_flat, double* phi0_out, int* nseg_out,
-                 int max_total, int* out_total_pivots, int nthreads) {
+static int batch_core(const double* A, const double* c, const double* lb, const double* ub_base,
+                      const double* b0_all, const double* ubgen_all, int m, int nx, int G, int T,
+                      int* status_io, const double* dvec, double lo, double eff, double shift,
+                      double* slopes_flat, double* breaks_flat, double* phi0_out, int* nseg_out,
+                      int max_total, int* out_total_pivots, int nthreads) {
     const double tol = 1e-7;
+    vector<int> dnz;                                           // nonzero direction entries (<= 3 in practice)
+    for (int k = 0; k < m; ++k) if (dvec[k] != 0.0) dnz.push_back(k);
+    if (dnz.empty()) return -7;                                // a zero direction traces nothing
     { int nb = 0; for (int j = 0; j < nx; ++j) if (status_io[j] == 0) ++nb; if (nb != m) return -2; }
     // Sparse structure of A (constant across hours/pivots -- read-only, shared across threads). A column
     // has <=2 nonzeros (a gen/shed/curt hits 1 node, a line 2), a row a handful -> pivot-row entries &
@@ -270,7 +292,7 @@ int batch_curves(const double* A, const double* c, const double* lb, const doubl
             return inv_mat(Bmat.data(), Binv.data(), m);
         };
         auto cxB = [&](double th) {                            // rhs via CSR (O(nnz)), then dense back-sub O(m^2)
-            for (int k = 0; k < m; ++k) { double r = b0[k] + (k == node ? th : 0.0);
+            for (int k = 0; k < m; ++k) { double r = b0[k] + (dvec[k] != 0.0 ? th * dvec[k] : 0.0);
                 for (int p = csr_ptr[k]; p < csr_ptr[k + 1]; ++p) { int j = csr_col[p]; if (status[j] != 0) r -= csr_val[p] * val(j); }
                 rhs[k] = r; }
             for (int i = 0; i < m; ++i) { double s = 0; for (int k = 0; k < m; ++k) s += Binv[i * m + k] * rhs[k]; xB[i] = s; }
@@ -331,8 +353,14 @@ int batch_curves(const double* A, const double* c, const double* lb, const doubl
             vth.clear(); vph.clear(); vth.push_back(0.0); vph.push_back(phi);
             double theta = 0.0; guard = 0;
             while (theta > lo + tol && guard++ < 800) {
-                cy(); double slope = y[node];
-                for (int i = 0; i < m; ++i) d[i] = -Binv[i * m + node];
+                cy();
+                double slope = 0.0;                            // phi'(theta) = y . dvec (over the nonzeros)
+                for (int q : dnz) slope += y[q] * dvec[q];
+                for (int i = 0; i < m; ++i) {                  // march direction d = -Binv . dvec
+                    double s = 0.0;
+                    for (int q : dnz) s += Binv[i * m + q] * dvec[q];
+                    d[i] = -s;
+                }
                 double best = theta - lo; int leave = -1, hu = 0;
                 for (int i = 0; i < m; ++i) {
                     if (d[i] > tol && ub[basis[i]] < BIG) { double r = (ub[basis[i]] - xB[i]) / d[i]; if (r < best - tol) { best = r; leave = i; hu = 1; } }
@@ -422,4 +450,33 @@ int batch_curves(const double* A, const double* c, const double* lb, const doubl
     return off;
 }
 
+extern "C" {
+
+// Classic single-node batched trace: dvec = e_node (bit-identical to the historical implementation --
+// see the direction note above batch_core). Keeps the efficiency-kink (eff, shift) reparametrisation.
+int batch_curves(const double* A, const double* c, const double* lb, const double* ub_base,
+                 const double* b0_all, const double* ubgen_all, int m, int nx, int G, int T,
+                 int* status_io, int node, double lo, double eff, double shift,
+                 double* slopes_flat, double* breaks_flat, double* phi0_out, int* nseg_out,
+                 int max_total, int* out_total_pivots, int nthreads) {
+    vector<double> dvec(m, 0.0);
+    if (node < 0 || node >= m) return -8;
+    dvec[node] = 1.0;
+    return batch_core(A, c, lb, ub_base, b0_all, ubgen_all, m, nx, G, T, status_io,
+                      dvec.data(), lo, eff, shift, slopes_flat, breaks_flat, phi0_out, nseg_out,
+                      max_total, out_total_pivots, nthreads);
+}
+
+// DIRECTION batched trace (multi-resource): b(theta) = b0 + theta * dvec over theta in [lo, 0], slope
+// = y . dvec. No kink reparametrisation here -- the caller composes charge/discharge half-traces.
+int batch_curves_dir(const double* A, const double* c, const double* lb, const double* ub_base,
+                     const double* b0_all, const double* ubdyn_all, int m, int nx, int G, int T,
+                     int* status_io, const double* dvec, double lo,
+                     double* slopes_flat, double* breaks_flat, double* phi0_out, int* nseg_out,
+                     int max_total, int* out_total_pivots, int nthreads) {
+    return batch_core(A, c, lb, ub_base, b0_all, ubdyn_all, m, nx, G, T, status_io,
+                      dvec, lo, 1.0, 0.0, slopes_flat, breaks_flat, phi0_out, nseg_out,
+                      max_total, out_total_pivots, nthreads);
+}
+
 }  // extern "C"

fltoptim-0.3.0/FLToptim/mr_decompose.py

@@ -0,0 +1,307 @@
+"""Multi-resource (elec + H2) spatial-LP <-> storage-DP decomposition -- the M2 generalisation of the
+elec-only `elec.decompose`.
+
+A "node" is an (area, resource) pair; a column may touch two balances (a conversion consumes one resource
+and produces another); there are two transport layers. A storage's control x_s = its state-of-charge
+increment (pin - pout); the grid LOAD it adds is
+    Ladd_s(x)[k] = cch_k * x   (x >= 0, charging draws the grid)
+                 = cdis_k * x   (x <  0, discharging supplies the grid)
+at each node k it touches, with (cch, cdis) per node:
+  * elec reservoir at node n : [(n, 1, 1)]                        (lossless, no pumping)
+  * H2 storage               : [(h2, cin, fout), (elec, paras, 0)]   (charge consumes cin MWh_H2 +
+                                                                       paras MWh_elec; discharge gives fout)
+So an H2 storage shifts TWO balance RHS entries in fixed proportion -- which the sampling curve build
+handles directly (set both entries, solve). This is the correctness-first engine; a parametric-simplex
+speed lever (a direction trace through the coupled LP) is the later analogue of `csimplex` for elec.
+
+`MrSpatial` is the persistent hourly coupled LP (cost_of); `decompose_mr` runs the damped Gauss-Seidel /
+Jacobi sweeps and returns (best x[S,T], history). Validate against `mr.solve_mr_monolith`.
+"""
+import time
+
+import numpy as np
+
+from . import Pycplfunctionvec
+from .elec import _curve_cost_sum, _prof, _safe_pycpl, _soc_clamp
+
+try:
+    import highspy
+except Exception:                                              # pragma: no cover
+    highspy = None
+
+
+class MrSpatial:
+    """Persistent HiGHS hourly coupled elec+H2 network LP. Columns: p[C] (gens / conversions / imports),
+    shed[M], curtail[M] (elec only -- H2 spill forbidden), flow_e[Le], flow_h[Lh]. Rows: balance[M].
+    Storage enters only as a per-node net-load shift: RHS[m] = demand[m] + sum_s Ladd_s(x_s)[m]."""
+
+    def __init__(self, case):
+        self.M = M = len(case["nodes"]); self.T = case["T"]
+        cols = list(case["cols"]); self.C = C = len(cols)
+        self.voll = float(case["voll"])
+        self.costC = np.array([c["cost"] for c in cols]) if C else np.zeros(0)
+        self.capC = (np.vstack([np.broadcast_to(np.asarray(c["cap"], float), (self.T,)) for c in cols])
+                     if C else np.zeros((0, self.T)))
+        le = list(case["lines_e"]); lh = list(case["lines_h"]); self.Le = Le = len(le); self.Lh = Lh = len(lh)
+        curt_ok = case["curt_ok"]
+        h = highspy.Highs(); h.setOptionValue("output_flag", False)
+        h.setOptionValue("presolve", "off"); h.setOptionValue("solver", "simplex")
+        nx = C + M + M + Le + Lh
+        self.op, self.osh, self.ocu, self.ofe, self.ofh = 0, C, C + M, C + 2 * M, C + 2 * M + Le
+        cost = np.concatenate([self.costC, np.full(M, self.voll), np.zeros(M), np.zeros(Le + Lh)])
+        lb = np.zeros(nx); ub = np.full(nx, highspy.kHighsInf)
+        for m in range(M):
+            if not bool(curt_ok[m]):
+                ub[self.ocu + m] = 0.0                          # H2 (and any non-curtailable) node: no spill
+        for l, (a, b, f, rv) in enumerate(le):
+            lb[self.ofe + l] = -float(rv); ub[self.ofe + l] = float(f)
+        for l, (a, b, f, rv) in enumerate(lh):
+            lb[self.ofh + l] = -float(rv); ub[self.ofh + l] = float(f)
+        h.addVars(nx, lb, ub)
+        h.changeColsCost(nx, np.arange(nx, dtype=np.int32), cost)
+        per_node = [[] for _ in range(M)]                      # (col, coeff) touching each balance
+        for ci, c in enumerate(cols):
+            for nd, cf in c["coeffs"].items():
+                per_node[int(nd)].append((ci, float(cf)))
+        for m in range(M):
+            idx = [self.op + ci for ci, _cf in per_node[m]] + [self.osh + m, self.ocu + m]
+            val = [cf for _ci, cf in per_node[m]] + [1.0, -1.0]
+            for l, (a, b, f, rv) in enumerate(le):
+                if b == m: idx.append(self.ofe + l); val.append(1.0)
+                if a == m: idx.append(self.ofe + l); val.append(-1.0)
+            for l, (a, b, f, rv) in enumerate(lh):
+                if b == m: idx.append(self.ofh + l); val.append(1.0)
+                if a == m: idx.append(self.ofh + l); val.append(-1.0)
+            h.addRow(0.0, 0.0, len(idx), np.array(idx, np.int32), np.array(val, float))
+        self.h = h
+
+    def set_hour(self, tt):
+        if self.C:
+            cols = np.arange(self.op, self.op + self.C, dtype=np.int32)
+            self.h.changeColsBounds(self.C, cols, np.zeros(self.C), self.capC[:, tt].copy())
+
+    def set_rhs(self, net):
+        for m in range(self.M):
+            self.h.changeRowBounds(m, float(net[m]), float(net[m]))
+
+    def cost_of(self, net, tt):
+        self.set_hour(tt); self.set_rhs(net); self.h.run(); return float(self.h.getObjectiveValue())
+
+
+def mr_stor_arrays(case):
+    stor = list(case["storages"]); S = len(stor); T = case["T"]
+    Pcha = np.array([s["Pcha"] for s in stor]); Pdis = np.array([s["Pdis"] for s in stor])
+    E = np.array([s["E"] for s in stor]); init = np.array([s["init"] for s in stor])
+    inflow = np.vstack([np.asarray(s["inflow"], float) for s in stor]) if S else np.zeros((0, T))
+    contrib = [_contrib(s) for s in stor]
+    return stor, S, Pcha, Pdis, E, init, inflow, contrib
+
+
+def _contrib(s):
+    """The (node, charge_coeff, discharge_coeff) grid-load contributions of one storage."""
+    c = [(int(s["node"]), float(s["cin"]), float(s["fout"]))]
+    if float(s["paras"]) > 0 and int(s["node_e"]) >= 0:
+        c.append((int(s["node_e"]), float(s["paras"]), 0.0))   # parasitic elec on charge only
+    return c
+
+
+def _ladd(cch, cdis, xv):
+    return cch * xv if xv >= 0 else cdis * xv
+
+
+def levels_from_x(case, x):
+    """Reconstruct each storage's level trajectory: init + cumsum(inflow + x)."""
+    _, S, _, _, _, init, inflow, _ = mr_stor_arrays(case)
+    return init[:, None] + np.cumsum(inflow + x, axis=1) if S else np.zeros((0, case["T"]))
+
+
+def decompose_mr(case, sweeps=20, theta=0.5, mono=None, nsamp=15, pad=1.03, prune_tol=1e-3,
+                 jacobi=False, engine="sample", curve_threads=1, slope_merge=0.0, fast_cost=True,
+                 _profile=None):
+    """Damped Gauss-Seidel (or Jacobi) between the coupled spatial LP and the per-storage DP.
+
+    engine='sample' builds each hour's injection-cost curve by nsamp warm HiGHS solves (setting every
+    balance the storage touches, reading the summed duals). engine='csimplex' traces the EXACT curve
+    with the C++ parametric simplex generalised to a RHS *direction* (batch_curves_dir): a storage's
+    control shifts several balances in fixed proportion, and the proportions DIFFER between charge and
+    discharge (parasitic elec on charge only), so per storage and sweep it runs TWO half-traces from
+    one HiGHS seed -- the discharge direction over x in [-Pdis*pad, 0], the negated charge direction
+    over theta = -x in [-Pcha*pad, 0], reflected back -- and stitches them at x=0 (the slopes must be
+    non-decreasing across the join, which convex duality guarantees up to roundoff; a genuinely
+    non-convex join falls back to the sampling build for that storage-update and is counted in
+    _profile['mr_kink_fallback']). curve_threads>1 hour-chunks each half-trace (exactness-preserving).
+
+    fast_cost (csimplex + Gauss-Seidel only): the LAST-updated storage's stitched curve IS the exact
+    system cost as a function of that storage's control with the others at their end-of-sweep values,
+    so the sweep cost is read off the curve with NO LP solves (same lever as elec.decompose; guarded
+    by curve truncation and the control leaving the traced domain, where it falls back to cost_of).
+    As in elec, skipping the T monitoring solves also stops them nudging the shared HiGHS basis, so a
+    fast_cost run can follow a DIFFERENT equal-cost degenerate best-iterate path than a cost_of run;
+    the read-off value itself is exact at the committed state (pinned by the package test).
+
+    Returns (best-cost x[S,T], history rows (sweep, cost, gap%, cumsec))."""
+    M = len(case["nodes"]); T = case["T"]; dem = case["demand"]
+    stor, S, Pcha, Pdis, E, init, inflow, contrib = mr_stor_arrays(case)
+    Acc = np.cumsum(inflow, axis=1) if S else np.zeros((0, T))
+    Clo = -init[:, None] - Acc; Chi = E[:, None] - init[:, None] - Acc
+    grids = [np.unique(np.concatenate([np.linspace(-Pdis[s] * pad, Pcha[s] * pad, nsamp), [0.0]]))
+             for s in range(S)]
+    _pmoins = [(-Pdis[s] * np.ones(T)).tolist() for s in range(S)]
+    _pplus = [(Pcha[s] * np.ones(T)).tolist() for s in range(S)]
+    _clo = [Clo[s].tolist() for s in range(S)]; _chi = [Chi[s].tolist() for s in range(S)]
+    if engine == "csimplex":
+        from .param_simplex import batch_curves_dir, build_hour_lp_mr, status_from_highs
+        _A0, _c0, _lb0, _ub0, _b00, _off = build_hour_lp_mr(case, 0)
+        _capC = np.vstack([np.broadcast_to(np.asarray(col["cap"], float), (T,)) for col in case["cols"]])
+        _ubdyn = np.ascontiguousarray(_capC.T, np.float64)     # [T, C] per-hour caps of the C columns
+        _dc = np.zeros((S, M)); _dd = np.zeros((S, M))         # per-storage charge/discharge directions
+        for s in range(S):
+            for (nd, cch, cdis) in contrib[s]:
+                _dc[s, nd] += cch; _dd[s, nd] += cdis
+    sp = MrSpatial(case); h = sp.h
+    x = np.zeros((S, T)); hist = []; t0 = time.perf_counter(); best = (np.inf, None)
+    _cc = {"ok": False}                                # last-updated storage's stitched curve (fast_cost)
+    for s in range(S):                                 # feasible baseline (see elec.decompose)
+        x[s], _ = _soc_clamp(x[s], Pdis[s], Pcha[s], Clo[s], Chi[s])
+
+    def net_col(tt, Xcol):                                     # full net load at hour tt (all storages)
+        nl = dem[:, tt].copy()
+        for s in range(S):
+            for (nd, cch, cdis) in contrib[s]:
+                nl[nd] += _ladd(cch, cdis, Xcol[s])
+        return nl
+
+    def _curves_cs(s, X, capture=False):
+        """Exact curves for storage s: two direction half-traces stitched at the x=0 kink. Returns a
+        filled Pycplfunctionvec, or raises ValueError on a (roundoff-level rare) non-convex join.
+        capture=True stores the stitched (slopes, breaks, phi0, nseg) into _cc for fast_cost."""
+        node_load = dem.copy()                                 # base: everyone except s, s at 0
+        for s2 in range(S):
+            if s2 == s:
+                continue
+            for (nd, cch, cdis) in contrib[s2]:
+                node_load[nd] = node_load[nd] + np.where(X[s2] >= 0, cch, cdis) * X[s2]
+        b0_all = np.ascontiguousarray(node_load.T, np.float64)
+        sp.set_hour(0); sp.set_rhs(b0_all[0])
+        _t = time.perf_counter(); h.run(); _prof(_profile, "seed", _t)
+        st = np.ascontiguousarray(status_from_highs(h), np.int32)
+        _t = time.perf_counter()
+        have_d = Pdis[s] > 0; have_c = Pcha[s] > 0
+        if have_d:                                             # discharge: b(x) = b0 + x*dd, x in [lo,0]
+            sl_d, br_d, p0_d, ns_d, _ = batch_curves_dir(_A0, _c0, _lb0, _ub0, b0_all, _ubdyn,
+                                                         st.copy(), _dd[s], float(-Pdis[s] * pad), T,
+                                                         nthreads=curve_threads)
+            od = np.concatenate([[0], np.cumsum(ns_d)])
+        if have_c:                                             # charge via theta=-x: b = b0 + theta*(-dc)
+            sl_c, br_c, p0_c, ns_c, _ = batch_curves_dir(_A0, _c0, _lb0, _ub0, b0_all, _ubdyn,
+                                                         st.copy(), -_dc[s], float(-Pcha[s] * pad), T,
+                                                         nthreads=curve_threads)
+            oc = np.concatenate([[0], np.cumsum(ns_c)])
+        _prof(_profile, "curve", _t)
+        _t = time.perf_counter()
+        SL = []; BR = []; P0 = np.empty(T); NS = np.empty(T, np.int32)
+        for tt in range(T):
+            if have_d:
+                sd = sl_d[od[tt]:od[tt + 1]]; bd = br_d[od[tt]:od[tt + 1]]
+            if have_c:                                         # reflect theta pieces to x (reverse+negate)
+                sc = sl_c[oc[tt]:oc[tt + 1]]; bc = br_c[oc[tt]:oc[tt + 1]]
+                ss_c = -sc[::-1]                               # ascending in x
+                xs_c = np.concatenate([[0.0], -bc[:0:-1]])     # left ends: 0, -bc[-1], ..., -bc[1]
+            if have_d and have_c:
+                if ss_c[0] < sd[-1] - 1e-6:                    # non-convex join (should not happen)
+                    raise ValueError(f"non-convex kink join at hour {tt}")
+                if ss_c[0] <= sd[-1] + 1e-9:                   # smooth join: merge the zero-jump piece
+                    ss_c = ss_c[1:]; xs_c = xs_c[1:]
+                s_all = np.concatenate([sd, ss_c]); b_all = np.concatenate([bd, xs_c])
+                p0t = p0_d[tt]
+            elif have_d:                                       # discharge-only (MR reservoir)
+                s_all, b_all, p0t = sd, bd, p0_d[tt]
+            else:                                              # charge-only: anchor at phi(0)
+                widths = np.diff(np.concatenate([bc, [0.0]]))
+                p0t = p0_c[tt] + float(sc @ widths)
+                s_all, b_all = ss_c, xs_c
+            if slope_merge > 0 and len(s_all) > 1:             # optional coarsening: merge pieces whose
+                keep = [0]; last = s_all[0]                    # slope rise is below slope_merge EUR/MWh
+                for i in range(1, len(s_all)):                 # (the sampled engine's implicit smoothing,
+                    if s_all[i] > last + slope_merge:          # here applied to EXACT anchor points)
+                        keep.append(i); last = s_all[i]
+                if len(keep) < len(s_all):
+                    s_all = s_all[keep]; b_all = b_all[keep]
+            SL.append(s_all); BR.append(b_all); P0[tt] = p0t; NS[tt] = len(s_all)
+        slf = np.ascontiguousarray(np.concatenate(SL), np.float64)
+        brf = np.ascontiguousarray(np.concatenate(BR), np.float64)
+        p0f = np.ascontiguousarray(P0, np.float64)
+        nsf = np.ascontiguousarray(NS, np.int32)
+        vec = Pycplfunctionvec()
+        vec.push_batched(slf, brf, p0f, nsf)
+        if capture:                                            # the sweep-cost curve (fast_cost)
+            trunc = ((have_d and int(ns_d.max()) >= 31) or (have_c and int(ns_c.max()) >= 31))
+            _cc.update(ok=True, s=s, sl=slf, br=brf, phi0=p0f, nseg=nsf, trunc=trunc,
+                       xlo=float(-Pdis[s] * pad), xhi=float(Pcha[s] * pad))
+        _prof(_profile, "build", _t)
+        return vec
+
+    def update(s, X):
+        vec = None
+        if engine == "csimplex":
+            try:                                               # fast_cost: capture the LAST GS update's
+                cap = fast_cost and not jacobi and s == S - 1  # curve (others then at end-of-sweep x)
+                vec = _curves_cs(s, X, capture=cap)
+            except Exception:                                  # NEVER silent: count + sample this update
+                if _profile is not None:
+                    _profile["mr_kink_fallback"] = _profile.get("mr_kink_fallback", 0) + 1
+                vec = None
+        if vec is None:
+            vec = Pycplfunctionvec(); xg = grids[s]
+            for tt in range(T):
+                nl = dem[:, tt].copy()                         # base: everyone except s
+                for s2 in range(S):
+                    if s2 == s:
+                        continue
+                    for (nd, cch, cdis) in contrib[s2]:
+                        nl[nd] += _ladd(cch, cdis, X[s2, tt])
+                phis = []; slopes = []
+                for xv in xg:
+                    nlx = nl.copy()
+                    for (nd, cch, cdis) in contrib[s]:
+                        nlx[nd] += _ladd(cch, cdis, xv)
+                    sp.set_hour(tt); sp.set_rhs(nlx); h.run()
+                    phis.append(float(h.getObjectiveValue()))
+                    rd = h.getSolution().row_dual
+                    slopes.append(sum(rd[nd] * (cch if xv >= 0 else cdis) for (nd, cch, cdis) in contrib[s]))
+                vec.push_back(_safe_pycpl(xg, np.asarray(phis), np.asarray(slopes)))
+        _t = time.perf_counter()
+        if prune_tol and prune_tol > 0:
+            xnew = np.asarray(vec.OptimMargIntPruned(_pmoins[s], _pplus[s], _clo[s], _chi[s], float(prune_tol)))
+        else:
+            xnew = np.asarray(vec.OptimMargInt(_pmoins[s], _pplus[s], _clo[s], _chi[s]))
+        _prof(_profile, "dp", _t)
+        xnew, _slack = _soc_clamp(xnew, Pdis[s], Pcha[s], Clo[s], Chi[s])
+        return xnew
+
+    for it in range(sweeps):
+        _cc["ok"] = False
+        if jacobi:
+            X = x.copy()
+            xns = [update(s, X) for s in range(S)]
+            for s in range(S):
+                x[s] = (1 - theta) * X[s] + theta * xns[s]
+        else:
+            for s in range(S):
+                x[s] = (1 - theta) * x[s] + theta * update(s, x)
+        _t = time.perf_counter()
+        use_curve = _cc["ok"] and not _cc.get("trunc", False)
+        if use_curve:                                          # the traced curve only covers its own
+            _xs = x[_cc["s"]]                                  # x-domain; outside it would extrapolate
+            if _xs.max() > _cc["xhi"] + 1.0 or _xs.min() < _cc["xlo"] - 1.0:
+                use_curve = False
+        if use_curve:                                          # sweep cost off the exact curve, no LP
+            c = _curve_cost_sum(_cc["sl"], _cc["br"], _cc["phi0"], _cc["nseg"], x[_cc["s"]])
+        else:
+            c = sum(sp.cost_of(net_col(tt, x[:, tt]), tt) for tt in range(T))
+        _prof(_profile, "cost", _t)
+        if c < best[0]:
+            best = (float(c), x.copy())
+        gap = 100.0 * (c - mono) / mono if mono else np.nan
+        hist.append((it, float(c), gap, time.perf_counter() - t0))
+    return best[1], hist

{fltoptim-0.2.0 → fltoptim-0.3.0}/FLToptim/param_simplex.py

@@ -27,6 +27,10 @@ _lib.batch_curves.restype = ctypes.c_int
 _lib.batch_curves.argtypes = [_dp, _dp, _dp, _dp, _dp, _dp, ctypes.c_int, ctypes.c_int, ctypes.c_int,
                               ctypes.c_int, _ip, ctypes.c_int, ctypes.c_double, ctypes.c_double,
                               ctypes.c_double, _dp, _dp, _dp, _ip, ctypes.c_int, _ip, ctypes.c_int]
+_lib.batch_curves_dir.restype = ctypes.c_int
+_lib.batch_curves_dir.argtypes = [_dp, _dp, _dp, _dp, _dp, _dp, ctypes.c_int, ctypes.c_int, ctypes.c_int,
+                                  ctypes.c_int, _ip, _dp, ctypes.c_double,
+                                  _dp, _dp, _dp, _ip, ctypes.c_int, _ip, ctypes.c_int]
 _BIG = 1e30
 
 
@@ -53,6 +57,38 @@ def build_hour_lp(case, tt):
     return A, c, lb, ub, case["demand"][:, tt].copy(), (og, os_, oc, of, G, N, L)
 
 
+def build_hour_lp_mr(case, tt):
+    """Dense hourly COUPLED multi-resource LP (mirrors mr_decompose.MrSpatial): columns p[C]
+    (gens / conversions / imports; a conversion column touches TWO balances through its `coeffs`),
+    shed[M], curt[M] (bounded to 0 where curt_ok is False -- H2 spill forbidden), flow_e[Le],
+    flow_h[Lh]; rows = the M balances. Returns A[M,nx], c, lb, ub, b0 and offsets."""
+    M = len(case["nodes"]); T = case["T"]
+    cols = list(case["cols"]); C = len(cols)
+    le = list(case["lines_e"]); lh = list(case["lines_h"]); Le, Lh = len(le), len(lh)
+    voll = float(case["voll"]); curt_ok = case["curt_ok"]
+    nx = C + M + M + Le + Lh
+    op, osh, ocu, ofe, ofh = 0, C, C + M, C + 2 * M, C + 2 * M + Le
+    c = np.zeros(nx); lb = np.zeros(nx); ub = np.full(nx, np.inf)
+    A = np.zeros((M, nx))
+    for ci, col in enumerate(cols):
+        c[op + ci] = float(col["cost"])
+        ub[op + ci] = float(np.broadcast_to(np.asarray(col["cap"], float), (T,))[tt])
+        for nd, cf in col["coeffs"].items():
+            A[int(nd), op + ci] = float(cf)
+    for m_ in range(M):
+        c[osh + m_] = voll
+        A[m_, osh + m_] = 1.0; A[m_, ocu + m_] = -1.0
+        if not bool(curt_ok[m_]):
+            ub[ocu + m_] = 0.0
+    for l, (a, b, f, rv) in enumerate(le):
+        lb[ofe + l] = -float(rv); ub[ofe + l] = float(f)
+        A[b, ofe + l] += 1.0; A[a, ofe + l] -= 1.0
+    for l, (a, b, f, rv) in enumerate(lh):
+        lb[ofh + l] = -float(rv); ub[ofh + l] = float(f)
+        A[b, ofh + l] += 1.0; A[a, ofh + l] -= 1.0
+    return A, c, lb, ub, case["demand"][:, tt].copy(), (op, osh, ocu, ofe, ofh, C, M, Le, Lh)
+
+
 def status_from_highs(h):
     """Map HiGHS col_status -> {0 basic, 1 lower, 2 upper} for the structural columns."""
     import highspy
@@ -154,3 +190,33 @@ def batch_curves(A, c, lb, ub_base, b0_all, ubgen_all, status_io, node, lo, T, m
     if tot < 0:
         raise RuntimeError(f"batch_curves error {tot}")
     return slopes[:tot], breaks[:tot], phi0, nseg, tp.value
+
+
+def batch_curves_dir(A, c, lb, ub_base, b0_all, ubdyn_all, status_io, dvec, lo, T,
+                     max_seg_per_hour=32, nthreads=1):
+    """DIRECTION trace: all T hourly curves of phi(theta) = LP objective at b(theta) = b0 + theta*dvec,
+    theta in [lo, 0], in ONE C++ call carrying the basis (curve slope = y . dvec). The multi-resource
+    engine calls this twice per storage -- discharge direction over [-Pdis*pad, 0], NEGATED charge
+    direction over [-Pcha*pad, 0] (reflected by the caller) -- and stitches at x=0. b0_all: [T,m]
+    per-hour rhs at x=0; ubdyn_all: [T,G] per-hour caps of the G leading columns. Returns
+    (slopes_flat, breaks_flat, phi0[T], nseg[T], total_reopt_pivots); slice by prefix sums of nseg.
+    nthreads>1 traces contiguous hour-chunks concurrently (exactness-preserving, as batch_curves)."""
+    m, nx = A.shape; G = ubdyn_all.shape[1]
+    A = np.ascontiguousarray(A, np.float64); c = np.ascontiguousarray(c, np.float64)
+    lb = np.ascontiguousarray(lb, np.float64)
+    ub_base = np.ascontiguousarray(np.where(np.isinf(ub_base), _BIG, ub_base), np.float64)
+    b0_all = np.ascontiguousarray(b0_all, np.float64); ubdyn_all = np.ascontiguousarray(ubdyn_all, np.float64)
+    dvec = np.ascontiguousarray(dvec, np.float64)
+    assert dvec.shape == (m,)
+    assert status_io.dtype == np.int32 and status_io.flags["C_CONTIGUOUS"]
+    max_total = T * max_seg_per_hour
+    slopes = np.zeros(max_total); breaks = np.zeros(max_total)
+    phi0 = np.zeros(T); nseg = np.zeros(T, np.int32); tp = ctypes.c_int()
+    P = lambda a: a.ctypes.data_as(_dp)
+    tot = _lib.batch_curves_dir(P(A), P(c), P(lb), P(ub_base), P(b0_all), P(ubdyn_all), m, nx, G, T,
+                                status_io.ctypes.data_as(_ip), P(dvec), float(lo),
+                                P(slopes), P(breaks), P(phi0), nseg.ctypes.data_as(_ip), max_total,
+                                ctypes.byref(tp), int(nthreads))
+    if tot < 0:
+        raise RuntimeError(f"batch_curves_dir error {tot}")
+    return slopes[:tot], breaks[:tot], phi0, nseg, tp.value

fltoptim-0.3.0/FLToptim/tests/test_mr_decompose.py

@@ -0,0 +1,190 @@
+"""Engine tests for the multi-resource (elec + H2) decomposition (FLToptim.mr_decompose), against a
+self-contained HiGHS coupled monolith (tests.cases.solve_mr_monolith).
+
+The synthetic case couples the two balances the way the real TYNDP one does: H2 demand is served by
+electrolysis (consumes 1.53 MWh elec / MWh H2), H2 nodes forbid spill, and the H2 store's charge draws
+a parasitic electricity load -- so one storage shifts TWO balance RHS entries in fixed proportion.
+The sampling engine prices that through the summed duals; the csimplex engine traces the exact curve
+along the storage's RHS DIRECTIONS (batch_curves_dir), one half-trace per side of the charge/discharge
+kink, stitched at x=0.
+"""
+import numpy as np
+import pytest
+
+pytest.importorskip("highspy")
+
+from FLToptim.mr_decompose import MrSpatial, decompose_mr, levels_from_x, mr_stor_arrays
+from FLToptim.param_simplex import batch_curves_dir, build_hour_lp_mr, status_from_highs
+from FLToptim.tests.cases import mr_case, solve_mr_monolith
+
+
+@pytest.fixture(scope="module")
+def case():
+    return mr_case(T=72)
+
+
+@pytest.fixture(scope="module")
+def mono(case):
+    return solve_mr_monolith(case)
+
+
+def test_spatial_matches_monolith_without_storage():
+    """Exactness anchor: with no storage the coupled hourly LP sums to the coupled monolith."""
+    c = mr_case(T=48)
+    c = dict(c); c["storages"] = []
+    mono0 = solve_mr_monolith(c)
+    sp = MrSpatial(c)
+    tot = sum(sp.cost_of(c["demand"][:, tt], tt) for tt in range(c["T"]))
+    assert tot == pytest.approx(mono0, rel=1e-9)
+
+
+def test_case_is_discriminating(case, mono):
+    """Anti-vacuity guard: the storages must be worth something in the coupled case (here ~13%), so a
+    broken engine cannot pass the convergence tests by leaving them idle."""
+    c0 = dict(case); c0["storages"] = []
+    m0 = solve_mr_monolith(c0)
+    assert 100.0 * (m0 - mono) / mono > 2.0
+
+
+def test_mr_decompose_matches_monolith(case, mono):
+    """Gauss-Seidel sampling decomposition converges to the coupled monolith and stays feasible."""
+    x, hist = decompose_mr(case, sweeps=12, theta=0.5, mono=mono, nsamp=11, prune_tol=1e-3)
+    gap = min(g for _, _, g, _ in hist)
+    assert gap < 0.05, f"MR decomposition gap too large: {gap:+.4f}%"
+
+    stor, S, Pcha, Pdis, E, init, inflow, contrib = mr_stor_arrays(case)
+    lev = levels_from_x(case, x)
+    for s in range(S):
+        assert x[s].max() <= Pcha[s] + 1e-6 and x[s].min() >= -Pdis[s] - 1e-6, f"storage {s} power bound"
+        assert lev[s].max() <= E[s] + 1e-6 and lev[s].min() >= -1e-6, f"storage {s} level bound"
+
+
+def test_mr_decompose_jacobi_converges(case, mono):
+    """The Jacobi variant (frozen-snapshot updates) converges under damping too."""
+    x, hist = decompose_mr(case, sweeps=14, theta=0.5, mono=mono, nsamp=11, jacobi=True)
+    gap = min(g for _, _, g, _ in hist)
+    assert gap < 0.2, f"MR Jacobi gap too large: {gap:+.4f}%"
+
+
+def _pwl_value(sl, br, p0, off, t, x):
+    """Hour t's traced PWL at x (left-end breaks, value p0 at br[0], last piece to +inf)."""
+    o0, o1 = off[t], off[t + 1]
+    s, b = sl[o0:o1], br[o0:o1]
+    v = p0[t]; prev = b[0]
+    for i in range(len(s)):
+        hi = b[i + 1] if i + 1 < len(s) else np.inf
+        top = min(max(x, prev), hi)
+        v += s[i] * (top - prev); prev = max(prev, top)
+        if x <= hi:
+            break
+    return v
+
+
+def test_mr_direction_trace_exact_vs_lp(case):
+    """The direction trace equals a direct LP solve on BOTH sides of every storage's kink, and the
+    two half-traces agree at x=0 -- including the H2 store whose charge direction couples the H2 AND
+    elec balances (the total-unimodularity-breaking case the periodic refactor guards)."""
+    sp = MrSpatial(case); h = sp.h; T = case["T"]; M = len(case["nodes"])
+    stor, S, Pcha, Pdis, E, init, inflow, contrib = mr_stor_arrays(case)
+    A0, c0, lb0, ub0, _b0, _off = build_hour_lp_mr(case, 0)
+    capC = np.vstack([np.broadcast_to(np.asarray(col["cap"], float), (T,)) for col in case["cols"]])
+    ubdyn = np.ascontiguousarray(capC.T, np.float64)
+    dem = case["demand"]; PAD = 1.03
+    rng = np.random.default_rng(0)
+    for s in range(S):
+        dc = np.zeros(M); dd = np.zeros(M)
+        for (nd, cch, cdis) in contrib[s]:
+            dc[nd] += cch; dd[nd] += cdis
+        b0_all = np.ascontiguousarray(dem.T, np.float64)       # every storage at x=0
+        sp.set_hour(0); sp.set_rhs(b0_all[0]); h.run()
+        st = np.ascontiguousarray(status_from_highs(h), np.int32)
+        tr = {}
+        if Pdis[s] > 0:
+            sl, br, p0, ns, _ = batch_curves_dir(A0, c0, lb0, ub0, b0_all, ubdyn, st.copy(), dd,
+                                                 -Pdis[s] * PAD, T)
+            tr["d"] = (sl, br, p0, np.concatenate([[0], np.cumsum(ns)]))
+        if Pcha[s] > 0:
+            sl, br, p0, ns, _ = batch_curves_dir(A0, c0, lb0, ub0, b0_all, ubdyn, st.copy(), -dc,
+                                                 -Pcha[s] * PAD, T)
+            tr["c"] = (sl, br, p0, np.concatenate([[0], np.cumsum(ns)]))
+        worst = join = 0.0
+        for t in rng.choice(T, size=12, replace=False):
+            t = int(t)
+            for _ in range(4):
+                x = (float(rng.uniform(-Pdis[s] * 0.95, Pcha[s] * 0.95)) if Pcha[s] > 0
+                     else -float(rng.uniform(0.0, Pdis[s] * 0.95)))
+                nlx = dem[:, t].copy()
+                for (nd, cch, cdis) in contrib[s]:
+                    nlx[nd] += (cch if x >= 0 else cdis) * x
+                ref = sp.cost_of(nlx, t)
+                got = (_pwl_value(*tr["d"], t, x) if x <= 0 else _pwl_value(*tr["c"], t, -x))
+                worst = max(worst, abs(got - ref) / max(abs(ref), 1.0))
+            if "d" in tr and "c" in tr:
+                join = max(join, abs(_pwl_value(*tr["d"], t, 0.0) - _pwl_value(*tr["c"], t, 0.0)))
+        assert worst < 1e-9, f"storage {s}: direction trace vs LP, worst rel err {worst:.2e}"
+        assert join < 1e-6, f"storage {s}: half-traces disagree at x=0 by {join:.2e}"
+
+
+def test_mr_decompose_csimplex_matches_monolith(case, mono):
+    """The exact-curve (direction-trace) engine converges to the coupled monolith, never falls back
+    to sampling, and stays feasible. It needs MORE damping than the sampling engine (theta~0.35 vs
+    0.5): its curves carry every true breakpoint, so the per-storage best response is sharper.
+    Tolerance note: near the floor the GS trajectory is rounding-path dependent (macOS reaches
+    +0.003%, Linux +0.07% at the same sweep count -- same class as the elec degeneracy findings), so
+    the assertion uses the cross-platform envelope; the anti-vacuity guard keeps it discriminating
+    (idle storages would sit at ~13%)."""
+    prof = {}
+    x, hist = decompose_mr(case, sweeps=24, theta=0.35, mono=mono, engine="csimplex", _profile=prof)
+    gap = min(g for _, _, g, _ in hist)
+    assert gap < 0.1, f"MR csimplex gap too large: {gap:+.4f}%"
+    assert prof.get("mr_kink_fallback", 0) == 0, "csimplex engine fell back to sampling"
+    assert prof.get("curve", 0.0) > 0.0
+
+    stor, S, Pcha, Pdis, E, init, inflow, contrib = mr_stor_arrays(case)
+    lev = levels_from_x(case, x)
+    for s in range(S):
+        assert x[s].max() <= Pcha[s] + 1e-6 and x[s].min() >= -Pdis[s] - 1e-6, f"storage {s} power bound"
+        assert lev[s].max() <= E[s] + 1e-6 and lev[s].min() >= -1e-6, f"storage {s} level bound"
+
+
+def test_mr_decompose_csimplex_jacobi_smoke(case, mono):
+    """csimplex + Jacobi (frozen snapshot) also converges under damping."""
+    x, hist = decompose_mr(case, sweeps=24, theta=0.3, mono=mono, engine="csimplex", jacobi=True)
+    gap = min(g for _, _, g, _ in hist)
+    assert gap < 0.2, f"MR csimplex Jacobi gap too large: {gap:+.4f}%"
+
+
+def test_mr_fast_cost_reads_the_true_cost(case, mono, monkeypatch):
+    """The sweep cost read off the last stitched curve (fast_cost) equals a direct LP evaluation OF
+    THE SAME COMMITTED STATE, sweep by sweep. (Comparing two runs fast_cost on/off is NOT the right
+    invariant: the LP cost loop nudges the shared HiGHS basis between sweeps, so the two runs follow
+    different equal-cost degenerate paths -- the same artifact documented for elec.) The check
+    recomputes the LP total inside the cost call, reading the engine's committed x from the caller's
+    frame (CPython)."""
+    import inspect
+
+    import FLToptim.mr_decompose as mrd
+    from FLToptim.elec import _curve_cost_sum as real_ccs
+
+    sp = MrSpatial(case)
+    stor, S, Pcha, Pdis, E, init, inflow, contrib = mr_stor_arrays(case)
+    dem = case["demand"]; T = case["T"]
+    checked = []
+
+    def spy(sl, br, phi0, nseg, xvals):
+        got = real_ccs(sl, br, phi0, nseg, xvals)
+        x = inspect.currentframe().f_back.f_locals["x"]
+        lp = 0.0
+        for t in range(T):
+            nl = dem[:, t].copy()
+            for s2 in range(S):
+                for (nd, cch, cdis) in contrib[s2]:
+                    nl[nd] += (cch if x[s2, t] >= 0 else cdis) * x[s2, t]
+            lp += sp.cost_of(nl, t)
+        assert got == pytest.approx(lp, rel=1e-9)
+        checked.append(1)
+        return got
+
+    monkeypatch.setattr(mrd, "_curve_cost_sum", spy)
+    decompose_mr(case, sweeps=4, theta=0.35, mono=mono, engine="csimplex", fast_cost=True)
+    assert len(checked) >= 3, "fast_cost curve path was not exercised"

{fltoptim-0.2.0 → fltoptim-0.3.0}/FLToptim/tests/test_param_simplex.py

@@ -20,8 +20,8 @@ import pytest
 pytest.importorskip("highspy")
 
 from FLToptim.elec import ElecSpatial, _ladd, _stor_arrays
-from FLToptim.param_simplex import (batch_curves, build_hour_lp, reopt_trace_data,
-                                    status_from_highs, trace_curve_data)
+from FLToptim.param_simplex import (batch_curves, batch_curves_dir, build_hour_lp,
+                                    reopt_trace_data, status_from_highs, trace_curve_data)
 from FLToptim.tests.cases import elec_case
 
 PAD = 1.03
@@ -170,6 +170,28 @@ def test_reopt_trace_data_carries_its_own_basis(case_res):
             assert _pwl_from_data(sl, br, phi0, float(x)) == pytest.approx(r, rel=1e-9), f"hour {tt}"
 
 
+def test_batch_curves_dir_reproduces_the_node_trace(case_res):
+    """The DIRECTION trace with dvec = e_node must reproduce the classic single-node trace
+    BIT-FOR-BIT (same segments, breaks, values): batch_curves is the dvec=e_node special case of the
+    shared core, and the elec engine's historical output is pinned to it."""
+    case = case_res
+    sp = ElecSpatial(case); h = sp.h; T = case["T"]
+    _, S, Pcha, Pdis, E, eff, init, snode, inflow = _stor_arrays(case)
+    n = snode[0]
+    A0, c0, lb0, ub0, _b0, _off = build_hour_lp(case, 0)
+    capG = np.vstack([np.asarray(g[2], float) for g in case["gens"]])
+    ubgen = np.ascontiguousarray(capG.T, np.float64)
+    b0_all = np.ascontiguousarray(case["demand"].T, np.float64)
+    sp.set_hour(0); sp.set_rhs(b0_all[0]); h.run()
+    st = np.ascontiguousarray(status_from_highs(h), np.int32)
+    lo = -Pdis[0] * PAD
+    ref = batch_curves(A0, c0, lb0, ub0, b0_all, ubgen, st.copy(), n, lo, T, eff=1.0, shift=0.0)
+    dvec = np.zeros(case["N"]); dvec[n] = 1.0
+    got = batch_curves_dir(A0, c0, lb0, ub0, b0_all, ubgen, st.copy(), dvec, lo, T)
+    for a, b, name in zip(got, ref, ("slopes", "breaks", "phi0", "nseg", "pivots")):
+        np.testing.assert_array_equal(a, b, err_msg=f"direction trace differs on {name}")
+
+
 def test_batch_curves_battery_kink_exact_vs_lp(case_bat):
     """For an efficiency storage (eff<1) the trace spans charge AND discharge through the ladd kink at
     x=0; the reparametrised curve must match direct LP solves on both sides."""

{fltoptim-0.2.0 → fltoptim-0.3.0/FLToptim.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FLToptim
-Version: 0.2.0
+Version: 0.3.0
 Summary: Fast Legendre-transform convex optimisation for energy-storage operation and spatial economic dispatch
 Author-email: Robin Girard <robin.girard@minesparis.psl.eu>
 License-Expression: MIT

{fltoptim-0.2.0/FLToptim.egg-info → fltoptim-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FLToptim
-Version: 0.2.0
+Version: 0.3.0
 Summary: Fast Legendre-transform convex optimisation for energy-storage operation and spatial economic dispatch
 Author-email: Robin Girard <robin.girard@minesparis.psl.eu>
 License-Expression: MIT

{fltoptim-0.2.0 → fltoptim-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FLToptim"
-version = "0.2.0"
+version = "0.3.0"
 description = "Fast Legendre-transform convex optimisation for energy-storage operation and spatial economic dispatch"
 readme = "README.md"
 requires-python = ">=3.9"

fltoptim-0.2.0/FLToptim/mr_decompose.py

@@ -1,183 +0,0 @@
-"""Multi-resource (elec + H2) spatial-LP <-> storage-DP decomposition -- the M2 generalisation of the
-elec-only `elec.decompose`.
-
-A "node" is an (area, resource) pair; a column may touch two balances (a conversion consumes one resource
-and produces another); there are two transport layers. A storage's control x_s = its state-of-charge
-increment (pin - pout); the grid LOAD it adds is
-    Ladd_s(x)[k] = cch_k * x   (x >= 0, charging draws the grid)
-                 = cdis_k * x   (x <  0, discharging supplies the grid)
-at each node k it touches, with (cch, cdis) per node:
-  * elec reservoir at node n : [(n, 1, 1)]                        (lossless, no pumping)
-  * H2 storage               : [(h2, cin, fout), (elec, paras, 0)]   (charge consumes cin MWh_H2 +
-                                                                       paras MWh_elec; discharge gives fout)
-So an H2 storage shifts TWO balance RHS entries in fixed proportion -- which the sampling curve build
-handles directly (set both entries, solve). This is the correctness-first engine; a parametric-simplex
-speed lever (a direction trace through the coupled LP) is the later analogue of `csimplex` for elec.
-
-`MrSpatial` is the persistent hourly coupled LP (cost_of); `decompose_mr` runs the damped Gauss-Seidel /
-Jacobi sweeps and returns (best x[S,T], history). Validate against `mr.solve_mr_monolith`.
-"""
-import time
-
-import numpy as np
-
-from . import Pycplfunctionvec
-from .elec import _safe_pycpl, _soc_clamp
-
-try:
-    import highspy
-except Exception:                                              # pragma: no cover
-    highspy = None
-
-
-class MrSpatial:
-    """Persistent HiGHS hourly coupled elec+H2 network LP. Columns: p[C] (gens / conversions / imports),
-    shed[M], curtail[M] (elec only -- H2 spill forbidden), flow_e[Le], flow_h[Lh]. Rows: balance[M].
-    Storage enters only as a per-node net-load shift: RHS[m] = demand[m] + sum_s Ladd_s(x_s)[m]."""
-
-    def __init__(self, case):
-        self.M = M = len(case["nodes"]); self.T = case["T"]
-        cols = list(case["cols"]); self.C = C = len(cols)
-        self.voll = float(case["voll"])
-        self.costC = np.array([c["cost"] for c in cols]) if C else np.zeros(0)
-        self.capC = (np.vstack([np.broadcast_to(np.asarray(c["cap"], float), (self.T,)) for c in cols])
-                     if C else np.zeros((0, self.T)))
-        le = list(case["lines_e"]); lh = list(case["lines_h"]); self.Le = Le = len(le); self.Lh = Lh = len(lh)
-        curt_ok = case["curt_ok"]
-        h = highspy.Highs(); h.setOptionValue("output_flag", False)
-        h.setOptionValue("presolve", "off"); h.setOptionValue("solver", "simplex")
-        nx = C + M + M + Le + Lh
-        self.op, self.osh, self.ocu, self.ofe, self.ofh = 0, C, C + M, C + 2 * M, C + 2 * M + Le
-        cost = np.concatenate([self.costC, np.full(M, self.voll), np.zeros(M), np.zeros(Le + Lh)])
-        lb = np.zeros(nx); ub = np.full(nx, highspy.kHighsInf)
-        for m in range(M):
-            if not bool(curt_ok[m]):
-                ub[self.ocu + m] = 0.0                          # H2 (and any non-curtailable) node: no spill
-        for l, (a, b, f, rv) in enumerate(le):
-            lb[self.ofe + l] = -float(rv); ub[self.ofe + l] = float(f)
-        for l, (a, b, f, rv) in enumerate(lh):
-            lb[self.ofh + l] = -float(rv); ub[self.ofh + l] = float(f)
-        h.addVars(nx, lb, ub)
-        h.changeColsCost(nx, np.arange(nx, dtype=np.int32), cost)
-        per_node = [[] for _ in range(M)]                      # (col, coeff) touching each balance
-        for ci, c in enumerate(cols):
-            for nd, cf in c["coeffs"].items():
-                per_node[int(nd)].append((ci, float(cf)))
-        for m in range(M):
-            idx = [self.op + ci for ci, _cf in per_node[m]] + [self.osh + m, self.ocu + m]
-            val = [cf for _ci, cf in per_node[m]] + [1.0, -1.0]
-            for l, (a, b, f, rv) in enumerate(le):
-                if b == m: idx.append(self.ofe + l); val.append(1.0)
-                if a == m: idx.append(self.ofe + l); val.append(-1.0)
-            for l, (a, b, f, rv) in enumerate(lh):
-                if b == m: idx.append(self.ofh + l); val.append(1.0)
-                if a == m: idx.append(self.ofh + l); val.append(-1.0)
-            h.addRow(0.0, 0.0, len(idx), np.array(idx, np.int32), np.array(val, float))
-        self.h = h
-
-    def set_hour(self, tt):
-        if self.C:
-            cols = np.arange(self.op, self.op + self.C, dtype=np.int32)
-            self.h.changeColsBounds(self.C, cols, np.zeros(self.C), self.capC[:, tt].copy())
-
-    def set_rhs(self, net):
-        for m in range(self.M):
-            self.h.changeRowBounds(m, float(net[m]), float(net[m]))
-
-    def cost_of(self, net, tt):
-        self.set_hour(tt); self.set_rhs(net); self.h.run(); return float(self.h.getObjectiveValue())
-
-
-def mr_stor_arrays(case):
-    stor = list(case["storages"]); S = len(stor); T = case["T"]
-    Pcha = np.array([s["Pcha"] for s in stor]); Pdis = np.array([s["Pdis"] for s in stor])
-    E = np.array([s["E"] for s in stor]); init = np.array([s["init"] for s in stor])
-    inflow = np.vstack([np.asarray(s["inflow"], float) for s in stor]) if S else np.zeros((0, T))
-    contrib = [_contrib(s) for s in stor]
-    return stor, S, Pcha, Pdis, E, init, inflow, contrib
-
-
-def _contrib(s):
-    """The (node, charge_coeff, discharge_coeff) grid-load contributions of one storage."""
-    c = [(int(s["node"]), float(s["cin"]), float(s["fout"]))]
-    if float(s["paras"]) > 0 and int(s["node_e"]) >= 0:
-        c.append((int(s["node_e"]), float(s["paras"]), 0.0))   # parasitic elec on charge only
-    return c
-
-
-def _ladd(cch, cdis, xv):
-    return cch * xv if xv >= 0 else cdis * xv
-
-
-def levels_from_x(case, x):
-    """Reconstruct each storage's level trajectory: init + cumsum(inflow + x)."""
-    _, S, _, _, _, init, inflow, _ = mr_stor_arrays(case)
-    return init[:, None] + np.cumsum(inflow + x, axis=1) if S else np.zeros((0, case["T"]))
-
-
-def decompose_mr(case, sweeps=20, theta=0.5, mono=None, nsamp=15, pad=1.03, prune_tol=1e-3,
-                 jacobi=False, _profile=None):
-    """Damped Gauss-Seidel (or Jacobi) between the coupled spatial LP and the per-storage DP, sampling
-    engine. Returns (best-cost x[S,T], history rows (sweep, cost, gap%, cumsec))."""
-    M = len(case["nodes"]); T = case["T"]; dem = case["demand"]
-    stor, S, Pcha, Pdis, E, init, inflow, contrib = mr_stor_arrays(case)
-    Acc = np.cumsum(inflow, axis=1) if S else np.zeros((0, T))
-    Clo = -init[:, None] - Acc; Chi = E[:, None] - init[:, None] - Acc
-    grids = [np.unique(np.concatenate([np.linspace(-Pdis[s] * pad, Pcha[s] * pad, nsamp), [0.0]]))
-             for s in range(S)]
-    _pmoins = [(-Pdis[s] * np.ones(T)).tolist() for s in range(S)]
-    _pplus = [(Pcha[s] * np.ones(T)).tolist() for s in range(S)]
-    _clo = [Clo[s].tolist() for s in range(S)]; _chi = [Chi[s].tolist() for s in range(S)]
-    sp = MrSpatial(case); h = sp.h
-    x = np.zeros((S, T)); hist = []; t0 = time.perf_counter(); best = (np.inf, None)
-    for s in range(S):                                 # feasible baseline (see elec.decompose)
-        x[s], _ = _soc_clamp(x[s], Pdis[s], Pcha[s], Clo[s], Chi[s])
-
-    def net_col(tt, Xcol):                                     # full net load at hour tt (all storages)
-        nl = dem[:, tt].copy()
-        for s in range(S):
-            for (nd, cch, cdis) in contrib[s]:
-                nl[nd] += _ladd(cch, cdis, Xcol[s])
-        return nl
-
-    def update(s, X):
-        vec = Pycplfunctionvec(); xg = grids[s]
-        for tt in range(T):
-            nl = dem[:, tt].copy()                             # base: everyone except s
-            for s2 in range(S):
-                if s2 == s:
-                    continue
-                for (nd, cch, cdis) in contrib[s2]:
-                    nl[nd] += _ladd(cch, cdis, X[s2, tt])
-            phis = []; slopes = []
-            for xv in xg:
-                nlx = nl.copy()
-                for (nd, cch, cdis) in contrib[s]:
-                    nlx[nd] += _ladd(cch, cdis, xv)
-                sp.set_hour(tt); sp.set_rhs(nlx); h.run()
-                phis.append(float(h.getObjectiveValue()))
-                rd = h.getSolution().row_dual
-                slopes.append(sum(rd[nd] * (cch if xv >= 0 else cdis) for (nd, cch, cdis) in contrib[s]))
-            vec.push_back(_safe_pycpl(xg, np.asarray(phis), np.asarray(slopes)))
-        if prune_tol and prune_tol > 0:
-            xnew = np.asarray(vec.OptimMargIntPruned(_pmoins[s], _pplus[s], _clo[s], _chi[s], float(prune_tol)))
-        else:
-            xnew = np.asarray(vec.OptimMargInt(_pmoins[s], _pplus[s], _clo[s], _chi[s]))
-        xnew, _slack = _soc_clamp(xnew, Pdis[s], Pcha[s], Clo[s], Chi[s])
-        return xnew
-
-    for it in range(sweeps):
-        if jacobi:
-            X = x.copy()
-            xns = [update(s, X) for s in range(S)]
-            for s in range(S):
-                x[s] = (1 - theta) * X[s] + theta * xns[s]
-        else:
-            for s in range(S):
-                x[s] = (1 - theta) * x[s] + theta * update(s, x)
-        c = sum(sp.cost_of(net_col(tt, x[:, tt]), tt) for tt in range(T))
-        if c < best[0]:
-            best = (float(c), x.copy())
-        gap = 100.0 * (c - mono) / mono if mono else np.nan
-        hist.append((it, float(c), gap, time.perf_counter() - t0))
-    return best[1], hist

fltoptim-0.2.0/FLToptim/tests/test_mr_decompose.py

@@ -1,63 +0,0 @@
-"""Engine tests for the multi-resource (elec + H2) decomposition (FLToptim.mr_decompose), against a
-self-contained HiGHS coupled monolith (tests.cases.solve_mr_monolith).
-
-The synthetic case couples the two balances the way the real TYNDP one does: H2 demand is served by
-electrolysis (consumes 1.53 MWh elec / MWh H2), H2 nodes forbid spill, and the H2 store's charge draws
-a parasitic electricity load -- so one storage shifts TWO balance RHS entries in fixed proportion,
-which is exactly what the sampling curve build must price through the summed duals.
-"""
-import numpy as np
-import pytest
-
-pytest.importorskip("highspy")
-
-from FLToptim.mr_decompose import MrSpatial, decompose_mr, levels_from_x, mr_stor_arrays
-from FLToptim.tests.cases import mr_case, solve_mr_monolith
-
-
-@pytest.fixture(scope="module")
-def case():
-    return mr_case(T=72)
-
-
-@pytest.fixture(scope="module")
-def mono(case):
-    return solve_mr_monolith(case)
-
-
-def test_spatial_matches_monolith_without_storage():
-    """Exactness anchor: with no storage the coupled hourly LP sums to the coupled monolith."""
-    c = mr_case(T=48)
-    c = dict(c); c["storages"] = []
-    mono0 = solve_mr_monolith(c)
-    sp = MrSpatial(c)
-    tot = sum(sp.cost_of(c["demand"][:, tt], tt) for tt in range(c["T"]))
-    assert tot == pytest.approx(mono0, rel=1e-9)
-
-
-def test_case_is_discriminating(case, mono):
-    """Anti-vacuity guard: the storages must be worth something in the coupled case (here ~13%), so a
-    broken engine cannot pass the convergence tests by leaving them idle."""
-    c0 = dict(case); c0["storages"] = []
-    m0 = solve_mr_monolith(c0)
-    assert 100.0 * (m0 - mono) / mono > 2.0
-
-
-def test_mr_decompose_matches_monolith(case, mono):
-    """Gauss-Seidel sampling decomposition converges to the coupled monolith and stays feasible."""
-    x, hist = decompose_mr(case, sweeps=12, theta=0.5, mono=mono, nsamp=11, prune_tol=1e-3)
-    gap = min(g for _, _, g, _ in hist)
-    assert gap < 0.05, f"MR decomposition gap too large: {gap:+.4f}%"
-
-    stor, S, Pcha, Pdis, E, init, inflow, contrib = mr_stor_arrays(case)
-    lev = levels_from_x(case, x)
-    for s in range(S):
-        assert x[s].max() <= Pcha[s] + 1e-6 and x[s].min() >= -Pdis[s] - 1e-6, f"storage {s} power bound"
-        assert lev[s].max() <= E[s] + 1e-6 and lev[s].min() >= -1e-6, f"storage {s} level bound"
-
-
-def test_mr_decompose_jacobi_converges(case, mono):
-    """The Jacobi variant (frozen-snapshot updates) converges under damping too."""
-    x, hist = decompose_mr(case, sweeps=14, theta=0.5, mono=mono, nsamp=11, jacobi=True)
-    gap = min(g for _, _, g, _ in hist)
-    assert gap < 0.2, f"MR Jacobi gap too large: {gap:+.4f}%"