optiwindnet 0.0.2__tar.gz

optiwindnet-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

optiwindnet-0.0.2/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: optiwindnet
+Version: 0.0.2
+Summary: Tools for optimizing the electrical cable network (collection system) for offshore wind power plants.
+Author: DTU Wind Energy
+Author-email: Mauricio Souza de Alencar <ma___@dtu.dk>
+License-Expression: MIT
+Project-URL: Documentation, https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/
+Project-URL: Source code, https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet
+Project-URL: Issue tracker, https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/-/issues
+Keywords: optimization,wind farms,routing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bidict~=0.23.1
+Requires-Dist: condeltri~=0.0.2
+Requires-Dist: darkdetect~=0.8.0
+Requires-Dist: hybgensea~=0.0.1
+Requires-Dist: matplotlib~=3.10.1
+Requires-Dist: networkx~=3.4.2
+Requires-Dist: numba~=0.61.0
+Requires-Dist: numpy~=2.1.3
+Requires-Dist: ortools~=9.12.4544
+Requires-Dist: osmium~=4.0.2
+Requires-Dist: pony~=0.7.18
+Requires-Dist: py~=1.11.0
+Requires-Dist: Pyomo~=6.9.1
+Requires-Dist: PyYAML~=6.0.2
+Requires-Dist: scipy~=1.15.2
+Requires-Dist: shapely~=2.0.7
+Requires-Dist: svg.py~=1.6.0
+Requires-Dist: utm~=0.7.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: psutil; extra == "test"
+Requires-Dist: memory_profiler; extra == "test"
+Requires-Dist: line_profiler; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Requires-Dist: ipywidgets; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Requires-Dist: sphinx_copybutton; extra == "docs"
+Requires-Dist: sphinx_sitemap; extra == "docs"
+Requires-Dist: ipympl; extra == "docs"
+Requires-Dist: ipykernel; extra == "docs"
+Requires-Dist: pypandoc; extra == "docs"
+Requires-Dist: sphinx-autoapi; 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)
+<!---
+[![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/commits/main)
+[![DOI](https://zenodo.org/badge/164115313.svg)](https://zenodo.org/badge/latestdoi/164115313)
+[![PyPi](https://img.shields.io/pypi/v/optiwindnet)](https://pypi.org/project/optiwindnet/)
+[![License](https://img.shields.io/pypi/l/optiwindnet)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/blob/main/LICENSE)
+-->
+
+OptiWindNet
+===========
+
+Tool for designing and optimizing the electrical cable network (collection system) for offshore wind power plants.
+
+Documentation: [https://topfarm.pages.windenergy.dtu.dk/OptiWindNet](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet)
+- [Installation](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/setup#Installation) ([requirements](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/setup#Requirements))
+- [Quickstart](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/Quickstart)
+- [API Reference](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/autoapi/optiwindnet/index.html)
+- [How to Cite](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/index.html#how-to-cite)
+
+Requirements
+------------
+
+- [requirements.txt](requirements.txt) if using `pip`
+- [environment.yml](environment.yml) if using `conda`
+
+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 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 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).

optiwindnet-0.0.2/README.md

@@ -0,0 +1,33 @@
+[![pipeline status](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/pipeline.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/commits/main)
+<!---
+[![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/commits/main)
+[![DOI](https://zenodo.org/badge/164115313.svg)](https://zenodo.org/badge/latestdoi/164115313)
+[![PyPi](https://img.shields.io/pypi/v/optiwindnet)](https://pypi.org/project/optiwindnet/)
+[![License](https://img.shields.io/pypi/l/optiwindnet)](https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/blob/main/LICENSE)
+-->
+
+OptiWindNet
+===========
+
+Tool for designing and optimizing the electrical cable network (collection system) for offshore wind power plants.
+
+Documentation: [https://topfarm.pages.windenergy.dtu.dk/OptiWindNet](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet)
+- [Installation](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/setup#Installation) ([requirements](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/setup#Requirements))
+- [Quickstart](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/Quickstart)
+- [API Reference](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/autoapi/optiwindnet/index.html)
+- [How to Cite](https://topfarm.pages.windenergy.dtu.dk/OptiWindNet/index.html#how-to-cite)
+
+Requirements
+------------
+
+- [requirements.txt](requirements.txt) if using `pip`
+- [environment.yml](environment.yml) if using `conda`
+
+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 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 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).

optiwindnet-0.0.2/optiwindnet/MILP/core.py

@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: MIT
+# https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/
+
+import abc
+import networkx as nx
+import logging
+
+from ..interarraylib import G_from_S
+from ..pathfinding import PathFinder
+
+
+logger = logging.getLogger(__name__)
+info = logger.info
+
+
+class PoolHandler(abc.ABC):
+    num_solutions: int
+
+    @abc.abstractmethod
+    def objective_at(self, index: int) -> float:
+        'Get objective value from solution pool at position `index`'
+        pass
+    
+    @abc.abstractmethod
+    def S_from_pool(self) -> nx.Graph:
+        'Build S from the pool solution at the last requested position'
+        pass
+
+def investigate_pool(P: nx.PlanarEmbedding, A: nx.Graph, pool: PoolHandler
+        ) -> nx.Graph:
+    '''Go through the CpSat's solutions checking which has the shortest length
+    after applying the detours with PathFinder.'''
+    Λ = float('inf')
+    num_solutions = pool.num_solutions
+    info(f'Solution pool has {num_solutions} solutions.')
+    for i in range(num_solutions):
+        λ = pool.objective_at(i)
+        #  print(f'λ[{i}] = {λ}')
+        if λ > Λ:
+            info(f'Pool investigation over - next best undetoured length: {λ:.3f}')
+            break
+        S = pool.S_from_pool()
+        G = G_from_S(S, A)
+        Hʹ = PathFinder(G, planar=P, A=A).create_detours()
+        Λʹ = Hʹ.size(weight='length')
+        if Λʹ < Λ:
+            H, Λ = Hʹ, Λʹ
+            pool_index = i
+            pool_objective = λ
+            info(f'Incumbent has (detoured) length: {Λ:.3f}')
+    H.graph['pool_count'] = num_solutions
+    if pool_index > 0:
+        H.graph['pool_entry'] = pool_index, pool_objective
+    return H
+

optiwindnet-0.0.2/optiwindnet/MILP/ortools.py

@@ -0,0 +1,328 @@
+# SPDX-License-Identifier: MIT
+# https://gitlab.windenergy.dtu.dk/TOPFARM/OptiWindNet/
+
+import math
+import logging
+from collections import defaultdict
+from itertools import chain
+import networkx as nx
+
+from ortools.sat.python import cp_model
+
+from .core import PoolHandler
+from ..crossings import edgeset_edgeXing_iter, gateXing_iter
+from ..interarraylib import fun_fingerprint
+
+logger = logging.getLogger(__name__)
+info = logger.info
+
+
+class _SolutionStore(cp_model.CpSolverSolutionCallback):
+    '''Ad hoc implementation of a callback that stores solutions to a pool.'''
+    solutions: list[tuple[float, dict]]
+
+    def __init__(self, model: cp_model.CpModel):
+        super().__init__()
+        self.solutions = []
+        int_lits = []
+        bool_lits = []
+        for var in model._CpModel__var_list._VariableList__var_list:
+            if var.is_boolean:
+                bool_lits.append(var)
+            elif var.is_integer():
+                int_lits.append(var)
+        self.bool_lits = bool_lits
+        self.int_lits = int_lits
+
+    def on_solution_callback(self):
+        solution = {var.index: self.boolean_value(var) for var in self.bool_lits}
+        solution |= {var.index: self.value(var) for var in self.int_lits}
+        self.solutions.append((self.objective_value, solution))
+
+
+class CpSat(PoolHandler, cp_model.CpSolver):
+    '''OR-Tools CpSolver wrapper.
+
+    This class wraps and changes the behavior of CpSolver in order to save all
+    solutions found to a pool. Meant to be used with `investigate_pool()`.
+    '''
+    solution_pool: list[tuple[float, dict]]
+
+    def solve(self, model: cp_model.CpModel) -> cp_model.cp_model_pb2.CpSolverStatus:
+        '''Wrapper for CpSolver.solve() that saves all solutions.
+
+        This method uses a custom CpSolverSolutionCallback to fill a solution
+        pool stored in the attribute self.solutions.
+        '''
+        self.model = model
+        storer = _SolutionStore(model)
+        result = super().solve(model, storer)
+        storer.solutions.reverse()
+        self.solution_pool = storer.solutions
+        _, self._value_map = storer.solutions[0]
+        self.num_solutions = len(storer.solutions)
+        return result
+
+    def load_solution(self, i: int) -> None:
+        '''Select solution at position `i` in the pool.
+
+        Indices start from 0 (last, aka best) and are ordered by increasing
+        objective function value.
+        It *only* affects methods `value()` and `boolean_value()` and
+        attribute `objective_value`.
+        '''
+        self._objective_value, self._value_map = self.solution_pool[i]
+
+    def boolean_value(self, literal: cp_model.IntVar) -> bool:
+        return self._value_map[literal.index]
+
+    def value(self, literal: cp_model.IntVar) -> int:
+        return self._value_map[literal.index]
+
+    def objective_at(self, index:int) -> float:
+        objective_value, self._value_map = self.solution_pool[index]
+        return objective_value
+
+    def S_from_pool(self) -> nx.Graph:
+        return S_from_solution(self.model, solver=self)
+
+
+def make_min_length_model(A: nx.Graph, capacity: int, *,
+                          gateXings_constraint: bool = False,
+                          gates_limit: bool | int = False,
+                          branching: bool = True) -> cp_model.CpModel:
+    '''
+    Build ILP CP OR-tools model for the collector system length minimization.
+    `A` is the graph with the available edges to choose from.
+
+    `capacity`: cable capacity
+
+    `gateXing_constraint`: if gates and edges are forbidden to cross.
+
+    `gates_limit`: if True, use the minimum feasible number of gates
+    (total for all roots); if False, no limit is imposed; if a number,
+    use it as the limit.
+
+    `branching`: if root branches are paths (False) or can be trees (True).
+    '''
+    R = A.graph['R']
+    T = A.graph['T']
+    d2roots = A.graph['d2roots']
+    A_nodes = nx.subgraph_view(A, filter_node=lambda n: n >= 0)
+    W = sum(w for _, w in A_nodes.nodes(data='power', default=1))
+
+    # Sets
+    _T = range(T)
+    _R = range(-R, 0)
+
+    E = tuple(((u, v) if u < v else (v, u))
+              for u, v in A_nodes.edges())
+    # using directed node-node links -> create the reversed tuples
+    Eʹ = tuple((v, u) for u, v in E)
+    # set of feeders to all roots
+    stars = tuple((t, r) for t in _T for r in _R)
+    linkset = E + Eʹ + stars
+
+    # Create model
+    m = cp_model.CpModel()
+
+    ##############
+    # Parameters #
+    ##############
+
+    k = capacity
+    weight_ = (2*tuple(A[u][v]['length'] for u, v in E)
+              + tuple(d2roots[t, r] for t, r in stars))
+
+    #############
+    # Variables #
+    #############
+
+    link_ = {e: m.new_bool_var(f'link_{e}') for e in linkset}
+    flow_ = {e: m.new_int_var(0, k - 1, f'flow_{e}') for e in chain(E, Eʹ)}
+    flow_ |= {e: m.new_int_var(0, k, f'flow_{e}') for e in stars}
+
+    ###############
+    # Constraints #
+    ###############
+
+    # total number of edges must be equal to number of terminal nodes
+    m.add(sum(link_.values()) == T)
+
+    # enforce a single directed edge between each node pair
+    for u, v in E:
+        m.add_at_most_one(link_[(u, v)], link_[(v, u)])
+
+    # gate-edge crossings
+    if gateXings_constraint:
+        for (u, v), tr in gateXing_iter(A):
+            m.add_at_most_one(link_[(u, v)], link_[(v, u)], link_[tr])
+
+    # edge-edge crossings
+    for Xing in edgeset_edgeXing_iter(A.graph['diagonals']):
+        m.add_at_most_one(sum(((link_[u, v], link_[v, u]) for u, v in Xing), ()))
+
+    # bind flow to link activation
+    for t, n in linkset:
+        m.add(flow_[t, n] == 0).only_enforce_if(link_[t, n].Not())
+        #  m.add(flow_[t, n] <= link_[t, n]*(k if n < 0 else (k - 1)))
+        m.add(flow_[t, n] > 0).only_enforce_if(link_[t, n])
+        #  m.add(flow_[t, n] >= link_[t, n])
+
+    # flow conservation with possibly non-unitary node power
+    for t in _T:
+        m.add(sum((flow_[t, n] - flow_[n, t]) for n in A_nodes.neighbors(t))
+              + sum(flow_[t, r] for r in _R)
+              == A.nodes[t].get('power', 1))
+
+    # gates limit
+    min_gates = math.ceil(T/k)
+    all_gate_vars_sum = sum(link_[t, r] for r in _R for t in _T)
+    if gates_limit:
+        if isinstance(gates_limit, bool) or gates_limit == min_gates:
+            # fixed number of gates
+            m.add(all_gate_vars_sum == min_gates)
+        else:
+            assert min_gates < gates_limit, (
+                    f'Infeasible: T/k > gates_limit (T = {T}, k = {k},'
+                    f' gates_limit = {gates_limit}).')
+            # number of gates within range
+            m.add_linear_constraint(all_gate_vars_sum, min_gates, gates_limit)
+    else:
+        # valid inequality: number of gates is at least the minimum
+        m.add(all_gate_vars_sum >= min_gates)
+
+    # non-branching
+    if not branching:
+        for t in _T:
+            m.add(sum(link_[n, t] for n in A_nodes.neighbors(t)) <= 1)
+
+    # assert all nodes are connected to some root
+    m.add(sum(flow_[t, r] for r in _R for t in _T) == W)
+
+    # valid inequalities
+    for t in _T:
+        # incoming flow limit
+        m.add(sum(flow_[n, t] for n in A_nodes.neighbors(t))
+              <= k - A.nodes[t].get('power', 1))
+        # only one out-edge per terminal
+        m.add(sum(link_[t, n] for n in chain(A_nodes.neighbors(t), _R)) == 1)
+
+    #############
+    # Objective #
+    #############
+
+    m.minimize(cp_model.LinearExpr.WeightedSum(tuple(link_.values()), weight_))
+
+    # save data structure as model attributes
+    m.link_, m.linkset, m.flow_, m.R, m.T, m.k = link_, linkset, flow_, R, T, k
+
+    ##################
+    # Store metadata #
+    ##################
+
+    m.handle = A.graph['handle']
+    m.name = A.graph.get('name', 'unnamed')
+    m.method_options = dict(gateXings_constraint=gateXings_constraint,
+                            gates_limit=gates_limit,
+                            branching=branching)
+    m.fun_fingerprint = fun_fingerprint()
+    m.warmed_by = None
+    return m
+
+
+def warmup_model(model: cp_model.CpModel, S: nx.Graph) -> cp_model.CpModel:
+    '''
+    Changes `model` in-place.
+    '''
+    R, T = model.R, model.T
+    model.ClearHints()
+    for u, v in model.linkset[:(len(model.linkset) - R*T)//2]:
+        edgeD = S.edges.get((u, v))
+        if edgeD is None:
+            model.add_hint(model.link_[u, v], False)
+            model.add_hint(model.flow_[u, v], 0)
+            model.add_hint(model.link_[v, u], False)
+            model.add_hint(model.flow_[v, u], 0)
+        else:
+            u, v = (u, v) if ((u < v) == edgeD['reverse']) else (v, u)
+            model.add_hint(model.link_[u, v], True)
+            model.add_hint(model.flow_[u, v], edgeD['load'])
+            model.add_hint(model.link_[v, u], False)
+            model.add_hint(model.flow_[v, u], 0)
+    for t, r in model.linkset[-R*T:]:
+        edgeD = S.edges.get((t, r))
+        model.add_hint(model.link_[t, r], edgeD is not None)
+        model.add_hint(model.flow_[t, r], 0 if edgeD is None else edgeD['load'])
+    model.warmed_by = S.graph['creator']
+    return model
+
+
+def S_from_solution(model: cp_model.CpModel,
+                    solver: cp_model.CpSolver, result: int = 0) -> nx.Graph:
+    '''Create a topology `S` from the OR-tools solution to the MILP model.
+
+    Args:
+        model: passed to the solver.
+        solver: used to solve the model.
+        result: irrelevant, exists only to mirror the Pyomo alternative.
+    Returns:
+        Graph topology from the solution.
+    '''
+    # the solution is in the solver object not in the model
+
+    # Metadata
+    R, T = model.R, model.T
+    solver_name = 'ortools'
+    bound = solver.best_objective_bound
+    objective = solver.objective_value
+    S = nx.Graph(
+        R=R, T=T,
+        handle=model.handle,
+        capacity=model.k,
+        objective=objective,
+        bound=bound,
+        runtime=solver.wall_time,
+        termination=solver.status_name(),
+        gap=1. - bound/objective,
+        creator='MILP.' + solver_name,
+        has_loads=True,
+        method_options=dict(
+            solver_name=solver_name,
+            mipgap=solver.parameters.relative_gap_limit,
+            timelimit=solver.parameters.max_time_in_seconds,
+            fun_fingerprint=model.fun_fingerprint,
+            **model.method_options,
+        ),
+        solver_details=dict(
+            strategy=solver.solution_info(),
+        )
+    )
+
+    if model.warmed_by is not None:
+        S.graph['warmstart'] = model.warmed_by
+
+    # Graph data
+    # Get active links and if flow is reversed (i.e. from small to big)
+    rev_from_link = {(u, v): u < v
+                     for (u, v), use in model.link_.items()
+                     if solver.boolean_value(use)}
+    S.add_weighted_edges_from(
+        ((u, v, solver.value(model.flow_[u, v]))
+         for (u, v) in rev_from_link.keys()), weight='load'
+    )
+    # set the 'reverse' edge attribute
+    nx.set_edge_attributes(S, rev_from_link, name='reverse')
+    # propagate loads from edges to nodes
+    subtree = -1
+    for r in range(-R, 0):
+        for u, v in nx.edge_dfs(S, r):
+            S.nodes[v]['load'] = S[u][v]['load']
+            if u == r:
+                subtree += 1
+            S.nodes[v]['subtree'] = subtree
+        rootload = 0
+        for nbr in S.neighbors(r):
+            rootload += S.nodes[nbr]['load']
+        S.nodes[r]['load'] = rootload
+    return S