optiwindnet 0.2.0__tar.gz → 0.2.2__tar.gz

{optiwindnet-0.2.0 → optiwindnet-0.2.2}/CHANGELOG.md

@@ -1,3 +1,82 @@
+# v0.2.2
+
+[Commit history since v0.2.1](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/compare/v0.2.1...v0.2.2)
+
+## Breaking Changes
+- **Advanced API Cleanups**: Helper functions for root-assignment and link-blockage moved from `optiwindnet.geometric` to `optiwindnet.interarraylib`. Users should import `add_terminal_closest_root()`, `add_link_blockmap()`, and `add_link_cosines()` from `optiwindnet.interarraylib`.
+
+## Important Changes
+- **Default Vector SVG Plotting**: High-level `WindFarmNetwork` plotting methods (`plot()`, `plot_location()`, `plot_available_links()`, `plot_navigation_mesh()`, and `plot_selected_links()`) now use a modern, interactive vector SVG plotting backend (`svgplot`/`svgpplot`) by default. This delivers clean, high-resolution inline displays in Jupyter notebooks. The legacy Matplotlib-based backend remains fully accessible by passing an explicit `ax` argument (including `ax=None` to dynamically instantiate Matplotlib figures).
+- **svgplot() matches gplot()'s features**: SVG plots now support node labeling, boundary/obstacle vertex tagging, and figure legend.
+- **Informative String Representations**: Added descriptive, debugger-safe string representations (`__repr__`) for `WindFarmNetwork` and `Router` subclasses (`EWRouter`, `HGSRouter`, `MILPRouter`) displaying key configuration parameters and solved network metrics.
+- **Shorter Substation Labels**: Pre-packaged offshore wind farm datasets (.osm.pbf format) have been updated with short, human-readable substation abbreviations (such as "Alpha", "Beta", "OSS") to fit cleanly in visualization labels.
+- **New Fused Heuristic**: Added `heuristics.constructor()` with `esau_williams`, `biased_EW`, `rootlust`, and `radial_EW` methods, unifying the constructive routing heuristics. The high-level `EWRouter` now uses this path, offering radial topology and the performant rootlust method.
+- **LKH-3 Solver Parity**: Added `lkh3()` as the preferred LKH entry point, bringing it to feature parity with the HGS solver. It supports single- and multi-root configurations, per-root clustering, warm starts, capacity-violation retries, crossing repair, and improved solver metadata.
+- **Expanded Crossing Diagnostics**: Added Shapely-based `find_geometric_crossings()` for geometry-first validation of arbitrary routesets, including detours, contour clones, shared-run overlap crossings, and branch-split cases.
+- **Robust PathFinder Detours**: Major robustness improvements when routing detours among cable routes that follow boundaries or exclusion zones, significantly reducing cable use on sites with many obstacles.
+
+## Deprecated
+- Standalone EW heuristics (`ClassicEW`, `CPEW`, `NBEW`, `OBEW`, and `EW_presolver`) are deprecated and will be removed in v0.3. They are superseded by the new unified `heuristics.constructor()`. Note that `constructor` expects the available-links graph `A`, not the location graph `L`.
+- The legacy `optiwindnet.interface` module (`heuristic_wrapper()`, `HeuristicFactory`) is deprecated and will be removed in v0.3; use `WindFarmNetwork`/`EWRouter` instead.
+
+## Fixes
+- **Pathfinder Robustness**: Resolved fatal crashes (`KeyError` and triangulation flip failures) when constructing detours.
+- **Diagonal Mesh Exclusion**: Prevented invalid diagonal paths by skipping edges in the site's boundary polygon during navigation mesh generation.
+- **Logging & Diagnostics**: Replaced all remaining raw `print()` statements across the API and utility modules with standard Python logging.
+- **LKH and Heuristic Repairs**: Fixed LKH warm-start tour construction (indexing, walk order within clusters) and aligned HGS/LKH repair behavior for capacity-violating and crossing routes.
+- **Overflow Prevention**: Added checks for LKH weight-matrix construction with clear guidance when inputs need normalization.
+- **Crossing Detection**: Fixed shared-route overlap crossing detection and added geometric handling for route intersections not expressible as available-edge crossings.
+
+## Refactoring & Maintenance
+- **Python 3.11–3.14 Support**: Explicitly declared support for Python 3.11 through 3.14 with standard Trove classifiers on PyPI.
+- **Updated OR-Tools Floor**: Aligned OR-Tools requirements in `pyproject.toml` to `>=9.14.6206` for consistency across development and production environments.
+- **Strict Deprecation Testing**: Test suite configured to treat `DeprecationWarning` as errors to guarantee API health.
+- **Linting & Code Quality**: Enforced strict Ruff linting and formatting rules via continuous integration.
+- **Performance Optimizations**: Optimized pathfinding sector lookups and precomputed chain-end topologies to speed up execution.
+
+# v0.2.1
+
+[Commit history since v0.2.0](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/compare/v0.2.0...v0.2.1)
+
+## Breaking Changes
+- `optiwindnet.db` module only: **RouteSet schema slimmed (v4)**: `num_gates` was renamed to `feeders_per_root`; the unused `valid`, `is_normalized`, and `stuntC` columns were removed. The `python -m optiwindnet.db.migrate` script now writes the v4 schema and accepts both v2 (Pony ORM) and v3 (Peewee) source databases.
+
+## Important Changes
+- **OR-Tools MILP backend switched to MathOpt API** (replacing `cp_model`), enabling multiple backends through a unified wrapper. No impact on use through either API. 
+- **Pyomo CPLEX/Gurobi solvers switched to the persistent interfaces** (`cplex_persistent`, `gurobi_persistent`). Relevant for successive calls to solver.solve().
+- **`PathFinder`**: `A` is now a mandatory argument, it is relied upon to inform about tentative feeder crossings (saves the repeated check done before); default options were updated; search heuristics improved.
+
+## Features
+- LKH improvements: iterations are also triggered on capacity violations, new `warmstart` argument.
+- Better estimation of obstructed feeder lengths pre-optimization (make_planar_embedding).
+- Default thread count for MathOpt solvers set to the number of physical cores; non-OR-Tools solvers also use `physical_core_count()`.
+- New context-managed database connection API; `open_database()` and `database_connection()` accept a `timeout` argument.
+- `.osm.pbf` parsing now accepts locations without borders.
+- Added typing stubs and improved type annotations.
+- Informative string repr for `SvgRepr`.
+
+## Fixes
+- Multiple PathFinder robustness fixes: collinear vertices in funnel apex update, expansion of `P_paths` shortcuts when building contour clones, shortcut provenance tracking for barriers, cumulative turning check for dropping traversers, and `bad_streak` decay on first arrival.
+- `make_planar_embedding` fixes: constraint checks and line-of-sight tagging now use Shapely's `STRtree`, proper handling of diagonal promotion conflicts in concave meshes, string-pulling skipped when only one border vertex is on the path (enabled by STRtree check).
+- `validate_routeset()`: corrected detour index range; touchpoint set as bunch-split corner apex.
+- LKH: replaced stale `_add_link_blockage` call with `add_link_blockmap`.
+- Removed WAL mode from the SQLite open pragma (caused issues on shared clusters).
+- Stunt vertices are no longer placed in `G` (regression since a70b575).
+- Gracefully handle repeated extents' vertices in .yaml input files.
+- Fixed `migrate.py` ImportError.
+
+## Refactoring & Maintenance
+- Replaced `dill` with `pickle` everywhere it was used in tests.
+- Removed `stuntC` from the routeset saving path.
+- CI now runs a test matrix covering Python 3.11–3.14 (default bumped to 3.14); release requires passing on all versions.
+- Increased test coverage and added topology-aware routeset comparison to prevent spurious failures.
+
+## Documentation
+- Major refactor of the Topfarm integration example (now including substation trajectory); several notebook updates.
+- Added links to TOPFARM and Ard, updated preamble with Jupyter tutorial links.
+- Acknowledged the DFF grant in README and doc index.
+- Improved docstrings and setup instructions.
+
 # v0.2.0
 
 [Commit history since v0.1.6](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/compare/v0.1.6...v0.2.0)

{optiwindnet-0.2.0 → optiwindnet-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optiwindnet
-Version: 0.2.0
+Version: 0.2.2
 Summary: Tool for designing and optimizing the electrical cable network of offshore wind farms
 Author-email: DTU Wind Energy <mikf@dtu.dk>, Mauricio Souza de Alencar <ma___@dtu.dk>, Amir Arasteh <am___@dtu.dk>
 License-Expression: MIT
@@ -15,6 +15,10 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering
@@ -32,7 +36,7 @@ Requires-Dist: matplotlib>=3.10.1
 Requires-Dist: networkx>=3.6
 Requires-Dist: numba>=0.62.1
 Requires-Dist: numpy>=2.0
-Requires-Dist: ortools>=9.12.4544
+Requires-Dist: ortools>=9.14.6206
 Requires-Dist: peewee>=3.17
 Requires-Dist: Pyomo>=6.9.5
 Requires-Dist: PyYAML>=6.0.2
@@ -46,7 +50,6 @@ Requires-Dist: gurobipy; extra == "solvers"
 Requires-Dist: highspy; extra == "solvers"
 Requires-Dist: pyscipopt; extra == "solvers"
 Provides-Extra: test
-Requires-Dist: dill; extra == "test"
 Requires-Dist: coverage; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
@@ -69,11 +72,11 @@ Requires-Dist: pypandoc; extra == "docs"
 Requires-Dist: setuptools-scm; extra == "docs"
 Dynamic: license-file
 
-[![pipeline status](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/pipeline.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/commits/main)
 [![PyPi](https://img.shields.io/pypi/v/optiwindnet)](https://pypi.org/project/optiwindnet/)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18388438.svg)](https://doi.org/10.5281/zenodo.18388438)
-[![License](https://img.shields.io/pypi/l/optiwindnet)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/blob/main/LICENSE)
-[![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/commits/main)
+[![License](https://img.shields.io/pypi/l/optiwindnet)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/blob/main/LICENSE.txt)
+[![pipeline status](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/pipeline.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/pipelines)
+[![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/jobs)
 <!---
 [![DOI](https://zenodo.org/badge/164115313.svg)](https://zenodo.org/badge/latestdoi/164115313)
 -->
@@ -113,7 +116,7 @@ Detailed instructions in [Installation](https://optiwindnet.readthedocs.io/stabl
 Requirements
 ------------
 
-Python version 3.11 or 3.12 is recommended to run *OptiWindNet*. Python 3.13+ may cause issues with the `optiwindnet.db` module, but all other features work fine. The last version to support Python 3.10 was v0.1.0.
+*OptiWindNet* requires Python version 3.11+ (tested with 3.11-14). The last version to support Python 3.10 was v0.0.6.
 
 The use of a Python virtual environment is recommended. OptiWindNet's dependencies (except for MILP solvers, see docs) will be installed automatically when using `pip install optiwindnet` or `conda install optiwindnet`.
 
@@ -146,11 +149,22 @@ European Journal of Operational Research,
 }
 ```
 
+Citing OptiWindNet
+------------------
+
+The OptiWindNet software package can be cited (unversioned) as:
+> Souza de Alencar, M., Arasteh, A., & Friis-Møller, M. (2026). OptiWindNet by DTU Wind Energy. Zenodo. https://doi.org/10.5281/zenodo.18388438
+
+To cite a specific version, get the version-specific DOI at [OptiWindNet's entry at Zenodo](https://doi.org/10.5281/zenodo.18388438). Select the desired version on the right column and use one of the ready-to-use citation formats available at the bottom right of that page.
+
+
 Acknowledgements
 ----------------
 
-The heuristics implemented in this repository (release 0.0.1) are presented and analyzed in the MSc thesis [Optimization heuristics for offshore wind power plant collection systems design](https://fulltext-gateway.cvt.dk/oafilestore?oid=62dddf809a5e7116caf943f3&targetid=62dddf80a41ba354e4ed35bc) (DTU Wind - Technical University of Denmark, July 4, 2022)
+The development of OptiWindNet was carried out as part of a Ph.D. project at the Technical University of Denmark (DTU Wind), financially supported by the Independent Research Fund Denmark / Danmarks Frie Forskningsfond (DFF) under grant no. 1127-00188B, project _Integrated Design of Offshore Wind Power Plants_.
+
+The heuristics implemented in this repository (release 0.0.1) are presented and analyzed in the MSc thesis [Optimization heuristics for offshore wind power plant collection systems design](https://fulltext-gateway.cvt.dk/oafilestore?oid=62dddf809a5e7116caf943f3&targetid=62dddf80a41ba354e4ed35bc) (DTU Wind - Technical University of Denmark, July 4, 2022).
 
-The meta-heuristic used is [vidalt/HGS-CVRP: Modern implementation of the hybrid genetic search (HGS) algorithm specialized to the capacitated vehicle routing problem (CVRP). This code also includes an additional neighborhood called SWAP\*.](https://github.com/vidalt/HGS-CVRP) via its Python bindings [chkwon/PyHygese: A Python wrapper for the Hybrid Genetic Search algorithm for Capacitated Vehicle Routing Problems (HGS-CVRP)](https://github.com/chkwon/PyHygese).
+The meta-heuristic used is [vidalt/HGS-CVRP](https://github.com/vidalt/HGS-CVRP) — a modern implementation of the hybrid genetic search (HGS) algorithm specialized to the capacitated vehicle routing problem (CVRP), including an additional neighborhood called SWAP\* — via its Python bindings [mdealencar/HybGenSea](https://github.com/mdealencar/HybGenSea).
 
-The cable routing relies on a navigation mesh generated by the library [artem-ogre/CDT: Constrained Delaunay Triangulation (C++)](https://github.com/artem-ogre/CDT) via its Python bindings - [artem-ogre/PythonCDT: Constrained Delaunay Triangulation (Python)](https://github.com/artem-ogre/PythonCDT).
+The cable routing relies on a navigation mesh generated by the library [artem-ogre/CDT](https://github.com/artem-ogre/CDT) (Constrained Delaunay Triangulation, C++) via its Python bindings [artem-ogre/PythonCDT](https://github.com/artem-ogre/PythonCDT).

{optiwindnet-0.2.0 → optiwindnet-0.2.2}/README.md

@@ -1,8 +1,8 @@
-[![pipeline status](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/pipeline.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/commits/main)
 [![PyPi](https://img.shields.io/pypi/v/optiwindnet)](https://pypi.org/project/optiwindnet/)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18388438.svg)](https://doi.org/10.5281/zenodo.18388438)
-[![License](https://img.shields.io/pypi/l/optiwindnet)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/blob/main/LICENSE)
-[![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/commits/main)
+[![License](https://img.shields.io/pypi/l/optiwindnet)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/blob/main/LICENSE.txt)
+[![pipeline status](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/pipeline.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/pipelines)
+[![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/jobs)
 <!---
 [![DOI](https://zenodo.org/badge/164115313.svg)](https://zenodo.org/badge/latestdoi/164115313)
 -->
@@ -42,7 +42,7 @@ Detailed instructions in [Installation](https://optiwindnet.readthedocs.io/stabl
 Requirements
 ------------
 
-Python version 3.11 or 3.12 is recommended to run *OptiWindNet*. Python 3.13+ may cause issues with the `optiwindnet.db` module, but all other features work fine. The last version to support Python 3.10 was v0.1.0.
+*OptiWindNet* requires Python version 3.11+ (tested with 3.11-14). The last version to support Python 3.10 was v0.0.6.
 
 The use of a Python virtual environment is recommended. OptiWindNet's dependencies (except for MILP solvers, see docs) will be installed automatically when using `pip install optiwindnet` or `conda install optiwindnet`.
 
@@ -75,11 +75,22 @@ European Journal of Operational Research,
 }
 ```
 
+Citing OptiWindNet
+------------------
+
+The OptiWindNet software package can be cited (unversioned) as:
+> Souza de Alencar, M., Arasteh, A., & Friis-Møller, M. (2026). OptiWindNet by DTU Wind Energy. Zenodo. https://doi.org/10.5281/zenodo.18388438
+
+To cite a specific version, get the version-specific DOI at [OptiWindNet's entry at Zenodo](https://doi.org/10.5281/zenodo.18388438). Select the desired version on the right column and use one of the ready-to-use citation formats available at the bottom right of that page.
+
+
 Acknowledgements
 ----------------
 
-The heuristics implemented in this repository (release 0.0.1) are presented and analyzed in the MSc thesis [Optimization heuristics for offshore wind power plant collection systems design](https://fulltext-gateway.cvt.dk/oafilestore?oid=62dddf809a5e7116caf943f3&targetid=62dddf80a41ba354e4ed35bc) (DTU Wind - Technical University of Denmark, July 4, 2022)
+The development of OptiWindNet was carried out as part of a Ph.D. project at the Technical University of Denmark (DTU Wind), financially supported by the Independent Research Fund Denmark / Danmarks Frie Forskningsfond (DFF) under grant no. 1127-00188B, project _Integrated Design of Offshore Wind Power Plants_.
+
+The heuristics implemented in this repository (release 0.0.1) are presented and analyzed in the MSc thesis [Optimization heuristics for offshore wind power plant collection systems design](https://fulltext-gateway.cvt.dk/oafilestore?oid=62dddf809a5e7116caf943f3&targetid=62dddf80a41ba354e4ed35bc) (DTU Wind - Technical University of Denmark, July 4, 2022).
 
-The meta-heuristic used is [vidalt/HGS-CVRP: Modern implementation of the hybrid genetic search (HGS) algorithm specialized to the capacitated vehicle routing problem (CVRP). This code also includes an additional neighborhood called SWAP\*.](https://github.com/vidalt/HGS-CVRP) via its Python bindings [chkwon/PyHygese: A Python wrapper for the Hybrid Genetic Search algorithm for Capacitated Vehicle Routing Problems (HGS-CVRP)](https://github.com/chkwon/PyHygese).
+The meta-heuristic used is [vidalt/HGS-CVRP](https://github.com/vidalt/HGS-CVRP) — a modern implementation of the hybrid genetic search (HGS) algorithm specialized to the capacitated vehicle routing problem (CVRP), including an additional neighborhood called SWAP\* — via its Python bindings [mdealencar/HybGenSea](https://github.com/mdealencar/HybGenSea).
 
-The cable routing relies on a navigation mesh generated by the library [artem-ogre/CDT: Constrained Delaunay Triangulation (C++)](https://github.com/artem-ogre/CDT) via its Python bindings - [artem-ogre/PythonCDT: Constrained Delaunay Triangulation (Python)](https://github.com/artem-ogre/PythonCDT).
+The cable routing relies on a navigation mesh generated by the library [artem-ogre/CDT](https://github.com/artem-ogre/CDT) (Constrained Delaunay Triangulation, C++) via its Python bindings [artem-ogre/PythonCDT](https://github.com/artem-ogre/PythonCDT).

optiwindnet-0.2.2/_run_chain_tests.py

@@ -0,0 +1,137 @@
+"""Validation driver for the chain-sleeve pathfinding feature.
+
+Loads pickled G_db routesets for four RIDs and re-runs PathFinder, checking
+that the expected feeder paths and total length are produced.
+
+Usage:
+    python _run_chain_tests.py
+"""
+
+import math
+import pickle
+import sys
+from pathlib import Path
+
+from optiwindnet.interarraylib import G_from_S, L_from_G, S_from_G
+from optiwindnet.mesh import make_planar_embedding
+from optiwindnet.pathfinding import PathFinder
+
+EXPECTED = {
+    22822: {
+        'length': 9.4484,
+        'feeders': [[-1, 46, 70, 35], [-1, 46, 70, 26]],
+    },
+    33303: {
+        'length': 9.5741,
+        'feeders': [[-1, 46, 70, 35], [-1, 46, 70, 26]],
+    },
+    33372: {
+        'length': 11.1059,
+        'feeders': [[-1, 40, 57, 44], [-1, 40, 57, 58, 59, 5]],
+    },
+    35875: {
+        'length': None,
+        'feeders': [[-1, 60, 75, 76, 77, 8]],
+    },
+}
+
+
+def _feeder_paths(G):
+    """Extract every -1->...->terminal path through the routeset, mapped to primes."""
+    R = G.graph['R']
+    T = G.graph['T']
+    fnT = G.graph.get('fnT')
+
+    def prime(n):
+        if n < 0:
+            return n
+        if fnT is not None and n < len(fnT):
+            return int(fnT[n])
+        return n
+
+    feeders = []
+    # walk every root->...->terminal path through detour clones and contour
+    # helpers; emit one feeder per terminal-anchored path that starts at root
+    for r in range(-R, 0):
+        for first in G.neighbors(r):
+            # DFS to find paths root → ... → terminal (prime in [0, T))
+            stack = [(first, [r, first], {r, first})]
+            while stack:
+                cur, path, visited = stack.pop()
+                # Terminate on actual terminal node (not a clone whose prime is
+                # a terminal — those happen along contour helpers).
+                if 0 <= cur < T:
+                    feeders.append([prime(x) for x in path])
+                    continue
+                for nxt in G.neighbors(cur):
+                    if nxt in visited:
+                        continue
+                    stack.append((nxt, path + [nxt], visited | {nxt}))
+    return feeders
+
+
+def _run_one(rid):
+    p = Path(__file__).parent / 'tests' / 'locations' / f'G_{rid}.pkl'
+    with open(p, 'rb') as f:
+        G_db = pickle.load(f)
+
+    # reconstruct site → planar+A → topology → tentative → PathFinder
+    L = L_from_G(G_db)
+    L.graph['border'] = G_db.graph['border']
+    L.graph['VertexC'] = G_db.graph['VertexC'][
+        : G_db.graph['T'] + G_db.graph['B'] - G_db.graph.get('D', 0)
+    ] if False else G_db.graph['VertexC'][
+        : G_db.graph['T'] + G_db.graph['B']
+    ].copy()
+    # Stitch the actual VertexC together: terminals + borders + roots
+    import numpy as np
+    R, T, B = G_db.graph['R'], G_db.graph['T'], G_db.graph['B']
+    VertexC = G_db.graph['VertexC']
+    L.graph['VertexC'] = np.vstack((VertexC[: T + B], VertexC[-R:]))
+    L.graph['B'] = B
+    L.graph['R'] = R
+    L.graph['T'] = T
+
+    P, A = make_planar_embedding(L)
+    S = S_from_G(G_db)
+    G_tent = G_from_S(S, A)
+    pf = PathFinder(G_tent, planar=P, A=A)
+    G_out = pf.create_detours()
+    length = G_out.size(weight='length')
+    feeders = _feeder_paths(G_out)
+    return length, feeders
+
+
+def main():
+    failures = 0
+    for rid, expected in EXPECTED.items():
+        try:
+            length, feeders = _run_one(rid)
+        except Exception as e:
+            print(f'  RID {rid}: ERROR {type(e).__name__}: {e}')
+            failures += 1
+            continue
+        ok_len = (
+            expected['length'] is None
+            or math.isclose(length, expected['length'], abs_tol=1e-3)
+        )
+        # Match expected feeders as multisets of prime-vertex sequences
+        got_set = {tuple(f) for f in feeders}
+        want_set = {tuple(f) for f in expected['feeders']}
+        missing = want_set - got_set
+        ok_feeders = not missing
+        status = 'OK' if (ok_len and ok_feeders) else 'FAIL'
+        if status == 'FAIL':
+            failures += 1
+        print(
+            f'RID {rid}: {status}  length={length:.4f}'
+            + (f' (expected {expected["length"]})' if expected['length'] else '')
+        )
+        if missing:
+            print(f'    missing feeders: {sorted(missing)}')
+            print(f'    got feeders:     {sorted(got_set)}')
+    return failures
+
+
+if __name__ == '__main__':
+    sys.exit(main())

{optiwindnet-0.2.0 → optiwindnet-0.2.2}/optiwindnet/MILP/__init__.py

@@ -9,8 +9,8 @@ from ._core import (
     FeederRoute,
     ModelMetadata,
     ModelOptions,
-    OWNWarmupFailed,
     OWNSolutionNotFound,
+    OWNWarmupFailed,
     SolutionInfo,
     Solver,
     Topology,
@@ -36,18 +36,22 @@ def solver_factory(solver_name: str) -> Solver:
     Note that the only solver that is a dependency of OptiWindNet is 'ortools'.
     Check OptiWindNet's documentation on how to install optional solvers.
 
+    Legacy compatibility: if solver_name == 'ortools' then the CP-SAT backend is used.
+
     Args:
-      solver_name: one of 'ortools', 'cplex', 'gurobi', 'cbc', 'scip', 'highs'.
+      solver_name: one of 'ortools.cp_sat', 'ortools.gscip',
+        'ortools.highs', 'cplex', 'gurobi', 'cbc', 'scip', 'highs'.
 
     Returns:
       Solver instance that can produce solutions for the cable routing problem.
     """
+    solver_name, *backend = solver_name.split('.', maxsplit=1)
     match solver_name:
         case 'ortools':
             if find_spec('ortools'):
                 from .ortools import SolverORTools
 
-                return SolverORTools()
+                return SolverORTools(backend[0] if backend else 'cp_sat')
             raise ModuleNotFoundError(
                 "Package 'ortools' not found. Try 'pip install ortools'."
             )
@@ -95,8 +99,9 @@ def solver_factory(solver_name: str) -> Solver:
                     return SolverFSCIP()
                 else:
                     raise FileNotFoundError(
-                        "Executable 'fscip' not found. Ensure the system PATH includes the "
-                        "path to 'fscip' (part of scipoptsuite from https://www.scipopt.org)."
+                        "Executable 'fscip' not found. Ensure the system PATH includes"
+                        " the path to 'fscip' (part of scipoptsuite from"
+                        ' https://www.scipopt.org).'
                     )
             else:
                 raise ModuleNotFoundError(
@@ -105,9 +110,10 @@ def solver_factory(solver_name: str) -> Solver:
                 )
         case 'highs':
             if find_spec('highspy'):
-                from .pyomo import SolverPyomoAppsi
                 from pyomo.contrib.appsi.solvers.highs import Highs
 
+                from .pyomo import SolverPyomoAppsi
+
                 return SolverPyomoAppsi(solver_name, Highs)
             raise ModuleNotFoundError(
                 "Package 'highspy' not found. Try 'pip install highspy' or "

{optiwindnet-0.2.0 → optiwindnet-0.2.2}/optiwindnet/MILP/_core.py

@@ -3,11 +3,14 @@
 
 import abc
 import logging
-from dataclasses import asdict, dataclass
-
+import os
+import sys
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass, field
 from enum import StrEnum, auto
 from itertools import chain
-from typing import Any, Mapping
+from pathlib import Path
+from typing import Any
 
 import networkx as nx
 from makefun import with_signature
@@ -19,6 +22,37 @@ _lggr = logging.getLogger(__name__)
 error, info = _lggr.error, _lggr.info
 
 
+def physical_core_count() -> int:
+    """Count physical cores available to this process (cross-platform).
+
+    On Linux, reads sysfs topology to count physical cores within the
+    process affinity set. On other platforms, falls back to psutil.
+    """
+    if sys.platform == 'linux':
+        try:
+            affinity = os.sched_getaffinity(0)
+        except OSError:
+            affinity = None
+        if affinity is not None:
+            physical_cores = set()
+            for cpu_id in affinity:
+                topo = Path(f'/sys/devices/system/cpu/cpu{cpu_id}/topology')
+                try:
+                    pkg = (topo / 'physical_package_id').read_text().strip()
+                    core = (topo / 'core_id').read_text().strip()
+                    physical_cores.add((pkg, core))
+                except OSError:
+                    # sysfs unavailable (e.g. container), fall through
+                    physical_cores = None
+                    break
+            if physical_cores is not None:
+                return len(physical_cores)
+    # Windows, macOS, or Linux without sysfs
+    import psutil
+
+    return psutil.cpu_count(logical=False) or os.cpu_count() or 1
+
+
 def _identifier_from_class_name(c: type) -> str:
     "Convert a camel-case class name to a snake-case identifier"
     s = c.__name__
@@ -50,7 +84,9 @@ class FeederRoute(StrEnum):
 
 
 class FeederLimit(StrEnum):
-    'Whether to limit the maximum number of feeders, if set to "specified", additional kwarg "max_feeders" must be given.'
+    'Whether to limit the maximum number of feeders, if set to "specified",'
+
+    ' additional kwarg "max_feeders" must be given.'
 
     UNLIMITED = auto()
     SPECIFIED = auto()
@@ -125,16 +161,21 @@ class ModelOptions(dict):
             print(f'{name} [{kind.__name__}] default: {default}\n    {desc}\n')
 
 
+_Link = tuple[int, int]
+
+
 @dataclass(slots=True)
 class ModelMetadata:
     R: int
     T: int
     capacity: int
-    linkset: tuple
-    link_: Mapping
-    flow_: Mapping
-    model_options: dict
+    linkset: tuple[_Link, ...]
+    link_: Mapping[_Link, Any]
+    flow_: Mapping[_Link, Any]
+    model_options: dict[str, Any]
     fun_fingerprint: dict[str, str | bytes]
+    weight_: tuple[float, ...] = ()
+    solution_hint: dict[Any, float] = field(default_factory=dict)
     warmed_by: str = ''
 
 

optiwindnet-0.2.2/optiwindnet/MILP/_core.pyi

@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: MIT
+# Typing stubs for optiwindnet.MILP._core
+# Surfaces the dynamically generated ModelOptions.__init__ signature.
+
+import abc
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+import networkx as nx
+
+def physical_core_count() -> int: ...
+
+class OWNWarmupFailed(Exception): ...
+class OWNSolutionNotFound(Exception): ...
+
+class Topology(StrEnum):
+    RADIAL: str
+    BRANCHED: str
+    DEFAULT: str
+
+class FeederRoute(StrEnum):
+    STRAIGHT: str
+    SEGMENTED: str
+    DEFAULT: str
+
+class FeederLimit(StrEnum):
+    UNLIMITED: str
+    SPECIFIED: str
+    MINIMUM: str
+    MIN_PLUS1: str
+    MIN_PLUS2: str
+    MIN_PLUS3: str
+    DEFAULT: str
+
+_Link = tuple[int, int]
+
+class ModelOptions(dict[str, Any]):
+    """Hold options for the modelling of the cable routing problem."""
+
+    hints: dict[str, type[StrEnum]]
+    simple: dict[str, tuple[type, Any, str]]
+
+    def __init__(
+        self,
+        *,
+        topology: Topology | str = ...,
+        feeder_route: FeederRoute | str = ...,
+        feeder_limit: FeederLimit | str = ...,
+        balanced: bool = ...,
+        max_feeders: int = ...,
+    ) -> None: ...
+    @classmethod
+    def help(cls) -> None: ...
+
+@dataclass(slots=True)
+class ModelMetadata:
+    R: int
+    T: int
+    capacity: int
+    linkset: tuple[_Link, ...]
+    link_: Mapping[_Link, Any]
+    flow_: Mapping[_Link, Any]
+    model_options: dict[str, Any]
+    fun_fingerprint: dict[str, str | bytes]
+    weight_: tuple[float, ...] = ()
+    solution_hint: dict[Any, float] = field(default_factory=dict)
+    warmed_by: str = ''
+
+@dataclass(slots=True)
+class SolutionInfo:
+    runtime: float
+    bound: float
+    objective: float
+    relgap: float
+    termination: str
+
+class Solver(abc.ABC):
+    name: str
+    metadata: ModelMetadata
+    solver: Any
+    options: dict[str, Any]
+    stopping: dict[str, Any]
+    solution_info: SolutionInfo
+    applied_options: dict[str, Any]
+
+    @abc.abstractmethod
+    def _link_val(self, var: Any) -> int | bool: ...
+    @abc.abstractmethod
+    def _flow_val(self, var: Any) -> int: ...
+    @abc.abstractmethod
+    def set_problem(
+        self,
+        P: nx.PlanarEmbedding,
+        A: nx.Graph,
+        capacity: int,
+        model_options: ModelOptions,
+        warmstart: nx.Graph | None = None,
+    ) -> None: ...
+    @abc.abstractmethod
+    def solve(
+        self,
+        time_limit: float,
+        mip_gap: float,
+        options: dict[str, Any] = ...,
+        verbose: bool = False,
+    ) -> SolutionInfo: ...
+    @abc.abstractmethod
+    def get_solution(self, A: nx.Graph | None = None) -> tuple[nx.Graph, nx.Graph]: ...
+
+class PoolHandler(abc.ABC):
+    name: str
+    num_solutions: int
+    model_options: ModelOptions
+
+    @abc.abstractmethod
+    def _objective_at(self, index: int) -> float: ...
+    @abc.abstractmethod
+    def _topology_from_mip_pool(self) -> nx.Graph: ...