diff --git a/docs/images/res1d_network_mapping.png b/docs/images/res1d_network_mapping.png deleted file mode 100644 index 2930e9914..000000000 Binary files a/docs/images/res1d_network_mapping.png and /dev/null differ diff --git a/docs/images/res1d_network_mapping.svg b/docs/images/res1d_network_mapping.svg new file mode 100644 index 000000000..2d085c749 --- /dev/null +++ b/docs/images/res1d_network_mapping.svg @@ -0,0 +1,182 @@ + + + + + Res1D + Network + + + + + + + + + + + + + + + + + gridpoints + reaches + nodes + combined + + + + + + + + + + + + + + + r1 + r2 + + + + + A + + B + + C + + + + + + + + + + + + + + + + A + + + + + + + + B + + + + + + + C + + + + (same location) + (same location, ×3) + (same location) + + + + + + from_mike() + + + + + + + + + + + + + + + + + + 0.0 + 0.0 + 0.0 + 0.0 + + + + + + + + + + + + + + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + + + + + + reach segment (length > 0) + + boundary edge (length = 0.0) + + + + + Boundary edge (zoomed) + + + + length: 0.0 + boundary: True + + + + + + 1 + 2 + + + + Node 1 — old id: "A" + ordinary node — no boundary flag on it + Node 2 — old id: reach "r1" @ 0.0 + r1's own first gridpoint, promoted to a + breakpoint since it sits where node 1 does + + + + + recall(1) → {"node": "A"} + recall(2) → {"reach": "r1", "distance": 0.0} + find(node="A") → 1 + + + + diff --git a/docs/user-guide/network.qmd b/docs/user-guide/network.qmd index e769cc28a..d22f0c1c6 100644 --- a/docs/user-guide/network.qmd +++ b/docs/user-guide/network.qmd @@ -27,7 +27,6 @@ uv add modelskill[networks] import pandas as pd import numpy as np -from typing import Any from modelskill.network import Network, NetworkNode, NetworkReach, ReachBreakPoint @@ -46,10 +45,6 @@ class ExampleNode(NetworkNode): def data(self) -> pd.DataFrame: return self._data - @property - def boundary(self) -> dict[str, Any]: - return {} - class ExampleReach(NetworkReach): """Reach connecting two nodes with a given length.""" @@ -242,9 +237,21 @@ For the same reason, `resx=` merges node quantities only. Its reach-level quanti Node timeseries, `to_dataframe()`, `to_dataset()`, `find(node=...)` and `recall()` are unaffected. ::: -A MIKE 1D network contains multiple levels that are unified into a generic network structure as depicted in the image below. The image introduces concepts like _find_, _recall_ and _boundary_ which are explained in the following sections. +A MIKE 1D network contains multiple levels that are unified into a generic network structure as depicted in the image below. The image introduces the _find_ and _recall_ concepts explained in the following sections. + +![How a Res1D file maps to a Network object. Reaches and nodes are re-indexed as integers, exposing `find()`/`recall()` round-trip lookups. A reach's own start/end gridpoint sits at the same location as its node but stays a distinct graph node, joined to it by a zero-length boundary edge.](../images/res1d_network_mapping.svg) + +::: {.callout-note} +## Zero-length boundary edges + +A reach's first and last gridpoint sit at the same location as its start/end node, so each becomes a breakpoint connected to that node by an edge of length `0.0`. That edge carries `boundary=True` in `network.graph`, distinguishing it from an ordinary segment: -![How a Res1D file maps to a Network object. Reaches and nodes are re-indexed as integers; boundary nodes expose `find()`/`recall()` round-trip lookups.](../images/res1d_network_mapping.png) +```{python} +[d for *_, d in network.graph.edges(data=True) if d["boundary"]][:2] +``` + +If you run a length-weighted `networkx` algorithm on `network.graph` (e.g. shortest path), it will silently treat these as free hops rather than erroring — unlike an edge with `length=None` (see the EPANET callout above), a `0.0` weight is valid input and networkx has no reason to reject it. Filter on `boundary` first if you need distances that only count real reach segments. +::: #### Selective loading @@ -470,7 +477,7 @@ Use `ReachObservation` when your measured quantity is representative of the whol In case you have your network data in a format that is not included in [Building a Network](#building-a-network), you can assemble a `Network` object by subclassing the abstract base classes `NetworkNode` and `NetworkReach`. -`NetworkNode` requires three properties: `id`, `data`, and `boundary`. +`NetworkNode` requires two properties: `id` and `data`. `NetworkReach` requires four: `id`, `start`, `end`, and `breakpoints`. `NetworkReach.length` is optional and defaults to `None`. Reach length matters in some domains (rivers, sewer networks) and not in others (link-node water distribution models), so override it only where a length exists. Where it is left undefined, the reach contributes an edge with `length=None` to `network.graph`, which keeps length-weighted graph algorithms from quietly treating the reach as free. Nothing else in modelskill reads the length — matching and extraction work from break point distances alone. @@ -481,7 +488,6 @@ The following is a simple implementation example: ```python import pandas as pd import numpy as np -from typing import Any from modelskill.network import NetworkNode, NetworkReach, Network @@ -500,10 +506,6 @@ class ExampleNode(NetworkNode): def data(self) -> pd.DataFrame: return self._data - @property - def boundary(self) -> dict[str, Any]: - return {} - class ExampleReach(NetworkReach): """Reach connecting two nodes with a given length.""" @@ -540,7 +542,7 @@ class ExampleReach(NetworkReach): ``` ::: {.callout-tip} -The three abstract properties that **every** `NetworkNode` subclass must implement are `id`, `data` and `boundary`. If `boundary` is not relevant for your use case, define the property to return an empty dictionary, as in the example above. Similarly, a `NetworkReach` with no intermediate points can return an empty `breakpoints` list, and one with no meaningful length can leave the `length` property out altogether. +The two abstract properties that **every** `NetworkNode` subclass must implement are `id` and `data`. A `NetworkReach` with no intermediate points can return an empty `breakpoints` list, and one with no meaningful length can leave the `length` property out altogether. ::: diff --git a/notebooks/Collection_systems_network.ipynb b/notebooks/Collection_systems_network.ipynb index 89e9962e0..771402583 100644 --- a/notebooks/Collection_systems_network.ipynb +++ b/notebooks/Collection_systems_network.ipynb @@ -1,1629 +1,1590 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "fdb0d0b9", - "metadata": {}, - "outputs": [], - "source": [ - "import modelskill as ms\n", - "import pandas as pd\n", - "import numpy as np\n", - "\n", - "import networkx as nx\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from modelskill.network import Network" - ] - }, - { - "cell_type": "markdown", - "id": "b643e568", - "metadata": {}, - "source": [ - "# 1D network workflow\n", - "\n", - "This notebook shows how to use `modelskill` to evaluate model results from 1D network simulations, such as collection systems or river networks. The workflow follows the same four-step pattern used elsewhere in `modelskill`: define model results → define observations → match → compare.\n", - "\n", - "## Loading network results\n", - "\n", - "The `Network` class organises data from a network simulation (e.g. a sewer system or a river) into a form that `modelskill` can work with. It stores time-series data for every node and break point in the network, and exposes the topology via a `networkx` graph.\n", - "\n", - "### Loading from a supported format\n", - "\n", - "The easiest way to create a `Network` is to load it directly from a supported file format. Currently **Res1D** (MIKE 1D) is supported:\n", - "\n", - "```python\n", - "from modelskill.network import Network\n", - "\n", - "network = Network.from_mike(\"path/to/results.res1d\")\n", - "``` \n", - "\n", - "### Custom network format\n", - "\n", - "For other simulation tools you can build a `Network` from your own data by subclassing the abstract base classes `NetworkNode` and `NetworkEdge`. Notice that this approach requires that you build the logic to generate a list of `NetworkEdge` to pass it to the network.\n", - "\n", - "```python\n", - "from modelskill.network import Network, NetworkNode, NetworkEdge\n", - "\n", - "class MyNode(NetworkNode): ...\n", - "\n", - "class MyEdge(NetworkEdge): ...\n", - "\n", - "\n", - "def generate_list_of_edges(a_network: CustomNetwork) -> list[MyEdge]: ...\n", - "\n", - "\n", - "edges = generate_list_of_edges(custom_network)\n", - "\n", - "network = Network(edges)\n", - "``` \n", - "\n", - "#### Break points\n", - "\n", - "Edges can optionally contain **break points** — intermediate locations along a reach (e.g. cross-section chainages) that carry their own time-series data. You can include them with subclass `EdgeBreakPoint`.\n", - "\n", - "### Example" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "cd363bae", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Reaches: 118\n", - "Nodes: 259\n", - "Quantities: ['WaterLevel', 'Discharge']\n", - "Time: 1994-08-07 16:35:00 - 1994-08-07 18:35:00" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network = Network.from_mike(\"../tests/testdata/network.res1d\")\n", - "network" - ] - }, - { - "cell_type": "markdown", - "id": "33a451d3", - "metadata": {}, - "source": [ - "All time-series data stored in the network can be accessed as an `xarray.Dataset` with `to_dataset()`. The dataset has one variable per physical quantity and uses the network's integer node IDs as the `node` coordinate:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2a2d7414", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 231kB\n",
-              "Dimensions:     (time: 110, node: 259)\n",
-              "Coordinates:\n",
-              "  * time        (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n",
-              "  * node        (node) int64 2kB 0 1 2 3 4 5 6 7 ... 252 253 254 255 256 257 258\n",
-              "Data variables:\n",
-              "    WaterLevel  (time, node) float32 114kB 195.4 194.7 nan ... 188.5 nan nan\n",
-              "    Discharge   (time, node) float32 114kB nan nan 5.72e-06 ... nan 0.01692 0.0
" - ], - "text/plain": [ - " Size: 231kB\n", - "Dimensions: (time: 110, node: 259)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n", - " * node (node) int64 2kB 0 1 2 3 4 5 6 7 ... 252 253 254 255 256 257 258\n", - "Data variables:\n", - " WaterLevel (time, node) float32 114kB 195.4 194.7 nan ... 188.5 nan nan\n", - " Discharge (time, node) float32 114kB nan nan 5.72e-06 ... nan 0.01692 0.0" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.to_dataset()" - ] - }, - { - "cell_type": "markdown", - "id": "a972271a", - "metadata": {}, - "source": [ - "`Network` also exposes the underlying `networkx.Graph` via the `graph` property. This graph contains the full network topology — each graph node stores the node's data and boundary metadata — making it straightforward to run graph-based analyses (shortest path, connectivity checks, etc.):" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "06e8c2cb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.graph" - ] - }, - { - "cell_type": "markdown", - "id": "885523e1", - "metadata": {}, - "source": [ - "Querying the underlying `networkx` graph lets you run topology-based analyses (e.g. shortest path, connected components) directly on the network. The visualisation below plots the graph, highlighting boundary/junction nodes with a thicker outline:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1d068e44", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_network(g: nx.Graph):\n", - "\n", - " g = g.copy()\n", - " lengths = nx.get_edge_attributes(g, \"length\")\n", - " max_len = max(lengths.values()) if lengths else 1.0\n", - " nx.set_edge_attributes(\n", - " g,\n", - " {e: v / max_len for e, v in lengths.items()},\n", - " \"norm_length\",\n", - " )\n", - "\n", - " widthmap = [2 if 'boundary' in g.nodes[node] else 1 for node in g.nodes()]\n", - " plot_kwargs = {\n", - " \"font_size\": 6,\n", - " \"node_size\": 130,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": widthmap,\n", - " \"with_labels\": True,\n", - " }\n", - " fig, ax = plt.subplots(1, 1, sharey=True, layout=\"tight\", figsize=(10, 9))\n", - "\n", - " n = g.number_of_nodes()\n", - " k = 10 / np.sqrt(n) # increase multiplier (5, 10, ...) until nodes stop overlapping\n", - "\n", - " pos = nx.kamada_kawai_layout(g, weight=\"norm_length\", scale=10)\n", - " nx.draw(g, ax=ax, pos=pos, **plot_kwargs)\n", - "\n", - " # Set limits explicitly AFTER draw, otherwise matplotlib auto-scales them away\n", - " xs, ys = zip(*pos.values())\n", - " pad = 0.5\n", - " ax.set_xlim(min(xs) - pad, max(xs) + pad)\n", - " ax.set_ylim(min(ys) - pad, max(ys) + pad)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "53ab2b9c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_network(network.graph)" - ] - }, - { - "cell_type": "markdown", - "id": "5d3030f5", - "metadata": {}, - "source": [ - "Notice that in the visualisation above, some graph nodes have a thicker outline — these are the *nodes* (junctions and boundaries), while the others are *break points* along each reach.\n", - "\n", - "#### Mapping original IDs to integer IDs\n", - "\n", - "Internally, the `Network` relabels all nodes and break points with consecutive integers for efficient indexing. The original IDs used by the simulation tool are preserved and can be looked up with `find()`:\n", - "\n", - "In this Res1D example the original node IDs are strings. `find(node=...)` returns the corresponding integer ID:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d9d23a8b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "252" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.find(node=\"98\")" - ] - }, - { - "cell_type": "markdown", - "id": "ae495c5d", - "metadata": {}, - "source": [ - "Break points are identified in the original network by the edge (reach) they belong to and their distance from the start node.\n", - "\n", - "> **Note:** The current `Network` implementation assumes a directed edge, so distance is always measured from the start node." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "30c88717", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "131" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.find(reach=\"44l1\", distance=44.841)" - ] - }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "fdb0d0b9", + "metadata": {}, + "outputs": [], + "source": [ + "import modelskill as ms\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from modelskill.network import Network" + ] + }, + { + "cell_type": "markdown", + "id": "b643e568", + "metadata": {}, + "source": [ + "# 1D network workflow\n", + "\n", + "This notebook shows how to use `modelskill` to evaluate model results from 1D network simulations, such as collection systems or river networks. The workflow follows the same four-step pattern used elsewhere in `modelskill`: define model results → define observations → match → compare.\n", + "\n", + "## Loading network results\n", + "\n", + "The `Network` class organises data from a network simulation (e.g. a sewer system or a river) into a form that `modelskill` can work with. It stores time-series data for every node and break point in the network, and exposes the topology via a `networkx` graph.\n", + "\n", + "### Loading from a supported format\n", + "\n", + "The easiest way to create a `Network` is to load it directly from a supported file format. Currently **Res1D** (MIKE 1D) is supported:\n", + "\n", + "```python\n", + "from modelskill.network import Network\n", + "\n", + "network = Network.from_mike(\"path/to/results.res1d\")\n", + "``` \n", + "\n", + "### Custom network format\n", + "\n", + "For other simulation tools you can build a `Network` from your own data by subclassing the abstract base classes `NetworkNode` and `NetworkEdge`. Notice that this approach requires that you build the logic to generate a list of `NetworkEdge` to pass it to the network.\n", + "\n", + "```python\n", + "from modelskill.network import Network, NetworkNode, NetworkEdge\n", + "\n", + "class MyNode(NetworkNode): ...\n", + "\n", + "class MyEdge(NetworkEdge): ...\n", + "\n", + "\n", + "def generate_list_of_edges(a_network: CustomNetwork) -> list[MyEdge]: ...\n", + "\n", + "\n", + "edges = generate_list_of_edges(custom_network)\n", + "\n", + "network = Network(edges)\n", + "``` \n", + "\n", + "#### Break points\n", + "\n", + "Edges can optionally contain **break points** — intermediate locations along a reach (e.g. cross-section chainages) that carry their own time-series data. You can include them with subclass `EdgeBreakPoint`.\n", + "\n", + "### Example" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cd363bae", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "a7e41a31", - "metadata": {}, - "source": [ - "Multiple IDs can be looked up in a single call. For break points, each distance value corresponds to the edge at the same position in the `edge` list (one-to-one pairing):" + "data": { + "text/plain": [ + "\n", + "Reaches: 118\n", + "Nodes: 259\n", + "Quantities: ['WaterLevel', 'Discharge']\n", + "Time: 1994-08-07 16:35:00 - 1994-08-07 18:35:00" ] - }, + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network = Network.from_mike(\"../tests/testdata/network.res1d\")\n", + "network" + ] + }, + { + "cell_type": "markdown", + "id": "33a451d3", + "metadata": {}, + "source": [ + "All time-series data stored in the network can be accessed as an `xarray.Dataset` with `to_dataset()`. The dataset has one variable per physical quantity and uses the network's integer node IDs as the `node` coordinate:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2a2d7414", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 10, - "id": "e25a4ba8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "([241, 3, 40], [131, 133])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 231kB\n",
+       "Dimensions:     (time: 110, node: 259)\n",
+       "Coordinates:\n",
+       "  * time        (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n",
+       "  * node        (node) int64 2kB 0 1 2 3 4 5 6 7 ... 252 253 254 255 256 257 258\n",
+       "Data variables:\n",
+       "    WaterLevel  (time, node) float32 114kB 195.4 194.7 nan ... 188.5 nan nan\n",
+       "    Discharge   (time, node) float32 114kB nan nan 5.72e-06 ... nan 0.01692 0.0
" ], - "source": [ - "network.find(node=[\"92\", \"101\", \"113\"]), network.find(reach=[\"44l1\", \"45l1\"], distance=[44.841, 37.206])" + "text/plain": [ + " Size: 231kB\n", + "Dimensions: (time: 110, node: 259)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n", + " * node (node) int64 2kB 0 1 2 3 4 5 6 7 ... 252 253 254 255 256 257 258\n", + "Data variables:\n", + " WaterLevel (time, node) float32 114kB 195.4 194.7 nan ... 188.5 nan nan\n", + " Discharge (time, node) float32 114kB nan nan 5.72e-06 ... nan 0.01692 0.0" ] - }, + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.to_dataset()" + ] + }, + { + "cell_type": "markdown", + "id": "a972271a", + "metadata": {}, + "source": "`Network` also exposes the underlying `networkx.Graph` via the `graph` property. This graph contains the full network topology — each graph node stores its own time-series data — making it straightforward to run graph-based analyses (shortest path, connectivity checks, etc.):" + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "06e8c2cb", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "c4f36cfd", - "metadata": {}, - "source": [ - "Use `recall()` to translate integer IDs back to the original identifiers. This is useful when you want to know which original node or break point corresponds to a given integer ID:" + "data": { + "text/plain": [ + "" ] - }, + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.graph" + ] + }, + { + "cell_type": "markdown", + "id": "885523e1", + "metadata": {}, + "source": "Querying the underlying `networkx` graph lets you run topology-based analyses (e.g. shortest path, connected components) directly on the network. The visualisation below plots the graph, highlighting junction/reservoir nodes with a thicker outline:" + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d068e44", + "metadata": {}, + "outputs": [], + "source": "def plot_network(g: nx.Graph):\n\n g = g.copy()\n lengths = nx.get_edge_attributes(g, \"length\")\n max_len = max(lengths.values()) if lengths else 1.0\n nx.set_edge_attributes(\n g,\n {e: v / max_len for e, v in lengths.items()},\n \"norm_length\",\n )\n\n # A node's alias is a string for a real junction/reservoir node, and a\n # (reach, distance) tuple for a break point along a reach.\n widthmap = [2 if isinstance(g.nodes[node][\"alias\"], str) else 1 for node in g.nodes()]\n plot_kwargs = {\n \"font_size\": 6,\n \"node_size\": 130,\n \"node_color\": \"white\",\n \"edgecolors\": \"black\",\n \"linewidths\": widthmap,\n \"with_labels\": True,\n }\n fig, ax = plt.subplots(1, 1, sharey=True, layout=\"tight\", figsize=(10, 9))\n\n n = g.number_of_nodes()\n k = 10 / np.sqrt(n) # increase multiplier (5, 10, ...) until nodes stop overlapping\n\n pos = nx.kamada_kawai_layout(g, weight=\"norm_length\", scale=10)\n nx.draw(g, ax=ax, pos=pos, **plot_kwargs)\n\n # Set limits explicitly AFTER draw, otherwise matplotlib auto-scales them away\n xs, ys = zip(*pos.values())\n pad = 0.5\n ax.set_xlim(min(xs) - pad, max(xs) + pad)\n ax.set_ylim(min(ys) - pad, max(ys) + pad)\n plt.show()" + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "53ab2b9c", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 11, - "id": "cb1ae550", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "({'node': '98'},\n", - " {'reach': '45l1', 'distance': 37.20599457458005},\n", - " [{'node': '98'}, {'reach': '45l1', 'distance': 37.20599457458005}])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.recall(252), network.recall(133), network.recall([252, 133]) " + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_network(network.graph)" + ] + }, + { + "cell_type": "markdown", + "id": "5d3030f5", + "metadata": {}, + "source": [ + "Notice that in the visualisation above, some graph nodes have a thicker outline — these are the *nodes* (junctions and boundaries), while the others are *break points* along each reach.\n", + "\n", + "#### Mapping original IDs to integer IDs\n", + "\n", + "Internally, the `Network` relabels all nodes and break points with consecutive integers for efficient indexing. The original IDs used by the simulation tool are preserved and can be looked up with `find()`:\n", + "\n", + "In this Res1D example the original node IDs are strings. `find(node=...)` returns the corresponding integer ID:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d9d23a8b", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "41ca197f", - "metadata": {}, - "source": [ - "## Integration with `modelskill`\n", - "\n", - "Wrap a `Network` in a `NetworkModelResult` to make it compatible with the standard `modelskill` comparison workflow. The `item` argument selects which quantity to use when more than one is available in the network:" + "data": { + "text/plain": [ + "252" ] - }, + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.find(node=\"98\")" + ] + }, + { + "cell_type": "markdown", + "id": "ae495c5d", + "metadata": {}, + "source": [ + "Break points are identified in the original network by the edge (reach) they belong to and their distance from the start node.\n", + "\n", + "> **Note:** The current `Network` implementation assumes a directed edge, so distance is always measured from the start node." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "30c88717", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 13, - "id": "edec2e5a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - ": WaterLevel" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network_model = ms.NetworkModelResult(network, item=\"WaterLevel\")\n", - "network_model" + "data": { + "text/plain": [ + "131" ] - }, + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.find(reach=\"44l1\", distance=44.841)" + ] + }, + { + "cell_type": "markdown", + "id": "a7e41a31", + "metadata": {}, + "source": [ + "Multiple IDs can be looked up in a single call. For break points, each distance value corresponds to the edge at the same position in the `edge` list (one-to-one pairing):" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e25a4ba8", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "5905e267", - "metadata": {}, - "source": [ - "To evaluate the model we need observations at network nodes. These are represented by `NodeObservation`, which requires an integer node ID obtained via `Network.find()`.\n", - "\n", - "In this example we create synthetic sensor observations by extracting data from the network dataset and adding random noise to simulate real-world measurement error and timing jitter:" + "data": { + "text/plain": [ + "([241, 3, 40], [131, 133])" ] - }, + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.find(node=[\"92\", \"101\", \"113\"]), network.find(reach=[\"44l1\", \"45l1\"], distance=[44.841, 37.206])" + ] + }, + { + "cell_type": "markdown", + "id": "c4f36cfd", + "metadata": {}, + "source": [ + "Use `recall()` to translate integer IDs back to the original identifiers. This is useful when you want to know which original node or break point corresponds to a given integer ID:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cb1ae550", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 14, - "id": "817e1800", - "metadata": {}, - "outputs": [], - "source": [ - "ds = network.to_dataset()\n", - "\n", - "# Script to generate dummy sensor data\n", - "sensor_1 = ds[\"WaterLevel\"].sel(node=30).to_pandas().rename(\"water_level@sens1\")\n", - "sensor_2 = ds[\"WaterLevel\"].sel(node=54).to_pandas().rename(\"water_level@sens2\")\n", - "sensor_3 = ds[\"WaterLevel\"].sel(node=71).to_pandas().rename(\"water_level@sens3\")\n", - "\n", - "perfect_sensors = [sensor_1, sensor_2, sensor_3]\n", - "real_sensors = []\n", - "\n", - "for n, sensor in enumerate(perfect_sensors, start=1):\n", - " sensor += np.random.normal(0, 0.1, len(sensor))\n", - " sensor.index = [sensor.index[i] + pd.Timedelta(s, unit=\"s\") for i, s in enumerate(np.random.uniform(-10, 10, len(sensor)))]\n", - " sensor.sort_index(inplace=True)\n", - " if n == 2:\n", - " sensor = sensor.iloc[30:]\n", - " if n == 3:\n", - " sensor = pd.concat([sensor.iloc[:50], sensor.iloc[70:]])\n", - "\n", - " real_sensors.append(sensor)\n", - " sensor.to_csv(f\"../tests/testdata/network_sensor_{n}.csv\")\n", - "\n", - "sensor_1 = real_sensors[0]\n", - "sensor_2 = real_sensors[1]\n", - "sensor_3 = real_sensors[2]" + "data": { + "text/plain": [ + "({'node': '98'},\n", + " {'reach': '45l1', 'distance': 37.20599457458005},\n", + " [{'node': '98'}, {'reach': '45l1', 'distance': 37.20599457458005}])" ] - }, + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.recall(252), network.recall(133), network.recall([252, 133]) " + ] + }, + { + "cell_type": "markdown", + "id": "41ca197f", + "metadata": {}, + "source": [ + "## Integration with `modelskill`\n", + "\n", + "Wrap a `Network` in a `NetworkModelResult` to make it compatible with the standard `modelskill` comparison workflow. The `item` argument selects which quantity to use when more than one is available in the network:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "edec2e5a", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 15, - "id": "66d1b420", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
water_level@sens2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "water_level@sens2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "\n", - " si r2 \n", - "observation \n", - "water_level@sens2 0.000501 0.721882 " - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# The name is taken from the name of the series\n", - "node_id = network.find(reach=\"117l1\", distance=48.7)\n", - "single_obs = ms.NodeObservation(sensor_2, at=node_id)\n", - "cmp = ms.match(single_obs, network_model)\n", - "cmp.skill()" + "data": { + "text/plain": [ + ": WaterLevel" ] - }, + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network_model = ms.NetworkModelResult(network, item=\"WaterLevel\")\n", + "network_model" + ] + }, + { + "cell_type": "markdown", + "id": "5905e267", + "metadata": {}, + "source": [ + "To evaluate the model we need observations at network nodes. These are represented by `NodeObservation`, which requires an integer node ID obtained via `Network.find()`.\n", + "\n", + "In this example we create synthetic sensor observations by extracting data from the network dataset and adding random noise to simulate real-world measurement error and timing jitter:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "817e1800", + "metadata": {}, + "outputs": [], + "source": [ + "ds = network.to_dataset()\n", + "\n", + "# Script to generate dummy sensor data\n", + "sensor_1 = ds[\"WaterLevel\"].sel(node=30).to_pandas().rename(\"water_level@sens1\")\n", + "sensor_2 = ds[\"WaterLevel\"].sel(node=54).to_pandas().rename(\"water_level@sens2\")\n", + "sensor_3 = ds[\"WaterLevel\"].sel(node=71).to_pandas().rename(\"water_level@sens3\")\n", + "\n", + "perfect_sensors = [sensor_1, sensor_2, sensor_3]\n", + "real_sensors = []\n", + "\n", + "for n, sensor in enumerate(perfect_sensors, start=1):\n", + " sensor += np.random.normal(0, 0.1, len(sensor))\n", + " sensor.index = [sensor.index[i] + pd.Timedelta(s, unit=\"s\") for i, s in enumerate(np.random.uniform(-10, 10, len(sensor)))]\n", + " sensor.sort_index(inplace=True)\n", + " if n == 2:\n", + " sensor = sensor.iloc[30:]\n", + " if n == 3:\n", + " sensor = pd.concat([sensor.iloc[:50], sensor.iloc[70:]])\n", + "\n", + " real_sensors.append(sensor)\n", + " sensor.to_csv(f\"../tests/testdata/network_sensor_{n}.csv\")\n", + "\n", + "sensor_1 = real_sensors[0]\n", + "sensor_2 = real_sensors[1]\n", + "sensor_3 = real_sensors[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "66d1b420", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 16, - "id": "ed1f9094", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
network_sensor_2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "network_sensor_2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "\n", - " si r2 \n", - "observation \n", - "network_sensor_2 0.000501 0.721882 " - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
water_level@sens2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", + "
" ], - "source": [ - "# The name is taken from the name of the file\n", - "path_to_sensor2 = \"../tests/testdata/network_sensor_2.csv\"\n", - "single_obs = ms.NodeObservation(path_to_sensor2, at=node_id)\n", - "cmp = ms.match(single_obs, network_model)\n", - "cmp.skill()" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "water_level@sens2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens2 0.000501 0.721882 " ] - }, + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is taken from the name of the series\n", + "node_id = network.find(reach=\"117l1\", distance=48.7)\n", + "single_obs = ms.NodeObservation(sensor_2, at=node_id)\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ed1f9094", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 17, - "id": "de621fec", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
Sensor 2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc si \\\n", - "observation \n", - "Sensor 2 80 0.007241 0.097285 0.097015 0.077789 0.850782 0.000501 \n", - "\n", - " r2 \n", - "observation \n", - "Sensor 2 0.721882 " - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
network_sensor_2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", + "
" ], - "source": [ - "# The name is passed\n", - "single_obs = ms.NodeObservation(path_to_sensor2, at=node_id, name=\"Sensor 2\")\n", - "cmp = ms.match(single_obs, network_model)\n", - "cmp.skill()" - ] - }, - { - "cell_type": "markdown", - "id": "2357349d", - "metadata": {}, - "source": [ - "### Plotting" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "network_sensor_2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", + "\n", + " si r2 \n", + "observation \n", + "network_sensor_2 0.000501 0.721882 " ] - }, + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is taken from the name of the file\n", + "path_to_sensor2 = \"../tests/testdata/network_sensor_2.csv\"\n", + "single_obs = ms.NodeObservation(path_to_sensor2, at=node_id)\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "de621fec", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 18, - "id": "923a1d93", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
Sensor 2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", + "
" ], - "source": [ - "cmp = ms.match(single_obs, network_model)\n", - "cmp.plot()\n", - "cmp.plot.timeseries();" + "text/plain": [ + " n bias rmse urmse mae cc si \\\n", + "observation \n", + "Sensor 2 80 0.007241 0.097285 0.097015 0.077789 0.850782 0.000501 \n", + "\n", + " r2 \n", + "observation \n", + "Sensor 2 0.721882 " ] - }, + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is passed\n", + "single_obs = ms.NodeObservation(path_to_sensor2, at=node_id, name=\"Sensor 2\")\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "markdown", + "id": "2357349d", + "metadata": {}, + "source": [ + "### Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "923a1d93", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "02e77cf0", - "metadata": {}, - "source": [ - "## Multiple sensors\n", - "\n", - "When you have observations at several nodes you can use `NodeObservation.from_multiple()` to create a list of `NodeObservation` objects. Pass `nodes` as a `dict` mapping each node ID to either a column name/index within a shared `data` source, or to a separate data source entirely:" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 19, - "id": "752261bf", - "metadata": {}, - "outputs": [], - "source": [ - "sensor_df = pd.concat(real_sensors, axis=1)" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmp = ms.match(single_obs, network_model)\n", + "cmp.plot()\n", + "cmp.plot.timeseries();" + ] + }, + { + "cell_type": "markdown", + "id": "02e77cf0", + "metadata": {}, + "source": [ + "## Multiple sensors\n", + "\n", + "When you have observations at several nodes you can use `NodeObservation.from_multiple()` to create a list of `NodeObservation` objects. Pass `nodes` as a `dict` mapping each node ID to either a column name/index within a shared `data` source, or to a separate data source entirely:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "752261bf", + "metadata": {}, + "outputs": [], + "source": [ + "sensor_df = pd.concat(real_sensors, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9acfaf6f", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 20, - "id": "9acfaf6f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0008440.0989450.0989410.0760150.9749860.0005090.950559
water_level@sens2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
water_level@sens389-0.0208130.1046320.1025410.0821040.9360940.0005290.871119
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "water_level@sens1 110 0.000844 0.098945 0.098941 0.076015 0.974986 \n", - "water_level@sens2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "water_level@sens3 89 -0.020813 0.104632 0.102541 0.082104 0.936094 \n", - "\n", - " si r2 \n", - "observation \n", - "water_level@sens1 0.000509 0.950559 \n", - "water_level@sens2 0.000501 0.721882 \n", - "water_level@sens3 0.000529 0.871119 " - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0008440.0989450.0989410.0760150.9749860.0005090.950559
water_level@sens2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
water_level@sens389-0.0208130.1046320.1025410.0821040.9360940.0005290.871119
\n", + "
" ], - "source": [ - "multi_obs = ms.NodeObservation.from_multiple(data=sensor_df, nodes={30: \"water_level@sens1\", 54: \"water_level@sens2\", 71: \"water_level@sens3\"})\n", - "ms.match(multi_obs, network_model).skill()" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "water_level@sens1 110 0.000844 0.098945 0.098941 0.076015 0.974986 \n", + "water_level@sens2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", + "water_level@sens3 89 -0.020813 0.104632 0.102541 0.082104 0.936094 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens1 0.000509 0.950559 \n", + "water_level@sens2 0.000501 0.721882 \n", + "water_level@sens3 0.000529 0.871119 " ] - }, + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "multi_obs = ms.NodeObservation.from_multiple(data=sensor_df, nodes={30: \"water_level@sens1\", 54: \"water_level@sens2\", 71: \"water_level@sens3\"})\n", + "ms.match(multi_obs, network_model).skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d7a0acf1", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 21, - "id": "d7a0acf1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0008440.0989450.0989410.0760150.9749860.0005090.950559
network_sensor_2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
water_level@sens389-0.0208130.1046320.1025410.0821040.9360940.0005290.871119
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "water_level@sens1 110 0.000844 0.098945 0.098941 0.076015 0.974986 \n", - "network_sensor_2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "water_level@sens3 89 -0.020813 0.104632 0.102541 0.082104 0.936094 \n", - "\n", - " si r2 \n", - "observation \n", - "water_level@sens1 0.000509 0.950559 \n", - "network_sensor_2 0.000501 0.721882 \n", - "water_level@sens3 0.000529 0.871119 " - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0008440.0989450.0989410.0760150.9749860.0005090.950559
network_sensor_2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
water_level@sens389-0.0208130.1046320.1025410.0821040.9360940.0005290.871119
\n", + "
" ], - "source": [ - "multi_obs = ms.NodeObservation.from_multiple(nodes={30: sensor_1, 54: path_to_sensor2, 71: sensor_3})\n", - "ms.match(multi_obs, network_model).skill()" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "water_level@sens1 110 0.000844 0.098945 0.098941 0.076015 0.974986 \n", + "network_sensor_2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", + "water_level@sens3 89 -0.020813 0.104632 0.102541 0.082104 0.936094 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens1 0.000509 0.950559 \n", + "network_sensor_2 0.000501 0.721882 \n", + "water_level@sens3 0.000529 0.871119 " ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" } - ], - "metadata": { - "kernelspec": { - "display_name": "modelskill (3.13.13)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.13" - } + ], + "source": [ + "multi_obs = ms.NodeObservation.from_multiple(nodes={30: sensor_1, 54: path_to_sensor2, 71: sensor_3})\n", + "ms.match(multi_obs, network_model).skill()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "modelskill (3.13.13)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 -} + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/src/modelskill/model/adapters/_res1d.py b/src/modelskill/model/adapters/_res1d.py index 3ed0032e5..aea5dfd6d 100644 --- a/src/modelskill/model/adapters/_res1d.py +++ b/src/modelskill/model/adapters/_res1d.py @@ -106,11 +106,9 @@ def __init__( id: str, *, data: pd.DataFrame | None = None, - boundary: dict[str, pd.DataFrame] | None = None, ): self._id = id self._data = _EMPTY_DATA if data is None else data - self._boundary = {} if boundary is None else boundary @property def id(self) -> str: @@ -120,10 +118,6 @@ def id(self) -> str: def data(self) -> pd.DataFrame: return self._data - @property - def boundary(self) -> dict[str, pd.DataFrame]: - return self._boundary - class GridPoint(ReachBreakPoint): def __init__( @@ -169,9 +163,14 @@ def __init__( if end_node.id != reach.end_node: raise ValueError("Incorrect ending node.") - intermediate_gridpoints = ( - reach.gridpoints[1:-1] if len(reach.gridpoints) > 2 else [] - ) + # Reaches with more than 2 gridpoints have real, independently-measured + # start/end points, so the first and last gridpoint become breakpoints + # too (coincident with start_node/end_node - Network._generate_graph + # connects them with a zero-length edge). Reaches with 2 or fewer + # gridpoints are link-node models (e.g. EPANET), whose single synthetic + # gridpoint belongs to neither end; that case is not handled here, see + # https://github.com/DHI/modelskill/issues/680. + breakpoint_gridpoints = reach.gridpoints if len(reach.gridpoints) > 2 else [] self._start = start_node self._end = end_node @@ -191,7 +190,7 @@ def __init__( if populate_gridpoints else None, ) - for gridpoint in intermediate_gridpoints + for gridpoint in breakpoint_gridpoints ] @property diff --git a/src/modelskill/network.py b/src/modelskill/network.py index ee0506081..0938a1008 100644 --- a/src/modelskill/network.py +++ b/src/modelskill/network.py @@ -33,6 +33,11 @@ _MIKE_EXTENSIONS = frozenset({".res1d", ".res11"}) _EPANET_EXTENSIONS = frozenset({".res"}) +# Tolerance for comparing along-reach chainage/distance values, in whatever +# distance unit the network uses. Shared between find()'s breakpoint lookup +# and _generate_graph's boundary-edge detection. +_CHAINAGE_TOLERANCE = 1e-3 + _NO_FIXTURE = ( "{product} results are not supported yet: modelskill has no test fixture for " "this format, so support cannot be verified. Please open an issue if you need it." @@ -89,16 +94,15 @@ def _check_file_path_is_str(res: Res1D) -> None: class NetworkNode(ABC): """Abstract base class for a node in a network. - A node represents a discrete location in the network (e.g. a junction, - reservoir, or boundary point) that carries time-series data for one or - more physical quantities. + A node represents a discrete location in the network (e.g. a junction + or reservoir) that carries time-series data for one or more physical + quantities. - Three properties must be implemented: + Two properties must be implemented: * :attr:`id` - a unique string identifier for the node. * :attr:`data` - a time-indexed :class:`pandas.DataFrame` whose columns are quantity names. - * :attr:`boundary` - a dict of boundary-condition metadata (may be empty). The concrete helper :class:`BasicNode` is provided for the common case where the data is already available as a DataFrame. @@ -122,12 +126,6 @@ def data(self) -> pd.DataFrame: """Time-indexed DataFrame with one column per quantity.""" pass - @property - @abstractmethod - def boundary(self) -> dict[str, Any]: - """Boundary-condition metadata dict (may be empty).""" - pass - @property def quantities(self) -> list[str]: """List of quantity names available at this node.""" @@ -297,8 +295,6 @@ class BasicNode(NetworkNode): Unique node identifier. data : pd.DataFrame Time-indexed DataFrame with one column per quantity. - boundary : dict, optional - Boundary condition metadata, by default empty. Examples -------- @@ -311,11 +307,9 @@ def __init__( self, id: str, data: pd.DataFrame, - boundary: dict[str, Any] | None = None, ) -> None: self._id = id self._data = data - self._boundary: dict[str, Any] = boundary or {} @property def id(self) -> str: @@ -325,10 +319,6 @@ def id(self) -> str: def data(self) -> pd.DataFrame: return self._data - @property - def boundary(self) -> dict[str, Any]: - return self._boundary - class BasicReach(NetworkReach): """Concrete :class:`NetworkReach` for programmatic network construction. @@ -853,12 +843,10 @@ def _load_res1d_network( # A node shared by several reaches is visited once per reach endpoint, but # _generate_graph keeps only the first copy of its data, so read it once. - # The boundary is per-reach and must stay outside the cache. node_data: dict[str, pd.DataFrame] = {} def _init_node(reach: ResultReach, is_end: bool) -> Res1DNode: id = reach.end_node if is_end else reach.start_node - gpt_idx = -1 if is_end else 0 if id in nodes_set: if id not in node_data: df = _simplify_colnames(res.nodes[id], quantities) @@ -871,11 +859,7 @@ def _init_node(reach: ResultReach, is_end: bool) -> Res1DNode: node_id=id, ) node_data[id] = df - overlapping_gridpoint = reach.gridpoints[gpt_idx] - boundary = _simplify_colnames(overlapping_gridpoint, quantities) - return Res1DNode( - id, data=node_data[id], boundary={reach.name: boundary} - ) + return Res1DNode(id, data=node_data[id]) else: return Res1DNode(id) @@ -978,33 +962,55 @@ def _generate_graph(reaches: Sequence[NetworkReach]) -> nx.Graph: # 1) Add start and end nodes for node in [reach.start, reach.end]: node_key = node.id - if node_key in g0.nodes: - g0.nodes[node_key]["boundary"].update(node.boundary) - else: - g0.add_node(node_key, data=node.data, boundary=node.boundary) + if node_key not in g0.nodes: + g0.add_node(node_key, data=node.data) # 2) Add edges connecting start/end nodes to their adjacent breakpoints start_key = reach.start.id end_key = reach.end.id if reach.n_breakpoints == 0: - g0.add_edge(start_key, end_key, length=reach.length) + g0.add_edge(start_key, end_key, length=reach.length, boundary=False) else: bp_keys = [bp.id for bp in reach.breakpoints] for bp, bp_key in zip(reach.breakpoints, bp_keys): g0.add_node(bp_key, data=bp.data) - g0.add_edge(start_key, bp_keys[0], length=reach.breakpoints[0].distance) + # A breakpoint sitting at distance 0 (or, on the other end, at + # the reach's full length) is not an intermediate point - it is + # geometrically the same location as start_key/end_key, one of + # the reach's own gridpoints promoted to a breakpoint. Tag that + # edge and clamp it to an exact 0.0: leading_distance/diff are + # each derived from a different upstream source than the other + # endpoint's coordinate, so floating-point noise could otherwise + # leave a spurious tiny positive or negative edge weight where + # the true value is analytically zero. + leading_distance = reach.breakpoints[0].distance + leading_is_boundary = abs(leading_distance) <= _CHAINAGE_TOLERANCE + leading_length = 0.0 if leading_is_boundary else leading_distance + g0.add_edge( + start_key, + bp_keys[0], + length=leading_length, + boundary=leading_is_boundary, + ) # Only the final segment needs the total length. Break point # distances are known even when the total is not, so a reach # without a length still gets real lengths on every edge but # this one. - tail_length = ( - None - if reach.length is None - else reach.length - reach.breakpoints[-1].distance + if reach.length is None: + tail_length = None + tail_is_boundary = False + else: + tail_diff = reach.length - reach.breakpoints[-1].distance + tail_is_boundary = abs(tail_diff) <= _CHAINAGE_TOLERANCE + tail_length = 0.0 if tail_is_boundary else tail_diff + g0.add_edge( + bp_keys[-1], + end_key, + length=tail_length, + boundary=tail_is_boundary, ) - g0.add_edge(bp_keys[-1], end_key, length=tail_length) # 3) Connect consecutive intermediate breakpoints for i in range(reach.n_breakpoints - 1): @@ -1015,6 +1021,7 @@ def _generate_graph(reaches: Sequence[NetworkReach]) -> nx.Graph: current_.id, next_.id, length=length, + boundary=False, ) return nx.convert_node_labels_to_integers(g0, label_attribute="alias") @@ -1149,8 +1156,6 @@ def find( ) ids.append((reach_i, distance_i)) - _CHAINAGE_TOLERANCE = 1e-3 - def _resolve_id(id): if id in self._alias_map: return self._alias_map[id] diff --git a/tests/test_network.py b/tests/test_network.py index ce388e647..30db67a8e 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -456,7 +456,9 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data def test_open_res1d(): path_to_file = "./tests/testdata/network.res1d" network = Network.from_mike(path_to_file) - assert network.graph.number_of_nodes() == 259 + # 259 topology nodes, plus 2 reach-end breakpoints per reach (118 reaches) + # now that they are promoted from boundary metadata to real breakpoints. + assert network.graph.number_of_nodes() == 259 + 2 * 118 @pytest.mark.skipif( @@ -673,8 +675,10 @@ def test_from_mike_reads_each_selected_node_once(monkeypatch): """A node shared by several reaches is read once, not once per reach. _generate_graph keeps only the first copy of a node's data, so the repeat - reads were discarded work (gh #679). The per-reach boundary reads are - genuinely distinct and must not be collapsed. + reads were discarded work (gh #679). Reach-end gridpoints are now ordinary + breakpoints, so - like every other breakpoint - reaches=[] skips reading + them entirely; there is one loading rule, not a special case for the ones + that used to be boundary metadata. """ from modelskill.model.adapters import _res1d @@ -695,10 +699,34 @@ def counting_simplify_colnames(location, *args, **kwargs): {reach.start.id for reach in network._reaches.values()} | {reach.end.id for reach in network._reaches.values()} ) - n_reach_endpoints = 2 * len(network._reaches) assert reads["ResultNode"] == n_unique_nodes - assert reads["ResultGridPoint"] == n_reach_endpoints + assert "ResultGridPoint" not in reads + + +@pytest.mark.skipif( + sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" +) +def test_from_mike_reads_each_reach_endpoint_gridpoint_when_loaded(monkeypatch): + """The default (reaches=None) loads every reach's endpoint gridpoints too.""" + from modelskill.model.adapters import _res1d + + reads: dict[str, int] = {} + unpatched = _res1d._simplify_colnames + + def counting_simplify_colnames(location, *args, **kwargs): + name = type(location).__name__ + reads[name] = reads.get(name, 0) + 1 + return unpatched(location, *args, **kwargs) + + monkeypatch.setattr(_res1d, "_simplify_colnames", counting_simplify_colnames) + + path_to_file = "./tests/testdata/network.res1d" + network = Network.from_mike(path_to_file, nodes=[]) + + n_breakpoints = sum(r.n_breakpoints for r in network._reaches.values()) + + assert reads["ResultGridPoint"] == n_breakpoints # --------------------------------------------------------------------------- @@ -814,6 +842,91 @@ def test_known_length_is_unchanged(self): ] +class TestBoundaryEdges: + """A breakpoint coincident with a reach's own start/end node is tagged. + + This is the mechanism that replaced the removed `boundary` attribute: + reach-end data lives on an ordinary breakpoint, connected to its node by + an edge tagged boundary=True and clamped to an exact 0.0. + """ + + def test_edge_with_no_breakpoints_is_tagged_non_boundary(self): + a, b = _two_node_pair() + + network = Network([BasicReach("r1", a, b, length=100.0)]) + + (_, _, data), = network.graph.edges(data=True) + assert data["boundary"] is False + + def test_breakpoint_at_reach_start_is_tagged_boundary(self): + a, b = _two_node_pair() + breakpoints = [_StubBreakPoint("r1", 0.0), _StubBreakPoint("r1", 40.0)] + + network = Network([BasicReach("r1", a, b, 100.0, breakpoints)]) + + edges = {frozenset((u, v)): d for u, v, d in network.graph.edges(data=True)} + start_bp_key = frozenset((network.find(node="a"), network.find(reach="r1", distance=0.0))) + interior_key = frozenset( + ( + network.find(reach="r1", distance=0.0), + network.find(reach="r1", distance=40.0), + ) + ) + + assert edges[start_bp_key] == {"length": 0.0, "boundary": True} + assert edges[interior_key] == {"length": 40.0, "boundary": False} + + def test_breakpoint_at_reach_end_is_tagged_boundary(self): + a, b = _two_node_pair() + breakpoints = [_StubBreakPoint("r1", 60.0), _StubBreakPoint("r1", 100.0)] + + network = Network([BasicReach("r1", a, b, 100.0, breakpoints)]) + + end_bp_key = frozenset((network.find(node="b"), network.find(reach="r1", distance=100.0))) + + assert network.graph.edges[tuple(end_bp_key)]["boundary"] is True + assert network.graph.edges[tuple(end_bp_key)]["length"] == 0.0 + + def test_end_breakpoint_length_is_clamped_despite_floating_point_noise(self): + """Clamp near-zero noise between two independently-sourced values. + + reach.length and the breakpoint's own distance come from independent + sources and are not guaranteed to be bit-identical; the near-zero + difference must be clamped to an exact 0.0, not left as tiny noise + that could turn negative and break weighted graph algorithms. + """ + a, b = _two_node_pair() + noisy_length = 100.0 + 1e-9 + breakpoints = [_StubBreakPoint("r1", 100.0)] + + network = Network([BasicReach("r1", a, b, noisy_length, breakpoints)]) + + end_bp_key = frozenset((network.find(node="b"), network.find(reach="r1", distance=100.0))) + data = network.graph.edges[tuple(end_bp_key)] + + assert data["boundary"] is True + assert data["length"] == 0.0 + + def test_interior_breakpoint_is_never_tagged_boundary_even_near_zero_length(self): + """Only edges to a reach's own endpoints are ever boundary edges. + + A genuinely tiny reach still tags interior segments correctly. + """ + a, b = _two_node_pair() + breakpoints = [_StubBreakPoint("r1", 0.0005)] + + network = Network([BasicReach("r1", a, b, 0.001, breakpoints)]) + + bp_alias = network.find(reach="r1", distance=0.0005) + start_key = frozenset((network.find(node="a"), bp_alias)) + end_key = frozenset((network.find(node="b"), bp_alias)) + + # Both are boundary edges here since the reach itself is shorter than + # the chainage tolerance - not a contradiction, just a degenerate case. + assert network.graph.edges[tuple(start_key)]["boundary"] is True + assert network.graph.edges[tuple(end_key)]["boundary"] is True + + # --------------------------------------------------------------------------- # Which extensions each constructor accepts, and why the rest are refused # --------------------------------------------------------------------------- @@ -1253,22 +1366,63 @@ class TestFromMike: def test_res1d(self): network = Network.from_mike("./tests/testdata/network.res1d") - assert network.graph.number_of_nodes() == 259 + # 259 topology nodes, plus 2 reach-end breakpoints per reach (118 + # reaches), now that they are promoted from boundary metadata to + # real breakpoints. + assert network.graph.number_of_nodes() == 259 + 2 * 118 def test_res11(self): """MIKE 11 keeps its data on gridpoints, so its nodes are empty.""" network = Network.from_mike("./tests/testdata/network_cali.res11") assert len(network._reaches) == 3 - assert network.graph.number_of_nodes() == 71 + # 71 topology nodes, plus 2 reach-end breakpoints per reach (3 reaches). + assert network.graph.number_of_nodes() == 71 + 2 * 3 assert set(network.quantities) == {"Discharge", "Water Level"} - assert [r.n_breakpoints for r in network._reaches.values()] == [23, 21, 23] + # +2 per reach: the first/last gridpoint is now a breakpoint too. + assert [r.n_breakpoints for r in network._reaches.values()] == [25, 23, 25] + + def test_reach_end_waterlevel_differs_from_node_waterlevel(self): + """The reach-end gridpoint is a distinct h-point, not the node's own value. + + This is the data #599/#680 asked to make reachable: it was previously + discarded (never read) or hidden in the now-removed `boundary` dict. + """ + network = Network.from_mike("./tests/testdata/network.res1d") + reach = network._reaches["100l1"] + + node_waterlevel = reach.start.data["WaterLevel"] + breakpoint_waterlevel = reach.breakpoints[0].data["WaterLevel"] + + assert not np.allclose(node_waterlevel.values, breakpoint_waterlevel.values) - def test_res11_reaches_have_real_lengths(self): + def test_find_reach_end_breakpoint_distinct_from_node(self): + """distance="start" resolves to the node; a number resolves elsewhere. + + distance="start"/"end" still resolve to the node; a numeric distance + resolves to the new, distinct reach-end breakpoint at the same location. + """ + network = Network.from_mike("./tests/testdata/network.res1d") + reach = network._reaches["100l1"] + + node_alias = network.find(node=reach.start.id) + start_by_keyword = network.find(reach=reach.id, distance="start") + start_by_distance = network.find(reach=reach.id, distance=0.0) + + assert start_by_keyword == node_alias + assert start_by_distance != node_alias + assert network.recall(start_by_distance) == {"reach": reach.id, "distance": 0.0} + + def test_res11_boundary_edges_are_exactly_zero(self): + """Reach-end breakpoints are coincident with their node, tagged and clamped.""" network = Network.from_mike("./tests/testdata/network_cali.res11") - lengths = [d["length"] for *_, d in network.graph.edges(data=True)] - assert all(length > 0 for length in lengths) + edges = list(network.graph.edges(data=True)) + boundary_lengths = {d["length"] for *_, d in edges if d["boundary"]} + non_boundary_lengths = [d["length"] for *_, d in edges if not d["boundary"]] + + assert boundary_lengths == {0.0} + assert all(length > 0 for length in non_boundary_lengths) def test_open_res1d_object(self): from mikeio1d import Res1D @@ -1277,7 +1431,8 @@ def test_open_res1d_object(self): network = Network.from_mike(res, nodes=[], reaches=[]) - assert network.graph.number_of_nodes() == 259 + # Topology is always fully constructed regardless of nodes=[]/reaches=[]. + assert network.graph.number_of_nodes() == 259 + 2 * 118 def test_epanet_file_is_redirected(self): with pytest.raises(ValueError, match=r"Use Network\.from_epanet\(\)"):