diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index cd57ed263..e854ab5b1 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -36,7 +36,7 @@ jobs: version: "1.8.27" - name: Install dependencies - run: uv sync --group dev --group docs --group networks + run: uv sync --group dev --group docs --group network - name: Build documentation run: just docs diff --git a/.github/workflows/full_test.yml b/.github/workflows/full_test.yml index bd62ad2b4..55f019b59 100644 --- a/.github/workflows/full_test.yml +++ b/.github/workflows/full_test.yml @@ -35,7 +35,7 @@ jobs: enable-cache: true - name: Install dependencies - run: uv sync --group test --group networks --no-dev + run: uv sync --group test --group network --no-dev - name: Install pandas 2.x if: matrix.pandas-version == 'pandas2' @@ -54,7 +54,7 @@ jobs: - name: Test run: just test - build-no-networks: + build-no-network: runs-on: ubuntu-latest steps: @@ -68,7 +68,7 @@ jobs: python-version: "3.12" enable-cache: true - - name: Install dependencies (without networks) + - name: Install dependencies (without network) run: uv sync --group test --no-dev - name: Test diff --git a/.github/workflows/notebooks_test.yml b/.github/workflows/notebooks_test.yml index dd64a1df6..84cbd346e 100644 --- a/.github/workflows/notebooks_test.yml +++ b/.github/workflows/notebooks_test.yml @@ -21,7 +21,7 @@ jobs: python-version: "3.14" enable-cache: true - name: Install dependencies - run: uv sync --group test --group notebooks --group networks --no-dev + run: uv sync --group test --group notebooks --group network --no-dev - name: Test notebooks run: | uv run pytest tests/notebooks/ diff --git a/adr/010-optional-domain-dependencies.md b/adr/010-optional-domain-dependencies.md index c67cab5b9..fc5e9dc89 100644 --- a/adr/010-optional-domain-dependencies.md +++ b/adr/010-optional-domain-dependencies.md @@ -56,7 +56,10 @@ Installation: `pip install modelskill modelskill-network` **Open Questions:** - Should `modelskill[all]` install all optional model types? -- How to handle version constraints for optional dependencies? +- How to handle version constraints for optional dependencies? Answered for network + support by [ADR-013](013-network-topology-in-mikeio1d.md): the `network` extra names a + minimum mikeio1d, because the topology layer ships there. Network support requires + whatever Python that release requires. - Should optional dependencies be tested in CI for every commit or separately? ## Status Notes diff --git a/adr/012-network-format-constructors.md b/adr/012-network-format-constructors.md index 324959247..8a863068a 100644 --- a/adr/012-network-format-constructors.md +++ b/adr/012-network-format-constructors.md @@ -1,9 +1,19 @@ # ADR-012: One Network Constructor per Modelling Product -**Status**: Draft +**Status**: Accepted, narrowed by [ADR-013](013-network-topology-in-mikeio1d.md) **Date**: 2026-08 +## Narrowed by ADR-013 + +The constructors, the companion arguments, the extension tables, the coverage test and the +`.inp` reader are mikeio1d's. It replaced `from_mike` and `from_epanet` with one +`Network.open` that reads the extension. Naming a constructor after the product that wrote +the file is still the rule, and mikeio1d applies it. + +`NetworkModelResult` hands a path to mikeio1d. The refusal messages for `.out`, `.resx` +and the formats without a fixture are written there. + ## Context `Network` is built from result files read through mikeio1d, whose single `Res1D` class opens nine extensions across five products — MIKE 1D (`.res1d`), MIKE 11 (`.res11`), MOUSE (`.prf`, `.crf`, `.xrf`), EPANET (`.res`), SWMM (`.out`), Water Hammer (`.whr`), and `.resx`, which is shared by the last three. There is no per-format reader and no per-format constructor argument, so from mikeio1d's side all nine look alike. modelskill's constructor was named `from_res1d`, and its extension guard was briefly widened to accept everything mikeio1d could read — making the name promise one format while reading nine. diff --git a/adr/013-network-topology-in-mikeio1d.md b/adr/013-network-topology-in-mikeio1d.md new file mode 100644 index 000000000..6d28abecf --- /dev/null +++ b/adr/013-network-topology-in-mikeio1d.md @@ -0,0 +1,48 @@ +# ADR-013: The Network Topology Layer Belongs to mikeio1d + +**Status**: Accepted + +**Date**: 2026-08 + +## Context + +`modelskill.network` grew into a topology layer of its own: the abstract node/reach/breakpoint types, a `Res1D` adapter, one constructor per modelling product, the `.resx` and `.inp` companions, a table of which extensions we refuse and why, a networkx graph carrying reach lengths and boundary edges, an alias map, and `find`/`recall`/`to_dataset` on top. Roughly 630 code lines, against 25 for mikeio1d's `experimental.to_networkx`, which converts the same file and ignores gridpoints. + +Most of those 630 lines do work the upstream function declines to do. The layer still sits on the wrong side of a line ADR-001 drew for mikeio: we call `mikeio.read()` and stop, without modelling dfsu geometry or policing its format list. Here we do both. `Res1D` reads nine extensions across five products; our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against — `network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp` — are copies of mikeio1d's own. Meanwhile `NetworkModelResult` uses five members of `Network`, two of them private, and never traverses the graph. + +## Decision + +mikeio1d gains an optional network module that builds and owns `Network`. modelskill requires it and consumes what it produces. + +| Owner | Pieces | +|---|---| +| mikeio1d | abstract types and `BasicNode`/`BasicReach`, the `Res1D` adapter, `Network.open`, the `.resx` and `.inp` companions, the extension policy tables, graph construction with its length and boundary semantics, the alias map, `find`, `recall`, `to_dataframe`, `to_dataset` | +| modelskill | `NetworkModelResult`, `NodeModelResult`, `NodeObservation`, `ReachObservation`, matching, the MIKE+ station resolver | + +`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` ships with the class. modelskill's `network` extra requires a mikeio1d release new enough to contain it. + +Original IDs become the only identifier a user handles: `NodeObservation.at` takes a node name or a `(reach, distance)` pair, and no longer an integer. The alias integers stay an internal index. They exist because the ID space mixes names and break points, and a tuple cannot be an xarray coordinate value. A saved comparer records the original ID, with the integer beside it as `node_index`, so reloading does not depend on the numbering the installed mikeio1d handed out. + +Before anything moved, the loader's output over six fixture loads was recorded: graph edges with their lengths and boundary flags, the alias map, the dataframe, and every answer `find` and `recall` give. Those snapshots are the upstream module's acceptance test. + +Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), merged 2026-08-19. The snapshots pass there unchanged, twice: against the code moved verbatim, and again after the two product constructors collapsed into `Network.open`. The second pass covers the redesign. + +modelskill 1.4.0 waits for the mikeio1d release carrying the module. That release is not out yet. + +## Alternatives Considered + +**Keep the layer here.** Defensible while the API is private. It means maintaining a format matrix, an EPANET `.inp` parser and a graph contract for traversals we never perform. It also means a CI failure whenever someone else's release adds a format. + +**Move only the constructors and companions**, leaving the graph and the abstract types here. Splits the format knowledge from the topology it produces, and leaves `Res1DReach` here as the single adapter for a plug point with no second implementation. + +**A separate `modelskill-network` package.** Rejected in ADR-010 for fragmenting the install. It would still own format knowledge that belongs with mikeio1d. + +**Ask mikeio1d to guarantee stable node numbering** instead of dropping integers from our API. Puts a promise on someone else's release process, to protect a number users should not be handling. + +## Consequences + +- ADR-012 is narrowed: the constructors, the companion arguments, the extension tables and the coverage test become mikeio1d's. Naming a constructor after the product that wrote the file is still the rule, and mikeio1d applies it. +- ADR-010's open question about version constraints for optional dependencies is answered for this feature: the `network` extra pins a minimum mikeio1d, and network support requires whatever Python that release requires. +- A hand-built network needs mikeio1d installed, since `BasicNode`/`BasicReach` move too. That costs a .NET dependency for users who touch no MIKE file, which only matters for tests and for a backend nobody has written. +- Dropping `at=` is a breaking change for a signature that shipped in the 1.4.0a3 alpha only, while the network module is opt-in and absent from the API reference. Removing it after 1.4.0 would cost more. +- Releases become coupled in one direction: a fix to network file reading ships on mikeio1d's schedule. A format mikeio1d adds no longer breaks our CI. diff --git a/adr/README.md b/adr/README.md index 59b6d3bf2..fe0639ba0 100644 --- a/adr/README.md +++ b/adr/README.md @@ -30,7 +30,8 @@ Each ADR follows this structure: - [ADR-009](009-factory-pattern.md) - Factory pattern for type detection - [ADR-010](010-optional-domain-dependencies.md) - Optional dependencies for domain-specific model types (Draft) - [ADR-011](011-vertical-pre-extracted-columns.md) - VerticalModelResult ingests pre-extracted columns -- [ADR-012](012-network-format-constructors.md) - One Network constructor per modelling product (Draft) +- [ADR-012](012-network-format-constructors.md) - One Network constructor per modelling product (narrowed by ADR-013) +- [ADR-013](013-network-topology-in-mikeio1d.md) - The network topology layer belongs to mikeio1d ## Contributing 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/user-guide/network.qmd b/docs/user-guide/network.qmd index a769d9c16..07d628043 100644 --- a/docs/user-guide/network.qmd +++ b/docs/user-guide/network.qmd @@ -7,17 +7,18 @@ jupyter: python3 ::: {.callout-warning collapse="true"} ## Extra dependencies required -Network support depends on libraries that are **not** installed -by default, e.g. `networkx`. You can install them alongside `modelskill` using the _networks_ extra: +Network support depends on `mikeio1d`, which reads the result files and builds +the network, and which is **not** installed by default. Install it alongside +`modelskill` with the _network_ extra: ```bash -uv pip install modelskill[networks] +uv pip install modelskill[network] ``` or ```bash -uv add modelskill[networks] +uv add modelskill[network] ``` ::: @@ -25,382 +26,71 @@ uv add modelskill[networks] ```{python} # | echo: false -import pandas as pd -import numpy as np -from typing import Any -from modelskill.network import Network, NetworkNode, NetworkReach, ReachBreakPoint - - -class ExampleNode(NetworkNode): - """Node backed by an in-memory DataFrame, e.g. model output.""" - - def __init__(self, node_id: str, data: pd.DataFrame): - self._id = node_id - self._data = data - - @property - def id(self) -> str: - return self._id - - @property - 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.""" - - def __init__( - self, - reach_id: str, - start: NetworkNode, - end: NetworkNode, - length: float, - breakpoints: list | None = None, - ): - self._id = reach_id - self._start = start - self._end = end - self._length = length - self._breakpoints = breakpoints or [] - - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> NetworkNode: - return self._start - - @property - def end(self) -> NetworkNode: - return self._end - - @property - def length(self) -> float: - return self._length - - @property - def breakpoints(self) -> list: - return self._breakpoints - - -class ExampleBreakPoint(ReachBreakPoint): - def __init__(self, reach_id: str, distance: float, data: pd.DataFrame): - self._id = (reach_id, distance) - self._data = data - - @property - def id(self): - return self._id - - @property - def data(self): - return self._data - - -# Synthetic model output covering the observation period -model_time = pd.date_range("1994-08-07 16:00", periods=180, freq="1min") -t = np.linspace(0, 2 * np.pi, len(model_time)) - -df1 = pd.DataFrame({"WaterLevel": 194.0 + np.sin(t)}, index=model_time) -df2 = pd.DataFrame({"WaterLevel": 193.8 + 0.8 * np.sin(t)}, index=model_time) -df3 = pd.DataFrame({"WaterLevel": 193.6 + 0.6 * np.sin(t)}, index=model_time) -df4 = pd.DataFrame({"WaterLevel": 193.9 + 0.9 * np.sin(t)}, index=model_time) - -node_s1 = ExampleNode("sensor_1", df1) -node_s2 = ExampleNode("sensor_2", df2) -node_s3 = ExampleNode("sensor_3", df3) - -bp = ExampleBreakPoint("r1", 200.0, df4) -reach1 = ExampleReach("r1", node_s1, node_s2, length=500.0, breakpoints=[bp]) -reach2 = ExampleReach("r2", node_s2, node_s3, length=300.0) -network = Network(reaches=[reach1, reach2]) -``` - -A **Network** represents a 1D pipe or river network as a directed graph: nodes hold timeseries data (e.g. water level at a junction) and reaches carry the topology and reach length between them. Break points along a reach (e.g. cross-section chainages) are supported as observation locations too. - -The typical workflow is: - -``` -Network → NetworkModelResult → match() → Comparer -``` - -## Building a Network - -You can build a `Network` object by loading it from a supported network result file. Reading these files relies on [mikeio1d](https://github.com/DHI/mikeio1d), so install the `networks` dependency group first. - -There is one constructor per product that writes the file: - -| Constructor | Extensions | Product | -|---|---|---| -| `Network.from_mike` | `.res1d`, `.res11` | MIKE 1D, MIKE 11 | -| `Network.from_epanet` | `.res`, plus optional `.resx` and `.inp` | EPANET | - -The remaining formats mikeio1d can open cannot be turned into a `Network`, and say so when you try: - -| Extension | Why not | -|---|---| -| `.out` (SWMM) | The reach connectivity is not in the `.out` at all — it lives in the companion `.inp` input file, which modelskill does not read yet ([#689](https://github.com/DHI/modelskill/issues/689)). | -| `.resx` | Not a network on its own. It holds extra results for the network defined in the sibling `.res`, so pass it as `from_epanet(res, resx=...)` instead. | -| `.prf`, `.crf`, `.xrf` (MOUSE), `.whr` (Water Hammer) | No test fixture exists for these formats, so support cannot be verified. [Open an issue](https://github.com/DHI/modelskill/issues) if you need one. | - -### From a network result file - -The quickest way to get a `Network` is from the path to a result file: - -```{python} -# | echo: false - path_to_res1d = "../../tests/testdata/network.res1d" -path_to_res11 = "../../tests/testdata/network_cali.res11" -path_to_epanet = "../../tests/testdata/epanet.res" path_to_sensor_data_1 = "../../tests/testdata/network_sensor_1.csv" path_to_sensor_data_2 = "../../tests/testdata/network_sensor_2.csv" ``` -```{python} -from modelskill.network import Network - -network = Network.from_mike(path_to_res1d) -network -``` - -or a `mikeio1d.Res1D` that has already been opened: - -```python -from mikeio1d import Res1D - -res = Res1D(path_to_res1d) -network = Network.from_mike(res) -``` - -MIKE 11 files work the same way. Note that MIKE 11 keeps its timeseries on reach gridpoints rather than on nodes, so the nodes of such a network carry no data of their own: - -```{python} -Network.from_mike(path_to_res11) -``` - -EPANET results use `from_epanet`: - -```{python} -Network.from_epanet(path_to_epanet) -``` - -#### EPANET companion files - -An EPANET run writes more than one file, and the `.res` is not the whole picture: - -| File | What it adds | -|---|---| -| `.res` | The network and its main timeseries. Required. | -| `.resx` | Extra results — tank volume and pump energy. Merged onto matching nodes. | -| `.inp` | The model input. The only one of the three carrying reach lengths. | - -Pass the companions alongside the result file to get a fuller network: - -```{python} -# | echo: false -path_to_epanet_resx = "../../tests/testdata/epanet.resx" -path_to_epanet_inp = "../../tests/testdata/epanet.inp" -``` - -```{python} -network_epanet = Network.from_epanet( - path_to_epanet, - resx=path_to_epanet_resx, - inp=path_to_epanet_inp, -) -network_epanet -``` - -`Volume` and `Volume Percentage` come from the `.resx`, and the reach lengths from the `.inp`: - -```{python} -sorted( - d["length"] - for *_, d in network_epanet.graph.edges(data=True) - if d["length"] is not None -) -``` - -::: {.callout-warning} -## EPANET reach geometry is limited - -EPANET is a link-node model, and mikeio1d reports no length and a single synthetic gridpoint for each reach. So for an EPANET network: - -* without `inp=`, every edge of `network.graph` has `length=None`. A length-weighted `networkx` call then fails rather than returning a meaningless number — shortest-path treats the edge as unreachable, and anything that sums the weights raises `TypeError`. The attribute is always present, since `networkx` defaults a missing weight to `1`. With `inp=`, only pumps and valves stay `None`, since `[PIPES]` is the one section carrying lengths -* reaches have no breakpoints, so a `ReachObservation` cannot be matched — use `NodeObservation` instead -* `find(reach=..., distance=)` never resolves; only `distance="start"` and `distance="end"` work - -For the same reason, `resx=` merges node quantities only. Its reach-level quantities — pump energy, efficiency and costs — have no breakpoint to live on, which is tracked in [#680](https://github.com/DHI/modelskill/issues/680). - -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. - -![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) - -#### Selective loading - -Large result files can contain thousands of nodes and gridpoints. Loading all of that data into memory is slow and may cause memory issues — especially when you only need the timeseries at a handful of nodes where observations exist. - -Both constructors accept the same two optional arguments to restrict what gets loaded: - -| Argument | Type | Effect | -|---|---|---| -| `nodes` | `None` \| `str` \| `list[str]` | Control which nodes have timeseries data loaded. `None` (default) loads all nodes; `[]` skips all node data; a name or list loads only those nodes. | -| `reaches` | `None` \| `str` \| `list[str]` | Control which reaches have intermediate gridpoint data populated. `None` (default) loads everything; `[]` skips all gridpoints; a name or list of names loads only those reaches. | - -::: {.callout-note} -Selective loading only controls **which timeseries are held in memory**. The full network topology (nodes, reaches, lengths) is always constructed so that `find()`, `recall()`, and graph algorithms still work on the complete network. -::: - -The most memory-efficient setup — useful when you only care about specific junction nodes — is to pass the node IDs you need and skip all intermediate gridpoints with `reaches=[]`: - -```{python} -network_subset = Network.from_mike( - path_to_res1d, - nodes=["78", "46"], - reaches=[], -) -network_subset -``` - -If you also need gridpoint data along a particular reach, pass its name (or a list of names): - -```{python} -network_subset = Network.from_mike( - path_to_res1d, - nodes=["78", "46"], - reaches=["94l1"], -) -network_subset -``` - -When only some nodes are loaded, `to_dataframe()` and `to_dataset()` only contain columns for those nodes — the rest are graph-connected but data-free: - -```{python} -network_subset.to_dataframe(sel="WaterLevel").head() -``` - -## Inspecting the Network +A **network** is a 1D pipe or river network read as a graph: nodes hold timeseries +data (water level at a junction, say), reaches carry the topology and the length +between them, and break points along a reach are locations in their own right. -### Available quantities +The workflow is the usual four steps, with the network standing in for a grid or a +mesh: -```{python} -network.quantities ``` - -### Underlying graph - -The network exposes a `networkx.Graph` so you can use any NetworkX algorithm or -plotting function directly: - -```{python} -# | echo: false - -plot_kwargs = { - "font_size": 6, - "node_size": 130, - "node_color": "white", - "edgecolors": "black", - "with_labels": True, -} +result file → NetworkModelResult → match() → Comparer ``` -```{python} -import networkx as nx -import matplotlib.pyplot as plt +## Where the network comes from -fig, ax = plt.subplots(figsize=(10, 9), layout="tight") -nx.draw(network.graph, ax=ax, **plot_kwargs) -plt.show() -``` +Reading the file and building the graph is [mikeio1d](https://github.com/DHI/mikeio1d)'s +job, not modelskill's. `Network.open` reads MIKE 1D (`.res1d`), MIKE 11 (`.res11`) +and EPANET (`.res`) results, finds the EPANET companion files, and says so when a +format cannot be turned into a network. See its documentation for the companions, +for loading only part of a large file, and for `find`/`recall` between the names the +model uses and the graph's own integers. -### Timeseries data +modelskill takes the file path directly, and opens it for you: ```{python} -# Multi-index DataFrame: columns are (node, quantity) -network.to_dataframe().head() -``` +import modelskill as ms -```{python} -# Select a single quantity -network.to_dataframe(sel="WaterLevel").head() +mr = ms.NetworkModelResult(path_to_res1d, name="MyModel", item="WaterLevel") +mr ``` -## Looking up node IDs - -After construction, nodes are re-labelled as integers. Use `find()` to go from original coordinates to the integer ID and `recall()` to go back. - -::: {.callout-tip} -When creating `NodeObservation` objects for skill assessment you generally do **not** need to call `find()`. You can pass the original string ID as `node=`, and `NetworkModelResult` will resolve it for you during matching. For breakpoints, use `at=(reach, distance)` rather than `node=`. See [Skill assessment workflow](#skill-assessment-workflow) for details. -::: +Open the network yourself when you need to name EPANET companion files, or to keep +memory down on a large model by reading only the locations you will score: ```{python} -# Look up a named node by its original id -node_id = network.find(node="117") -print(f"Node '117' → integer id {node_id}") +from mikeio1d.network import Network -# Recover the original label -print(network.recall(node_id)) -``` - -```{python} -# Look up a break point by reach + chainage -bp_id = network.find(reach="94l1", distance=21.285) -print(f"Break point (94l1, 21.285) → integer id {bp_id}") -print(network.recall(bp_id)) -``` - -```{python} -# Node batch lookup -ids = network.find(node=["20", "113", "38"]) -print(ids) -``` - -```{python} -# Reach lookup -ids = network.find(reach="58l1", distance="start") -print(ids) -ids = network.find(reach="58l1", distance=[51.456, 77.185]) -print(ids) -ids = network.find(reach="58l1", distance=["start", 77.185]) -print(ids) +network = Network.open(path_to_res1d, nodes=["78", "46"], reaches=["94l1"]) +ms.NetworkModelResult(network, name="MyModel", item="WaterLevel") ``` ## Skill assessment workflow -### 1. Wrap the Network in a NetworkModelResult +### 1. The model result -```{python} -import modelskill as ms -from modelskill.model.network import NetworkModelResult - -mr = NetworkModelResult(network, name="MyModel", item="WaterLevel") -mr -``` +`mr` above is the model side of the comparison, holding one quantity over every +location the file was read for. ### 2. Create NodeObservations and compute skill `NodeObservation` accepts a file path directly; the observation name is taken from the filename. -The `at=` argument can be specified in three ways, depending on what information you have at hand. +The `at=` argument takes either of two forms, depending on what you have at hand. ::: {.callout-note} ## MIKE 1D vocabulary vs the modelskill API -In MIKE 1D, "nodes" are the named connection points in the 1D network (manholes, junctions, outfalls) while "reaches" are the pipe or channel segments that connect them. The modelskill API uses `NodeObservation` more broadly: the `at=` argument accepts either a node ID (int or string) **or** a `(reach_id, distance)` breakpoint tuple that identifies a specific chainage along a reach. If you only need a reach-level quantity (uniform across the reach), use `ReachObservation` with `reach=` instead. +In MIKE 1D, "nodes" are the named connection points in the 1D network (manholes, junctions, outfalls) while "reaches" are the pipe or channel segments that connect them. The modelskill API uses `NodeObservation` more broadly: the `at=` argument accepts either the node's name **or** a `(reach_id, distance)` break point tuple that identifies a specific chainage along a reach. If you only need a reach-level quantity (uniform across the reach), use `ReachObservation` with `reach=` instead. ::: -#### Option A — original string alias +#### Option A — the node's name -Pass the original node identifier from the source format (e.g. the Res1D node name) as a plain string. The `NetworkModelResult` resolves it to the correct integer ID at match time, so you do not need to call `network.find()` yourself: +Pass the node's name in the model, e.g. the Res1D node name. It is resolved against the network at match time: ```{python} obs_1 = ms.NodeObservation(path_to_sensor_data_1, at="78") @@ -411,7 +101,7 @@ cc.skill() ``` ::: {.callout-note} -Resolution happens inside `ms.match()`. If the string is not found in the network's alias map a `ValueError` is raised with a clear message indicating which alias could not be resolved. +Resolution happens inside `ms.match()`. A name the network does not hold raises a `ValueError` that names the near misses. ::: #### Option B — breakpoint by `(reach, distance)` tuple @@ -425,12 +115,12 @@ cc = ms.match(obs=obs_bp, mod=mr) cc.skill() ``` -The tuple form is equivalent to calling `network.find(reach="94l1", distance=21.285)` beforehand and is resolved during matching. +The tuple form is equivalent to calling `network.find(reach="94l1", distance=21.285)` beforehand, and is resolved during matching. ::: {.callout-note} ## Chainage tolerance -Breakpoint distances are matched with a tolerance of **1 × 10⁻³** (i.e. ±0.001 in whatever distance units the network uses). This means that small floating-point discrepancies between the distance you type and the value stored in the network are handled gracefully. If no breakpoint falls within that tolerance a `ValueError` is raised. +Break point distances are matched within the tolerance mikeio1d uses to decide two chainages are the same place, so small floating-point discrepancies between the distance you type and the value stored in the network are handled gracefully. If no break point falls within it, a `ValueError` is raised. The distance recorded on the match is the network's own, not the one you typed. ::: ### 3. Using ReachObservation for reach-uniform quantities @@ -447,7 +137,7 @@ obs_q Pass the observation to `ms.match()` exactly as you would a `NodeObservation`. modelskill resolves which breakpoint to use automatically: ```{python} -mr_q = NetworkModelResult(network, name="MyModel", item="Discharge") +mr_q = ms.NetworkModelResult(network, name="MyModel", item="Discharge") cc_q = ms.match(obs=obs_q, mod=mr_q) cc_q.skill() ``` @@ -456,130 +146,45 @@ cc_q.skill() Use `ReachObservation` when your measured quantity is representative of the whole reach (e.g. discharge, which is constant along a reach in steady flow). If you need to compare a quantity that varies spatially along the reach (e.g. water level at a specific chainage), use a `NodeObservation` with a `(reach, distance)` tuple instead (see [Option B](#option-b-breakpoint-by-reach-distance-tuple) above). ::: -## Development - -### Custom network formats - -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`. +## Locating observations with a MIKE+ database -`NetworkNode` requires three properties: `id`, `data`, and `boundary`. -`NetworkReach` requires four: `id`, `start`, `end`, and `breakpoints`. +The examples above assume you already know where each sensor sits in the network. A MIKE+ project normally records that itself, in the sqlite database shipped alongside the result files: `m_Measurement` says which file and item each measured timeseries lives in, and `m_Station` says where in the network it belongs. -`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. - - -The following is a simple implementation example: +Pass that database as `db` and modelskill does the lookup for you: ```python -import pandas as pd -import numpy as np -from typing import Any -from modelskill.network import NetworkNode, NetworkReach, Network - - -class ExampleNode(NetworkNode): - """Node backed by an in-memory DataFrame, e.g. model output.""" - - def __init__(self, node_id: str, data: pd.DataFrame): - self._id = node_id - self._data = data - - @property - def id(self) -> str: - return self._id - - @property - 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.""" +quantity = "Pressure" - def __init__( - self, reach_id: str, start: NetworkNode, end: NetworkNode, length: float, - breakpoints: list | None = None, - ): - self._id = reach_id - self._start = start - self._end = end - self._length = length - self._breakpoints = breakpoints or [] +network = Network.open("model.res", quantities=quantity) +network_model = ms.NetworkModelResult(network, item=quantity) - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> NetworkNode: - return self._start - - @property - def end(self) -> NetworkNode: - return self._end - - @property - def length(self) -> float: - return self._length - - @property - def breakpoints(self) -> list: - return self._breakpoints -``` - -::: {.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. -::: - - -```{python} -from modelskill.network import Network - -# df1, df2 and df3 are DataFrame objects that are loaded in memory -node_s1 = ExampleNode("sensor_1", df1) -node_s2 = ExampleNode("sensor_2", df2) -node_s3 = ExampleNode("sensor_3", df3) - -reach1 = ExampleReach("r1", node_s1, node_s2, length=500.0) -reach2 = ExampleReach("r2", node_s2, node_s3, length=300.0) +obs = ms.NodeObservation.from_multiple( + data="calibration.dfs0", + db="model.sqlite", + quantity=quantity, +) -network = Network(reaches=[reach1, reach2]) -network +cc = ms.match(obs, network_model) ``` -### Adding break points along a reach +One observation is created per item of the data source, named after the station's asset name. Because the mapping runs item by item rather than location by location, several sensors at the same node — a pair either side of a check valve, say — all become separate observations. -Break points represent intermediate chainage locations on a reach (e.g. cross-sections). Subclass `ReachBreakPoint` the same way — implement `id` (a `(reach_id, distance)` tuple) and `data`: +Reach-uniform quantities work the same way through the sibling method: ```python -from modelskill.network import ReachBreakPoint - - -class ExampleBreakPoint(ReachBreakPoint): - def __init__(self, reach_id: str, distance: float, data: pd.DataFrame): - self._id = (reach_id, distance) - self._data = data - - @property - def id(self): - return self._id - - @property - def data(self): - return self._data +obs_q = ms.ReachObservation.from_multiple( + data="calibration.dfs0", db="model.sqlite", quantity="Flow" +) +``` +Which class to use is decided by the database, not by you: stations recorded on a junction or a tank are node observations, and stations recorded on a link are reach observations. Asking `NodeObservation` for a quantity that the database places on links raises an error naming `ReachObservation`, and the other way around. -# df4 is a DataFrame object that has been loaded in memory -bp = ExampleBreakPoint("r1", 200.0, df4) -reach1 = ExampleReach("r1", node_s1, node_s2, length=500.0, breakpoints=[bp]) -reach2 = ExampleReach("r2", node_s2, node_s3, length=300.0) -network = Network(reaches=[reach1, reach2]) -``` +A few details worth knowing: +* **`quantity` is optional.** Omit it and the quantity is inferred, as long as the data holds only one for the class you asked for. A calibration file mixing pressure and flow raises an error listing what it found. +* **The quantity name comes from the database, the unit from the data.** Calibration files often carry no usable EUM information, so the database is the only reliable source for the name. +* **`source` picks between files.** It defaults to `data` when that is a path. Pass it explicitly if you hand over an already-read `mikeio.Dataset` or a `DataFrame`, since neither remembers where it came from. +* **Items the database cannot place raise by default**, separating the two causes: a station that exists but has no measurement registered for this file, and an item that is not in the database at all. Pass `on_missing="skip"` to build observations from the rest. ## See also diff --git a/notebooks/Collection_systems_network.ipynb b/notebooks/Collection_systems_network.ipynb index 89e9962e0..ffb8e9548 100644 --- a/notebooks/Collection_systems_network.ipynb +++ b/notebooks/Collection_systems_network.ipynb @@ -1,1629 +1,1883 @@ { - "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\")" - ] - }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "fdb0d0b9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:00.197602Z", + "iopub.status.busy": "2026-08-25T14:20:00.197216Z", + "iopub.status.idle": "2026-08-25T14:20:02.473745Z", + "shell.execute_reply": "2026-08-25T14:20:02.471396Z" + } + }, + "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 mikeio1d.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", + "It comes from [mikeio1d](https://github.com/DHI/mikeio1d), which reads the result files, and it arrives with `modelskill[network]`.\n", + "\n", + "### Loading from a supported format\n", + "\n", + "`Network.open` reads MIKE 1D (`.res1d`), MIKE 11 (`.res11`) and EPANET (`.res`) results:\n", + "\n", + "```python\n", + "from mikeio1d.network import Network\n", + "\n", + "network = Network.open(\"path/to/results.res1d\")\n", + "```\n", + "\n", + "It also takes the arguments for reading only part of a large file, and for naming the EPANET companion files. See mikeio1d's documentation for those, and for building a network from a format it does not read.\n", + "\n", + "### Break points\n", + "\n", + "A reach can carry **break points** — intermediate locations along it (e.g. cross-section chainages) with their own time-series data. They are locations you can compare against, addressed by their reach and their distance along it.\n", + "\n", + "### Example" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cd363bae", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:02.477942Z", + "iopub.status.busy": "2026-08-25T14:20:02.477210Z", + "iopub.status.idle": "2026-08-25T14:20:03.381839Z", + "shell.execute_reply": "2026-08-25T14:20:03.377494Z" + } + }, + "outputs": [ { - "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." + "data": { + "text/plain": [ + "\n", + "Reaches: 118\n", + "Nodes: 495\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.open(\"../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 the `node` coordinate is the graph's own integer index. Alongside it, `name`, `reach` and `distance` carry the names the model gave each location, so a column can be read without holding on to the network:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2a2d7414", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:03.387636Z", + "iopub.status.busy": "2026-08-25T14:20:03.387172Z", + "iopub.status.idle": "2026-08-25T14:20:03.730978Z", + "shell.execute_reply": "2026-08-25T14:20:03.729115Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 9, - "id": "30c88717", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "131" - ] - }, - "execution_count": 9, - "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: 498kB\n",
+       "Dimensions:     (time: 110, node: 495)\n",
+       "Coordinates:\n",
+       "  * time        (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n",
+       "  * node        (node) int64 4kB 0 1 2 3 4 5 6 7 ... 488 489 490 491 492 493 494\n",
+       "    name        (node) <U17 34kB '100' '99' '' '' '' '101' ... '' '' '' '' '' ''\n",
+       "    reach       (node) <U10 20kB '' '' '100l1' ... 'Pump:115p1' 'Pump:115p1'\n",
+       "    distance    (node) float64 4kB nan nan 0.0 23.84 ... 1.0 0.0 41.21 82.43\n",
+       "Data variables:\n",
+       "    WaterLevel  (time, node) float32 218kB 195.4 194.7 195.4 ... 193.8 nan 195.0\n",
+       "    Discharge   (time, node) float32 218kB nan nan nan 5.72e-06 ... nan 0.0 nan
" ], - "source": [ - "network.find(reach=\"44l1\", distance=44.841)" + "text/plain": [ + " Size: 498kB\n", + "Dimensions: (time: 110, node: 495)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n", + " * node (node) int64 4kB 0 1 2 3 4 5 6 7 ... 488 489 490 491 492 493 494\n", + " name (node) " ] - }, + }, + "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": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:03.742500Z", + "iopub.status.busy": "2026-08-25T14:20:03.742219Z", + "iopub.status.idle": "2026-08-25T14:20:03.748104Z", + "shell.execute_reply": "2026-08-25T14:20:03.746842Z" + } + }, + "outputs": [], + "source": [ + "def plot_network(network):\n", + "\n", + " g = network.graph.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", + " # recall() says what each integer stands for: a named node, or a break point\n", + " # given as a reach and a distance along it.\n", + " kinds = network.recall(list(g.nodes()))\n", + " widthmap = [2 if \"node\" in kind else 1 for kind in kinds]\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", + " 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()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "53ab2b9c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:03.752735Z", + "iopub.status.busy": "2026-08-25T14:20:03.752107Z", + "iopub.status.idle": "2026-08-25T14:20:04.992453Z", + "shell.execute_reply": "2026-08-25T14:20:04.991033Z" + } + }, + "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" - } - ], - "source": [ - "network.find(node=[\"92\", \"101\", \"113\"]), network.find(reach=[\"44l1\", \"45l1\"], distance=[44.841, 37.206])" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/japr/Repos/modelskill/.venv/lib/python3.12/site-packages/networkx/drawing/layout.py:987: RuntimeWarning: divide by zero encountered in divide\n", + " costargs = (np, 1 / (dist_mtx + np.eye(dist_mtx.shape[0]) * 1e-3), meanwt, dim)\n" + ] }, { - "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": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "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]) " - ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_network(network)" + ] + }, + { + "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": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:04.995517Z", + "iopub.status.busy": "2026-08-25T14:20:04.995321Z", + "iopub.status.idle": "2026-08-25T14:20:05.000066Z", + "shell.execute_reply": "2026-08-25T14:20:04.998667Z" + } + }, + "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": [ + "478" ] - }, + }, + "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": 8, + "id": "30c88717", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.002631Z", + "iopub.status.busy": "2026-08-25T14:20:05.002358Z", + "iopub.status.idle": "2026-08-25T14:20:05.007373Z", + "shell.execute_reply": "2026-08-25T14:20:05.005888Z" + } + }, + "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": [ + "240" ] - }, + }, + "execution_count": 8, + "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": 9, + "id": "e25a4ba8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.009708Z", + "iopub.status.busy": "2026-08-25T14:20:05.009423Z", + "iopub.status.idle": "2026-08-25T14:20:05.015680Z", + "shell.execute_reply": "2026-08-25T14:20:05.014411Z" + } + }, + "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": [ + "([455, 5, 68], [240, 244])" ] - }, + }, + "execution_count": 9, + "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": 10, + "id": "cb1ae550", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.018483Z", + "iopub.status.busy": "2026-08-25T14:20:05.018235Z", + "iopub.status.idle": "2026-08-25T14:20:05.024805Z", + "shell.execute_reply": "2026-08-25T14:20:05.022827Z" + } + }, + "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": [ + "({'reach': '47l1', 'distance': 26.7092518454833},\n", + " {'reach': '1l1', 'distance': 0.0},\n", + " [{'reach': '47l1', 'distance': 26.7092518454833},\n", + " {'reach': '1l1', 'distance': 0.0}])" ] - }, + }, + "execution_count": 10, + "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": 11, + "id": "edec2e5a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.028134Z", + "iopub.status.busy": "2026-08-25T14:20:05.027832Z", + "iopub.status.idle": "2026-08-25T14:20:05.040168Z", + "shell.execute_reply": "2026-08-25T14:20:05.038998Z" + } + }, + "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": 11, + "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 is addressed the way the model names the location: a node's name, or a break point as a `(reach, distance)` pair. The integers the graph uses are an internal index, and observations never mention them.\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": 12, + "id": "817e1800", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.043090Z", + "iopub.status.busy": "2026-08-25T14:20:05.042858Z", + "iopub.status.idle": "2026-08-25T14:20:05.064739Z", + "shell.execute_reply": "2026-08-25T14:20:05.063884Z" + } + }, + "outputs": [], + "source": [ + "ds = network.to_dataset()\n", + "\n", + "# Script to generate dummy sensor data. Two sensors sit at named nodes and one\n", + "# at a break point along a reach, which is the pair of forms an observation takes.\n", + "sensor_locations = [\"98\", (\"117l1\", 48.7), \"101\"]\n", + "\n", + "\n", + "def graph_id(at):\n", + " if isinstance(at, str):\n", + " return network.find(node=at)\n", + " reach, distance = at\n", + " return network.find(reach=reach, distance=distance)\n", + "\n", + "\n", + "sensor_1, sensor_2, sensor_3 = (\n", + " ds[\"WaterLevel\"].sel(node=graph_id(at)).to_pandas().rename(f\"water_level@sens{n}\")\n", + " for n, at in enumerate(sensor_locations, start=1)\n", + ")\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": 13, + "id": "66d1b420", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.067278Z", + "iopub.status.busy": "2026-08-25T14:20:05.067089Z", + "iopub.status.idle": "2026-08-25T14:20:05.115372Z", + "shell.execute_reply": "2026-08-25T14:20:05.114441Z" + } + }, + "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@sens2790.0112470.1060830.1054850.0825450.851650.0005450.720208
\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 79 0.011247 0.106083 0.105485 0.082545 0.85165 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens2 0.000545 0.720208 " ] - }, + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is taken from the name of the series\n", + "# sensor 2 sits at a break point, addressed by its reach and distance along it\n", + "at = (\"117l1\", 48.7)\n", + "single_obs = ms.NodeObservation(sensor_2, at=at)\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ed1f9094", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.117280Z", + "iopub.status.busy": "2026-08-25T14:20:05.117046Z", + "iopub.status.idle": "2026-08-25T14:20:05.150538Z", + "shell.execute_reply": "2026-08-25T14:20:05.149228Z" + } + }, + "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_2790.0112470.1060830.1054850.0825450.851650.0005450.720208
\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 79 0.011247 0.106083 0.105485 0.082545 0.85165 \n", + "\n", + " si r2 \n", + "observation \n", + "network_sensor_2 0.000545 0.720208 " ] - }, + }, + "execution_count": 14, + "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=at)\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "de621fec", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.152192Z", + "iopub.status.busy": "2026-08-25T14:20:05.152048Z", + "iopub.status.idle": "2026-08-25T14:20:05.176449Z", + "shell.execute_reply": "2026-08-25T14:20:05.175587Z" + } + }, + "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 2790.0112470.1060830.1054850.0825450.851650.0005450.720208
\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 79 0.011247 0.106083 0.105485 0.082545 0.85165 0.000545 \n", + "\n", + " r2 \n", + "observation \n", + "Sensor 2 0.720208 " ] - }, + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is passed\n", + "single_obs = ms.NodeObservation(path_to_sensor2, at=at, 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": 16, + "id": "923a1d93", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.178104Z", + "iopub.status.busy": "2026-08-25T14:20:05.177945Z", + "iopub.status.idle": "2026-08-25T14:20:05.761740Z", + "shell.execute_reply": "2026-08-25T14:20:05.760245Z" + } + }, + "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": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAG5CAYAAACa+qCwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAeYdJREFUeJzt3Xd4k+X6B/Bvkibdg0LbtKWbllL2RkH2FBFQFBFBVBzHhSIOfgqIIrgPoqjHo4IKx0EFRGUplC17Q0tbuhgdtHSvpMnz+6MkNJCWjjSr38919YK+efPmuZu2791n3I9ECCFARERERAaklm4AERERkTVikkRERERkBJMkIiIiIiOYJBEREREZwSSJiIiIyAgmSURERERGMEkiIiIiMoJJEhEREZERTJKIiIiIjGCSRERERGQEkyQisiqnTp3CpEmTEBISAicnJwQGBmLEiBH49NNPLd20ZnPhwgUsXLgQffr0QatWrdCmTRsMHjwYf//9t6WbRtSiSbh3GxFZi3379mHIkCEIDg7Gww8/DKVSiQsXLmD//v04f/48kpOTLd3EZvHZZ5/hlVdewYQJE9C/f39UVVXh+++/x9GjR/Htt9/ikUcesXQTiVokJklEZDXGjh2LQ4cOITExEV5eXgaP5eTkwNfX1zINM4HS0lK4uroafezMmTPw8/NDmzZt9McqKyvRrVs3lJSU4MKFC+ZqJhHVwOE2IrIa58+fR8eOHW9KkAAYTZBWrVqFnj17wtnZGd7e3njggQduSigGDx6MTp064ezZsxgyZAhcXFwQGBiI999//6brffrpp+jYsSNcXFzQqlUr9OrVC//73/8Mzjl27BjGjBkDDw8PuLm5YdiwYdi/f7/BOStXroREIsHOnTvx9NNPw9fXF23btq017o4dOxokSADg6OiIO++8ExcvXkRxcXGtzyWi5sMkiYisRkhICI4cOYLTp0/f8tx33nkH06dPR2RkJD7++GO88MIL2LZtGwYOHIiCggKDc/Pz8zF69Gh07doVH330EaKjo/Hqq69i06ZN+nP++9//4vnnn0dMTAyWLl2KhQsXolu3bjhw4ID+nDNnzuCOO+7AiRMn8Morr2DevHlITU3F4MGDDc7Tefrpp3H27FnMnz8fr732WoO/HllZWXBxcYGLi0uDn0tEJiCIiKzE1q1bhUwmEzKZTNx2223ilVdeEVu2bBEqlcrgvLS0NCGTycQ777xjcPzUqVPCwcHB4PigQYMEAPH999/rj1VWVgqlUinuvfde/bHx48eLjh071tm+CRMmCIVCIc6fP68/dvnyZeHu7i4GDhyoP7ZixQoBQAwYMEBUVVU17ItwTVJSknBychLTpk1r1POJqOnYk0REVmPEiBH4559/cPfdd+PEiRN4//33MWrUKAQGBmLDhg3689auXQutVov7778fubm5+g+lUonIyEjExcUZXNfNzQ0PPfSQ/nOFQoE+ffogJSVFf8zLywsXL17EoUOHjLZNo9Fg69atmDBhAsLDw/XH/f398eCDD2LPnj0oKioyeM7jjz8OmUzW4K9DWVkZ7rvvPjg7O+Pdd99t8POJyDSYJBGRVenduzfWrl2L/Px8HDx4EHPnzkVxcTEmTZqEs2fPAgCSkpIghEBkZCR8fHwMPuLj45GTk2NwzbZt20IikRgca9WqFfLz8/Wfv/rqq3Bzc0OfPn0QGRmJZ555Bnv37tU/fuXKFZSVlaF9+/Y3tblDhw7QarU3zYcKCwtrcPwajQYPPPAAzp49i9jYWAQEBDT4GkRkGg6WbgARkTEKhQK9e/dG7969ERUVhUceeQRr1qzBggULoNVqIZFIsGnTJqM9NW5ubgaf19abI2os7u3QoQPOnTuHP/74A5s3b8avv/6Kzz//HPPnz8fChQsbFYOzs3ODn/P444/jjz/+wOrVqzF06NBGvS4RmQaTJCKyer169QIAZGZmAgAiIiIghEBYWBiioqJM9jqurq6YPHkyJk+eDJVKhXvuuQfvvPMO5s6dCx8fH7i4uODcuXM3PS8hIQFSqRRBQUFNev2XX34ZK1aswNKlSzFlypQmXYuImo7DbURkNeLi4gx6d3Q2btwIAPqhrnvuuQcymQwLFy686XwhBPLy8hr82jc+R6FQICYmBkIIqNVqyGQyjBw5Er/99hvS0tL052VnZ+N///sfBgwYAA8Pjwa/rs4HH3yADz/8EP/3f/+HWbNmNfo6RGQ67EkiIqvx3HPPoaysDBMnTkR0dDRUKhX27duHn3/+GaGhofrK0xEREVi0aBHmzp2LtLQ0TJgwAe7u7khNTcW6devwxBNPYM6cOQ167ZEjR0KpVKJ///7w8/NDfHw8PvvsM4wdOxbu7u4AgEWLFuGvv/7CgAED8PTTT8PBwQH/+c9/UFlZabTuUn2tW7cOr7zyCiIjI9GhQwesWrXK4PERI0bAz8+v0dcnosZhkkREVuPDDz/EmjVrsHHjRnz11VdQqVQIDg7G008/jTfeeMOgyORrr72GqKgo/Pvf/9bPGQoKCsLIkSNx9913N/i1n3zySaxevRoff/wxSkpK0LZtWzz//PN444039Od07NgRu3fvxty5c7FkyRJotVr07dsXq1atQt++fRsd94kTJwBUT0ifNm3aTY/HxcUxSSKyAG5LQkRERGQE5yQRERERGcEkiYiIiMgIJklERERERjBJIiIiIjKCSRIRERGREUySiIiIiIxgnaRG0mq1uHz5Mtzd3W/aOJOIiIiskxACxcXFCAgIgFRad18Rk6RGunz5cpP3aSIiIiLLuHDhAtq2bVvnOUySGkm3TcGFCxeatF8TERERmU9RURGCgoL09/G6MElqJN0Qm4eHB5MkIiIiG1OfqTKcuE1ERERkBJMkIiIiIiOYJBEREREZwTlJzUyj0UCtVlu6GWQF5HI5ZDKZpZtBRET1xCSpmQghkJWVhYKCAks3hayIl5cXlEola2sREdkAJknNRJcg+fr6wsXFhTfFFk4IgbKyMuTk5AAA/P39LdwiIiK6FSZJzUCj0egTpNatW1u6OWQlnJ2dAQA5OTnw9fXl0BsRkZXjxO1moJuD5OLiYuGWkLXRfU9wnhoRkfVjktSMOMRGN+L3BBGR7WCSRERUD+qsLJTuPwB1Vpalm0JEZsIkiaiBBg8ejBdeeMHSzSAzKoiNRfLQYciYMQPJQ4ehIDbW0k0iIjNgkkR6X375Jdzd3VFVVaU/VlJSArlcjsGDBxucu2PHDkgkEpw/f77Oa+rOM1UphJUrV8LLy8sk1yKqD3VWFjLnLwC02uoDWi0y5y9gjxJRC8AkifSGDBmCkpISHD58WH9s9+7dUCqVOHDgACoqKvTH4+LiEBwcjIiICLO0TQhhkLwRmYsqLf16gqSj1UKVnmGZBhGR2TBJIr327dvD398fO3bs0B/bsWMHxo8fj7CwMOzfv9/g+JAhQ/DDDz+gV69ecHd3h1KpxIMPPqivBZSWloYhQ4YAAFq1agWJRIIZM2YAALRaLZYsWYKwsDA4Ozuja9euiK0xhKHrgdq0aRN69uwJR0dH7Nmz55YxFBQUYObMmfDx8YGHhweGDh2KEydOAAASExMhkUiQkJBg8Jx///vfBsne6dOnMWbMGLi5ucHPzw/Tpk1Dbm5uw76YZDcUoSGA9IZflVIpFCHBlmkQEZkNkyQzEUKgTFVl9g8hRIPaOWTIEMTFxek/j4uLw+DBgzFo0CD98fLychw4cABDhgyBWq3G22+/jRMnTmD9+vVIS0vTJ0JBQUH49ddfAQDnzp1DZmYmPvnkEwDAkiVL8P333+PLL7/EmTNn8OKLL+Khhx7Czp07Ddrz2muv4d1330V8fDy6dOlyy/bfd999yMnJwaZNm3DkyBH06NEDw4YNw9WrVxEVFYVevXph9erVBs9ZvXo1HnzwQQDVSdbQoUPRvXt3HD58GJs3b0Z2djbuv//+Bn0dyX7IlUr4v7XweqIklcL/rYWQK5WWbRgRNTsWkzSTcrUGMQu2mP11zy4cBRdF/d/mIUOG4IUXXkBVVRXKy8tx7NgxDBo0CGq1Gl9++SUA4J9//kFlZSWGDBmC4ODrf02Hh4dj2bJl6N27N0pKSuDm5gZvb28AgK+vr34uUWVlJRYvXoy///4bt912m/65e/bswX/+8x8MGjRIf8233noLI0aMqFfb9+zZg4MHDyInJweOjo4AgA8//BDr169HbGwsnnjiCUydOhWfffYZ3n77bQDVvUtHjhzBqlWrAACfffYZunfvjsWLF+uv++233yIoKAiJiYmIioqq99eS7IfXpElwHTAAqvQMKEKCmSARtRBMksjA4MGDUVpaikOHDiE/Px9RUVHw8fHBoEGD8Mgjj6CiogI7duxAeHg4goODceTIEbz55ps4ceIE8vPzob02dyMjIwMxMTFGXyM5ORllZWU3JT8qlQrdu3c3ONarV696t/3EiRMoKSm5qcp5eXm5foL5Aw88gDlz5mD//v3o168fVq9ejR49eiA6Olp/jbi4OLi5ud10/fPnzzNJasHkSiWTI6IWhkmSmTjLZTi7cJRFXrch2rVrh7Zt2yIuLg75+fn6Xp2AgAAEBQVh3759iIuLw9ChQ1FaWopRo0Zh1KhRWL16NXx8fJCRkYFRo0ZBpVLV+holJSUAgD///BOBgYEGj+l6gHRcXV3r3faSkpKb5lTp6HqxlEolhg4div/973/o168f/ve//+Ff//qXwTXGjRuH995776ZrcL81IqKWhUmSmUgkkgYNe1nSkCFDsGPHDuTn5+Pll1/WHx84cCA2bdqEgwcP4l//+hcSEhKQl5eHd999F0FBQQBgsDIOABQKBYDq/ex0YmJi4OjoiIyMDIOhtabq0aMHsrKy4ODggNDQ0FrPmzp1Kl555RVMmTIFKSkpeOCBBwyu8euvvyI0NBQODrbxfhERUfPgxG26yZAhQ7Bnzx4cP37cIIkZNGgQ/vOf/0ClUunnIykUCnz66adISUnBhg0b9HN9dEJCQiCRSPDHH3/gypUrKCkpgbu7O+bMmYMXX3wR3333Hc6fP4+jR4/i008/xXfffXfL9mk0Ghw/ftzgIz4+HsOHD8dtt92GCRMmYOvWrUhLS8O+ffvw+uuvGyRv99xzD4qLi/Gvf/0LQ4YMQUBAgP6xZ555BlevXsWUKVNw6NAhnD9/Hlu2bMEjjzxikOgREZH9Y5JENxkyZAjKy8vRrl07+Pn56Y8PGjQIxcXF+lIBPj4+WLlyJdasWYOYmBi8++67+PDDDw2uFRgYiIULF+K1116Dn58fnn32WQDA22+/jXnz5mHJkiXo0KEDRo8ejT///BNhYWG3bF9JSQm6d+9u8DFu3DhIJBJs3LgRAwcOxCOPPIKoqCg88MADSE9PN4jD3d0d48aNw4kTJzB16lSDawcEBGDv3r3QaDQYOXIkOnfujBdeeAFeXl6Q3rgMnIiI7JpENHSNOAEAioqK4OnpicLCQnh4eBg8VlFRgdTUVISFhcHJyclCLSRrxO8NIiLLquv+fSP+aUxERERkBJMkIiIiIiOYJBEREREZwSSJiIiIyAgmSURERERGMEkiIiIiMoJJEhHRNeqsLJTuPwB1Vpalm0JEVoBJEhERgILYWCQPHYaMGTOQPHQYCmJjLd0kIrIwJklE1OKps7KQOX8BoNVWH9BqkTl/AXuUiFo4JknUKKGhoVi6dKmlm2EyO3bsgEQiQUFBgaWbQhagSku/niDpaLVQpWdYpkFEZBWYJNFNLly4gEcffRQBAQFQKBQICQnBrFmzkJeXZ+mmmcTgwYPxwgsvGBy7/fbbkZmZCU9PT8s0iixKERoC3Lg3n1QKRUiwZRpERFaBSRIZSElJQa9evZCUlIQff/wRycnJ+PLLL7Ft2zbcdtttuHr1qkXapdFooL3xL30TUigUUCqVkEgkzfYaZL3kSiX831p4PVGSSuH/1kLIlUrLNoyILIpJEhl45plnoFAosHXrVgwaNAjBwcEYM2YM/v77b1y6dAmvv/66/tzi4mJMmTIFrq6uCAwMxPLly/WPCSHw5ptvIjg4GI6OjggICMDzzz+vf7yyshJz5sxBYGAgXF1d0bdvX+zYsUP/+MqVK+Hl5YUNGzYgJiYGjo6O+Prrr+Hk5HTTkNisWbMwdOhQAEBeXh6mTJmCwMBAuLi4oHPnzvjxxx/1586YMQM7d+7EJ598AolEAolEgrS0NKPDbb/++is6duwIR0dHhIaG4qOPPjJ43dDQUCxevBiPPvoo3N3dERwcjK+++qopX36yIK9Jk9Bu+zYEf/cd2m3fBq9JkyzdJLJyXA3ZAghqlMLCQgFAFBYW3vRYeXm5OHv2rCgvL2/y66gyM0XJP/uFKjOzyde6lby8PCGRSMTixYuNPv7444+LVq1aCa1WK0JCQoS7u7tYsmSJOHfunFi2bJmQyWRi69atQggh1qxZIzw8PMTGjRtFenq6OHDggPjqq6/015o5c6a4/fbbxa5du0RycrL44IMPhKOjo0hMTBRCCLFixQohl8vF7bffLvbu3SsSEhJESUmJ8PPzE19//bX+OlVVVQbHLl68KD744ANx7Ngxcf78eX27Dhw4IIQQoqCgQNx2223i8ccfF5mZmSIzM1NUVVWJuLg4AUDk5+cLIYQ4fPiwkEql4q233hLnzp0TK1asEM7OzmLFihX61w4JCRHe3t5i+fLlIikpSSxZskRIpVKRkJBQ69fYlN8bZFnm/Nkk65O/Zo042yFGnG0fLc52iBH5a9ZYuklUT3Xdv2/EJKmRzJEkmfuHcP/+/QKAWLdundHHP/74YwFAZGdni5CQEDF69GiDxydPnizGjBkjhBDio48+ElFRUUKlUt10nfT0dCGTycSlS5cMjg8bNkzMnTtXCFGdJAEQx48fNzhn1qxZYujQofrPt2zZIhwdHfXJjTFjx44VL730kv7zQYMGiVmzZhmcc2OS9OCDD4oRI0YYnPPyyy+LmJgY/echISHioYce0n+u1WqFr6+v+OKLL2ptC5Mk+8AbZMumysy8/v7rPjrEMGG2EQ1JkjjcZqUsuSRZCFGv82677babPo+PjwcA3HfffSgvL0d4eDgef/xxrFu3DlVVVQCAU6dOQaPRICoqCm5ubvqPnTt34vz58/rrKRQKdOnSxeA1pk6dih07duDy5csAgNWrV2Ps2LHw8vICUD136e2330bnzp3h7e0NNzc3bNmyBRkZDVulFB8fj/79+xsc69+/P5KSkqDRaPTHarZPIpFAqVQiJyenQa9FtoXlAoirIVsOJklWyhI/hO3atYNEItEnOjeKj49Hq1at4OPjc8trBQUF4dy5c/j888/h7OyMp59+GgMHDoRarUZJSQlkMhmOHDmC48eP6z/i4+PxySef6K/h7Ox800Tq3r17IyIiAj/99BPKy8uxbt06TJ06Vf/4Bx98gE8++QSvvvoq4uLicPz4cYwaNQoqlaqRX5W6yeVyg88lEkmzTjAny+MNkrgasuVgkmSlLPFD2Lp1a4wYMQKff/45ysvLDR7LysrC6tWrMXnyZH3isn//foNz9u/fjw4dOug/d3Z2xrhx47Bs2TLs2LED//zzD06dOoXu3btDo9EgJycH7dq1M/hQ1mM10dSpU7F69Wr8/vvvkEqlGDt2rP6xvXv3Yvz48XjooYfQtWtXhIeHIzEx0eD5CoXCoDfImA4dOmDv3r0Gx/bu3YuoqCjIZLJbtpHsF2+QxNWQLQeTJCtlqR/Czz77DJWVlRg1ahR27dqFCxcuYPPmzRgxYgQCAwPxzjvv6M/du3cv3n//fSQmJmL58uVYs2YNZs2aBaB6ddo333yD06dPIyUlBatWrYKzszNCQkIQFRWFqVOnYvr06Vi7di1SU1Nx8OBBLFmyBH/++ect2zh16lQcPXoU77zzDiZNmgRHR0f9Y5GRkfjrr7+wb98+xMfH48knn0R2drbB80NDQ3HgwAGkpaUhNzfXaM/PSy+9hG3btuHtt99GYmIivvvuO3z22WeYM2dOY7+0ZCV2J11Bbkllo5/PGyQBXA3ZYjT/FCn7ZNbVbfsPmHVCYFpamnj44YeFn5+fkMvlIigoSDz33HMiNzdXf05ISIhYuHChuO+++4SLi4tQKpXik08+0T++bt060bdvX+Hh4SFcXV1Fv379xN9//309LpVKzJ8/X4SGhgq5XC78/f3FxIkTxcmTJ4UQ1RO3PT09a21jnz59BACxfft2g+N5eXli/Pjxws3NTfj6+oo33nhDTJ8+XYwfP15/zrlz50S/fv2Es7OzACBSU1NvmrgthBCxsbEiJiZGyOVyERwcLD744AOD1woJCRH//ve/DY517dpVLFiwoNZ2c+K2Ze1KzBEhr/0h7nh/uygsv3lRQUNY4meTiJquIRO3JULUc5YuGSgqKoKnpycKCwvh4eFh8FhFRQVSU1MRFhYGJycnC7WQrBG/NyzrnY1n8d/dqQCAsZ398dmU7iwgStTC1HX/vhGH24ioxTiQeH3o9c9Tmfjx0AULtoaIrJ1Fk6Rdu3Zh3LhxCAgIgEQiwfr16w0ez87OxowZMxAQEAAXFxeMHj0aSUlJRq8lhMCYMWOMXsfYufPnz4e/vz+cnZ0xfPjwWq9LRPbh0s+xOJ1ZDAAYf343AGDh72cQn1lkkfawWjOR9bNoklRaWoquXbsabGehI4TAhAkTkJKSgt9++w3Hjh1DSEgIhg8fjtLS0pvOX7p0ab27zd9//30sW7YMX375JQ4cOABXV1eMGjUKFRUVTY6JiKyPOisLcZ+vglYqg7I0D0+c3IDeWfGorNLimR+PorSyyqztKYiNRfLQYciYMQPJQ4ehIDbWrK9PRPVj0SRpzJgxWLRoESZOnHjTY0lJSdi/fz+++OIL9O7dG+3bt8cXX3yB8vJyg724AOD48eP46KOP8O23397yNYUQWLp0Kd544w2MHz8eXbp0wffff4/Lly/fsgeKiGyTKi0dp73DAACdclMghcBLR36En5MUKVdK8eh3h1BUoTZLW1iMksh2WO2cpMrK6iW6NSe3SqVSODo6Ys+ePfpjZWVlePDBB7F8+fJ61dhJTU1FVlYWhg8frj/m6emJvn374p9//jFhBPWvXE0tB78nLEMRGoLTbcIBAJ3yUgAAnlUV+PTuSLg7OuBA6lVM/mo/coqavzeZxSiJbIfVJknR0dEIDg7G3LlzkZ+fD5VKhffeew8XL15EZmam/rwXX3wRt99+O8aPH1+v62Zd+2vNz8/P4Lifn5/+MWMqKytRVFRk8FEbXRXmsrKyerWJWg7d98SNlbqpeWla++CcT3VPUufcFH1toz7d2+GnJ/qhjZsj4jOLcO+X+5Cae/NwvimxGCWR7XCwdANqI5fLsXbtWjz22GPw9vaGTCbD8OHDMWbMGP1f4xs2bMD27dtx7NixZm/PkiVLsHDhwnqdK5PJ4OXlpd/Dy8XFhcuMWzghBMrKypCTkwMvLy9W7TazExcLoBYS+LrK0Xf5R3AMDdEXf+wY4Im1/7od0745gPSrZZj05T6se7o/gr1dmqUtumKU+iE3FqMkslpWmyQBQM+ePXH8+HEUFhZCpVLBx8cHffv2Ra9evQAA27dvx/nz5/Wbm+rce++9uOOOO7Bjx46brqkbksvOzoa/v7/+eHZ2Nrp161ZrW+bOnYvZs2frPy8qKkJQUFCt5+teh5udUk1eXl71GhYm0zqYehUA0CeiDdz69bjp8WBvF8Q+dTumrziI+MwizP7lOH5+4jbIpM3zx43XpElwHTAAqvQMKEKCmSARWSmrTpJ0PD09AVRP5j58+DDefvttAMBrr72GmTNnGpzbuXNn/Pvf/8a4ceOMXissLAxKpRLbtm3TJ0VFRUU4cOAA/vWvf9XaBkdHR4PtL25FIpHA398fvr6+UKvNMyGUrJtcLmcPkoXokqS+od61nuPj7oivpvXEmE9243B6Pr7ceR7PDGnXbG2SK5VMjoisnEWTpJKSEiQnJ+s/T01NxfHjx+Ht7Y3g4GCsWbMGPj4+CA4OxqlTpzBr1ixMmDABI0eOBFDdW2Psr/Lg4GCEhYXpP4+OjsaSJUswceJESCQSvPDCC1i0aBEiIyMRFhaGefPmISAgABMmTDB5jDKZjDdGIgtSa7Q4kpEPAOgT1rrOc4NaueDNcR0xJ/YE/v13IgZG+aBzoKc5mklEVsiiSdLhw4cxZMgQ/ee64ayHH34YK1euRGZmJmbPnq0fGps+fTrmzZvX4Nc5d+4cCgsL9Z+/8sorKC0txRNPPIGCggIMGDAAmzdv5jYRRHbozOUilKk08HKWI9LX7Zbn39sjENsSsrHpdBZe+PkY/nj2Djgr+IcOUUvEvdsaqSF7vxCRZaizsvCfv+Px4ZkyjIjxw3+n9arX8/JLVRj1yS7kFFdiWr8QvHV3x1suvlBnZUGVlg5FjUnhDW1rU55PRPXDvduIqMXTVbXe/fchAECXoov1fm4rVwU+mNQVAPDD/nS89cdZaLW1/z3Z1ArarMBNZJ2YJBGR3dFVtdZqBc60rp6fGLz6iwZVtR4U5YN5Y2MAACv2peG5n46hQq2p9bUaW0GbFbiJrBeTJCKyO7qq1pmurVGicIFCo0ZE/sUGV7V+bEAYlj3QHXKZBH+eysT0FQdRWG64WrWpFbRZgZvIejFJIiK7o6tqneZZPbcnpCgLMgkaVdX67q4B+O6RPnB3csDB1KuY9OU+XC4ov+m1DDSggjYrcBNZLyZJRGR3dFWt0zwCAAAhxdlNqmp9e0QbrHnyNig9nJCUU4J7vtiHxOxig9fSJzoNrKDd1OcTUfPh6rZG4uo2Iuv31Dd7sTm5AK/d0RZP3dm1yde7XFCO6SsOIjmnBB5ODvh6em/0CasuUKnOympSBe2mPp+I6oer24iIACQVVs8fimkXYJLrBXg5I/bJ29ArpBWKKqrw0LcHsPlM9QRruVIJ1759Gp3gNPX5RGR6TJKIyC5VqDVIyysDALRXupvsul4uCqx6rC9GxPhBVaXF06uP4KdDnGRNZI+YJBGRXTp/pQQarYCXsxy+7vXfd7E+nOQyfPFgDzzQOwhaAby29hSW70gGZy8Q2RcmSURkl85lVU+sjlK637JadmM4yKRYMrEznhkcAQD4YMs5vP1nfJ1FJ4nItjBJIiK7dO7a6rNoP9MNtd1IIpHg5VHR+qKT3+5Nxf+tP8VEichOMEkiIrtUsyepuT02IAwf39cVUgnw06ELeG3dSSZKRHaASRIR2SVz9CTVdE+Ptvj3/d0glQC/HL6Il389CQ0TJSKbxiSJiOxOYbkamYUVAIBIMyVJADC+WyA+eaA7ZFIJfj16ES/HnmCPEpENY5JERHZHVw07wNMJns5ys772uC4BWHYtUVp77BKWbU8y+Wuos7JQuv8AN8ElamZMkojI7uiG2qLM2ItU09jO/lgysTMAYOm2JGw6nWmyxKYgNhbJQ4chY8YMJA8dhoLYWFM0mYiMYJJERHZHN2nblEUkG+r+XkF4tH8YAODFH49g64SHmpzYqLOykDl/AaDVVh/QapE5fwF7lIiaCZMkIrI7up6k9hbqSdL5vzHR6B/sjgqtBAv7PIwChWuTEhtVWvr1BElHq4UqnRW/iZoDkyQisitCCKvoSQKqC05+0FGOgJIryHH1xpI+06CBpNGJjSI0BJDe8GtbKoUiJNhELSaimpgkEZFdySmuRGG5GjKpBBE+bpZuDnyiwrDgwHdwVlfgpE87/Nx+WKMTG7lSCf+3Fl5PlKRS+L+1kJviEjUTB0s3gIjIlBKu9SKFtnaBk1xm4dZUJzZ9X3kGz3y1Hh/2fACrO4zE0IlD0KGRiY3XpElwHTAAqvQMKEKCmSARNSP2JBGRXUm0kvlINXlNmoQnv/8Adwc5QiuR4vUsTxSUqRp9PblSCde+fZggETUzJklEZFcS9PORPCzcEkNypRKLHxuM0NYuuFxYgVfXnoQQLDRJZM2YJBGRXbnek2T5+Ug3cnN0wKdTekAuk2DLmWz8eOiCpZtERHVgkkREdkOjFdeTJAv3JNVWPLJzoCdeHRUNAFi8MR6XC8ot0TwiqgcmSURkNzKulqGySgtHBymCvV0s1o5bVcV+pH8Yeoa0QkllFd5Yf5rDbkRWikkSEdkNXRHJSF83yKQSi7ShPlWxZVIJ3runMxQyKbafy8GGE5ct0lYiqhuTJCKyG4lZlt2zDah/Vex2vu54bmg7AMCbv59BXkmluZpIRPXEJImI7IZ+OxILVtpuSFXsJwdGIFrpjvwyNd7646yZWkhE9cUkiYjshm7StiV7khpSFVvhIMX793aBVAL8duIy4s7lmLm1RFQXVtwmIpumzsqCKi0dom0QUnNLAQDR9exJ0j1XERpi0sKMDamK3aWtFx7tH4av96Ri4e9ncHtEazg63FwpvLnaSkS1Y08SEdmsmqvIdk2ahiqtgLuTA1qXFRhdfl/bc42tQGuqhlTFnjUsEr7ujkjLK8PXu1PN3lYiMo5JEhHZpBtXkaW5+QEAwlGG88OG15lQ1GcFmjm5O8nxf2M6AAA+jUvCpRq1k6ytrdaqtrpURE3BJImIbNKNq8jSPap7bALjj9wyoajvCjRzGt8tAH1CvVGh1uKdP69P4rbGtlob9rRRc2GSREQ26cZVZGnXkqSQoht6EowkFA1ZgWYuEokEC+/uCKkE2Hg6C3uScwFYZ1utCXvaqDkxSSIim3TjKjJdT1JocbbhiUYSioasQDOnDv4emN4vFACwYMNpqKq0VttWa8GeNmpOEsF6+I1SVFQET09PFBYWwsPDunYbJ2pJ1FlZyD+fjj5/VPe8xHUtR8Vb13oWriUUXpMm1frc+qxAM6fCcjWGfrQDeaUqzL8rBo/2DwNgnW1tbvVZ0afOykLy0GGGiZJUinbbt9nd14krHE2jIfdvlgAgIpsmVypxWe0EIBc+7o4Ie2As1IPrt/xerlRa3c3G01mOl0a2x/+tO4Vl25Jwb4+28HSWW2Vbm1NBbOz1YbQ6kl1dT9uN59rb16q+Xw8yLfYkNRJ7koisxy+HL+CVX09iQLs2WPVYX0s3p8mqNFqMWbYbSTkleOKOcPzfnR0s3SSzakzvkD33tLWk3jJzaMj9m3OSiMjmJVjBnm2m5CCT6ksCrNyXhgtXyyzcIvNqzDyjhtSlam6mLkfAeVeWwySJiGyebjuS9n5uFm6J6Qxu74P+Ea2h0mjx/pZzlm6OWdnyir7mKEdgy18PW8ckiYhs3jkr2LPN1CQSCf7vzg6QSIDfT17GsYx8SzfJbGx1RV9zlSOw1a+HPeDEbSKyaVdLVbhSXAkAiLSjJAkAOgZ44t4ebRF75CIWb4rHL0/cBolEYulmmUVD9r+zFnUNizW1/bb49bAH7EkiIpumG2oLauUMN0f7+7vvpRFRcJJLcSgtH3/FZxs9x1635LCmeUb10dzDYrb29bAHTJKIyKbp5yMp7asXScff01lfK2np30m4cUEyt+SwHrY6LGavSbYp2N+fXUTUouhWtkX62leSVLNw4OMDwvHdvjSczSzCX/HZGBmj1J9jbA6M64ABVn9jtle2NizG+kt1Y08SEdm0s5lFAICYAPupV3Zj75Bk0wY8fHsoAOCTbdd7k7g03DrZyrAY9727NSZJRGSzNFqBhKxrSZK/fSRJtd24Ho5yg4tChjOXi/B3fA4ALg2npmGSfWtMkojIZqXmlqJCrYWzXIbQ1q6Wbo5J1Hbjcsu5jIdvCwUAfLItEUIIm50DQ9aBSfatMUkiIpt15nIhAKCDvztkUvtYGl/XjevxO8LhopDh9OUibEuo7k3ymjQJ7bZvQ/B336Hd9m2cT0L1xiT71pgkEZHN0s9HaqahNkus+qnrxuXtqsB0fW/S9blJtjIHpqWzxlVkTLLrxtVtRGSzrk/a9jT5tS256qeuFVKPDwjDd/vScOpSIbYn5GBYBz+ztImaxppXkcmVSibYtWBPEhHZJCEEzl5unp4ka1j1U1vvUGs3R0y/LQQAsHxHstnaQ41nDd9P1DhMkojIJl0prkReqQpSCdDexNuRWPuqn8f6h0Ehk+JoRgGOpF+1dHPoFqz9+4lqxySJiGzSmWtDbeE+bnBWyEx6bWtf9ePr4YSJ3QMBAP/dnWrh1tCtWPv3E9WOSRIR2STdUFvHZpi0bQurfmYOqN6qZMvZLKTmllq4NVQXW/h+IuMsmiTt2rUL48aNQ0BAACQSCdavX2/weHZ2NmbMmIGAgAC4uLhg9OjRSEpKMjjnySefREREBJydneHj44Px48cjISGhztctKSnBs88+i7Zt28LZ2RkxMTH48ssvTR0eETWj5q60be2rfiL93DG0vS+EAL7Zk2Lp5tAtWPv3Exln0SSptLQUXbt2xfLly296TAiBCRMmICUlBb/99huOHTuGkJAQDB8+HKWl1/9q6tmzJ1asWIH4+Hhs2bIFQgiMHDkSGo2m1tedPXs2Nm/ejFWrViE+Ph4vvPACnn32WWzYsKFZ4iQi02uuSds1WfvS+scHhgMA1hy5iLySyno/zxqXorcE1v79RDeTiBu3lLYQiUSCdevWYcKECQCAxMREtG/fHqdPn0bHjh0BAFqtFkqlEosXL8bMmTONXufkyZPo2rUrkpOTERERYfScTp06YfLkyZg3b57+WM+ePTFmzBgsWrSoXu0tKiqCp6cnCgsL4eFhH9shENmKksoqdF64BUIAh18fjjZujpZukkUIITB++V6cvFSIF4dHYdawyFs+x5qXohOZQ0Pu31Y7J6mysvqvIicnJ/0xqVQKR0dH7Nmzx+hzSktLsWLFCoSFhSEoKKjWa99+++3YsGEDLl26BCEE4uLikJiYiJEjR9bZnqKiIoMPIrKMc1lFEALw83BssQkSUP3Hpa436ft/0lChrr0HHeBSdHvDHsHmZ7VJUnR0NIKDgzF37lzk5+dDpVLhvffew8WLF5GZmWlw7ueffw43Nze4ublh06ZN+Ouvv6BQKGq99qeffoqYmBi0bdsWCoUCo0ePxvLlyzFw4MBan7NkyRJ4enrqP+pKwoioeZljqM1WjOmoRKCXM/JKVVh37FKd53Ipuv0oiI1F8tBhyJgxA8lDh6EgNtbSTbJLVpskyeVyrF27FomJifD29oaLiwvi4uIwZswYSG9YSjl16lQcO3YMO3fuRFRUFO6//35UVFTUeu1PP/0U+/fvx4YNG3DkyBF89NFHeOaZZ/D333/X+py5c+eisLBQ/3HhwgWTxUpEDaObtN2xGSpt2xoHmRSP3B4KAPjunzTUNYOCS9HtA3sEzcdqkySgep7Q8ePHUVBQgMzMTGzevBl5eXkIDw83OM/T0xORkZEYOHAgYmNjkZCQgHXr1hm9Znl5Of7v//4PH3/8McaNG4cuXbrg2WefxeTJk/Hhhx/W2hZHR0d4eHgYfBCRZZxhT5KB+3oFwVkuQ0JWMQ6m1V5ckkvR7QN7BM3HJvZu8/Ss/msxKSkJhw8fxttvv13ruUIICCH0c5pupFaroVarb+qNkslk0N74TUdEVqdKo0VCdjEAJkk6ns5yTOgeiB8PZuD7f9LRN6x1refWtS8c2QZ9j2DNexZ7BJuFRXuSSkpKcPz4cRw/fhwAkJqaiuPHjyMjozobXrNmDXbs2KEvAzBixAhMmDBBP8E6JSUFS5YswZEjR5CRkYF9+/bhvvvug7OzM+68807960RHR+t7ljw8PDBo0CC8/PLL2LFjB1JTU7Fy5Up8//33mDhxonm/AETUYCm5pVBVaeGqkCHY28XSzbEaD1/bz23zmSxkFdY+3QDgUnRbZys9gvYwsdyiPUmHDx/GkCFD9J/Pnj0bAPDwww9j5cqVyMzMxOzZs5GdnQ1/f39Mnz7dYNm+k5MTdu/ejaVLlyI/Px9+fn4YOHAg9u3bB19fX/15586dQ2Fhof7zn376CXPnzsXUqVNx9epVhISE4J133sFTTz1lhqiJqCl0k7Y7+HtAKpVYuDXWI1rpgb5h3jiQehWrD6TjpZHtLd0kakbW3iNoL6UmrKZOkq1hnSQiy3hn41n8d3cqHr4tBAvv7mTp5liVjacy8fT/jqKNmwJ7Xx0KRwfT7mlHVB/qrCwkDx1203Bgu+3brCKZs4s6SURExnDSdu1GxPhB6eGE3BIVNp2y3SEOsm32NLGcSRIR2QwhhD5J4vL/m8llUjzUr3ry7sp/0vTH7WFuCNkOeyo1wSSJiGzG5cIKFJar4SCVINLPzdLNsUoP9A6GQibF8QsFOHmxgEUHyexsZWJ5fdhECQAiIgA4c7l6AUY7XzfOt6lFGzdHjOmkxG8nLuOX3YmY+vbNRQddBwywyRsW2Q5rn1heX+xJIiKbwaG2+rm3R1sAwO/xuVCLG1YA2ujcELo1axtWtYdSE+xJIiKbcX07Ek7arkv/dm3g6+6InOJKHAyIQf9Lp64/aKNzQ6hutrjkXgiBcrUGpZUalKmqUKrSoKyy+t/ya5+393NHp0DL/VHEJImIbMbZy0yS6kMmlWBi90D8Z1cK9o58CP2/m2tw87Tlv+zNQZ2VBVVaOhShITbxtaptL7fmHFbVagWKK6tQVK5GYbkaRRVqFJWrUVRRfay4sgrFFVUoqVSjuKLq2of62rEqlFZWoUytwa2KED07pB2TJCKiW8kvVeFSQTmA6kKSVLd7urfFf3alYE+xA979cwvcci7b9NwQc7HFHpm6ltzX9X5XabQoqqhC4bVEp+ZH0bXEx9hjheVqlFRW3TLBaQhXhQwujg5wkVf/66qQwUXhYPGq+kySiMgm6Ibagr1d4OEkt3BrrF97pTs6BnjgzOUibMmqwvTb+li6SVbPEj0yTaHRCpRUVuGqtxIpXoEokTmiTO6EErkzSh1doMh0QMkfZ/U9Pfrk51qiU6rSNLkNTnIpPJzk8HSWw8NZDg8nB7g7yeFe819HB4PPXR0d4Kao/tdFIYOzXGa11fOZJBGRTeB8pIa7p3tbnLl8Fr8evYTpt4VaujlWr7E9Mk0lRPXQVU5RJa6UVCK/VIWCcjUKylQoKFOjoFz3b3WCU1xjSEtvyIs3X/hAZr1e383RAR5ODvB0UcDT2aE64bmW+NT88HCqToT0nzs72P0qUyZJRGQTdMv/WWm7/u7uGoDFm+Jx4mIBknNK0M6XtaXqoi+CeMN2GqaY6F5YrkZyTgnS80pxIb8cF/PLcCG/DJfyy3GlpBIVau2tL1ILRwcpPJzlcHcA3KCBp4cLPD1db+rhqZnsuJQUwDknE60jQ+Ec4N/k+OwVkyQisglnOGm7wXzcHTEo0gfbz+Vg3bGLeHlUtKWbZNV0RRBvnJPUkF6kksoqJGQW4Vx2MZJySpCcU4KknGJkF1Xe8rnuTg7wcXdEG1dHeLrI4eUsh5eLHF7OCni6VCc4XjV6dKqHsBrem6Obd1Ws1aLYRuZdWQqTJCKyehVqDc5fKQHAGkkNdU+PwGtJ0iW8NKK91c79sBYNKYKYU1yBM5eLcDazCGcvV3+kXS2tdUKz0sMJYW1cEeTtjKBWLghq5YLAVs7w83CCj5sjnBXNP3Rla/OuLI1JEhFZvYSsYmgF0MZNAV93R0s3x6YM7+AHdycHXC6swMG0q+gX3trSTbJ6cqXSIGHQagVS80qvJ0OZRThzuQi5JcZ7h5QeTohWuiPKzx3tfN0Q6euGCF+3ei04aO7yAw2dd9WY9thaCYW6MEkiIqunm4/Uwd8DEgl7QhrCSS7DqI5KxB65iD9PZTJJqkNllQYZeWVIyS1F8pUSJGdXD5UlXykxOmdIIgHC27iiY4AnYvw90DHAAzH+Hmjt1rhE3hzlBxoy76ox7Wnoc6w9oZIIYcpKBy1HUVERPD09UVhYCA8PzpEgak6vrz+F1Qcy8NSgCLw2mvNqGiruXA4eWXkIbdwUODB3OGQWHnKz5I1RCIErxZU4l12M1NxSg48L+WXQ1nJHdJJLEa2sToJiAjzQ0d8D7ZXucFGYpq9BnZWF5KHDbkpe2m3fZvKvUX0Smca0p6HPsVRNqobcv9mTRERWj5O2m2ZAuzbwdJYjt0SFA6l5uD2ijcXaYu4bY2ZhOQ6n5+NIej7iM4uQmF2M/DJ1ree7OTogrI0rwtu46ofLovzcEezt0qzJpTnLD9Rn3lVj2tOQ59jK3CgmSURk1TRagYSs6iSJy/8bRy6TYnRHJX4+fAF/nMy0WJJkjhujqkqLvedzsfFUJvYm5+JyYcVN50glQIi3KyJ83RDexhVhbVwR2sYVEW1c4ePuaJEh3eYsP2DMjfOuTNGehjzHUjWpGopJEhFZteSc6vkgLgoZQlu7Wro5NuuuLv74+fAFbD6Thbfu7ggHmdTsbWjOG2N8ZhFW7EvFljPZKCy/3lMkk0rQQemOXiHe6NzWE+2V7mjn4wYnuXUVQTRF+QFLt6chzzF3UthYTJKIyKqduFgAAOgc6GnxuTS27Lbw1mjlIsfVUhX+ScnDHZE+Zm9Dc9wYy1RVWPp3Er7ZmwrNtQlFbdwccWcnJUbE+KFHcCu4OtrGra4h5QestT31fY61JYW1sY3vHCJqsU5eS5K6tvWyaDtsnYNMitGd/PHjwQz8eSrTIkmSqW+McQk5eOO30/qNj0d3VOLh20PRJ9TbZhPqWw2DmVtj2lPf51hbUmgMkyQismonLlYv/+/SlkUkm2pcl+okafPpLLw9vhPkFhhyM8WNMae4Agt/P4s/T1XvTRbo5Yy37u6IYR38TN1cambWlhTeiEkSEVmtyiqNftI2e5Kark+oN9q4KZBbosLe5FwMbu9rkXY09sao1Qr8eCgD725OQHFFFaQS4NH+YXhxeJTNDKmZi7XXH7IV/K4iIqsVn1kMtUbA21WBtq2cLd0cm+cgk2JMJ3/8sD8df57KtFiS1BgVag2eXHUEOxOvAKieo7ZkYmd0CmQP440sVX/IHpm/r5WIqJ5OXCgAAHQJ9GSlbRMZ27l6x/ctZ7Kgqmr8zvPmVKHW4IkfqhMkZ7kM8++Kwfqn+zNBMqK2MgvqrCzLNsxGMUkiIqulW9nWhUNtJtP72pBbUUUVjmTkW7o5t6Sq0uKZ/x3FrqTqBOm7R/rg0f5hNjsxu7nVVWbBVNRZWSjdf6BFJF5MkojIap28VD1pu1sQewxMRSaVYEC76mKSu5OuWLg1dVNrtHjup6PYlpADRwcpvnm4F/qEeZv+dezopq8vs1CTCesPFcTGInnoMGTMmIHkocNQEBtrkutaKyZJRFbOnn6BN0RxhRrnr5QAYE+SqemW/+9JyrVwS2pXpdHihZ+PY8uZbChkUvx3Wq9mqRRubzd9XZkFfaJkwvpDLXEojxO3iaxYS56AeepSIYSoXt7dppG7qpNxd1zrSTp1uRBXS1XwdlVYuEWGhBBY8PsZ/HkqE3KZBF8+1AMDo0xf18lW9g9rqOaqP2QrW4mYEnuSiKxUS/qrzVhv2clr9ZG6sj6Syfl6OKG9nzuEAPaet77epB/2p2P1gQxIJMCnD3TH0OjmqX9kjvk7liJXKuHat49Jk5fmHsqzRkySiKyUPf8Cr6m24Q5O2m5ed0Ra57ykPcm5WPjHWQDAq6OiMbqTf7O9Vku86TdFcw7lWSsmSURWqiX8Aq+rt+wkK203ya3mstWclySEMGfTapWaW4qnVx+BRitwT/dAPDkwvFlfryXe9JvKa9IktNu+DcHffYd227fZ/fB/veYknTx5ssEXjomJgYMDpzwRNZatbADZFLX1ll0+l4ZLBeWQSKqLBlLD1GcuW59QbygcpLhcWIHzV0rRztfNQq2tVlShxmPfH0JRRRV6BHth8cTOZqmNZcn9w2y1Kra1byViSvXKYrp16waJRFLvvzakUikSExMRHt68fwUQ2Ttb2ACyKWrbFT5B7gUgDxE+bnB3kluqeTapvpORnRUy9A5phb3n87A76YrFk6SFv59FypVSKJ2l+GxkMJzkMrO9tiVu+i15UYYtqXdXz4EDB+Djc+vVBUIIdOrUqUmNIqLr7Pmvttp6yzaVVg9/dGEvUoM1ZAXSHZE+15KkXDwU4WyxXo2tZ7Pw69GLkAgt5mz+DIU/ZcDFjpMGe11VZ4/qlSQNGjQI7dq1g5eXV70uOnDgQDg7c58lIro1Y71lJ1ccBMBNbRujtt45Y3PZ7ohsg3c3A/8kZSP+g8cg16j1iarrgAFmSZpySyrxWuwJAMCkpB3oeDUNAOw6aWiJS+ltVb2SpLi4uAZddOPGjY1qDBG1TDf2lp3JLAIAdOak7QZryFy2DkoPtHZ2QF55FeK9gtAlL6W6V2PefEAiafahICEEXl9/ClfLqxBaeBkPxW+5/qAdJw0NSWTJsri6jYisSkGZCleKKwEAYSgD0HKrjjdWfVcgSaUS9GtdPffnqF/U9QeEMEt9rnXHLmHLmWzIpRLMOfozFFpNzcbZbdLAVXW2o15J0uzZs1FaWlrvi86dOxdXr15tdKOIqOU69ssfAADfsnxkjR6Jy6/NtattI8ylvsUEB3aorkN01Ld97Sc1Q32uywXlWPD7GQDAC8OjMGDOUy0qaWhpS+kB2/xjp15J0ieffIKysrJ6X3T58uUoKChobJuIqIVSZ2Xh6M/VSVJwUTag1aJw/foWUXXcUgb3igAAJHsFokjhUj3MduPSexP36mi1Aq/8ehLFFVXoHuSFJweGt8ikoTmqYlsrW90jr15zkoQQiIqKqnfNiob0OhER6ajS0pHhVr2KNrg42/hJdjxXxRL8rm1Rci67GBff/Dfuvj0KpXv2NGt9rlUH0rEnORdOcik+uq8rHGTVf6/b80rOlsyWV/PVK0lasWJFgy/s59c8e+0QkX0wVkhPERqCDI/q/9eaJNnxXBVLuSOyDc5lF+Og8MK9SmWz1ue6kF+GxZviAQBzR3dAuI9l6zNR87Pl1Xz1SpIefvjh5m4HEbUgtRXSkyuVuBgYCaivJUlSKTzvvhuFGzbYbdVxa9AvvDW+3pOKQ+nX55I2V6/O7ycuo0KtRa+QVpjWL8Tk1yfrY8ur+bhvCBGZVV1d72WerXFFXT2sf/v7b6J1u1DIlUr4vDDLbquOW4Oewa0AAClXSnG1VAVvV0WzvdbOxOoNdcd3DYBU2vzbjpDl2fIWS0ySiMis6up6T1Y6AgCUHk5QDuinf5hzVZpXK1cFInxccf5KKY6k52NETPNMlyiuUONIej4AYFB732Z5jdrY6j5p9sJWt1hinSQiMit913tN17rek3OKAQCRFt5HrCXqFeINADic3nzlW/aez0OVViC8jSuCvV2a7XVuZKsrq+yNLa7mY5JERGZVVyG9xOwSALD4ZqstUc+Q6iG3oxn5zfYauqG2gVG33gfUVGob3mUZCaoPDrcRkdnV1vWelFOdJEX6uVuyeS1Sr2tJ0omLhais0sDRQWaS6+qGueQhwdh5LgcAMMiMSZItr6wiy2OSREQWYWyekW64LYo9SWYX1sYVrV0VyCtV4fSlIn3PUlPUXMWY7qnE5aFz4OggxW3hrU3Q4vqx5ZVVZHkcbiMiq1BcocblwgoAHG6zBIlEgh7XEqMjJpiXdOMw1xGf6r3h+gS6wUluml6q+uA+adQU7EkiIqtw/kp1pX4fd0d4uTTfEnSqXc/gVvjrbDYOp+fjiSZe68ZhrsN+0QCA2901tT2l2djqyiqyPCZJRGQVErO5ss3Seul7kvIhhKj3VlTG1BzmqpApcKp1OABgaI9QUzS1wVhGghqDw21EZBWSr03ajvLlpG1L6RToCYVMirxSFdLz6r+puTE1h7lO+ESgSuaAAIUWUdGssk22g0kSEVmFpGuTttv5sSfJUpzkMnRu6wkAOJze9FIAXpMmod32bTj34DMAgKHdQ5vUO0VkbkySiMgq6Jf/c7jNonqZcPI2UN2jtK+w+lYzKMq8VbaJmsqiSdKuXbswbtw4BAQEQCKRYP369QaPZ2dnY8aMGQgICICLiwtGjx6NpKQkg3OefPJJREREwNnZGT4+Phg/fjwSEhJu+drx8fG4++674enpCVdXV/Tu3RsZGRmmDI+I6qlMVYWL+eUAgEgOt1mUbum/KXqSACA1txTpV8sgl0lwW4T5lv4TmYJFk6TS0lJ07doVy5cvv+kxIQQmTJiAlJQU/Pbbbzh27BhCQkIwfPhwlJaW6s/r2bMnVqxYgfj4eGzZsgVCCIwcORIaTe0rKM6fP48BAwYgOjoaO3bswMmTJzFv3jw4OTk1S5xEVDfdfKTWropm3VyVbk232W1STgkKylRNvt7OxOoCkr1DveHmaL61QuqsLJTuP8DK2tQkFl3dNmbMGIwZM8boY0lJSdi/fz9Onz6Njh07AgC++OILKJVK/Pjjj5g5cyYA4Iknri9UDQ0NxaJFi9C1a1ekpaUhIiLC6LVff/113HnnnXj//ff1x2o7l4ia3/VK2xxqs7TWbo4Ib+OKlNxSHM3Ix9Dopm12q9uKxJxVtmsWsdTVRfKaNMngHG54S/VhtXOSKisrAcCgd0cqlcLR0RF79uwx+pzS0lKsWLECYWFhCAoKMnqOVqvFn3/+iaioKIwaNQq+vr7o27fvTUN9xtpTVFRk8EFEpnF9PhKH2qxBjxqlAJqiQq3BPyl5AMyXJNVnrzZueEv1ZbVJUnR0NIKDgzF37lzk5+dDpVLhvffew8WLF5GZmWlw7ueffw43Nze4ublh06ZN+Ouvv6BQGO+yz8nJQUlJCd59912MHj0aW7duxcSJE3HPPfdg586dtbZnyZIl8PT01H/UloQRUcPphtva+bAnyRr0MtG8pIOpV1Gh1kLp4YT2ZtqPr6692oDGbXjbEofuWmLMxlhtkiSXy7F27VokJibC29sbLi4uiIuLw5gxYyCVGjZ76tSpOHbsGHbu3ImoqCjcf//9qKioMHpd7bUfjPHjx+PFF19Et27d8Nprr+Guu+7Cl19+WWt75s6di8LCQv3HhQsXTBcsUQuXcuVaksSVbVZBNy/p1KVCaLSi0dc5dakQANAv3NtsS//1RSxrqrFX262SqBu1xF6nlhhzbaw2SQKqJ2UfP34cBQUFyMzMxObNm5GXl4fw8HCD8zw9PREZGYmBAwciNjYWCQkJWLdundFrtmnTBg4ODoiJiTE43qFDhzpXtzk6OsLDw8Pgg4iaTlWlRfrV6sKFEexJsgrhPm5wUchQptLg/LUEtjF0ta+izNSLBNx6r7ZbJVE1NabXyda1xJjrYtVJko6npyd8fHyQlJSEw4cPY/z48bWeK4SAEEI/p+lGCoUCvXv3xrlz5wyOJyYmIiSElWCJzC09rxQarYCrQgY/D0dLN4cAyKQSdAqsLip58mJho6+TmG2ZuWa6IpbB332Hdtu3GUzabsiGtw3tdbIHLTHmulh0dVtJSQmSk5P1n6empuL48ePw9vZGcHAw1qxZAx8fHwQHB+PUqVOYNWsWJkyYgJEjRwIAUlJS8PPPP2PkyJHw8fHBxYsX8e6778LZ2Rl33nmn/rrR0dFYsmQJJk6cCAB4+eWXMXnyZAwcOBBDhgzB5s2b8fvvv2PHjh1mjZ+IoO+piPBxYzVmK9Il0BMHU6/i1KUCTOrZtsHP12iF/r21RIHQuvZqq++GtzX3n9OrpdfJXrTEmOti0Z6kw4cPo3v37ujevTsAYPbs2ejevTvmz58PAMjMzMS0adMQHR2N559/HtOmTcOPP/6of76TkxN2796NO++8E+3atcPkyZPh7u6Offv2wdf3emXXc+fOobDw+l9DEydOxJdffon3338fnTt3xtdff41ff/0VAwYMMFPkRKRz/kp13TPOR7Iuna/1JJ1oZE/SxfwyVFZpoXCQIsjbxZRNMwm5UgnXvn3qXP7fkF4ne9ESY66LRAjR+Fl5LVhRURE8PT1RWFjI+UlETTD7l+NYe+wSXh7ZHs8MaWfp5tA1abmlGPzRDigcpDjz5ijIZQ37m/rv+GzM/P4wOvh7YNPzdzRTK81DnZV1y14ne2PPMTfk/m3R4TYiouvDba4WbgnVFNLaBe5ODiiuqEJidjE6Bng26Pn2tBdfXUN39qolxmyMTUzcJiLzMHdtFCGEfriNK9usi0QiQZcmTN5Oyq5e2WYPSRLVzZ5rKjFJIiIAlqmNkl1UiZLKKsikEgS3tr55Ky1d57ZeAICTlxqeJCXbUU+SrWvOJMbeayoxSSIii9VG0Q21BbdygaODrN7Ps+e/XK1J17bVPUmnLhY06HlarUCyvkAot5qxpOZMYlpCTSUmSURksdoo+vlIDehtsPe/XK2JboVbQlYxKtSaej/vcmE5ylQayGUShLCH0GKaO4lpCTWVmCQRWRlL9JI0pAqxKTV00nZL+MvVmgR6OcPbVYEqrUBCVnG9n6ebtB3WxrXBq+LIdJo7ibHU7w1z4ncvkRWxVC+JpWqjNHTSdkv4y9Wa1Jy83ZAht+vzkTjUZknNncS0hJpKLAFAZCVq6yVxHTDALL906luF2JRqVtuuD1YDNr8ubT2xI/EKTlwqxLR6Pke3ZxsLhFqWLonR/15phiTGEr83zIlJEpGVqKuXxFy/eMxZG6WksgqZhRUA6j/cZo5f+mSoc6AXAOBUA8oAJGVzZZu1MEcSY881lZgkEVmJltZLknKtF6mNmwJeLop6P8/e/3K1Nl2urXBLyilGmaoKLoq6bxtCCP1wW5Qfh9usgT0nMc2Nc5KIrERLGN+vqaFDbTXVZ98tMg0/Dyf4eThCK4Azl4tueX52USWKr9W+Cm3NKupk29iTRGRFWlIvCStt247OgV7ILsrGyYuF6B3qXee5uvlIoa1doHDg3+Fk2/gdTGRlWkovSVN6ksi89EUlLxXc8twkrmwjO8IkiYgsghvb2o7ODdjDrTk3tmWldTI3JklEZHZVGi1Sc68Nt3EFlNXrcm0Pt5TcUhRVqOs8N7mZlv+z0jpZApMkIjK7C/nlUGsEnORSBHo6W7o5dAvergq0bVX9Pp2uY7NbIQQSdcv/TbiyjZXWyVKYJBGR2emG2sLbuEEqlVi4NVQfXeox5JZbokJhuRpSCRDexnTDqKy0TpbCJImIzE63lDzKj0NttqLztSG34xcKaj1Ht7It2NsFTnKZyV67JewRRtaJSRIRmd2JazfabkFeFm0H1d/t4a0BANsTcpBbUmn0HF0RyXYmXtnW0mqIkfVgnSQiahbqrCyo0tKhCA0xuJkJIXDi2mapXa/1TpD16xrkhW5BXjh+oQCrD2Rg1rBIg8eFENhw4jIAIMbfw+Sv35JqiJH1YE8SEZlcXSuRLhaUI69UBblMgg7NcDOl5vNo/zAAwA/701FZpTF4bHtCDg6n58NJLsXUvs0zDNZSaoiR9WCSREQmdauVSLqhtg5KD5POW6HmN6aTEkoPJ+SWVOKPk5n64xqtwPtbzgEAHrk9DH4eTpZqIpFJMUkiIpO61Uok/VAb5yPZHLlMium3hQAAvt2bCiEEAGDDiUs4l10MDycHPDUowpJNJDIpJklEZFK3Wol04kL1EnLOR7JNU3oHw0kuxZnLRTiUlg9VlRYf/ZUIAHhqUAQ8neUWbiGR6TBJIiKTqmslUpVGi1PXihFyZZttauWqwD3d2wKo7k368WAGLuaXw9fdEY/cHmbh1hGZFle3EZHJ1bYSKTGnBOVqDdwdHUxabJDM65HbQ/G/gxnYejYL+1PyAADPD4uEs4JzzMi+MEkiomYhVypvWoWkm7Tdpa0nK23bsEg/dwyM9MGupCsoKFcjxNsFk3sFWbpZRCbH4TYiMhtO2rYfj/YP1f//pZHtIZfxdkL2hz1JRGQ2ui0tOGnb9g2M9MHkXkEQELirs7+lm0PULJgkEZFZlKmqkJhdvbdXd/Yk2TypVIL37u1i6WYQNSv2jxKRWZy+VAStAPw9neDLYoNEZAOYJBGRWXC/NiKyNUySiMgs9PORONRGRDaCSRIRmcX1Sduelm0INZo6Kwul+w/o9+EjsndMkoisgL3ffBKzi3GpoBwSCdA5kEmSLSqIjUXy0GHImDEDyUOHoSA21tJNImp2XN1GZGEFsbHInL+gelPYa1t4eE2adMvnabUCaq0Wao2AukoLtUYLtVagSqNFlVZAoxWo0goIISCRSCABIJFUb1KqcJDCUSaFo1wGF4WsWWvcqDVavLTmBABgeAc/uDtxby9bo87Kuv49CgBaLTLnL4DrgAE3FQwlsidMkojMRFWlxdVSFa6WqZBfqkJhuRr52XlI+W4bStuPRLmDI8rkjqjYkAhp7m5USB1QodagXK1BhVqLyioNKtVaVF5LiKq0wmRtc3SQwt3JAe6Ocni6yOHlLEcrFwVauSrQ2k2BNq4KtHFzRGgbV4S2doWsAdWyP99xHqcuFcLTWY5F4zuZrM1kPqq09OsJko5WC1V6BpMksmtMkohMoFylQcbVMlwuKMfFgnJcKihHVmE5coorkVNcieyiChRXVBl/cqe7bj6WXtTgNuh6iRykkuoPmRQyaXUPkgAgBAAIqKq0UGmqky1xLc+qrNKiskSF3BIVkFf36zjJpYjydUe0vzs6B3phWLQvArycjZ576lIhPt2eBAB46+6O8OPSf5ukCA2p3rC4ZqIklUIREmy5RhGZgUQIYbo/R1uQoqIieHp6orCwEB4eHpZuDpmBVitwqbAcyTklOJ9TgvNXSpCSW4r0vDJkFVXU6xoyqaS6h8ZFDi8XOdwlWkh2bYeLqhwuVRVwrlLBWaNC8OxZcPfxhrNcBqdrH44OUjg6XBsqc5BBLpNA7iCFQiaF/FpC1BBCCKg1AqWVVShRVaG0sgpF5VXVPVxlKhSUqXC1TI28kkrkllQne+evlKBCrb3pWp0CPDAyRomh0b6I8HGDs0KGCrUGdy/fg8TsEozt7I/PpnSHRML92mxVY4eFiaxNQ+7fTJIaiUmSfcsrqURCVjESsopxLrsI57JKkJRTjDKVptbnuDs5oG0rFwR6OaOtlzP8vZzg5+4EXw9H+Lo7oo2bIzyc5Ddt7GpLNx+NViDjahkSsooQn1mEf1LycDg9Hzf+FvF2VcDN0QEZV8vQxs0RW18YCG9XhWUaTSajzsqCKj0DipBgDrORzWKSZAZMkuxDZZUGyTkl1cnQtaQoPqsIV4orjZ4vl0kQ1sYV7Xzc0M7XDeFt3BDS2gWhrV3RqglJQH1vPuqsLKjS0qEIDbGam1RuSSW2J+Rg69lsHEjJQ3Gl4bDif6f1wogYPwu1jojIEJMkM2CSZDuEEMgtUSHjahkyrpbi/JVSJOUUIymnBOl5ZdAYmQAtkQAh3i5or3RHez8PRCvdEeXnjpDWLhbb7dxWepwKy9W4VFCOS/nl8HB2QN+w1pZuEhGRHpMkM7DnJEkIASEArRDQCkBA6IdTxA2fN/o1rr3O9f8bvrZA9evr2qFf0q7RQqMVUGm0KK3UoKRSjZJKDUorq+fUlFRWoaiiCleKK3GlpAJXiitxuaAC5erah8k8neVor3RHB6U72is90OFaQuTqaD3rGtRZWUgeOuymibPttm+zmh6lW7HGXjAiankacv+2nrsAAQCOZuTjQOrV6mQBAK4lJVUaYZAsqHR1cTQCak31aqWax1Qa7fXaOZpr9XSqtPraOTX/1X8IoU9M7I1EAgR4OqNtK2eE+7gh0lf34Q4/D0ern1BsrUuw65v42EovGBFRTUySrMw/KXn4YMs5SzfDqjhIJZBdW9Yuu7a03UEqgZujA1wdHeDqKKv+v6L6c3cnB/i4O8LHzRE+7o5QejghsJUzHB1klg6l0axxCXZ9Ex8WIiQiW8Ukycp0ULrj3h5tIZFAXyFZghuTBAnk15Z9Vy//vvb5teXgimv/l9c4Ty6TwEFa/a9MWn1cKrl2TZkEMkn1calEAqkEkEok1a+t+xfVx3CtTUB1u2p+3li6GAFAqntN3XEr7+ExF7lSCf+3Ft6UlFgqyWhI4mOtvWBERLfCJMnKDI32w9BorgSim3lNmgTXAQOsYgl2QxIfa+wFIyKqD25wS2RD5EolXPv2aVSCZMpNdPWJT021JD66XjD9+RbuBSMiqi/2JBG1AKaeON3Q4T9r6gUjIqovlgBoJHsuAUD2pTnLB7ACMxHZGpYAICK95pw4LVcqmRwRkd3inCQiO9eQ+UNERHQdkyQiO1fXxGlTTuYmIrI3HG4jagGMTZxmFWwiorpx4nYjceI22TJ72AuOiKgxGnL/tuhw265duzBu3DgEBARAIpFg/fr1Bo9nZ2djxowZCAgIgIuLC0aPHo2kpCSDc5588klERETA2dkZPj4+GD9+PBISEurdhqeeegoSiQRLly41QUREtqGuydxERFTNoklSaWkpunbtiuXLl9/0mBACEyZMQEpKCn777TccO3YMISEhGD58OEpLS/Xn9ezZEytWrEB8fDy2bNkCIQRGjhwJjab2Xd911q1bh/379yMgIMCkcRFZO07mJiK6NYvOSRozZgzGjBlj9LGkpCTs378fp0+fRseOHQEAX3zxBZRKJX788UfMnDkTAPDEE0/onxMaGopFixaha9euSEtLQ0RERK2vfenSJTz33HPYsmULxo4da8KoiKyfte0FR0Rkjax24nZlZSUAwMnJSX9MKpXC0dERe/bs0SdJNZWWlmLFihUICwtDUFBQrdfWarWYNm0aXn75ZX0CVp/26NoEVI9pElk7dVYWVGnpUISG3JQAsQo2EVHdrLYEQHR0NIKDgzF37lzk5+dDpVLhvffew8WLF5GZmWlw7ueffw43Nze4ublh06ZN+Ouvv6BQKGq99nvvvQcHBwc8//zz9W7PkiVL4Onpqf+oKwkjsgYFsbFIHjoMGTNmIHnoMBTExt50TlP2giMisndWmyTJ5XKsXbsWiYmJ8Pb2houLC+Li4jBmzBhIb5hLMXXqVBw7dgw7d+5EVFQU7r//flRUVBi97pEjR/DJJ59g5cqVkEgk9W7P3LlzUVhYqP+4cOFCk+Ijak7qrKzrQ2kAoNUic/6CBtVDamgNJdZcIiJ7Y7XDbUD1pOzjx4+jsLAQKpUKPj4+6Nu3L3r16mVwnq53JzIyEv369UOrVq2wbt06TJky5aZr7t69Gzk5OQgOvj5BVaPR4KWXXsLSpUuRlpZmtC2Ojo5wdHQ0aXxEzaWpW5HcWEPJ96XZcOrYyeiwnbHzWXOJiOyBVSdJOp6engCqJ3MfPnwYb7/9dq3nCiEghDCYP1TTtGnTMHz4cINjo0aNwrRp0/DII4+YrtFEFqRfvXZDHaT6rF4z1guV88GH+mvcmADV1mvlOmAAh/GIyKZZdLitpKQEx48fx/HjxwEAqampOH78ODIyqmu1rFmzBjt27NCXARgxYgQmTJiAkSNHAgBSUlKwZMkSHDlyBBkZGdi3bx/uu+8+ODs7484779S/TnR0NNatWwcAaN26NTp16mTwIZfLoVQq0b59e/N+AYiaSV1bkdyK0V4oHSPDdqy5RET2yqI9SYcPH8aQIUP0n8+ePRsA8PDDD2PlypXIzMzE7NmzkZ2dDX9/f0yfPh3z5s3Tn+/k5ITdu3dj6dKlyM/Ph5+fHwYOHIh9+/bB19dXf965c+dQWFhovsCIrEBjV68Z7YWq6YZhu6b0WhERWTNuS9JI3JaE7JnBHKMbGdm+hHOSiMhWNOT+zSSpkZgkkb1TZ2VBlZ6BitOnkPPRx7dMgHTns+YSEVkzJklmwCSJWhImQGRMXcVKiaxVQ+7fNrG6jYgsS65U8iZIBjjESi2B1RaTJCIi62SKYqVEtoBJEpGNY6VrMjeWfaCWgkkSkQ2rz/5sRKamL/tQE8s+kB1ikkRkozjkQZbSlGKlRLaEE7eJbFRT92cjaorGFislsiVMkohsFCtdk6Vx1SPZOw63EdkoDnkQETUv9iQR2TAOeRARNR8mSUQ2jkMeRETNg8NtREREREYwSSIiIiIygkkSERERkRFMkoiIiIiMYJJEREREZASTJCIiIiIjmCQRERERGcEkiYiIiMgIJklERERERjBJIiIiIjKCSRIRERGREUySiIiIiIxgkkRERERkBJMkIiIiIiOYJBEREREZwSSJiIiIyAgmSURERERGMEkiIiIiMoJJEhEREZERTJKIiIiIjGCSRERERGQEkyQiIiIiI5gkERERERnBJImIiIjICCZJREREREYwSSIiIiIygkkSERERkRFMkoiIiIiMYJJEREREZASTJCI7os7KQun+A1BnZVm6KURENo9JEpGdKIiNRfLQYciYMQPJQ4ehIDbW0k0iIrJpTJKI7IA6KwuZ8xcAWm31Aa0WmfMXsEeJiKgJmCQR2QFVWvr1BElHq4UqPcMyDSIisgNMkojsgCI0BJDe8OMslUIREmyZBhER2QEmSUR2QK5Uwv+thdcTJakU/m8thFyptGzDiIhsmIOlG0BEpuE1aRJcBwyAKj0DipBgJkhERE3EJInIjsiVSiZHREQmwuE2IiIiIiOYJBEREREZwSSJiIiIyAgmSUREZDLcGofsCZMkIiIyCW6NQ/aGSRIRETUZt8Yhe2TRJGnXrl0YN24cAgICIJFIsH79eoPHs7OzMWPGDAQEBMDFxQWjR49GUlKSwTlPPvkkIiIi4OzsDB8fH4wfPx4JCQm1vqZarcarr76Kzp07w9XVFQEBAZg+fTouX77cHCESEbUI3BqH7JFFk6TS0lJ07doVy5cvv+kxIQQmTJiAlJQU/Pbbbzh27BhCQkIwfPhwlJaW6s/r2bMnVqxYgfj4eGzZsgVCCIwcORIajcboa5aVleHo0aOYN28ejh49irVr1+LcuXO4++67my1OIiJ7x61xyB5JhBDC0o0AAIlEgnXr1mHChAkAgMTERLRv3x6nT59Gx44dAQBarRZKpRKLFy/GzJkzjV7n5MmT6Nq1K5KTkxEREVGv1z506BD69OmD9PR0BAfX7we6qKgInp6eKCwshIeHR72eQ0RkzwpiY68PuV3bGsdr0iRLN4vIQEPu31ZbcbuyshIA4OTkpD8mlUrh6OiIPXv2GE2SSktLsWLFCoSFhSEoKKjer1VYWAiJRAIvL68mt5uIqKXi1jhkb6x24nZ0dDSCg4Mxd+5c5OfnQ6VS4b333sPFixeRmZlpcO7nn38ONzc3uLm5YdOmTfjrr7+gUCjq9ToVFRV49dVXMWXKlDozysrKShQVFRl8EBGRIblSCde+fZggkV2w2iRJLpdj7dq1SExMhLe3N1xcXBAXF4cxY8ZAesO499SpU3Hs2DHs3LkTUVFRuP/++1FRUXHL11Cr1bj//vshhMAXX3xR57lLliyBp6en/qMhPVVERERke6w2SQKqJ2UfP34cBQUFyMzMxObNm5GXl4fw8HCD8zw9PREZGYmBAwciNjYWCQkJWLduXZ3X1iVI6enp+Ouvv245Ljl37lwUFhbqPy5cuNDk+IiIiMh6We2cpJo8PT0BAElJSTh8+DDefvvtWs8VQkAIoZ/TZIwuQUpKSkJcXBxat259yzY4OjrC0dGx4Y0nIiIim2TRJKmkpATJycn6z1NTU3H8+HF4e3sjODgYa9asgY+PD4KDg3Hq1CnMmjULEyZMwMiRIwEAKSkp+PnnnzFy5Ej4+Pjg4sWLePfdd+Hs7Iw777xTf93o6GgsWbIEEydOhFqtxqRJk3D06FH88ccf0Gg0yLpW7Mzb27vec5mIiIjIvlk0STp8+DCGDBmi/3z27NkAgIcffhgrV65EZmYmZs+ejezsbPj7+2P69OmYN2+e/nwnJyfs3r0bS5cuRX5+Pvz8/DBw4EDs27cPvr6++vPOnTuHwsJCAMClS5ewYcMGAEC3bt0M2hMXF4fBgwc3U7RERERkS6ymTpKtYZ0kIiIi29OQ+7dVT9wmIiIishQmSURERERGMEkiIiIiMsImSgBYI91ULlbeJiIish26+3Z9pmQzSWqk4uJiAGDlbSIiIhtUXFysr8NYG65uayStVovLly/D3d0dEokERUVFCAoKwoULF+xytZu9xwfYf4yMz/bZe4yMz/bZQoxCCBQXFyMgIOCmbc5uxJ6kRpJKpWjbtu1Nxz08PKz2G8MU7D0+wP5jZHy2z95jZHy2z9pjvFUPkg4nbhMREREZwSSJiIiIyAgmSSbi6OiIBQsW2O0muPYeH2D/MTI+22fvMTI+22dvMXLiNhEREZER7EkiIiIiMoJJEhEREZERTJKIiIiIjGCSRERERGQEk6QGssd57hUVFdi1axcA+4zvRlqt1tJNMLmW9B7a4/sHAJWVlTh69CgA+38P7TG+8vJybNy4EYB9xnejlhAjwCTplj799FM8+OCDePPNN5GSkgKJRGLpJpnU+++/Dw8PD6xYsQJCCLuLDwA+//xzPP300/j888+Rm5t7yzL0tsbe30N7f/8A4L333oO3tzfWrFljl++hvf8e/eCDD+Dq6oply5ZBq9XaXXyA/b+HtRJkVF5enhg9erQIDQ0VzzzzjIiKihLt2rUT33zzjaWbZhLbt28XQUFBIjQ0VPzyyy+Wbk6zuHz5shg4cKAICwsTU6ZMEW3bthUdO3YU27Zts3TTTMLe30N7f/+EEGLbtm369/Dnn3+2dHNMzt5/j+7YsUO0bdvWbn8GhbD/9/BWmCTVYuvWrSIqKkqkpKToj02dOlX07dtXbN682YIta7pDhw6J4OBg0bNnT/2x/Px8UVFRIaqqqoQQQmi1Wks1z2R++eUXERMTI3Jzc4UQQqhUKtG/f38xduxYceDAAQu3rmlawntoz++fENW/Yzw8PMTw4cP1xwoLCw3OsfX30J5/j54/f1506dJFhIeH64/l5eXpfw7thT2/h/Vhf/3WTaSb73DhwgVotVqDDfpeeeUV+Pv746OPPrJU80yiXbt2mDJlChwcHHDu3Dm8/fbbGD58OIYMGYIJEybYfFeqVquFEAKnTp2Cp6cnnJycAAByuRyLFi1CUVERvv32Wwu3snHEtXkA9vwe2vP7V1OXLl0wduxY+Pj4ICMjA2+99RbuuusuDB8+HE888QSKi4tt+j0E7PP3qO5nMCAgAE8++SRKSkpw4sQJLFq0CAMGDMDw4cMxePBg7Nu3z8ItbRp7fg8bgkkSgM2bN+O3335DamoqqqqqAAClpaWQy+XIzc3Vn9elSxfcfffdyM3NxerVqy3V3Ab7+uuvMXnyZH1sXl5eGDduHGQyGTp37oy4uDg8++yzuOeee5CUlIQnn3wS+/fvt3CrG2bXrl04c+YMysvLIZVKIZFIUFVVhdLSUggh9D/wgwcPxpAhQ3D69Gn8/fffFm51/WVmZgIAJBIJhBB29x7GxcVh9+7duHLlCiQSid29fwCwcuVKvPTSS9BoNAAAPz8/3HPPPThz5gw6deqEbdu2YcqUKejevTs2bNiARx99FKmpqRZudf1t3boVO3fuRF5enn7emD39Hj1//jyA6z+DTk5OGDNmDLp27Yru3btj165dmDdvHp577jnI5XK89NJLWL9+vWUb3UD2fi9sFMt1Ylnevn37RKdOnURERISIiYkRHTp0EJ9//rkQorrb29HRUXz22WcGz0lPTxfDhg0Ts2fPFmq12hLNbpDi4mLh7+8vPD09xYcffqg/XlVVJT799FMxb948kZmZqT9+6tQpERMTI9566y39sI01O378uOjUqZMICAgQQUFBYtCgQeLPP/8UQgiRlJQkZDKZ+P3334UQQv9+nT17VnTo0EF8+umnFmt3fR0+fFj07NlT3HvvvSItLU0IIfTviz28h3v37hVdunQRERERIiIiQvTs2VP/fiUlJQkHBwebfv90zp8/L1xcXERUVJT4/vvv9cfVarV45ZVXxPz58/XDikJU/27y8vISP/zwgyWa2yCnT58WnTt3FoGBgSI0NFR0795dfPnll0II+/g9evToUdGrVy/Rt29fcfToUSGEMBjSXr9+vXj99df1P59CCJGamipGjBghHnnkEVFeXm6RdjdES7gXNlaLTJK0Wq345ptvRGBgoHjjjTdEfn6+SElJEffff7+YMmWKyM/PF0IIMWfOHBEUFCRSU1MNnv/AAw+IsWPH6q9lzY4dOybatm0rXnjhBdGlSxeRnp6ufywzM1NkZWXpP9fFMnbsWDFhwgSzt7WhysvLxf333y9mzJghLl68KP755x8xevRo0a1bN7Fz504hhBD333+/6Nixo9BoNAbPHTp0qJg+fboQwnrfw99//1106dJF9O7dW4SGhhrcXHW/pDMzMw0SJFt5D6uqqsSyZcuEv7+/eOONN0RWVpY4ffq06NWrl3j55ZeFRqMRVVVV4sEHH7TZ96+mnTt3CqVSKR588EFx1113iezsbP1jaWlp4tKlS/rPdfH06dNHzJw50+xtbagnn3xS3HvvvSI3N1ecPn1aPP3008LPz0+sX79eCCHECy+8YLO/R//66y/RvXt3MXDgQNGtWzexcOFC/fei7t/8/HyRk5Ojf44ulkcffVQMHDjQ/I1ugJZ0L2ysFjncVlVVBW9vb7z77ruYP38+PDw8EBYWhoCAALRt2xZeXl4AgAULFkCtVmPhwoXIysrSP18IAV9fX5tYqltUVISxY8di7NixcHFxweLFi/WPKZVK+Pn5GZxfUFCA3NxchISEmLupDZaZmYn169fjvvvuQ2BgIPr164f33nsPERERmDNnDgBg4cKFuHDhAubPnw+1Wg0A+n/9/f0BwCrfQ61WC5lMhuHDh2Pz5s3o3LkzVq1ahdOnTwOAfjhDqVRCqVQaPNcW3sOKigo4OTlh2bJlePPNN9GmTRt07NgRkZGR8PT0hFQqhUwmw9y5c3Hx4kWbe/9ulJGRgSeeeAITJkxAdnY2vv76a/1jISEhCAgIAAD975TLly+jsLAQwcHBlmpyveTl5eGnn37ChAkT0Lp1a3Ts2BFvvPEG7rrrLjz99NMAgMWLF0OlUtnk71Fvb2/0798fP/74IwYMGIBt27Zh+/btAK5/33l5ecHHx0f/HCEEKisrkZWVhdDQUKuuJ9SS7oWNZrH0zMLy8/NFZWWl/vMffvhBeHl5ibvvvlssXrxYHDlyRAghxIYNG0RYWJgYOnSoWL16tXjnnXdEmzZtxB9//GGppteLLqv//vvvxZ133imEEGLRokUiJiZGnD17Vpw5c0ZcvXpVf75GoxEVFRVi8eLFonPnzuLw4cMWaXdDxMfHi65du4o1a9YYHP/jjz9EQECAvsv/m2++ER4eHmL69Oli8+bNYsmSJcLf31/s2rXLEs2ut/z8fP1fcidPnhSBgYHi/fff13ff3/iXm629h5mZmQY/g999951o3bq1mDlzpvjyyy9FRkaGEMJ23z8hrvc2fPzxx/peoZkzZ4rhw4eLS5cuicTExJueU1lZKRYuXCh69eolEhISzNrehrp69aro0aOH+OijjwyOnz59Wvj4+IgFCxYIIap7RW3x96hardavOExOThZ9+/YVzzzzjCgoKBBC3PwzqFKpRGlpqXjvvfdEVFSUiIuLM3eTG8ze74VN1aKSpNrmZ8yePVu4u7uL+fPni4ULF4oRI0aI0NBQ/Q/H1q1bxeTJk0X//v1Fx44drfabwlh8H374oXjxxReFEEJcunRJDBw4ULi4uAilUqlf0rlp0ybx1FNPiQ4dOojw8HCrrUOj1WoNYszLyxMxMTFiwYIForS0VH/8ypUr4qmnnhKDBg0SZWVlQojqG+2oUaNE165dRVRUlH7ekjW5MT4d3Xj/c889J3r06GE0ObCF97C2+IQQ4rHHHhNyuVy8+uqrYtasWaJnz55iyJAhoqSkRAghxNdff231758Qtcf43HPPiXfeeUcIUT3HpWfPnsLT01MEBASIK1euCCGE+PPPP8UzzzwjYmJiRHh4uNixY4dZ215fNeMrLi4Wd955p3j88ccNhhArKyvFggULRNu2bfXv4V9//WWzv0d1x959913Ru3dvsXr16pvO2b59u5g1a5Zo3769CAsLE3/99Vezt7Wx7P1eaEp2mySVlJToM+CaKioq9H8FqFQqIUR10bqaP+AnTpwQUVFR4quvvjJ4bs1zLK0+8QkhxJtvvik+/vhjUV5eLh588EEhk8lE69atDf7yy87OFtOmTRPLly83S9vrq7i4WHzzzTfiwoULBscrKytFUVGREEKI1157TbRt21Y/oVJn+fLlonfv3ga1PYQQN31uSXXFp0vuNBqNwdyHdu3aiRdffFHk5eXpHxeiulfG2t7D+sSnSwCTk5MN5lb99ttvolOnTvpJ2zrW9P4JUb8Yhaiel/PLL7+I0tJS/c9hQECA+Pbbb/XnJCcni7vuukssW7bMbO2/laqqKqNzTSoqKvTfgx9//LFo3769WLt2rcE5f/75p+jatavYv3+/wXFr+j1aV3y636MajUZ/TlFRkRg+fLh44IEH9PNzdAlHTk6OePnll2+6b1hafWK05Xthc7PLJGnRokWiTZs24oEHHtD/FSOEEGfOnBG9evXSdwHr6L6BdN/s//zzj3B3d9f/gr5x0qilNSS+8ePHi27dugl3d3cxePBgsX79ejFz5kxx2223GTzX2mJ86623hEwmExKJRH8D0mg04uDBg6Jz585i5cqV+nP9/PzEU089ZXCjio2NFQqFQj8x3dbiqzlJW4jrycSnn34qIiIixO+//y5SUlLE/Pnz9b+srSnGhsano4tz8+bNQi6Xi3/++Uf/XGvTkBj79u0rBg0aJNzd3fXDFXfffbd48MEHDVY/WdNqxPfff1+MHz9ezJw5U+zfv1/ftlOnTolevXqJefPm6c/t16+fuP/++8WJEyf0x7Zt2yYcHBz0Q4bWNrH3VvHdeJ/QPf7TTz+J7t27i2XLlonU1FTx9NNPi3PnzgkhbD9GW7sXmoNdTdxWq9V45JFH8N133+Hrr7/GRx99BIVCoX88KioKwcHBaNOmjX7yJ3B9Ap5MJoNarcamTZswaNAg3HbbbQBgNXtFNSS+iooKAMDo0aNRXFyM//73v9i6dSvGjx+P0aNHIzMzE+vWrdM/11piXLt2Lfz9/bFq1Sp88MEHiI6O1k+UlEql6NatG+RyOYQQ+hiXLVuGLVu24MMPP8SlS5dQXl6Obdu24d5774W3t7f+udagvvFpNBp9PR2g+nsTAJ599ln4+Phg1qxZaN++Pf7++284OjpCCGEVMTY2Ph0HBwdUVFTg77//xj333IMuXbron2stGhKjSqUCAIwcORJZWVn46quvsHnzZjz44IO44447cPjwYcTFxemvrXufLen06dPo0aMHvv/+e/Tq1QuHDx/GY489hoSEBABAdHQ0QkJC4Ovri/LycgDVCyTS0tLwf//3f0hOTkZhYSH++usvjBgxQr+wwFom9tY3vhvvE7r3ZvLkyYiMjMSSJUvQvn177N69G05OTlY1ebmxMdrKvdCsLJykmdSJEydE9+7dxenTp4UQ1UMQOTk5Bj0mNScr65SWloq9e/eKVatWia5du4rIyEirnHDX2PhunGRYVFQk4uPjzdDi+tNqtWLatGlCIpGIpUuXCiGq35e2bduK//73v0IIoZ9cWLOejM7y5ctFhw4dREREhIiMjBSBgYFWNaejqfEJUV3yYN26dcLHx0e0a9dOxMbGmqfx9dDU+EpKSsS+fftEbGys6Nq1q+jQoYPYvXu3+QKoh6bEWFhYqJ+Er/s5zM3NvWmY2Bq88cYbYsyYMfrehNLSUiGRSAzeD10sNf3xxx+iV69eIjg4WISHhwt/f3+xdetWczW73hobnxDV7++aNWuEv7+/CA8PF7/++qs5mtxgjY3RVu6F5mRXSdK6detEr169RFFRkXjllVdESEiI6NGjh+jRo4e+bo4xmZmZ4uWXXxY9evS4qfvRmjQ2PmvrAq7NsWPH9Emerlv3jjvu0NfDMdbVW7Oo28WLF8XGjRuttgBfY+KrKSkpSTg7O4s5c+Y0b0MbqSnxXbx4UTz88MMiJibGYBjH2jQlRlv4OSwoKDCoVSWEEAkJCeKuu+66qUaOTs2YCwoKxMGDB60qga+pMfHVVFxcLJydncVLL73UzC1tvKbEaCv3QnOy2SRJN9Gspvfff1/ccccd4quvvhKDBg0SW7ZsEdu2bRNDhw4Vd9xxh8FmfHv27BGLFy/WZ9OpqakGPTKWZqr4aluqag2MxSjE9bZWVlaKf/3rX2LEiBGiuLj4pvP+/vtv8e233xpMkLUmzRFfzVV8lmaq+HQ/d2fOnDF6niW1pO9RXUxTp04VkZGR4uOPPxYffvihcHNzE2FhYUKpVIrHHntM7Nu3T/+cG3/PWJvmiM/aKmibKkZrvRdams0lSTt37hSdOnUymG2vy5aTkpKERCIRrVu3NljlEx8fL4YPHy5efPFF/cTQN998UyiVSqtbSmzq+DZu3GjeAOrBWIw30v2wv/rqq6Jz584Gx3Qee+wxoVQqra4eEONrWHwHDx5svsY2Ukt8D3W9svn5+WLBggXioYceEq1btxbff/+9yMzMFL///rsYPHiweOSRR/S73C9YsMAqf8/Ye3xCmD5Ga7sXWgubSZLUarX46quvRLt27URgYKAIDw+/aTuGqqoq8cQTTwiJRHJTd++0adPE+PHj9Z/n5+db1VirvccnxK1jrEmXGG7dulU4OzuL5ORkIUT110H3WE5OjlXV6WB819lifELYf4y3iq/m0Nm8efPEtGnTDBK/2bNni9tvv12//N/afs/Ye3xCtIwYrYnNTFUvLS1FdnY2ZsyYgZ07d6KsrAwff/yx/nGJRAKZTIbHH38cnp6e2LhxI65evap/XCqVonXr1vrPvby8MHjwYHOGUCd7jw+4dYw11VxFERQUZLADt1QqhRACPj4+GDt2rFnaXh+M7zpbjA+w/xhvFV/NmOLi4tClSxdIJBJotVoAgEajgbu7Ozw9PQFY3+8Ze48PaBkxWhXL5mgNEx8fb1CB18nJSZw8efKm8/7zn/8IDw8Pcd9994mNGzeKhQsXirZt21p1BVQh7D8+Ieofo05RUZFwd3cXv/zyixDC+ut0MD5DthafEPYf463i07V/7ty5ok2bNuLXX38V8fHxYtGiRcLf31/873//s0i768ve4xOiZcRoLWwqSdLRdWf37t1bTJw40WgBthUrVohRo0aJ3r17iy5duljlNg21sff4hKhfjBqNRpSUlIjo6GirXvFkDOOz7fiEsP8YbxVfUVGRGDp0qAgODhaRkZGic+fONvV7xt7jE6JlxGhpVpUk5eXlia+//rrWOQA32rFjh5BIJAZj/jd+k9y4XYAl2Xt8QpgmxpqqqqqsamIv4zNka/EJYf8xmiI+XU9EcXGxSEtL01c+twb2Hp8QLSNGW2E1SdLcuXOFRCIREomk1kJexjzwwAOiW7duorS0VCQkJIgff/zRKpcv2nt8Qth/jIzPOFuJTwj7j5HxGWcr8QnRMmK0JRZPklatWiW8vb1Fp06dxMcffyyioqIaVIjswoULwt3dXQwaNEhIJBLx8MMPW9U3hr3HJ4T9x8j46mbt8Qlh/zEyvrpZe3xCtIwYbZHFkiSNRiMmTJggJBKJ+OKLL4QQQly5ckUolUrx448/CiFuXQCxoqJC/PDDD0Iul4uYmBixbt265m52vdl7fELYf4yMz7bjE8L+Y2R8th2fEC0jRltm0Z6kQ4cO6avU6sZPu3fvLp599lmDY8ZoNBqxatUqIZfLxcKFC5u/sY1g7/EJYf8xMj7bjk8I+4+R8dl2fEK0jBhtlYM5yw38888/CA0Nhb+/PwCgV69eujIEkEqlqKioQOfOnZGRkYGKigo4OTnVei2pVIo77rgDBQUFcHFxMUv7b8Xe4wPsP0bGZ9vxAfYfI+Oz7fiAlhGjvTBLMclt27YhPDwcU6ZMQZ8+ffDEE08gMTERQPU3hUQiAQA4OTnB1dUV2dnZcHJy0he/qk1wcLBVfFPYe3yA/cfI+Gw7PsD+Y2R8th0f0DJitDvN3VWVkZEh+vXrJ+bNmyeSk5PFmjVrRHh4uLjnnntEWlqaEKK6u1DXnfjrr78Kd3d3cfny5eZumknYe3xC2H+MjM+24xPC/mNkfLYdnxAtI0Z71OxJ0o37GglR/eYPHDhQPPnkkzedv379ehEVFSV27tzZ3E0zCXuPTwj7j5HxGbK1+ISw/xgZnyFbi0+IlhGjPWr24barV6+iQ4cO0Gg0+mPjx4/HqFGjsHv3buzcuRMAUFVVBQDo16+ffhz2Wk9XczexSew9PsD+Y2R8th0fYP8xMj7bjg9oGTHao2ZPkjp27IizZ88iISFBf0wmk+HOO+9EUFAQfvvtNwCAg4MDtFotFAoFlEolTpw4AQD6MVprZe/xAfYfI+Oz7fgA+4+R8dl2fEDLiNEumaO7asyYMWLQoEH6JY4606ZNE+PHjzcYh62oqBCHDh0yR7NMxt7jE8L+Y2R8th2fEPYfI+Oz7fiEaBkx2huzJEnHjx8XDg4O4osvvhCVlZX646+//rpo166dOZrQrOw9PiHsP0bGZ/vsPUbGZ/taQoz2xix1krp27YpXX30Vb7/9NuRyOR544AFotVocPnwYDz30kDma0KzsPT7A/mNkfLbP3mNkfLavJcRobyRCmG822DPPPIN169YhODgYWVlZcHV1xZo1axATE2OuJjQre48PsP8YGZ/ts/cYGZ/tawkx2guzJkkVFRWIj4/H0aNH4ejoaHeZs73HB9h/jIzP9tl7jIzP9rWEGO2FWZMkIiIiIlthlm1JiIiIiGwNkyQiIiIiI5gkERERERnBJImIiIjICCZJREREREYwSSIiIiIygkkSERERkRFMkoiIiIiMYJJERC3Kjh07IJFIUFBQYOmmEJGVY8VtIrJrgwcPRrdu3bB06VIAgEqlwtWrV+Hn5weJRGLZxhGRVXOwdAOIiMxJoVBAqVRauhlEZAM43EZEdmvGjBnYuXMnPvnkE0gkEkgkEqxcudJguG3lypXw8vLCH3/8gfbt28PFxQWTJk1CWVkZvvvuO4SGhqJVq1Z4/vnnodFo9NeurKzEnDlzEBgYCFdXV/Tt2xc7duywTKBE1CzYk0REduuTTz5BYmIiOnXqhLfeegsAcObMmZvOKysrw7Jly/DTTz+huLgY99xzDyZOnAgvLy9s3LgRKSkpuPfee9G/f39MnjwZAPDss8/i7Nmz+OmnnxAQEIB169Zh9OjROHXqFCIjI80aJxE1DyZJRGS3PD09oVAo4OLioh9iS0hIuOk8tVqNL774AhEREQCASZMm4YcffkB2djbc3NwQExODIUOGIC4uDpMnT0ZGRgZWrFiBjIwMBAQEAADmzJmDzZs3Y8WKFVi8eLH5giSiZsMkiYhaPBcXF32CBAB+fn4IDQ2Fm5ubwbGcnBwAwKlTp6DRaBAVFWVwncrKSrRu3do8jSaiZsckiYhaPLlcbvC5RCIxekyr1QIASkpKIJPJcOTIEchkMoPzaiZWRGTbmCQRkV1TKBQGE65NoXv37tBoNMjJycEdd9xh0msTkfXg6jYismuhoaE4cOAA0tLSkJubq+8NaoqoqChMnToV06dPx9q1a5GamoqDBw9iyZIl+PPPP03QaiKyBkySiMiuzZkzBzKZDDExMfDx8UFGRoZJrrtixQpMnz4dL730Etq3b48JEybg0KFDCA4ONsn1icjyWHGbiIiIyAj2JBEREREZwSSJiIiIyAgmSURERERGMEkiIiIiMoJJEhEREZERTJKIiIiIjGCSRERERGQEkyQiIiIiI5gkERERERnBJImIiIjICCZJREREREYwSSIiIiIy4v8BVw9Wi+k7a90AAAAASUVORK5CYII=", + "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": 17, + "id": "752261bf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.765128Z", + "iopub.status.busy": "2026-08-25T14:20:05.764941Z", + "iopub.status.idle": "2026-08-25T14:20:05.775259Z", + "shell.execute_reply": "2026-08-25T14:20:05.772228Z" + } + }, + "outputs": [], + "source": [ + "sensor_df = pd.concat(real_sensors, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9acfaf6f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.781391Z", + "iopub.status.busy": "2026-08-25T14:20:05.781041Z", + "iopub.status.idle": "2026-08-25T14:20:06.015467Z", + "shell.execute_reply": "2026-08-25T14:20:06.014152Z" + } + }, + "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.0058920.1035770.1034090.0807410.9774310.0005310.955162
water_level@sens2790.0112470.1060830.1054850.0825450.8516500.0005450.720208
water_level@sens389-0.0238980.1026050.0997830.0864510.1610080.000509-0.056709
\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.005892 0.103577 0.103409 0.080741 0.977431 \n", + "water_level@sens2 79 0.011247 0.106083 0.105485 0.082545 0.851650 \n", + "water_level@sens3 89 -0.023898 0.102605 0.099783 0.086451 0.161008 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens1 0.000531 0.955162 \n", + "water_level@sens2 0.000545 0.720208 \n", + "water_level@sens3 0.000509 -0.056709 " ] - }, + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "multi_obs = ms.NodeObservation.from_multiple(data=sensor_df, nodes=dict(zip(sensor_locations, sensor_df.columns)))\n", + "ms.match(multi_obs, network_model).skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d7a0acf1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:06.018707Z", + "iopub.status.busy": "2026-08-25T14:20:06.018293Z", + "iopub.status.idle": "2026-08-25T14:20:06.126797Z", + "shell.execute_reply": "2026-08-25T14:20:06.124201Z" + } + }, + "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.0058920.1035770.1034090.0807410.9774310.0005310.955162
network_sensor_2790.0112470.1060830.1054850.0825450.8516500.0005450.720208
water_level@sens389-0.0238980.1026050.0997830.0864510.1610080.000509-0.056709
\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.005892 0.103577 0.103409 0.080741 0.977431 \n", + "network_sensor_2 79 0.011247 0.106083 0.105485 0.082545 0.851650 \n", + "water_level@sens3 89 -0.023898 0.102605 0.099783 0.086451 0.161008 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens1 0.000531 0.955162 \n", + "network_sensor_2 0.000545 0.720208 \n", + "water_level@sens3 0.000509 -0.056709 " ] + }, + "execution_count": 19, + "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=dict(zip(sensor_locations, [sensor_1, path_to_sensor2, 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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/pyproject.toml b/pyproject.toml index 890fc7574..e33d442ed 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,7 +43,9 @@ classifiers = [ ] [project.optional-dependencies] -networks = ["mikeio1d", "networkx"] +# networkx and xarray arrive through mikeio1d's own network extra, which +# carries the topology layer this package builds on (ADR-013). +network = ["mikeio1d[network]"] [dependency-groups] dev = ["pytest", "plotly >= 4.5", "ruff==0.6.2", "netCDF4", "dask"] @@ -62,7 +64,12 @@ test = [ notebooks = ["nbformat", "nbconvert", "jupyter", "plotly", "shapely", "seaborn"] -networks = ["mikeio1d>=1.2.1", "networkx"] +network = ["mikeio1d[network]"] + +[tool.uv.sources] +# TODO: swap for a version floor in both "network" entries above once mikeio1d +# releases the network module. ADR-013 holds modelskill 1.4.0 until it does. +mikeio1d = { git = "https://github.com/DHI/mikeio1d", branch = "main" } [project.urls] "Homepage" = "https://github.com/DHI/modelskill" diff --git a/roadmap/features/network-models.md b/roadmap/features/network-models.md index 2190befb9..246c8ad75 100644 --- a/roadmap/features/network-models.md +++ b/roadmap/features/network-models.md @@ -26,3 +26,5 @@ In active development. MIKE 1D, MIKE 11 and EPANET result files can be read toda MOUSE and Water Hammer results are not read yet: no shareable result file exists for either format, so support cannot be verified. SWMM results are not read yet: the reach connectivity lives in the companion '.inp' input file, which modelskill does not read yet. +The layer that reads those files and builds the network lives in mikeio1d, where the formats, the fixtures and a first graph conversion already were (ADR-013). ModelSkill keeps the model result, the observations and the matching, and requires `mikeio1d[network]`. The release is coordinated: this feature ships once mikeio1d has released the module it depends on. + diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 8838184e5..34387d07f 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -26,8 +26,14 @@ from .. import metrics as mtr from .. import Quantity from ..types import GeometryType -from ..obs import PointObservation, TrackObservation, NodeObservation +from ..obs import ( + PointObservation, + TrackObservation, + NodeObservation, + ReachObservation, +) from ..model import PointModelResult, TrackModelResult, VerticalModelResult +from ..timeseries._coords import NETWORK_LOCATION_COORDS, location_from_coords from ..timeseries._timeseries import _normalize_time_to_ns, _validate_data_var_name from ._comparer_plotter import ComparerPlotter from ..metrics import _parse_metric @@ -54,7 +60,7 @@ def _drop_scalar_coords(data: xr.Dataset) -> xr.Dataset: """Drop scalar coordinate variables that shouldn't appear as columns in dataframes""" - coords_to_drop = ["x", "y", "z", "node"] + coords_to_drop = ["x", "y", "z", *NETWORK_LOCATION_COORDS] return data.drop_vars(coords_to_drop, errors="ignore") @@ -72,8 +78,8 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # coordinates # Only add x, y, z coordinates if they don't exist and we don't have node coordinates - has_node_coords = "node" in data.coords - if not has_node_coords: + has_network_coords = bool({"node", "reach"} & set(data.coords)) + if not has_network_coords: if "x" not in data.coords: data.coords["x"] = np.nan if "y" not in data.coords: @@ -112,8 +118,10 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # Validate attrs if "gtype" not in data.attrs: # Determine gtype based on available coordinates - if "node" in data.coords: + if "node" in data.coords or {"reach", "distance"} <= set(data.coords): data.attrs["gtype"] = str(GeometryType.NODE) + elif "reach" in data.coords: + data.attrs["gtype"] = str(GeometryType.REACH) else: data.attrs["gtype"] = str(GeometryType.POINT) # assert "gtype" in data.attrs, "data must have a gtype attribute" @@ -642,9 +650,24 @@ def z(self) -> Any: @property def node(self) -> Any: - """node-coordinate""" + """Name of the node this comparer sits at""" return self._coordinate_values("node") + @property + def reach(self) -> Any: + """Name of the reach this comparer sits on""" + return self._coordinate_values("reach") + + @property + def distance(self) -> Any: + """along-reach distance of a breakpoint""" + return self._coordinate_values("distance") + + @property + def _at(self) -> Any: + """Where this comparer sits, in the form NodeObservation.at takes""" + return location_from_coords(self.data) + def _coordinate_values(self, coord: str) -> None | Any: """Get coordinate values if they exist, otherwise return None""" if coord not in self.data.coords: @@ -773,7 +796,9 @@ def rename( return Comparer(matched_data=data, raw_mod_data=raw_mod_data) - def _to_observation(self) -> PointObservation | TrackObservation | NodeObservation: + def _to_observation( + self, + ) -> PointObservation | TrackObservation | NodeObservation | ReachObservation: """Convert to Observation""" if self.gtype == "point": df = _drop_scalar_coords(self.data)[self._obs_str].to_dataframe() @@ -804,7 +829,16 @@ def _to_observation(self) -> PointObservation | TrackObservation | NodeObservati return NodeObservation( data=df, name=self.name, - at=self.node, + at=self._at, + quantity=self.quantity, + # TODO: add attrs + ) + elif self.gtype == "reach": + df = _drop_scalar_coords(self.data)[self._obs_str].to_dataframe() + return ReachObservation( + data=df, + name=self.name, + reach=self.reach, quantity=self.quantity, # TODO: add attrs ) @@ -1012,9 +1046,9 @@ def _to_long_dataframe( """Return a copy of the data as a long-format pandas DataFrame (for groupby operations)""" if self.gtype == "vertical": - data = self.data.drop_vars("node", errors="ignore") + data = self.data.drop_vars(NETWORK_LOCATION_COORDS, errors="ignore") else: - data = self.data.drop_vars(["z", "node"], errors="ignore") + data = self.data.drop_vars(["z", *NETWORK_LOCATION_COORDS], errors="ignore") # this step is necessary since we keep arbitrary derived data in the dataset, but not z/node # i.e. using a hardcoded whitelist of variables to keep is less flexible @@ -1361,7 +1395,7 @@ def save(self, filename: Union[str, Path]) -> None: # https://docs.xarray.dev/en/stable/user-guide/io.html#groups # There is no need to save raw data for track data, since it is identical to the matched data - if self.gtype in ("point", "node"): + if self.gtype in ("point", "node", "reach"): ds = self.data.copy() # copy needed to avoid modifying self.data for key, ts_mod in self.raw_mod_data.items(): @@ -1396,7 +1430,7 @@ def load(filename: Union[str, Path]) -> "Comparer": # FIXME: consider during Phase3 return Comparer(matched_data=data) - if data.gtype in ("point", "node"): + if data.gtype in ("point", "node", "reach"): raw_mod_data: Dict[ str, PointModelResult @@ -1413,10 +1447,8 @@ def load(filename: Union[str, Path]) -> "Comparer": {"_time_raw_" + new_key: "time", var_name: new_key} ) ts: PointModelResult | NodeModelResult - if data.gtype == "node": - ts = NodeModelResult( - data=ds, node=int(ds.coords["node"].item()), name=new_key - ) + if data.gtype in ("node", "reach"): + ts = NodeModelResult(data=ds, name=new_key) else: ts = PointModelResult(data=ds, name=new_key) diff --git a/src/modelskill/model/adapters/__init__.py b/src/modelskill/model/adapters/__init__.py deleted file mode 100644 index 33ad255b1..000000000 --- a/src/modelskill/model/adapters/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""Network format adapters.""" diff --git a/src/modelskill/model/adapters/_inp.py b/src/modelskill/model/adapters/_inp.py deleted file mode 100644 index 329b2c92a..000000000 --- a/src/modelskill/model/adapters/_inp.py +++ /dev/null @@ -1,109 +0,0 @@ -"""Minimal reader for EPANET and SWMM ``.inp`` input files. - -mikeio1d reads only the binary result formats, so the ``.inp`` that accompanies a -result file has to be parsed here. Both products use the same layout: bracketed -section headers, ``;``-prefixed comments (including the ``;;Name Node1 ...`` -column headers the products write), whitespace-delimited data rows, and blank -lines to ignore. - -Only the sections modelskill needs are interpreted; everything else is kept as -raw fields for a caller to use, or ignored. -""" - -from __future__ import annotations - -from pathlib import Path - - -def read_sections(path: str | Path) -> dict[str, list[list[str]]]: - """Parse an ``.inp`` file into its sections. - - Parameters - ---------- - path : str or Path - Path to an EPANET or SWMM ``.inp`` file. - - Returns - ------- - dict[str, list[list[str]]] - Section name (upper case, without brackets) mapped to its data rows, - each row split into whitespace-delimited fields. Comment-only and blank - lines are dropped, as is any trailing comment on a data row. - - Examples - -------- - >>> sections = read_sections("model.inp") # doctest: +SKIP - >>> sections["PIPES"][0] # doctest: +SKIP - ['10', '10', '11', '3209.544', '304.8', '100', '0', 'Open'] - """ - sections: dict[str, list[list[str]]] = {} - current: list[list[str]] | None = None - - with open(path, "r", encoding="utf-8", errors="replace") as f: - for line in f: - # A comment can trail a data row, so strip it before anything else. - line = line.split(";", 1)[0].strip() - if not line: - continue - - if line.startswith("["): - name = line.strip("[]").strip().upper() - current = sections.setdefault(name, []) - continue - - if current is not None: - current.append(line.split()) - - return sections - - -def read_pipe_lengths(path: str | Path) -> dict[str, float]: - """Read reach lengths from the ``[PIPES]`` section of an EPANET ``.inp``. - - Parameters - ---------- - path : str or Path - Path to an EPANET ``.inp`` file. - - Returns - ------- - dict[str, float] - Pipe ID mapped to its length. Pumps and valves are links too, but carry - no length, so they are absent from the result rather than present with a - placeholder. - - Raises - ------ - ValueError - If the file has no ``[PIPES]`` section, or a row there has too few - fields to read a length from. - - Notes - ----- - ``[PIPES]`` rows are ``ID Node1 Node2 Length Diameter Roughness ...``, so the - length is the fourth field. The units are whatever the model declares in - ``[OPTIONS]``; no conversion is applied. - """ - sections = read_sections(path) - - try: - rows = sections["PIPES"] - except KeyError: - raise ValueError( - f"'{path}' has no [PIPES] section, so it does not look like an " - "EPANET input file. Available sections: " - f"{sorted(sections)}." - ) - - _ID, _LENGTH = 0, 3 - lengths: dict[str, float] = {} - for row in rows: - if len(row) <= _LENGTH: - raise ValueError( - f"Cannot read a pipe length from [PIPES] row {' '.join(row)!r} " - f"in '{path}': expected at least {_LENGTH + 1} fields " - f"(ID, Node1, Node2, Length), got {len(row)}." - ) - lengths[row[_ID]] = float(row[_LENGTH]) - - return lengths diff --git a/src/modelskill/model/adapters/_res1d.py b/src/modelskill/model/adapters/_res1d.py deleted file mode 100644 index 567f0d498..000000000 --- a/src/modelskill/model/adapters/_res1d.py +++ /dev/null @@ -1,189 +0,0 @@ -from __future__ import annotations - -from typing import TYPE_CHECKING - -import pandas as pd - -if TYPE_CHECKING: - from mikeio1d.result_network import ResultNode, ResultGridPoint, ResultReach - -from modelskill.network import NetworkNode, ReachBreakPoint, NetworkReach - - -def _simplify_colnames(node: ResultNode | ResultGridPoint) -> pd.DataFrame: - # We remove suffixes and indexes so the columns contain only the quantity names - - # Some formats keep no timeseries at all on some locations - MIKE 11, for instance, - # stores everything on reach gridpoints, leaving the nodes empty. Asking mikeio1d - # for a dataframe there raises, so return an empty one instead. - if not node.quantities: - return pd.DataFrame() - - # The columns in a Res1D dataframe follow the convention "Quantity:Location:Sublocation" - # where Location refers to the node id or the reach id followed by the chainage. - RES1D_NAME_SEP = ":" - df = node.to_dataframe() - renamer_dict = {} - for quantity in node.quantities: - column_pairs = [ - (col, quantity) - for col in df.columns - if quantity in col.split(RES1D_NAME_SEP) - ] - if len(column_pairs) != 1: - raise ValueError( - f"There must be exactly one column per quantity, found {column_pairs}." - ) - old_name, new_name = column_pairs[0] - renamer_dict[old_name] = new_name - return df.rename(columns=renamer_dict).copy() - - -def _merge_extra_quantities( - base: pd.DataFrame, extra: pd.DataFrame, *, node_id: str -) -> pd.DataFrame: - """Append a companion file's quantities to a node's frame as extra columns. - - Parameters - ---------- - base : pd.DataFrame - The node's frame from the main result file. - extra : pd.DataFrame - The same node's frame from the companion file, sharing its time index. - node_id : str - Node ID, used in error messages. - - Returns - ------- - pd.DataFrame - - Raises - ------ - ValueError - If a quantity appears in both frames. Concatenating would give the node - two columns of the same name, which is the state ``_simplify_colnames`` - already refuses. - """ - if extra.empty: - return base - - overlapping = base.columns.intersection(extra.columns) - if len(overlapping) > 0: - raise ValueError( - f"Node {node_id!r} already has {sorted(overlapping)} in the main " - "result file, so the companion file's copy cannot be merged in." - ) - - return pd.concat([base, extra], axis=1) - - -class Res1DNode(NetworkNode): - def __init__( - self, - id: str, - *, - data: pd.DataFrame | None = None, - boundary: dict[str, pd.DataFrame] | None = None, - ): - self._id = id - self._data = pd.DataFrame() if data is None else data - self._boundary = {} if boundary is None else boundary - - @property - def id(self) -> str: - return self._id - - @property - def data(self) -> pd.DataFrame: - return self._data - - @property - def boundary(self) -> dict[str, pd.DataFrame]: - return self._boundary - - -class GridPoint(ReachBreakPoint): - def __init__( - self, reach_id: str, chainage: float, data: pd.DataFrame | None = None - ): - self._id = (reach_id, chainage) - self._data = pd.DataFrame() if data is None else data - - @property - def id(self) -> tuple[str, float]: - return self._id - - @property - def data(self) -> pd.DataFrame: - return self._data - - -class Res1DReach(NetworkReach): - """NetworkReach adapter for a mikeio1d ResultReach.""" - - def __init__( - self, - reach: ResultReach, - start_node: Res1DNode, - end_node: Res1DNode, - *, - populate_gridpoints: bool = True, - length: float | None = None, - ): - self._id = reach.name - - # Must be checked separately: some formats (.resx) report None for both the - # reach and the node, which the identity checks below would let through. - if reach.start_node is None or reach.end_node is None: - raise ValueError( - f"mikeio1d reported no start/end node for reach {reach.name!r}; " - "this result format's topology cannot be represented as a Network." - ) - - if start_node.id != reach.start_node: - raise ValueError("Incorrect starting node.") - if end_node.id != reach.end_node: - raise ValueError("Incorrect ending node.") - - intermediate_gridpoints = ( - reach.gridpoints[1:-1] if len(reach.gridpoints) > 2 else [] - ) - - self._start = start_node - self._end = end_node - - # A length read from a companion input file wins, since mikeio1d has none - # to offer for the formats that need one. Otherwise: mikeio1d returns 0 - # when it cannot read a reach length - link-node models such as EPANET - # report this for every reach. Report it as undefined rather than as a - # zero-length reach, which would make length-weighted graph algorithms - # treat the reach as free. The two cases cannot be told apart upstream. - self._length = length if length is not None else (reach.length or None) - self._breakpoints: list[ReachBreakPoint] = [ - GridPoint( - gridpoint.reach_name, - gridpoint.chainage, - _simplify_colnames(gridpoint) if populate_gridpoints else None, - ) - for gridpoint in intermediate_gridpoints - ] - - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> Res1DNode: - return self._start - - @property - def end(self) -> Res1DNode: - return self._end - - @property - def length(self) -> float | None: - return self._length - - @property - def breakpoints(self) -> list[ReachBreakPoint]: - return self._breakpoints diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 328c1cdea..7ca802fe7 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -1,20 +1,39 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Sequence +from pathlib import Path +from typing import TYPE_CHECKING, Any, Sequence import numpy as np import numpy.typing as npt import pandas as pd import xarray as xr -from modelskill.timeseries import TimeSeries, _parse_network_node_input +from modelskill.timeseries import ( + TimeSeries, + _parse_network_breakpoint_input, + _parse_network_node_input, +) +from modelskill.timeseries._coords import location_from_coords from ._base import SelectedItems from ..obs import NodeObservation, ReachObservation from ..quantity import Quantity from ..types import PointType if TYPE_CHECKING: - from modelskill.network import Network + from mikeio1d.network import Network + + +def _network_class() -> type[Network]: + # Imported here, not at module scope, so this module stays importable + # without the optional network dependencies (ADR-010). + try: + from mikeio1d.network import Network + except ImportError as err: + raise ImportError( + "NetworkModelResult needs the network topology layer from mikeio1d, " + "which the 'network' extra installs: pip install modelskill[network]" + ) from err + return Network class NodeModelResult(TimeSeries): @@ -30,8 +49,13 @@ class NodeModelResult(TimeSeries): name : str, optional The name of the model result, by default None (will be set to file name or item name) - node : int, optional - node ID (integer), by default None + node : str or tuple[str, float], optional + Where the data sits: a node name, or a break point as + ``(reach_id, distance)``. By default None, which requires data that + already carries a ``node`` or ``reach`` coordinate. + node_index : int, optional + The integer the network used for this location, recorded as provenance. + Nothing reads it back, by default None item : str | int | None, optional If multiple items/arrays are present in the input an item must be given (as either an index or a string), by default None @@ -43,62 +67,95 @@ class NodeModelResult(TimeSeries): Examples -------- >>> import modelskill as ms - >>> mr = ms.NodeModelResult(data, node=123, name="Node_123") - >>> mr2 = ms.NodeModelResult(df, item="Water Level", node=456) + >>> mr = ms.NodeModelResult(data, node="123", name="Node_123") + >>> mr2 = ms.NodeModelResult(df, item="Water Level", node=("r1", 24.5)) """ def __init__( self, data: PointType, - node: int, + node: str | tuple[str, float | None] | None = None, *, + node_index: int | None = None, name: str | None = None, item: str | int | None = None, quantity: Quantity | None = None, aux_items: Sequence[int | str] | None = None, ): if not self._is_input_validated(data): - data = _parse_network_node_input( - data, - name=name, - item=item, - quantity=quantity, - node=node, - aux_items=aux_items, - ) + if isinstance(node, tuple): + reach, distance = node + data = _parse_network_breakpoint_input( + data, + name=name, + item=item, + quantity=quantity, + aux_items=aux_items, + reach=reach, + distance=distance, + ) + elif node is not None: + data = _parse_network_node_input( + data, + name=name, + item=item, + quantity=quantity, + node=node, + aux_items=aux_items, + ) + else: + raise ValueError( + "'NodeModelResult' needs a node name or a (reach, distance) " + "pair when the data does not already carry its location" + ) if not isinstance(data, xr.Dataset): raise ValueError("'NodeModelResult' requires xarray.Dataset") - if data.coords.get("node") is None: - raise ValueError("'node' coordinate not found in data") + if not {"node", "reach"} & set(data.coords): + raise ValueError( + "'NodeModelResult' needs a node name, a (reach, distance) pair, or " + "data that already carries a 'node' or 'reach' coordinate" + ) + if node_index is not None: + data = data.assign_coords(node_index=int(node_index)) data_var = str(list(data.data_vars)[0]) data[data_var].attrs["kind"] = "model" super().__init__(data=data) @property - def node(self) -> int: - """Node ID of model result""" - node_val = self.data.coords["node"] - return int(node_val.item()) + def node(self) -> Any: + """Where this result was extracted, as its network named it.""" + return location_from_coords(self.data) + + @property + def node_index(self) -> int | None: + """Graph integer this location had in the network it came from, if recorded. + + Provenance only. Nothing reads it back: the numbering belongs to one + network built by one version, so a saved result is identified by + :attr:`node` instead. + """ + if "node_index" not in self.data.coords: + return None + return int(np.atleast_1d(self.data.coords["node_index"].values)[0]) def _create_new_instance(self, data: xr.Dataset) -> NodeModelResult: - """Extract node from data and create new instance""" - node = int(data.coords["node"].item()) - return self.__class__(data, node=node) + """Create a new instance; the location already travels in the coords.""" + return self.__class__(data) class NetworkModelResult: """Model result for network data with time and node dimensions. - Construct a NetworkModelResult from a Network object containing - timeseries data for each node. Users must provide exact node IDs - (integers obtained via ``Network.find()``) when creating observations — - no spatial interpolation is performed. + Construct one from a result file, or from a :class:`mikeio1d.network.Network` + already built. Observations name the location they sit at, and no spatial + interpolation is performed. Parameters ---------- - data : Network - Network-like object with a ``to_dataset()`` method (e.g. :class:`modelskill.network.Network`). + data : Network, str or Path + Path to a ``.res1d``, ``.res11`` or ``.res`` result file, or a + :class:`mikeio1d.network.Network`. name : str, optional The name of the model result, by default None (will be set to first data variable name) @@ -113,23 +170,46 @@ class NetworkModelResult: Examples -------- >>> import modelskill as ms - >>> from modelskill.network import Network - >>> network = Network(reaches) # reaches is a list[NetworkReach] - >>> mr = ms.NetworkModelResult(network, name="MyModel") - >>> obs = ms.NodeObservation(data, node=network.find(node="node_A")) + >>> mr = ms.NetworkModelResult("model.res1d", item="WaterLevel") + >>> obs = ms.NodeObservation(data, at="node_A") >>> extracted = mr.extract(obs) + + Open the network yourself to name EPANET companion files, or to keep memory + down on a large model by reading only the locations you will score: + + >>> from mikeio1d.network import Network + >>> network = Network.open("model.res1d", nodes=["node_A", "node_B"]) + >>> mr = ms.NetworkModelResult(network, name="MyModel") + + Notes + ----- + The network is used as given, not copied, so ``mr.network`` is the caller's + object. + + See Also + -------- + mikeio1d.network.Network.open : Read a network from a result file. """ def __init__( self, - data: Network, + data: Network | str | Path, *, name: str | None = None, item: str | int | None = None, quantity: Quantity | None = None, aux_items: Sequence[int | str] | None = None, ): - self.network = data.copy() + network_class = _network_class() + if isinstance(data, (str, Path)): + self.network = network_class.open(data) + elif isinstance(data, network_class): + self.network = data + else: + raise TypeError( + "NetworkModelResult takes a mikeio1d.network.Network or a path to a " + f"result file, got {type(data).__name__}" + ) ds = self.network.to_dataset() sel_items = SelectedItems.parse( @@ -144,6 +224,12 @@ def __init__( if quantity is None: da = self.data[sel_items.values] quantity = Quantity.from_cf_attrs(da.attrs) + if quantity == Quantity.undefined(): + # A result file names its quantity but carries no unit, and + # Quantity.from_cf_attrs needs both. Fall back to the name alone + # rather than reporting nothing at all. + name = da.attrs.get("long_name") or str(sel_items.values) + quantity = Quantity(name=name, unit="") self.quantity = quantity # Mark data variables as model data @@ -152,7 +238,10 @@ def __init__( def __repr__(self) -> str: return f"<{self.__class__.__name__}>: {self.name}" - _CHAINAGE_TOLERANCE = 1e-3 # Tolerance in source-network distance units (e.g., meters if chainage is in meters). + #: Coordinates mikeio1d puts on to_dataset() to say what each column is. They + #: are re-applied through NodeModelResult, which knows modelskill's names for + #: them, so they never reach a comparer under these. + _UPSTREAM_IDENTITY_COORDS = ("name", "reach", "distance") @property def time(self) -> pd.DatetimeIndex: @@ -173,7 +262,7 @@ def extract( Parameters ---------- observation : NodeObservation or ReachObservation - observation with node ID or reach ID + observation naming a node, a breakpoint, or a reach Returns ------- @@ -192,134 +281,97 @@ def extract( def _extract_node(self, observation: NodeObservation) -> NodeModelResult: node_id = self._resolve_alias(observation.at) - available_nodes = set(self.data.node.values) - if node_id not in available_nodes: + if node_id not in self.data.indexes["node"]: raise ValueError( - f"Node {node_id} exists in the network topology but its timeseries was not loaded. " - f"Re-create the NetworkModelResult with the relevant nodes populated, " - f"e.g. Network.from_mike(path, nodes=[...])." + f"{observation.at!r} exists in the network topology but its " + "timeseries was not loaded. Re-create the NetworkModelResult with " + "the relevant nodes populated, e.g. " + "NetworkModelResult(Network.open(path, nodes=[...]))." ) - return NodeModelResult( - data=self.data.sel(node=node_id).drop_vars("node"), - node=node_id, - name=self.name, - item=self.sel_items.values, - quantity=self.quantity, - aux_items=self.sel_items.aux, - ) + return self._as_node_result(node_id) def _extract_reach(self, observation: ReachObservation) -> NodeModelResult: - # Extract model result from an arbitrary breakpoint belonging to the reach. - - # Searches the alias map for breakpoints whose reach component matches - # ``observation.reach``, then returns the first one that has data in the - # dataset. Raises if no breakpoint with data is found or if the quantity - # is not present for any breakpoint of that reach. - + # A reach observation matches any breakpoint along the reach, so long as + # they agree. Which breakpoints those are is read off the dataset's own + # coordinates; the network is consulted only to explain a failure. item = self.sel_items.values reach_id = observation.reach - try: - reach = self.network._reaches[reach_id] - except KeyError: + if reach_id not in self.network.reaches: raise ValueError(f"Reach {reach_id} not found in network.") - # This only searches intermediate breakpoints since reach-level data is not - # expected in nodes. - - available_nodes = {int(node_id) for node_id in self.data.node.values} - found_ds = None - found_int_id: int | None = None - missing_node_data = False - for breakpoint in reach.breakpoints: - if breakpoint.data is None: - continue - if item not in breakpoint.data.columns: - continue - - int_id = self.network.find( - reach=breakpoint.id[0], distance=breakpoint.distance - ) - if int_id not in available_nodes: - missing_node_data = True - continue - - ds = self.data.sel(node=int_id).drop_vars("node") - if found_ds is not None: - da1, da2 = xr.align(ds[item], found_ds[item], join="inner") - if not np.allclose(da1.values, da2.values, equal_nan=True): - raise ValueError( - "Not all data in breakpoints are equivalent. " - "Select a specific node instead of the reach." - ) - else: - found_ds = ds - found_int_id = int_id - - if found_ds is not None and found_int_id is not None: - return NodeModelResult( - data=found_ds, - node=found_int_id, - name=self.name, - item=item, - quantity=self.quantity, - aux_items=self.sel_items.aux, - ) - if missing_node_data: + on_reach = np.flatnonzero(self.data["reach"].values == reach_id) + # A location that carries no data for this quantity is all-NaN here, + # since quantities with different coverage are aligned on the way in. + with_data = self.data[item].isel(node=on_reach).notnull().any("time").values + candidates = self.data.isel(node=on_reach[np.flatnonzero(with_data)]) + + if candidates.sizes["node"] == 0: + raise ValueError(self._explain_no_reach_data(reach_id, item)) + + values = candidates[item].transpose("time", "node").values + if not np.allclose(values, values[:, :1], equal_nan=True): raise ValueError( + "Not all data in breakpoints are equivalent. " + "Select a specific node instead of the reach." + ) + + # Lowest distance first, unknown distances last, so the breakpoint chosen + # does not depend on the numbering mikeio1d happened to hand out. + distance = np.nan_to_num(candidates["distance"].values, nan=np.inf) + order = np.lexsort((candidates["node"].values, distance)) + return self._as_node_result(int(candidates["node"].values[order[0]])) + + def _explain_no_reach_data(self, reach_id: str, item: str) -> str: + # Whether the reach has no such data at all, or has it at breakpoints this + # model result did not load, is a distinction only the network can make. + has_source_data = any( + breakpoint.data is not None and item in breakpoint.data.columns + for breakpoint in self.network.reaches[reach_id].breakpoints + ) + if has_source_data: + return ( f"Reach '{reach_id}' has breakpoint data for quantity " f"'{item}', but matching breakpoint nodes are " "missing from the model dataset. Re-create the NetworkModelResult " "with the relevant reaches populated." ) - - raise ValueError( + return ( f"Reach '{reach_id}' was found in the network but none of its " - f"breakpoints have data loaded for quantity '{self.sel_items.values}'. " + f"breakpoints have data loaded for quantity '{item}'. " f"Re-create the NetworkModelResult with the relevant reaches populated." ) - def _resolve_alias(self, alias: int | str | tuple[str, float]) -> int: - # Resolve a node alias to an internal node ID. - - # Breakpoint tuple aliases are matched first by exact key lookup and then - # by reach ID and distance within ``_CHAINAGE_TOLERANCE``. If multiple - # candidates are within tolerance, the closest distance is selected; ties - # are broken by choosing the smallest node ID. Distance units are the - # same as the network chainage units. - - if isinstance(alias, int): - if alias not in self.data.node: - raise ValueError( - f"Node {alias} not found. Available: {list(self.nodes[:5])}..." - ) - return alias - else: - if alias in self.network._alias_map: - return self.network._alias_map[alias] + def _as_node_result(self, node_id: int) -> NodeModelResult: + # The location is taken from the network rather than from the observation, + # so a distance given as 24.5001 is recorded as the network's own 24.5. + where = self.network.recall(int(node_id)) + location = ( + where["node"] if "node" in where else (where["reach"], where["distance"]) + ) + data = self.data.sel(node=node_id).drop_vars( + ("node", *self._UPSTREAM_IDENTITY_COORDS), errors="ignore" + ) + return NodeModelResult( + data=data, + node=location, + node_index=int(node_id), + name=self.name, + item=self.sel_items.values, + quantity=self.quantity, + aux_items=self.sel_items.aux, + ) + def _resolve_alias(self, alias: str | tuple[str, float]) -> int: + # Delegated to Network.find rather than matched against the dataset's own + # name/reach/distance coords: find() searches the whole topology, so a hit + # that is missing from the dataset is a location whose timeseries was not + # loaded, which is a different mistake from one that does not exist. + try: if isinstance(alias, tuple): - # Handle tolerances reach_id, distance = alias - candidates: list[tuple[float, int]] = [] - for key, node_id in self.network._alias_map.items(): - if isinstance(key, tuple) and key[0] == reach_id: - diff = abs(key[1] - distance) - if diff <= self._CHAINAGE_TOLERANCE: - candidates.append((diff, node_id)) - if candidates: - return min( - candidates, key=lambda candidate: (candidate[0], candidate[1]) - )[1] - - available = list(self.network._alias_map.keys())[:5] - if isinstance(alias, tuple): - raise ValueError( - f"Breakpoint {alias} not found in network. " - f"Available aliases (first 5): {available}" - ) - raise ValueError( - f"Node alias '{alias}' not found in network. " - f"Available aliases (first 5): {available}" - ) + return int(self.network.find(reach=str(reach_id), distance=distance)) + return int(self.network.find(node=str(alias))) + except KeyError as err: + raise ValueError(f"Location {alias!r} not found. {err.args[0]}") from err diff --git a/src/modelskill/network.py b/src/modelskill/network.py deleted file mode 100644 index 4487c5809..000000000 --- a/src/modelskill/network.py +++ /dev/null @@ -1,1200 +0,0 @@ -"""Opt-in network module for network model results (e.g. MIKE 1D / res1d). - -Requires the ``networks`` dependency group (networkx, mikeio1d). -Install with:: - - uv sync --group networks - -Import this module explicitly to use network functionality:: - - from modelskill.network import Network - -""" - -from __future__ import annotations - -import sys - -from abc import ABC, abstractmethod -from pathlib import Path -from typing import Any, Sequence, overload, TYPE_CHECKING -from copy import deepcopy - -import networkx as nx -import pandas as pd -import xarray as xr - -if TYPE_CHECKING: - from mikeio1d import Res1D - from mikeio1d.result_network import ResultReach - from .model.adapters._res1d import Res1DReach - - -_MIKE_EXTENSIONS = frozenset({".res1d", ".res11"}) -_EPANET_EXTENSIONS = frozenset({".res"}) - -_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." -) -# A result file that holds timeseries but no topology of its own. The connectivity -# is in a companion file we do not parse yet. -_TOPOLOGY_IN_COMPANION_FILE = ( - "SWMM '.out' files carry no reach connectivity of their own - it lives in the " - "companion '.inp' input file, which modelskill does not read yet. Tracked in " - "https://github.com/DHI/modelskill/issues/689." -) -# A companion result file: readable, but it describes a network defined elsewhere. -_COMPANION_RESULT_FILE = ( - "'.resx' holds extra EPANET results (tank volume, pump energy) for a network " - "defined in the sibling '.res' file, so it has no topology of its own. Read the " - "'.res' file and pass this one alongside it: " - "Network.from_epanet(res, resx=...)." -) - -# extension -> why modelskill will not read it, even though mikeio1d can -_UNSUPPORTED_EXTENSIONS: dict[str, str] = { - ".out": _TOPOLOGY_IN_COMPANION_FILE, - ".resx": _COMPANION_RESULT_FILE, - ".prf": _NO_FIXTURE.format(product="MOUSE"), - ".crf": _NO_FIXTURE.format(product="MOUSE"), - ".xrf": _NO_FIXTURE.format(product="MOUSE"), - ".whr": _NO_FIXTURE.format(product="Water Hammer"), -} - -# extension -> the constructor that reads it, for "use X instead" errors -_EXTENSION_CONSTRUCTORS: dict[str, str] = { - **{extension: "from_mike" for extension in _MIKE_EXTENSIONS}, - **{extension: "from_epanet" for extension in _EPANET_EXTENSIONS}, -} - - -def _check_file_path_is_str(res: Res1D) -> None: - """Reject a Res1D opened with a path object rather than a string. - - mikeio1d resolves reach topology with ``str.endswith`` on - ``Res1D.file_path``, which raises ``AttributeError`` from deep inside the - load when that attribute is a ``Path``. Fail here instead, where the cause - can be named. - """ - file_path = getattr(res, "file_path", None) - if file_path is not None and not isinstance(file_path, str): - raise TypeError( - f"This Res1D was opened with a {type(file_path).__name__} file_path, " - "which mikeio1d cannot resolve reach topology from. Re-open it as " - "Res1D(str(path)), or pass the path to the constructor directly." - ) - - -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. - - Three 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. - - See Also - -------- - BasicNode : Ready-to-use concrete implementation. - NetworkReach : Connects two NetworkNode instances. - Network : Container that assembles nodes and reaches into a graph. - """ - - @property - @abstractmethod - def id(self) -> str: - """Unique string identifier for this node.""" - pass - - @property - @abstractmethod - 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.""" - return list(self.data.columns) - - -class ReachBreakPoint(ABC): - """Abstract base class for an intermediate break point along a network reach. - - Break points represent locations between the start and end nodes of a - reach (e.g. cross-section chainage points along a river reach) that carry - their own time-series data. - - Two properties must be implemented: - - * :attr:`id` - a ``(reach_id, distance)`` tuple that uniquely locates the - break point within the network. - * :attr:`data` - a time-indexed :class:`pandas.DataFrame` whose columns - are quantity names. - - The :attr:`distance` convenience property returns ``id[1]`` (the - along-reach distance in the units used by the parent network). - - Examples - -------- - Minimal subclass: - - >>> class MyBreakPoint(ReachBreakPoint): - ... def __init__(self, reach_id, chainage, df): - ... self._id = (reach_id, chainage) - ... self._data = df - ... @property - ... def id(self): return self._id - ... @property - ... def data(self): return self._data - - See Also - -------- - NetworkReach : Owns a list of ReachBreakPoint instances. - NetworkNode : Represents a start/end node of a reach. - Network : Assembles reaches (and their break points) into a graph. - """ - - @property - @abstractmethod - def id(self) -> tuple[str, float]: - """``(reach_id, distance)`` tuple uniquely identifying this break point.""" - pass - - @property - @abstractmethod - def data(self) -> pd.DataFrame: - """Time-indexed DataFrame with one column per quantity.""" - pass - - @property - def distance(self) -> float: - """Along-reach distance of this break point, measured from the start node.""" - return self.id[1] - - @property - def quantities(self) -> list[str]: - """List of quantity names available at this break point.""" - return list(self.data.columns) - - -class NetworkReach(ABC): - """Abstract base class for a reach in a network. - - A reach represents a directed connection between two :class:`NetworkNode` - instances (e.g. a river reach between two junctions). It may also carry - a list of :class:`ReachBreakPoint` objects for intermediate chainage - locations. - - Subclass this to integrate your own network topology. Four properties - must be implemented: - - * :attr:`id` - a unique string identifier for the reach. - * :attr:`start` - the upstream/start :class:`NetworkNode`. - * :attr:`end` - the downstream/end :class:`NetworkNode`. - * :attr:`breakpoints` - list of :class:`ReachBreakPoint` instances ordered - by increasing distance from the start node (empty list if none). - - :attr:`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. - - The concrete helper :class:`BasicReach` is provided for the common case - where all data is already available in memory. - - Examples - -------- - Minimal subclass, without a length: - - >>> class MyReach(NetworkReach): - ... def __init__(self, rid, start_node, end_node): - ... self._id = rid - ... self._start = start_node - ... self._end = end_node - ... @property - ... def id(self): return self._id - ... @property - ... def start(self): return self._start - ... @property - ... def end(self): return self._end - ... @property - ... def breakpoints(self): return [] - - Add a :attr:`length` property on top of that when the domain has one: - - >>> class MyMeasuredReach(MyReach): - ... def __init__(self, rid, start_node, end_node, length): - ... super().__init__(rid, start_node, end_node) - ... self._length = length - ... @property - ... def length(self): return self._length - - See Also - -------- - BasicReach : Ready-to-use concrete implementation. - NetworkNode : Represents the start/end of this reach. - ReachBreakPoint : Intermediate data points along this reach. - Network : Assembles a list of NetworkReach objects into a graph. - """ - - @property - @abstractmethod - def id(self) -> str: - """Unique string identifier for this reach.""" - pass - - @property - @abstractmethod - def start(self) -> NetworkNode: - """Start (upstream) node of this reach.""" - pass - - @property - @abstractmethod - def end(self) -> NetworkNode: - """End (downstream) node of this reach.""" - pass - - @property - def length(self) -> float | None: - """Total length of this reach in network units, or ``None`` if undefined.""" - return None - - @property - @abstractmethod - def breakpoints(self) -> list[ReachBreakPoint]: - """Ordered list of intermediate :class:`ReachBreakPoint` objects (may be empty).""" - pass - - @property - def n_breakpoints(self) -> int: - """Number of break points in the reach.""" - return len(self.breakpoints) - - -class BasicNode(NetworkNode): - """Concrete :class:`NetworkNode` for programmatic network construction. - - Parameters - ---------- - id : str - Unique node identifier. - data : pd.DataFrame - Time-indexed DataFrame with one column per quantity. - boundary : dict, optional - Boundary condition metadata, by default empty. - - Examples - -------- - >>> import pandas as pd - >>> time = pd.date_range("2020", periods=3, freq="h") - >>> node = BasicNode("junction_1", pd.DataFrame({"WaterLevel": [1.0, 1.1, 1.2]}, index=time)) - """ - - 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: - return self._id - - @property - 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. - - Parameters - ---------- - id : str - Unique reach identifier. - start : NetworkNode - Start node. - end : NetworkNode - End node. - length : float, optional - Reach length, by default None (undefined). - breakpoints : list[ReachBreakPoint], optional - Intermediate break points, by default empty. - - Examples - -------- - >>> reach = BasicReach("reach_1", node_a, node_b, length=250.0) - - Where the domain has no reach length, leave it out: - - >>> reach = BasicReach("pipe_1", node_a, node_b) - """ - - def __init__( - self, - id: str, - start: NetworkNode, - end: NetworkNode, - length: float | None = None, - breakpoints: list[ReachBreakPoint] | None = None, - ) -> None: - self._id = id - self._start = start - self._end = end - self._length = length - self._breakpoints: list[ReachBreakPoint] = breakpoints or [] - - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> NetworkNode: - return self._start - - @property - def end(self) -> NetworkNode: - return self._end - - @property - def length(self) -> float | None: - return self._length - - @property - def breakpoints(self) -> list[ReachBreakPoint]: - return self._breakpoints - - -class Network: - """Network built from a set of reaches, with coordinate lookup and data access.""" - - def __init__(self, reaches: Sequence[NetworkReach]): - graph = self._generate_graph(reaches) - self._initialize_network_attributes(graph) - self._reaches = self._generate_reaches_dict(reaches) - - def _initialize_network_attributes(self, graph: nx.Graph): - self._alias_map = self._generate_alias_map(graph) - self._df = self._build_dataframe(graph) - self._graph = graph.copy() - - def __repr__(self) -> str: - time = self._df.index - time_window = "N/A - N/A" if len(time) == 0 else f"{time[0]} - {time[-1]}" - out = [ - "", - f"Reaches: {len(self._reaches)}", - f"Nodes: {self._graph.number_of_nodes()}", - f"Quantities: {self.quantities}", - f"Time: {time_window}", - ] - return "\n".join(out) - - @classmethod - def from_mike( - cls, - res: str | Path | Res1D, - *, - nodes: str | list[str] | None = None, - reaches: str | list[str] | None = None, - ) -> Network: - """Create a Network from a MIKE 1D or MIKE 11 result file. - - Parameters - ---------- - res : str, Path or Res1D - Path to a ``.res1d`` or ``.res11`` file, or an already-opened - :class:`mikeio1d.Res1D` object. - nodes : str, list of str, or None, optional - Controls which nodes have their timeseries data loaded into memory. - - * ``None`` *(default)* — data is loaded for every node. - * A single node ID or a list of node IDs — only those nodes get - data; others are topology-only. - * ``[]`` (empty list) — no node data is loaded at all. - - The full network topology is always constructed regardless of this - setting, so ``find()`` and ``recall()`` still work on all nodes. - reaches : str, list of str, or None, optional - Controls which reaches have their intermediate gridpoint data - populated. - - * ``None`` *(default)* — gridpoints are populated for every reach. - * A single reach name or a list of reach names — only those reaches - get gridpoint data; others are topology-only. - * ``[]`` (empty list) — no gridpoint data is loaded at all. - - Returns - ------- - Network - - Raises - ------ - NotImplementedError - If the file extension is not one modelskill can read. - ValueError - If the extension belongs to another constructor, such as EPANET. - - Examples - -------- - Load everything (default behaviour): - - >>> from modelskill.network import Network - >>> network = Network.from_mike("model.res1d") - - Load data only for the two nodes where observations exist, and skip - all intermediate gridpoint data to keep memory usage low: - - >>> network = Network.from_mike( - ... "model.res1d", - ... nodes=["node_a", "node_b"], - ... reaches=[], - ... ) - - Load data for selected nodes and gridpoints for one specific reach: - - >>> network = Network.from_mike( - ... "model.res1d", - ... nodes=["node_a", "node_b"], - ... reaches=["reach_1"], - ... ) - - Notes - ----- - MIKE 11 keeps its timeseries on reach gridpoints rather than on nodes, - so the nodes of a ``.res11`` network carry no data of their own. Pass - ``reaches`` rather than ``nodes`` to control what gets loaded. - - See Also - -------- - from_epanet : Read an EPANET result file. - """ - return cls._from_mikeio1d( - res, - nodes=nodes, - reaches=reaches, - allowed=_MIKE_EXTENSIONS, - caller="from_mike", - ) - - @classmethod - def from_epanet( - cls, - res: str | Path | Res1D, - *, - resx: str | Path | Res1D | None = None, - inp: str | Path | None = None, - nodes: str | list[str] | None = None, - reaches: str | list[str] | None = None, - ) -> Network: - """Create a Network from an EPANET result file and its companions. - - An EPANET run writes up to three files that modelskill can use. The - ``.res`` holds the network and its main timeseries; the optional - ``.resx`` holds extra results; and the optional ``.inp`` is the input - file, which is the only one of the three carrying reach lengths. - - Parameters - ---------- - res : str, Path or Res1D - Path to a ``.res`` file, or an already-opened - :class:`mikeio1d.Res1D` object. - resx : str, Path, Res1D or None, optional - Companion ``.resx`` file from the same run. Its extra node - quantities (tank ``Volume`` and ``Volume Percentage``) are merged - onto the matching nodes. By default None, and those quantities are - simply absent. - inp : str, Path or None, optional - EPANET ``.inp`` input file for the same model, read for its - ``[PIPES]`` lengths. By default None, and reach lengths are - undefined. - nodes : str, list of str, or None, optional - Which nodes get their timeseries loaded. See :meth:`from_mike`. - reaches : str, list of str, or None, optional - Which reaches get their gridpoint data loaded. See - :meth:`from_mike`. EPANET results have no intermediate gridpoints, - so this argument has no effect. - - Returns - ------- - Network - - Raises - ------ - NotImplementedError - If the file extension is not one modelskill can read. - ValueError - If the extension belongs to another constructor, such as MIKE, if a - companion file has the wrong extension, or if ``resx`` does not come - from the same run as ``res``. - - Examples - -------- - >>> from modelskill.network import Network - >>> network = Network.from_epanet("model.res") - - With both companions, for real edge lengths and the extra quantities: - - >>> network = Network.from_epanet( - ... "model.res", - ... resx="model.resx", - ... inp="model.inp", - ... ) - - Notes - ----- - EPANET is a link-node model, and mikeio1d reports no length and a - single synthetic gridpoint for each of its reaches. As a result: - - * without ``inp``, every edge of :attr:`graph` has ``length=None``, so a - length-weighted graph algorithm fails rather than returning a - meaningless number. Pumps and valves keep ``length=None`` even with - ``inp``, since ``[PIPES]`` is the only section carrying lengths - * reaches have no breakpoints, so - :class:`~modelskill.obs.ReachObservation` cannot be matched against - an EPANET network — use :class:`~modelskill.obs.NodeObservation` - * ``find(reach=..., distance=)`` never resolves; only - ``distance="start"`` and ``distance="end"`` work - - For the same reason, ``resx`` merges node quantities only. Its - reach-level quantities (pump energy, efficiency and costs) have no - breakpoint to live on, which is tracked in issue #680. - - Node timeseries, :meth:`to_dataframe`, :meth:`to_dataset`, - ``find(node=...)`` and :meth:`recall` are unaffected. - - See Also - -------- - from_mike : Read a MIKE 1D or MIKE 11 result file. - """ - return cls._from_mikeio1d( - res, - nodes=nodes, - reaches=reaches, - allowed=_EPANET_EXTENSIONS, - caller="from_epanet", - resx=resx, - inp=inp, - ) - - @classmethod - def _from_mikeio1d( - cls, - res: str | Path | Res1D, - *, - nodes: str | list[str] | None, - reaches: str | list[str] | None, - allowed: frozenset[str], - caller: str, - resx: str | Path | Res1D | None = None, - inp: str | Path | None = None, - ) -> Network: - """Shared implementation behind the public ``from_*`` constructors. - - Parameters - ---------- - allowed : frozenset of str - Extensions this constructor accepts. - caller : str - Name of the public method, used in error messages. - resx : str, Path, Res1D or None, optional - Companion result file whose node quantities are merged in. - inp : str, Path or None, optional - Companion input file read for reach lengths. - """ - if sys.version_info >= (3, 14): - raise NotImplementedError( - f"Current version of 'mikeio1d' requires python < 3.14 and {sys.version} is being used." - ) - - from mikeio1d import Res1D as _Res1D - - if isinstance(res, (str, Path)): - path = Path(res) - cls._validate_extension(path.suffix, allowed=allowed, caller=caller) - res = _Res1D(str(path)) - elif isinstance(res, _Res1D): - _check_file_path_is_str(res) - suffix = Path(res.file_path).suffix - cls._validate_extension(suffix, allowed=allowed, caller=caller) - else: - raise TypeError( - f"Expected a str, Path or Res1D object, got {type(res).__name__!r}" - ) - - if nodes is None: - nodes_list: list[str] = list(res.nodes.keys()) - elif isinstance(nodes, str): - nodes_list = [nodes] - else: - nodes_list = list(nodes) - - if reaches is None: - reaches_list: list[str] = list(res.reaches.keys()) - elif isinstance(reaches, str): - reaches_list = [reaches] - else: - reaches_list = list(reaches) - - extra = None if resx is None else cls._open_companion_result(res, resx) - lengths = None if inp is None else cls._read_companion_lengths(inp) - - list_of_reaches = cls._load_res1d_network( - res, nodes_list, reaches_list, extra=extra, lengths=lengths - ) - return cls(list_of_reaches) - - @staticmethod - def _read_companion_lengths(inp: str | Path) -> dict[str, float]: - """Read reach lengths from a companion ``.inp`` input file.""" - from modelskill.model.adapters._inp import read_pipe_lengths - - path = Path(inp) - if path.suffix.lower() != ".inp": - raise ValueError( - f"Expected an EPANET '.inp' input file, got '{path.suffix}'. " - "This argument reads reach lengths from the model input, not " - "from a result file." - ) - return read_pipe_lengths(path) - - @staticmethod - def _open_companion_result(res: Res1D, resx: str | Path | Res1D) -> Res1D: - """Open and validate a companion ``.resx`` result file. - - Raises - ------ - ValueError - If the extension is not ``.resx``, or if the file does not come from - the same run as ``res``. - """ - from mikeio1d import Res1D as _Res1D - - if isinstance(resx, (str, Path)): - path = Path(resx) - if path.suffix.lower() != ".resx": - raise ValueError( - f"Expected an EPANET '.resx' companion file, got '{path.suffix}'." - ) - extra = _Res1D(str(path)) - elif isinstance(resx, _Res1D): - _check_file_path_is_str(resx) - if Path(resx.file_path).suffix.lower() != ".resx": - raise ValueError( - "Expected an EPANET '.resx' companion file, got " - f"'{Path(resx.file_path).suffix}'." - ) - extra = resx - else: - raise TypeError( - f"Expected a str, Path or Res1D object, got {type(resx).__name__!r}" - ) - - # Merging two different runs would line up silently and produce a network - # that is wrong in a way no later error would reveal. - if not res.time_index.equals(extra.time_index): - raise ValueError( - "The '.resx' companion does not share a time axis with the " - "'.res' file, so the two are not from the same run. Got " - f"{len(extra.time_index)} steps ending {extra.end_time} against " - f"{len(res.time_index)} ending {res.end_time}." - ) - - unknown_nodes = set(extra.nodes) - set(res.nodes) - if unknown_nodes: - raise ValueError( - f"The '.resx' companion holds nodes {sorted(unknown_nodes)} that are " - "absent from the '.res' network, so the two files do not describe " - "the same model." - ) - - unknown_reaches = set(extra.reaches) - set(res.reaches) - if unknown_reaches: - raise ValueError( - f"The '.resx' companion holds reaches {sorted(unknown_reaches)} that are " - "absent from the '.res' network, so the two files do not describe " - "the same model." - ) - - return extra - - @staticmethod - def _validate_extension( - suffix: str, *, allowed: frozenset[str], caller: str - ) -> None: - """Check a file extension against mikeio1d and against one constructor. - - Raises - ------ - NotImplementedError - If modelskill cannot read the extension, either because mikeio1d - does not support it or because modelskill does not. - ValueError - If another constructor is the one that reads this extension. - """ - from mikeio1d import Res1D as _Res1D - - extension = suffix.lower() - - # Checked before the supported set below, since these all *are* readable - # by mikeio1d - it is modelskill that cannot use the result. - reason = _UNSUPPORTED_EXTENSIONS.get(extension) - if reason is not None: - raise NotImplementedError(f"Cannot read '{suffix}' files. {reason}") - - supported = _Res1D.get_supported_file_extensions() - if extension not in supported: - readable = sorted(supported - set(_UNSUPPORTED_EXTENSIONS)) - raise NotImplementedError( - f"Unsupported file extension '{suffix}'. " - f"Supported extensions are {readable}." - ) - - if extension not in allowed: - constructor = _EXTENSION_CONSTRUCTORS.get(extension) - if constructor is None: - raise NotImplementedError( - f"File extension '{suffix}' is supported by mikeio1d but is not mapped " - "to a Network constructor in this version of modelskill. " - "Please upgrade modelskill or open an issue." - ) - raise ValueError( - f"Network.{caller}() reads {sorted(allowed)} files, got '{suffix}'. " - f"Use Network.{constructor}() instead." - ) - - @staticmethod - def _load_res1d_network( - res: Res1D, - nodes: list[str], - reaches: list[str], - *, - extra: Res1D | None = None, - lengths: dict[str, float] | None = None, - ) -> list[Res1DReach]: - from modelskill.model.adapters._res1d import ( - Res1DReach, - Res1DNode, - _merge_extra_quantities, - _simplify_colnames, - ) - - nodes_set = set(nodes) - reaches_set = set(reaches) - lengths = lengths or {} - - # In order to work with bigger files, we might want to select a subset of nodes and avoid - # potential memory issues. For this reason, we create this intermediate step that populates - # only the data in the passed nodes - - 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: - node = res.nodes[id] - df = _simplify_colnames(node) - # Merged here rather than up front so selective loading still - # decides what is held in memory. - if extra is not None and id in extra.nodes: - df = _merge_extra_quantities( - df, _simplify_colnames(extra.nodes[id]), node_id=id - ) - overlapping_gridpoint = reach.gridpoints[gpt_idx] - boundary = _simplify_colnames(overlapping_gridpoint) - return Res1DNode(id, data=df, boundary={reach.name: boundary}) - else: - return Res1DNode(id) - - return [ - Res1DReach( - reach, - _init_node(reach, False), - _init_node(reach, True), - populate_gridpoints=reach.name in reaches_set, - length=lengths.get(reach.name), - ) - for reach in res.reaches.values() - ] - - @staticmethod - def _generate_alias_map(g: nx.Graph) -> dict[str | tuple[str, float], int]: - return {g.nodes[id]["alias"]: id for id in g.nodes()} - - @staticmethod - def _generate_reaches_dict( - reaches: Sequence[NetworkReach], - ) -> dict[str, NetworkReach]: - return {r.id: r for r in reaches} - - @staticmethod - def _build_dataframe(g: nx.Graph) -> pd.DataFrame: - data_in_nodes = { - k: v["data"] - for k, v in g.nodes.items() - if v["data"] is not None and not v["data"].empty - } - if len(data_in_nodes) == 0: - columns = pd.MultiIndex.from_arrays([[], []], names=["node", "quantity"]) - return pd.DataFrame(index=pd.Index([], name="time"), columns=columns) - df = pd.concat(data_in_nodes, axis=1) - df.columns = df.columns.set_names(["node", "quantity"]) - df.index.name = "time" - return df.copy() - - def to_dataframe(self, sel: str | None = None) -> pd.DataFrame: - """Dataframe using node ids as column names. - - It will be multiindex unless 'sel' is passed. - - Parameters - ---------- - sel : Optional[str], optional - Quantity to select, by default None - - Returns - ------- - pd.DataFrame - Timeseries contained in graph nodes - """ - df = self._df.copy() - if sel is None: - return df - else: - df.attrs["quantity"] = sel - return df.reorder_levels(["quantity", "node"], axis=1).loc[:, sel] - - def to_dataset(self) -> xr.Dataset: - """Dataset using node ids as coords. - - Returns - ------- - xr.Dataset - Timeseries contained in graph nodes - """ - df_raw = self.to_dataframe() - if len(df_raw.columns) == 0: - return xr.Dataset() - df = df_raw.reorder_levels(["quantity", "node"], axis=1) - quantities = df.columns.get_level_values("quantity").unique() - return xr.Dataset( - {q: xr.DataArray(df[q], dims=["time", "node"]) for q in quantities} - ) - - @property - def graph(self) -> nx.Graph: - """Graph of the network.""" - return self._graph - - @property - def quantities(self) -> list[str]: - """Quantities present in data. - - Returns - ------- - List[str] - List of quantities - """ - return list(self.to_dataframe().columns.get_level_values(1).unique()) - - @staticmethod - def _generate_graph(reaches: Sequence[NetworkReach]) -> nx.Graph: - g0 = nx.Graph() - for reach in reaches: - # 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) - - # 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) - 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) - - # 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 - ) - g0.add_edge(bp_keys[-1], end_key, length=tail_length) - - # 3) Connect consecutive intermediate breakpoints - for i in range(reach.n_breakpoints - 1): - current_ = reach.breakpoints[i] - next_ = reach.breakpoints[i + 1] - length = next_.distance - current_.distance - g0.add_edge( - current_.id, - next_.id, - length=length, - ) - - return nx.convert_node_labels_to_integers(g0, label_attribute="alias") - - @overload - def find( - self, - *, - node: str, - reach: None = None, - distance: None = None, - ) -> int: - pass - - @overload - def find( - self, - *, - node: list[str], - reach: None = None, - distance: None = None, - ) -> list[int]: - pass - - @overload - def find( - self, - *, - node: None = None, - reach: str | list[str], - distance: str | float, - ) -> int: - pass - - @overload - def find( - self, - *, - node: None = None, - reach: str | list[str], - distance: list[str | float], - ) -> list[int]: - pass - - def find( - self, - node: str | list[str] | None = None, - reach: str | list[str] | None = None, - distance: str | float | list[str | float] | None = None, - ) -> int | list[int]: - """Find node or breakpoint id in the Network object based on former coordinates. - - Parameters - ---------- - node : str | List[str], optional - Node id(s) in the original network, by default None - reach : str | List[str], optional - Reach id(s) for breakpoint lookup or reach endpoint lookup, by default None - distance : str | float | List[str | float], optional - Distance(s) along reach for breakpoint lookup, or "start"/"end" - for reach endpoints, by default None - - Returns - ------- - int | List[int] - Node or breakpoint id(s) in the generic network - - Raises - ------ - ValueError - If invalid combination of parameters is provided - KeyError - If requested node/breakpoint is not found in the network - """ - by_node = node is not None - by_breakpoint = reach is not None or distance is not None - - if by_node and by_breakpoint: - raise ValueError( - "Cannot specify both 'node' and 'reach'/'distance' parameters simultaneously" - ) - - if not by_node and not by_breakpoint: - raise ValueError( - "Must specify either 'node' or both 'reach' and 'distance' parameters" - ) - - ids: list[str | tuple[str, float]] - - if by_node: - assert node is not None - if not isinstance(node, list): - node = [node] - ids = list(node) - - else: - if reach is None or distance is None: - raise ValueError( - "Both 'reach' and 'distance' parameters are required for breakpoint/endpoint lookup" - ) - - if not isinstance(reach, list): - reach = [reach] - - if not isinstance(distance, list): - distance = [distance] - - if len(reach) == 1: - reach = reach * len(distance) - - if len(reach) != len(distance): - raise ValueError( - "Incompatible lengths of 'reach' and 'distance' arguments. One 'reach' admits multiple distances, otherwise they must be the same length." - ) - - ids = [] - for reach_i, distance_i in zip(reach, distance): - if distance_i in ["start", "end"]: - if reach_i not in self._reaches: - raise KeyError(f"Reach '{reach_i}' not found in the network.") - - network_reach = self._reaches[reach_i] - if distance_i == "start": - ids.append(network_reach.start.id) - else: - ids.append(network_reach.end.id) - else: - if not isinstance(distance_i, (int, float)): - raise ValueError( - "Invalid 'distance' value for breakpoint lookup: " - f"{distance_i!r}. Expected a numeric value or 'start'/'end'." - ) - 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] - if isinstance(id, tuple): - reach_id, distance = id - for key, val in self._alias_map.items(): - if ( - isinstance(key, tuple) - and key[0] == reach_id - and abs(key[1] - distance) <= _CHAINAGE_TOLERANCE - ): - return val - return None - - resolved = [_resolve_id(id) for id in ids] - missing_ids = [ids[i] for i, v in enumerate(resolved) if v is None] - if missing_ids: - raise KeyError( - f"Node/breakpoint(s) {missing_ids} not found in the network. Available nodes are {set(self._alias_map.keys())}" - ) - if len(resolved) == 1: - return resolved[0] - return resolved - - @overload - def recall(self, id: int) -> dict[str, Any]: - pass - - @overload - def recall(self, id: list[int]) -> list[dict[str, Any]]: - pass - - def recall(self, id: int | list[int]) -> dict[str, Any] | list[dict[str, Any]]: - """Recover the original coordinates of an element given the node id(s) in the Network object. - - Parameters - ---------- - id : int | List[int] - Node id(s) in the generic network - - Returns - ------- - Dict[str, Any] | List[Dict[str, Any]] - Original coordinates. For single input returns dict, for multiple inputs returns list of dicts. - Dict contains coordinates: - - For nodes: 'node' key with node id - - For breakpoints: 'reach' and 'distance' keys with reach id and distance - - Raises - ------ - KeyError - If node id is not found in the network - ValueError - If node id string format is invalid - """ - if not isinstance(id, list): - id = [id] - - reverse_alias_map = {v: k for k, v in self._alias_map.items()} - - results: list[dict[str, Any]] = [] - for node_id in id: - if node_id not in reverse_alias_map: - raise KeyError(f"Node ID {node_id} not found in the network.") - - key = reverse_alias_map[node_id] - if isinstance(key, str): - results.append({"node": key}) - else: - results.append({"reach": key[0], "distance": key[1]}) - - if len(results) == 1: - return results[0] - else: - return results - - def copy(self) -> "Network": - """Create a deep copy of the Network. - - Returns - ------- - Network - Deep copy of the Network object - """ - return deepcopy(self) - - -def _make_basic_network(node_ids, time, data, quantity="WaterLevel"): - nodes = [ - BasicNode(nid, pd.DataFrame({quantity: data[:, i]}, index=time)) - for i, nid in enumerate(node_ids) - ] - reaches = [ - BasicReach(f"r{i}", nodes[i], nodes[i + 1], length=100.0) - for i in range(len(nodes) - 1) - ] - return Network(reaches) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index e06b79858..330617375 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -1,21 +1,33 @@ """ # Observations -ModelSkill supports four types of observations: +ModelSkill supports five types of observations: * [`PointObservation`](`modelskill.PointObservation`) - a point timeseries from a dfs0/nc file or a DataFrame * [`TrackObservation`](`modelskill.TrackObservation`) - a track (moving point) timeseries from a dfs0/nc file or a DataFrame * [`VerticalObservation`](`modelskill.VerticalObservation`) - a vertical profile from a dfs0/nc file or a DataFrame -* [`NodeObservation`](`modelskill.NodeObservation`) - a network node timeseries for specific node IDs. +* [`NodeObservation`](`modelskill.NodeObservation`) - a network node timeseries for a named node or break point. +* [`ReachObservation`](`modelskill.ReachObservation`) - a network reach timeseries for a quantity uniform along the reach. An observation can be created by explicitly invoking one of the above classes or using the [`observation()`](`modelskill.observation`) function which will return the appropriate type based on the input data (if possible). """ from __future__ import annotations -from typing import Literal, Any, Union, overload +import sqlite3 +from pathlib import Path +from typing import ( + Any, + Iterable, + Literal, + NamedTuple, + Sequence, + Union, + overload, +) from typing_extensions import Self import warnings +import numpy as np import pandas as pd import xarray as xr @@ -34,6 +46,10 @@ # NetCDF attributes can only be str, int, float https://unidata.github.io/netcdf4-python/#attributes-in-a-netcdf-file Serializable = Union[str, int, float] +# Where a node observation sits: the name the network gave the node, or a +# breakpoint given as (reach_id, distance) along a reach. +NodeLocation = Union[str, tuple[str, float]] + def observation( data: DataInputType, @@ -78,7 +94,7 @@ def observation( >>> import modelskill as ms >>> o_pt = ms.observation(df, item=0, x=366844, y=6154291, name="Klagshamn") >>> o_tr = ms.observation("lon_after_lat.dfs0", item="wl", x_item=1, y_item=0) - >>> o_node = ms.observation(df, item="Water Level", at=123, name="123") + >>> o_node = ms.observation(df, item="Water Level", at="123", name="123") >>> o_reach = ms.observation(df, item="Discharge", reach="reach_1", name="reach_1_Q") """ if gtype is None: @@ -113,6 +129,339 @@ def _guess_gtype(**kwargs) -> GeometryType: return GeometryType.POINT +def _item_names(data: Any) -> list[str]: + """Names of the individual timeseries held by an already-opened data source.""" + if isinstance(data, pd.DataFrame): + return [str(c) for c in data.columns] + if isinstance(data, xr.Dataset): + return [str(v) for v in data.data_vars] + if hasattr(data, "names"): # mikeio.Dataset + return [str(n) for n in data.names] + if hasattr(data, "name"): # pd.Series, mikeio.DataArray, xr.DataArray + return [str(data.name)] + raise ValueError( + f"Cannot determine item names from data of type {type(data).__name__}" + ) + + +class _Station(NamedTuple): + """One measured timeseries, resolved to the network location it belongs to.""" + + item_name: str #: name of the item in the data source + name: str #: display name for the observation + location: str | tuple[str, float] #: node name, or (reach, chainage) + kind: Literal["node", "reach"] #: which observation class fits + quantity: str #: modelled quantity name + + +class _MikePlusStationResolver: + """Resolves data source items to network locations, via a MIKE+ database. + + A MIKE+ project ships a sqlite database alongside its result files. Two of + its tables say where the measured timeseries belong in the network: + + * ``m_Measurement`` - one row per measured timeseries, naming the file + (``tsfilename``) and the item within it (``tsitemname``), plus the + modelled quantity (``resitemname``). + * ``m_Station`` - the location, as ``locationid`` plus a ``locationtype`` + saying whether that identifier names a node or a link. + + Everything MIKE+ specific is contained here - the table names, the join, the + ``locationtype`` codes, the encoding of ``resitemname`` - so a change to the + database layout is a change to this class alone. Callers see only + :class:`_Station`. + """ + + _TABLES: dict[str, set[str]] = { + "m_Station": { + "muid", + "locationid", + "locationtype", + "chainagevalue", + "assetname", + }, + "m_Measurement": { + "measurementstationid", + "tsfilename", + "tsitemname", + "resitemname", + }, + } + + # m_Station.locationtype codes. 8 is a junction and 12 a tank or reservoir; + # both are graph nodes. 9 is a link, which becomes a breakpoint when the + # station carries a chainage and a whole reach when it does not. Unknown + # codes raise rather than guess. + _NODE_TYPES = frozenset({8, 12}) + _LINK_TYPES = frozenset({9}) + + _QUERY = """ + SELECT m.tsitemname AS item_name, + m.tsfilename AS tsfilename, + m.resitemname AS resitemname, + s.assetname AS assetname, + s.locationid AS locationid, + s.locationtype AS locationtype, + s.chainagevalue AS chainagevalue + FROM m_Measurement m + JOIN m_Station s ON s.muid = m.measurementstationid + """ + + def __init__( + self, + db: str | Path | sqlite3.Connection, + *, + source: str | None = None, + ) -> None: + """Read the join, and the station names needed to explain a failure. + + ``db`` is a path or an already-open connection; an open one is left open. + ``source`` restricts the measurements to one result file, matched on file + name, so a full path is fine. Without it, measurements from every file + are considered and an item registered against two of them raises. + """ + self._source = source + + if isinstance(db, sqlite3.Connection): + conn, opened = db, None + else: + conn = opened = sqlite3.connect(str(db)) + try: + self._validate(conn) + + query, params = self._QUERY, [] + if source is not None: + query += " WHERE m.tsfilename LIKE ?" + params.append(f"%{Path(source).name}%") + rows = pd.read_sql_query(query, conn, params=params) + + # Read the station names now rather than on demand: the only other + # use is naming stations that carry no measurement, on the failure + # path, and reading them here is what lets the connection close. + self._assets = set( + pd.read_sql_query("SELECT assetname FROM m_Station", conn)["assetname"] + .dropna() + .tolist() + ) + finally: + if opened is not None: + opened.close() + + rows["quantity"] = rows["resitemname"].str.split(";").str[0].str.strip() + self._rows = rows + + def resolve( + self, + item_names: Iterable[str], + *, + quantity: str | None = None, + kind: Literal["node", "reach"] | None = None, + on_missing: Literal["raise", "skip"] = "raise", + ) -> list[_Station]: + """Resolve item names, e.g. the columns of a dfs0, to their locations. + + ``quantity`` selects one of several measured quantities; left None it is + inferred, and raises when the selection holds more than one. ``kind`` + restricts the result to nodes or to reaches. ``on_missing="skip"`` drops + items the database does not register, which otherwise raise. + """ + requested = list(dict.fromkeys(item_names)) + rows = self._rows[self._rows["item_name"].isin(requested)].copy() + + missing = [item for item in requested if item not in set(rows["item_name"])] + if missing and on_missing == "raise": + raise ValueError( + f"{len(missing)} of {len(requested)} items could not be resolved " + f"against the MIKE+ database.\n" + + self._unresolved_message(missing) + + '\n Pass on_missing="skip" to ignore these.' + ) + + if ambiguous := sorted( + rows.loc[rows.duplicated("item_name", keep=False), "item_name"].unique() + ): + raise ValueError( + f"Item(s) {ambiguous} are registered against more than one file. " + "Pass 'source' to say which file the data comes from." + ) + + if rows.empty: + raise ValueError("No items could be resolved against the MIKE+ database.") + + located = rows.apply(self._location, axis=1) + rows["kind"] = [k for k, _ in located] + rows["location"] = [location for _, location in located] + + if quantity is None: + pool = rows if kind is None else rows[rows["kind"] == kind] + available = sorted(pool["quantity"].unique()) + if len(available) == 0: + raise ValueError( + f"No {kind} locations found. Quantities present: " + f"{rows['quantity'].value_counts().to_dict()}." + ) + if len(available) > 1: + raise ValueError( + "Several quantities present, so 'quantity' cannot be inferred: " + f"{pool['quantity'].value_counts().to_dict()}. " + f"Pass one of {available}." + ) + quantity = available[0] + + selection = rows[rows["quantity"] == quantity] + if selection.empty: + raise ValueError( + f"Quantity {quantity!r} not found. Available: " + f"{rows['quantity'].value_counts().to_dict()}." + ) + + if kind is not None: + of_kind = selection[selection["kind"] == kind] + if of_kind.empty: + other = sorted(selection["kind"].unique()) + raise ValueError( + f"All {len(selection)} {quantity!r} station(s) are of kind " + f"{other}, not {kind!r}." + ) + selection = of_kind + + names = self._display_names(selection) + return [ + _Station( + item_name=str(row.item_name), + name=str(name), + location=row.location, + kind=row.kind, + quantity=str(row.quantity), + ) + for name, row in zip(names, selection.itertuples()) + ] + + def _validate(self, conn: sqlite3.Connection) -> None: + tables = { + row[0] + for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'") + } + if missing := sorted(set(self._TABLES) - tables): + raise ValueError( + f"Database is missing table(s) {missing}. " + "A MIKE+ database with 'm_Station' and 'm_Measurement' is required." + ) + for table, required in self._TABLES.items(): + columns = {row[1] for row in conn.execute(f"PRAGMA table_info([{table}])")} + if missing_cols := sorted(required - columns): + raise ValueError( + f"Table '{table}' is missing column(s) {missing_cols}. " + "The database layout is not the one modelskill expects." + ) + + def _location(self, row: pd.Series) -> tuple[str, str | tuple[str, float]]: + # A link station with a chainage names a point along a reach, which is a + # node observation at a breakpoint. Without a chainage it names the reach + # as a whole. + try: + location_type = int(row["locationtype"]) + except (TypeError, ValueError): + location_type = -1 + + location_id = str(row["locationid"]) + if location_type in self._NODE_TYPES: + return "node", location_id + if location_type in self._LINK_TYPES: + chainage = row["chainagevalue"] + if pd.isna(chainage): + return "reach", location_id + return "node", (location_id, float(chainage)) + + raise ValueError( + f"Station '{row['locationid']}' has unsupported locationtype " + f"{row['locationtype']!r}. Known codes are " + f"{sorted(self._NODE_TYPES | self._LINK_TYPES)}." + ) + + def _unresolved_message(self, missing: Sequence[str]) -> str: + known = [item for item in missing if item in self._assets] + unknown = [item for item in missing if item not in self._assets] + + lines = [] + if known: + where = f" for '{Path(self._source).name}'" if self._source else "" + lines.append( + f" Known station, no measurement registered{where} ({len(known)}):\n" + + "\n".join(f" {item}" for item in known) + ) + if unknown: + lines.append( + f" Not found in the database ({len(unknown)}):\n" + + "\n".join(f" {item}" for item in unknown) + ) + return "\n".join(lines) + + @staticmethod + def _display_names(selection: pd.DataFrame) -> pd.Series: + # assetname is far shorter than the raw item name and is normally unique, + # but it is only safe as a display name when it distinguishes every row. + assets = selection["assetname"] + if assets.notna().all() and assets.nunique() == len(selection): + return assets.astype(str) + return selection["item_name"].astype(str) + + +def _observations_from_mikeplus( + cls: type, + *, + data: PointType, + db: Any, + kind: Literal["node", "reach"], + location_arg: str, + quantity: Quantity | str | None, + source: str | None, + on_missing: Literal["raise", "skip"], + aux_items: list[int | str] | None, + attrs: dict | None, +) -> list[Any]: + """Build observations from a data source and a MIKE+ database.""" + from .timeseries._point import _open_and_name + + if source is None and isinstance(data, (str, Path)): + source = str(data) + + # Open once rather than per observation; a path would otherwise be re-read + # for every station in the database. + opened, _ = _open_and_name(data, None) + + given_quantity = quantity if isinstance(quantity, Quantity) else None + wanted = quantity.name if isinstance(quantity, Quantity) else quantity + + stations = _MikePlusStationResolver(db, source=source).resolve( + _item_names(opened), + quantity=wanted, + kind=kind, + on_missing=on_missing, + ) + + observations = [] + for station in stations: + obs = cls( + opened, + item=station.item_name, + name=station.name, + quantity=given_quantity, + aux_items=aux_items, + attrs=attrs, + **{location_arg: station.location}, + ) + if given_quantity is None: + # The database names the quantity; the data source knows its unit. + obs.quantity = Quantity( + name=station.quantity, + unit=obs.quantity.unit, + is_directional=obs.quantity.is_directional, + ) + observations.append(obs) + return observations + + def _validate_attrs(data_attrs: dict, attrs: dict | None) -> None: # See similar method in xarray https://github.com/pydata/xarray/blob/main/xarray/backends/api.py#L165 @@ -470,14 +819,13 @@ class NodeObservation(Observation): """Class for observations at network nodes. Create a NodeObservation from a DataFrame or other data source. - The ``at`` parameter accepts three forms: + The ``at`` parameter accepts two forms: + + * **str** — the node's name in the model (e.g. a Res1D node name). + * **tuple[str, float]** — a breakpoint, as ``(reach_id, distance)`` along a + reach. - * **int** — internal network ID, used directly. - * **str** — original node alias (e.g. Res1D node name), resolved to an - integer ID automatically when matched against a - :class:`~modelskill.model.network.NetworkModelResult`. - * **tuple[str, float]** — breakpoint location as ``(reach_id, distance)`` - along a reach, resolved via the alias map at match time. + Both are resolved against the network when the observation is matched. .. note:: "Node" in this API follows the broad graph sense: it covers both @@ -494,12 +842,11 @@ class NodeObservation(Observation): ---------- data : str, Path, mikeio.Dataset, mikeio.DataArray, pd.DataFrame, pd.Series, xr.Dataset or xr.DataArray data source with time series for the node - at : int, str, or tuple[str, float] + at : str or tuple[str, float] Observation location. Accepted forms: - * **int** — internal network ID. - * **str** — original node alias (e.g. Res1D node name). - * **tuple[str, float]** — breakpoint as ``(reach_id, distance)``. + * **str** — the node's name in the model (e.g. a Res1D node name). + * **tuple[str, float]** — a breakpoint, as ``(reach_id, distance)``. item : (int, str), optional index or name of the wanted item/column, by default None if data contains more than one item, item must be given @@ -517,8 +864,8 @@ class NodeObservation(Observation): Examples -------- >>> import modelskill as ms - >>> o1 = ms.NodeObservation(data, at=123, name="123") - >>> o2 = ms.NodeObservation(df, item="Water Level", at=456) + >>> o1 = ms.NodeObservation(data, at="123", name="123") + >>> o2 = ms.NodeObservation(df, item="Water Level", at="456") >>> >>> # String alias resolved at match time >>> o3 = ms.NodeObservation(data, at="node_A") @@ -527,14 +874,14 @@ class NodeObservation(Observation): >>> o4 = ms.NodeObservation(data, at=("reach_1", 24.5)) >>> >>> # Multiple node observations from separate data sources - >>> obs = ms.NodeObservation.from_multiple(nodes={123: df1, 456: df2}) + >>> obs = ms.NodeObservation.from_multiple(nodes={"123": df1, "456": df2}) """ def __init__( self, data: PointType, *, - at: int | str | tuple[str, float], + at: str | tuple[str, float], item: int | str | None = None, name: str | None = None, weight: float = 1.0, @@ -542,6 +889,12 @@ def __init__( aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> None: + if isinstance(at, (int, np.integer)) and not isinstance(at, bool): + raise TypeError( + "'at' takes a node name or a (reach, distance) pair, not an integer. " + "The integers a Network hands out are an internal index; " + "network.recall() gives the name back." + ) if isinstance(at, tuple): reach, distance = str(at[0]), float(at[1]) if not self._is_input_validated(data): @@ -568,14 +921,14 @@ def __init__( super().__init__(data=data, weight=weight, attrs=attrs) @property - def at(self) -> int | str | tuple[str, float]: - """Observation location: node ID (int/str) or breakpoint ``(reach_id, distance)`` tuple.""" + def at(self) -> str | tuple[str, float]: + """Observation location: a node name, or a ``(reach_id, distance)`` breakpoint.""" if "reach" in self.data.coords: return ( str(self.data.coords["reach"].item()), float(self.data.coords["distance"].item()), ) - return self.data.coords["node"].item() # int or str + return str(self.data.coords["node"].item()) def _create_new_instance(self, data: xr.Dataset) -> Self: """Reconstruct instance from a dataset slice.""" @@ -587,7 +940,7 @@ def _create_new_instance(self, data: xr.Dataset) -> Self: float(data.coords["distance"].item()), ), ) - return self.__class__(data, at=data.coords["node"].item()) + return self.__class__(data, at=str(data.coords["node"].item())) @overload @classmethod @@ -595,7 +948,7 @@ def from_multiple( cls, *, data: PointType, - nodes: dict[int, str | int], + nodes: dict[NodeLocation, str | int], quantity: Quantity | None = None, aux_items: list[int | str] | None = None, attrs: dict | None = None, @@ -606,20 +959,37 @@ def from_multiple( def from_multiple( cls, *, - nodes: dict[int, PointType], + nodes: dict[NodeLocation, PointType], quantity: Quantity | None = None, aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> list[NodeObservation]: pass + @overload + @classmethod + def from_multiple( + cls, + *, + data: PointType, + db: str | Path | Any, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[NodeObservation]: ... + @classmethod def from_multiple( cls, *, data: PointType | None = None, - nodes: dict[int, Any] | None = None, - quantity: Quantity | None = None, + nodes: dict[NodeLocation, Any] | None = None, + db: str | Path | Any | None = None, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> list[NodeObservation]: @@ -630,22 +1000,49 @@ def from_multiple( 1. **Separate data sources** — pass only ``nodes`` as a dict mapping each node ID to its own data source (file path, DataFrame, etc.):: - obs = NodeObservation.from_multiple(nodes={123: df1, 456: "sensor.csv"}) + obs = NodeObservation.from_multiple(nodes={"123": df1, "456": "sensor.csv"}) 2. **Shared data source** — pass a single ``data`` object together with ``nodes`` as a dict mapping each node ID to the column name or index to select from ``data``:: - obs = NodeObservation.from_multiple(data=df, nodes={123: "col_a", 456: "col_b"}) + obs = NodeObservation.from_multiple(data=df, nodes={"123": "col_a", "456": "col_b"}) + + 3. **MIKE+ database** — pass a single ``data`` object together with + ``db``, and the locations are looked up in the database:: + + obs = NodeObservation.from_multiple(data="calib.dfs0", db="model.sqlite") + + One observation is created per item of ``data`` that the database + places on a node, so several sensors at the same node are all kept. Parameters ---------- data : PointType, optional - Shared data source (required when ``nodes`` values are column selectors). - nodes : dict[int, PointType | str | int] - Mapping of node_id -> data source or column selector. - quantity : Quantity | None, optional - Physical quantity metadata, by default None. + Shared data source (required when ``nodes`` values are column + selectors, and when ``db`` is given). + nodes : dict[str | tuple[str, float], PointType | str | int] + Mapping of location -> data source or column selector. A location + takes either of the forms accepted by ``at``: a node name, or a + ``(reach_id, distance)`` breakpoint. + + Note that a location can appear only once, so this form cannot + express several observations at the same node. Use ``db`` when the + data has several sensors at one location. + db : str, Path or sqlite3.Connection, optional + MIKE+ database locating the items of ``data`` in the network. + Mutually exclusive with ``nodes``. + quantity : Quantity or str, optional + Physical quantity metadata, by default None. With ``db``, a string + selects which quantity to build observations for and the metadata + comes from the database; omit it and the quantity is inferred when + the data holds only one. + source : str, optional + With ``db``, the file the items come from. Taken from ``data`` when + that is a path, by default None. + on_missing : {"raise", "skip"}, optional + With ``db``, what to do with items the database cannot place, by + default "raise". aux_items : list[int | str] | None, optional Auxiliary items, by default None. attrs : dict | None, optional @@ -655,7 +1052,39 @@ def from_multiple( ------- list[NodeObservation] List of NodeObservation objects. + + Raises + ------ + ValueError + If both ``nodes`` and ``db`` are given, if neither is, or if the + database cannot resolve the requested items. """ + if db is not None: + if nodes is not None: + raise ValueError( + "'nodes' and 'db' are mutually exclusive: the database " + "supplies the locations." + ) + if data is None: + raise ValueError("'data' is required when 'db' is given") + return _observations_from_mikeplus( + cls, + data=data, + db=db, + kind="node", + location_arg="at", + quantity=quantity, + source=source, + on_missing=on_missing, + aux_items=aux_items, + attrs=attrs, + ) + + if isinstance(quantity, str): + raise TypeError( + "'quantity' must be a Quantity unless 'db' is given, got str" + ) + if nodes is None: raise ValueError("'nodes' argument is required") if not isinstance(nodes, dict): @@ -764,6 +1193,183 @@ def _create_new_instance(self, data: xr.Dataset) -> Self: """Reconstruct instance from a dataset slice.""" return self.__class__(data, reach=str(data.coords["reach"].item())) + @overload + @classmethod + def from_multiple( + cls, + *, + data: PointType, + reaches: dict[str, str | int], + quantity: Quantity | None = None, + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: ... + + @overload + @classmethod + def from_multiple( + cls, + *, + reaches: dict[str, PointType], + quantity: Quantity | None = None, + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: + pass + + @overload + @classmethod + def from_multiple( + cls, + *, + data: PointType, + db: str | Path | Any, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: ... + + @classmethod + def from_multiple( + cls, + *, + data: PointType | None = None, + reaches: dict[str, Any] | None = None, + db: str | Path | Any | None = None, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: + """Create multiple ReachObservation objects. + + Two calling conventions are supported: + + 1. **Separate data sources** — pass only ``reaches`` as a dict mapping + each reach ID to its own data source (file path, DataFrame, etc.):: + + obs = ReachObservation.from_multiple(reaches={"r1": df1, "r2": "sensor.csv"}) + + 2. **Shared data source** — pass a single ``data`` object together with + ``reaches`` as a dict mapping each reach ID to the column name or + index to select from ``data``:: + + obs = ReachObservation.from_multiple(data=df, reaches={"r1": "col_a", "r2": "col_b"}) + + 3. **MIKE+ database** — pass a single ``data`` object together with + ``db``, and the reaches are looked up in the database:: + + obs = ReachObservation.from_multiple(data="calib.dfs0", db="model.sqlite") + + One observation is created per item of ``data`` that the database + places on a link without a chainage. + + Parameters + ---------- + data : PointType, optional + Shared data source (required when ``reaches`` values are column + selectors, and when ``db`` is given). + reaches : dict[str, PointType | str | int] + Mapping of reach_id -> data source or column selector. + + Note that a reach can appear only once, so this form cannot express + several observations on the same reach. Use ``db`` when the data has + several sensors on one reach. + db : str, Path or sqlite3.Connection, optional + MIKE+ database locating the items of ``data`` in the network. + Mutually exclusive with ``reaches``. + quantity : Quantity or str, optional + Physical quantity metadata, by default None. With ``db``, a string + selects which quantity to build observations for and the metadata + comes from the database; omit it and the quantity is inferred when + the data holds only one. + source : str, optional + With ``db``, the file the items come from. Taken from ``data`` when + that is a path, by default None. + on_missing : {"raise", "skip"}, optional + With ``db``, what to do with items the database cannot place, by + default "raise". + aux_items : list[int | str] | None, optional + Auxiliary items, by default None. + attrs : dict | None, optional + Additional attributes, by default None. + + Returns + ------- + list[ReachObservation] + List of ReachObservation objects. + + Raises + ------ + ValueError + If both ``reaches`` and ``db`` are given, if neither is, or if the + database cannot resolve the requested items. + """ + if db is not None: + if reaches is not None: + raise ValueError( + "'reaches' and 'db' are mutually exclusive: the database " + "supplies the locations." + ) + if data is None: + raise ValueError("'data' is required when 'db' is given") + return _observations_from_mikeplus( + cls, + data=data, + db=db, + kind="reach", + location_arg="reach", + quantity=quantity, + source=source, + on_missing=on_missing, + aux_items=aux_items, + attrs=attrs, + ) + + if isinstance(quantity, str): + raise TypeError( + "'quantity' must be a Quantity unless 'db' is given, got str" + ) + + if reaches is None: + raise ValueError("'reaches' argument is required") + if not isinstance(reaches, dict): + raise TypeError( + f"'reaches' must be a dict mapping reach_id -> data_source, got {type(reaches).__name__}" + ) + + reach_ids = list(reaches.keys()) + + if data is None: + data_sources: list[PointType] = list(reaches.values()) + return [ + cls( + data_i, + reach=reach_i, + item=None, + quantity=quantity, + aux_items=aux_items, + attrs=attrs, + ) + for data_i, reach_i in zip(data_sources, reach_ids) + ] + else: + reach_items: list[int | str | None] = list(reaches.values()) + return [ + cls( + data, + reach=reach_i, + item=item_i, + quantity=quantity, + aux_items=aux_items, + attrs=attrs, + ) + for reach_i, item_i in zip(reach_ids, reach_items) + ] + def unit_display_name(name: str) -> str: """Display name diff --git a/src/modelskill/timeseries/_coords.py b/src/modelskill/timeseries/_coords.py index 98304befa..ea768f4ce 100644 --- a/src/modelskill/timeseries/_coords.py +++ b/src/modelskill/timeseries/_coords.py @@ -1,4 +1,37 @@ +from __future__ import annotations + +from typing import Any + import numpy as np +import xarray as xr + +#: Scalar coordinates that say where a network timeseries sits, rather than what +#: it holds. They are dropped on the way to a dataframe, where they would +#: otherwise become columns. +NETWORK_LOCATION_COORDS = ("node", "node_index", "reach", "distance") + + +def location_from_coords(ds: xr.Dataset) -> Any: + """Where a network timeseries sits, as the network that produced it named it. + + Returns a node name for a node, a ``(reach, distance)`` pair for a + breakpoint, a reach name when no distance was given, and None for data that + carries no network location. The value is returned as recorded, so a comparer + saved by an older version gives back the integer it stored. + """ + if "node" in ds.coords: + return _scalar(ds, "node") + if "reach" in ds.coords: + reach = _scalar(ds, "reach") + if "distance" not in ds.coords: + return reach + return (reach, _scalar(ds, "distance")) + return None + + +def _scalar(ds: xr.Dataset, name: str) -> Any: + value = np.atleast_1d(ds.coords[name].values)[0] + return value.item() if hasattr(value, "item") else value class XYZCoords: @@ -18,7 +51,7 @@ def as_dict(self) -> dict: class NodeCoords: - def __init__(self, node: int | str | None = None): + def __init__(self, node: str | None = None): self.node = node if node is not None else np.nan @property diff --git a/src/modelskill/timeseries/_point.py b/src/modelskill/timeseries/_point.py index f0742f4dc..38d3bedb0 100644 --- a/src/modelskill/timeseries/_point.py +++ b/src/modelskill/timeseries/_point.py @@ -286,7 +286,7 @@ def _parse_network_node_input( name: str | None, item: str | int | None, quantity: Quantity | None, - node: int | str | None, + node: str | None, aux_items: Sequence[int | str] | None, ) -> xr.Dataset: if node is None: diff --git a/src/modelskill/timeseries/_timeseries.py b/src/modelskill/timeseries/_timeseries.py index bba5d78f7..4bec9abcd 100644 --- a/src/modelskill/timeseries/_timeseries.py +++ b/src/modelskill/timeseries/_timeseries.py @@ -10,6 +10,7 @@ from ..types import GeometryType from ..quantity import Quantity +from ._coords import NETWORK_LOCATION_COORDS from ._plotter import TimeSeriesPlotter, MatplotlibTimeSeriesPlotter from .. import __version__ @@ -366,10 +367,12 @@ def to_dataframe(self) -> pd.DataFrame: return df[cols] elif self.gtype == str(GeometryType.VERTICAL): return self.data.drop_vars(["x", "y"]).to_dataframe() - elif self.gtype == str(GeometryType.NODE): - return self.data.drop_vars(["node"]).to_dataframe() - elif self.gtype == str(GeometryType.REACH): - return self.data.drop_vars(["reach"]).to_dataframe() + elif self.gtype in (str(GeometryType.NODE), str(GeometryType.REACH)): + # A breakpoint carries reach and distance rather than node, so drop + # whichever of them this one has. + return self.data.drop_vars( + NETWORK_LOCATION_COORDS, errors="ignore" + ).to_dataframe() else: raise NotImplementedError(f"Unknown gtype: {self.gtype}") diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index bdf4aa807..8edd71129 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -454,9 +454,9 @@ def test_save_and_load_preserves_raw_model_data(cc, tmp_path): @pytest.fixture def node_comparer() -> modelskill.comparison.Comparer: """A comparer built by matching a NodeObservation against a NetworkModelResult (node gtype).""" - pytest.importorskip("networkx") + pytest.importorskip("mikeio1d.network") + from mikeio1d.network import Network, BasicNode, BasicReach from modelskill.model.network import NetworkModelResult - from modelskill.network import Network, BasicNode, BasicReach from modelskill.obs import NodeObservation time = pd.date_range("2019-01-01", periods=6, freq="D") @@ -472,8 +472,50 @@ def node_comparer() -> modelskill.comparison.Comparer: network = Network([reach]) nmr = NetworkModelResult(network, name="Network_Model") - node_id = network.find(node="123") - obs = NodeObservation(node_a_data, at=node_id, name="Node_123_Obs") + obs = NodeObservation(node_a_data, at="123", name="Node_123_Obs") + + return ms.match(obs, nmr) + + +@pytest.fixture +def reach_comparer() -> modelskill.comparison.Comparer: + """A comparer built by matching a ReachObservation (reach gtype).""" + pytest.importorskip("mikeio1d.network") + from mikeio1d.network import ( + Network, + BasicNode, + BasicReach, + ReachBreakPoint, + ) + from modelskill.model.network import NetworkModelResult + from modelskill.obs import ReachObservation + + class Point(ReachBreakPoint): + def __init__(self, reach, distance, data): + self._id = (reach, distance) + self._data = data + + @property + def id(self): + return self._id + + @property + def data(self): + return self._data + + time = pd.date_range("2019-01-01", periods=6, freq="D") + values = pd.DataFrame({"WaterLevel": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}, index=time) + empty = pd.DataFrame() + reach = BasicReach( + "r1", + BasicNode("123", empty), + BasicNode("456", empty), + length=100.0, + breakpoints=[Point("r1", 50.0, values)], + ) + + nmr = NetworkModelResult(Network([reach]), name="Network_Model") + obs = ReachObservation(values, reach="r1", name="Reach_r1_Obs") return ms.match(obs, nmr) @@ -490,6 +532,44 @@ def test_save_and_load_round_trips_node_gtype_raw_data(node_comparer, tmp_path): assert len(cc2[0].raw_mod_data["Network_Model"]) == len( node_comparer.raw_mod_data["Network_Model"] ) + # The node was addressed by name, and the name is what comes back: reloading + # must not depend on the integer the network happened to hand out. + assert cc2[0].node == "123" + assert cc2[0].raw_mod_data["Network_Model"].node == "123" + + +def test_a_comparer_saved_by_1_4_0a3_still_loads(): + """The alpha wrote the graph integer into the node coordinate. + + Nothing on the load path derives a location from it any more, so such a file + keeps working -- it just gives the integer back. Needs no mikeio1d: it is a + netcdf file, not a network. + """ + cmp = ms.load("tests/testdata/node_comparer_1.4.0a3.nc") + + assert cmp.gtype == "node" + assert cmp.node == 0 + assert cmp.skill().to_dataframe().shape[0] == 1 + + # Turning it back into an observation is where the integer is refused, since + # NodeObservation no longer accepts one. + with pytest.raises(TypeError, match="not an integer"): + cmp._to_observation() + + +def test_save_and_load_round_trips_reach_gtype_raw_data(reach_comparer, tmp_path): + """Reach-gtype comparers must survive a save()/load() round trip too.""" + cc = ms.ComparerCollection([reach_comparer]) + fn = tmp_path / "test_cc_reach.msk" + cc.save(fn) + + cc2 = ms.load(fn) + + assert cc2[0].gtype == "reach" + assert cc2[0].reach == "r1" + assert len(cc2[0].raw_mod_data["Network_Model"]) == len( + reach_comparer.raw_mod_data["Network_Model"] + ) # ======================== plotting ======================== diff --git a/tests/test_match.py b/tests/test_match.py index 3324f4788..781a8642e 100644 --- a/tests/test_match.py +++ b/tests/test_match.py @@ -7,10 +7,21 @@ import modelskill as ms from modelskill.comparison._comparison import ItemSelection from modelskill.model.dfsu import DfsuModelResult -try: - from modelskill.network import _make_basic_network -except ImportError: - pass + + +def _make_basic_network(node_ids, time, data, quantity="WaterLevel"): + """A chain of nodes, each carrying one quantity, joined by unit reaches.""" + from mikeio1d.network import Network, BasicNode, BasicReach + + nodes = [ + BasicNode(node_id, pd.DataFrame({quantity: data[:, i]}, index=time)) + for i, node_id in enumerate(node_ids) + ] + reaches = [ + BasicReach(f"r{i}", nodes[i], nodes[i + 1], length=100.0) + for i in range(len(nodes) - 1) + ] + return Network(reaches) @pytest.fixture @@ -366,7 +377,7 @@ def network_mr(network): @pytest.fixture def node_obs1(network): """NodeObservation for node '100'""" - node_id = network.find(node="100") + node_id = "100" time = pd.date_range("2017-10-27", periods=18, freq="h") # Add some noise to make it different from model np.random.seed(123) @@ -378,7 +389,7 @@ def node_obs1(network): @pytest.fixture def node_obs2(network): """NodeObservation for node '200'""" - node_id = network.find(node="200") + node_id = "200" time = pd.date_range("2017-10-27", periods=15, freq="h") np.random.seed(456) data = np.random.normal(1.6, 0.25, len(time)) @@ -392,7 +403,7 @@ def node_obs_invalid(network): time = pd.date_range("2017-10-27", periods=10, freq="h") data = np.random.normal(1.5, 0.2, len(time)) df = pd.DataFrame({"WaterLevel": data}, index=time) - return ms.NodeObservation(df, at=999, name="Node_999_Obs") + return ms.NodeObservation(df, at="999", name="Node_999_Obs") @pytest.fixture @@ -410,7 +421,7 @@ def network_mr2(network2): @pytest.fixture def node_obs_gaps(network): """NodeObservation with time gaps""" - node_id = network.find(node="100") + node_id = "100" time = pd.date_range("2017-10-27", periods=10, freq="2h") # Different frequency data = np.random.normal(1.5, 0.2, len(time)) df = pd.DataFrame({"WaterLevel": data}, index=time) @@ -1027,7 +1038,7 @@ def test_match_node_obs_with_multiple_network_models( def test_match_network_invalid_node_error(node_obs_invalid, network_mr): - with pytest.raises(ValueError, match="Node 999 not found"): + with pytest.raises(ValueError, match="not found"): ms.match(node_obs_invalid, network_mr) @@ -1064,7 +1075,8 @@ def test_network_match_multi_obs_multi_model_comprehensive( def test_network_match_error_non_node_observation(network_mr, point_obs_error): """Test that non-NodeObservation raises appropriate error""" with pytest.raises( - TypeError, match="NetworkModelResult supports NodeObservation and ReachObservation" + TypeError, + match="NetworkModelResult supports NodeObservation and ReachObservation", ): ms.match(point_obs_error, network_mr) diff --git a/tests/test_mikeplus.py b/tests/test_mikeplus.py new file mode 100644 index 000000000..1169033dc --- /dev/null +++ b/tests/test_mikeplus.py @@ -0,0 +1,478 @@ +import sqlite3 + +import numpy as np +import pandas as pd +import pytest + +from modelskill.obs import NodeObservation, ReachObservation + +STATION_COLUMNS = [ + "muid", + "locationid", + "locationtype", + "chainagevalue", + "assetname", +] +MEASUREMENT_COLUMNS = [ + "measurementstationid", + "tsfilename", + "tsitemname", + "resitemname", +] + +JUNCTION = 8 +LINK = 9 +TANK = 12 + + +def station(muid, locationid, locationtype, assetname, chainagevalue=None): + return dict( + muid=muid, + locationid=locationid, + locationtype=locationtype, + chainagevalue=chainagevalue, + assetname=assetname, + ) + + +def measurement(station_muid, item, quantity, file="calib.dfs0"): + return dict( + measurementstationid=station_muid, + tsfilename=rf"..\Scripts\{file}", + tsitemname=item, + resitemname=f"{quantity};{quantity};100450", + ) + + +def build_db(path, stations, measurements, *, station_columns=STATION_COLUMNS): + conn = sqlite3.connect(str(path)) + pd.DataFrame(stations, columns=station_columns).to_sql( + "m_Station", conn, index=False + ) + pd.DataFrame(measurements, columns=MEASUREMENT_COLUMNS).to_sql( + "m_Measurement", conn, index=False + ) + conn.commit() + conn.close() + return str(path) + + +@pytest.fixture +def db(tmp_path): + """Two pressure sensors on nodes, one flow meter on a link.""" + stations = [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "Tank_A", TANK, "LT.410"), + station("s3", "Pipe_7", LINK, "FT.403"), + ] + measurements = [ + measurement("s1", "item_pressure_1", "Pressure"), + measurement("s2", "item_pressure_2", "Pressure"), + measurement("s3", "item_flow_1", "Flow"), + ] + return build_db(tmp_path / "mikeplus.sqlite", stations, measurements) + + +def frame(*items): + """A data source holding one timeseries per named item.""" + time = pd.date_range("2024-01-01", periods=24, freq="h") + rng = np.random.default_rng(42) + return pd.DataFrame( + {item: rng.normal(35.0, 1.0, len(time)) for item in items}, index=time + ) + + +def test_junction_and_tank_resolve_to_nodes(db): + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "item_pressure_2"), db=db, quantity="Pressure" + ) + + assert {obs.at for obs in obs_list} == {"wNode_1", "Tank_A"} + + +def test_link_without_chainage_resolves_to_a_reach(db): + (obs,) = ReachObservation.from_multiple( + data=frame("item_flow_1"), db=db, quantity="Flow" + ) + + assert obs.reach == "Pipe_7" + + +def test_link_with_chainage_resolves_to_a_breakpoint(tmp_path): + path = build_db( + tmp_path / "chainage.sqlite", + [station("s1", "Pipe_7", LINK, "FT.403", chainagevalue=24.5)], + [measurement("s1", "item_flow_1", "Flow")], + ) + + (obs,) = NodeObservation.from_multiple( + data=frame("item_flow_1"), db=path, quantity="Flow" + ) + + assert obs.at == ("Pipe_7", 24.5) + + +def test_several_items_at_one_location_all_survive(tmp_path): + path = build_db( + tmp_path / "shared.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "wNode_1", JUNCTION, "PT.402"), + ], + [ + measurement("s1", "before_valve", "Pressure"), + measurement("s2", "after_valve", "Pressure"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("before_valve", "after_valve"), db=path, quantity="Pressure" + ) + + assert [obs.name for obs in obs_list] == ["PT.401", "PT.402"] + assert {obs.at for obs in obs_list} == {"wNode_1"} + + +def test_name_falls_back_to_item_name_when_assetnames_collide(tmp_path): + path = build_db( + tmp_path / "collide.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "same"), + station("s2", "wNode_2", JUNCTION, "same"), + ], + [ + measurement("s1", "item_a", "Pressure"), + measurement("s2", "item_b", "Pressure"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a", "item_b"), db=path, quantity="Pressure" + ) + + assert [obs.name for obs in obs_list] == ["item_a", "item_b"] + + +def test_quantity_is_inferred_when_unambiguous(db): + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "item_pressure_2"), db=db + ) + + assert {obs.quantity.name for obs in obs_list} == {"Pressure"} + + +def test_ambiguous_quantity_raises_and_lists_options(tmp_path): + path = build_db( + tmp_path / "two_quantities.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "wNode_2", JUNCTION, "LT.410"), + ], + [ + measurement("s1", "item_pressure", "Pressure"), + measurement("s2", "item_level", "Water Level"), + ], + ) + + with pytest.raises(ValueError, match="cannot be inferred") as excinfo: + NodeObservation.from_multiple( + data=frame("item_pressure", "item_level"), db=path + ) + + assert "Pressure" in str(excinfo.value) + assert "Water Level" in str(excinfo.value) + + +def test_the_observation_kind_narrows_the_pool_used_for_inference(db): + # The database holds pressure on two nodes and flow on a reach. Asking for + # node observations leaves only one quantity, so it needs no naming. + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "item_pressure_2", "item_flow_1"), db=db + ) + + assert {obs.quantity.name for obs in obs_list} == {"Pressure"} + assert len(obs_list) == 2 + + +def test_unknown_quantity_raises(db): + with pytest.raises(ValueError, match="not found"): + NodeObservation.from_multiple( + data=frame("item_pressure_1"), db=db, quantity="Discharge" + ) + + +def test_asking_for_a_node_when_the_station_is_a_reach_raises(db): + with pytest.raises(ValueError, match="not 'node'"): + NodeObservation.from_multiple(data=frame("item_flow_1"), db=db, quantity="Flow") + + +def test_missing_items_raise_and_separate_the_two_causes(db): + with pytest.raises(ValueError) as excinfo: + NodeObservation.from_multiple( + data=frame("item_pressure_1", "PT.401", "never_heard_of_it"), + db=db, + quantity="Pressure", + ) + + message = str(excinfo.value) + assert "no measurement registered" in message + assert "PT.401" in message + assert "Not found in the database" in message + assert "never_heard_of_it" in message + + +def test_missing_items_can_be_skipped(db): + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "never_heard_of_it"), + db=db, + quantity="Pressure", + on_missing="skip", + ) + + assert [obs.name for obs in obs_list] == ["PT.401"] + + +def test_source_selects_between_files(tmp_path): + path = build_db( + tmp_path / "files.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [ + measurement("s1", "item_a", "Pressure", file="main.dfs0"), + measurement("s1", "item_a", "Pressure", file="other.dfs0"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure", source="main.dfs0" + ) + + assert len(obs_list) == 1 + + +def test_source_accepts_a_full_path(tmp_path): + path = build_db( + tmp_path / "fullpath.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [measurement("s1", "item_a", "Pressure", file="main.dfs0")], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a"), + db=path, + quantity="Pressure", + source="/some/where/main.dfs0", + ) + + assert len(obs_list) == 1 + + +def test_item_registered_against_several_files_raises_without_source(tmp_path): + path = build_db( + tmp_path / "ambiguous.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [ + measurement("s1", "item_a", "Pressure", file="main.dfs0"), + measurement("s1", "item_a", "Pressure", file="other.dfs0"), + ], + ) + + with pytest.raises(ValueError, match="more than one file"): + NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure" + ) + + +def test_unknown_locationtype_raises(tmp_path): + path = build_db( + tmp_path / "weird.sqlite", + [station("s1", "wNode_1", 99, "PT.401")], + [measurement("s1", "item_a", "Pressure")], + ) + + with pytest.raises(ValueError, match="unsupported locationtype"): + NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure" + ) + + +def test_accepts_an_open_connection(db): + conn = sqlite3.connect(db) + try: + (obs,) = ReachObservation.from_multiple( + data=frame("item_flow_1"), db=conn, quantity="Flow" + ) + finally: + conn.close() + + assert obs.reach == "Pipe_7" + + +def test_missing_table_raises(tmp_path): + path = str(tmp_path / "empty.sqlite") + conn = sqlite3.connect(path) + pd.DataFrame({"a": [1]}).to_sql("something_else", conn, index=False) + conn.close() + + with pytest.raises(ValueError, match="missing table"): + NodeObservation.from_multiple(data=frame("item_a"), db=path) + + +def test_missing_column_raises(tmp_path): + path = build_db( + tmp_path / "thin.sqlite", + [ + dict(muid="s1", locationid="wNode_1", locationtype=JUNCTION, assetname="a"), + ], + [measurement("s1", "item_a", "Pressure")], + station_columns=["muid", "locationid", "locationtype", "assetname"], + ) + + with pytest.raises(ValueError, match="missing column"): + NodeObservation.from_multiple(data=frame("item_a"), db=path) + + +@pytest.fixture +def calibration_data(): + """A data source holding both pressure and flow items.""" + time = pd.date_range("2024-01-01", periods=24, freq="h") + rng = np.random.default_rng(42) + return pd.DataFrame( + { + "item_pressure_1": rng.normal(35.0, 1.0, len(time)), + "item_pressure_2": rng.normal(36.0, 1.0, len(time)), + "item_flow_1": rng.normal(120.0, 5.0, len(time)), + }, + index=time, + ) + + +class TestNodeObservationFromDatabase: + def test_builds_one_observation_per_item(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + assert len(obs_list) == 2 + assert all(isinstance(obs, NodeObservation) for obs in obs_list) + assert [obs.at for obs in obs_list] == ["wNode_1", "Tank_A"] + + def test_names_come_from_the_database(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + assert [obs.name for obs in obs_list] == ["PT.401", "LT.410"] + + def test_quantity_comes_from_the_database(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + assert all(obs.quantity.name == "Pressure" for obs in obs_list) + + def test_data_is_selected_per_item(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + expected = calibration_data["item_pressure_1"].to_numpy() + assert obs_list[0].values == pytest.approx(expected) + + def test_quantity_is_inferred_when_only_nodes_are_wanted( + self, db, calibration_data + ): + obs_list = NodeObservation.from_multiple(data=calibration_data, db=db) + + assert len(obs_list) == 2 + assert all(obs.quantity.name == "Pressure" for obs in obs_list) + + def test_several_sensors_at_one_node_are_all_kept(self, tmp_path): + path = build_db( + tmp_path / "shared.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "wNode_1", JUNCTION, "PT.402"), + ], + [ + measurement("s1", "before_valve", "Pressure"), + measurement("s2", "after_valve", "Pressure"), + ], + ) + time = pd.date_range("2024-01-01", periods=5, freq="h") + data = pd.DataFrame( + {"before_valve": range(5), "after_valve": range(5, 10)}, index=time + ) + + obs_list = NodeObservation.from_multiple(data=data, db=path) + + assert [obs.at for obs in obs_list] == ["wNode_1", "wNode_1"] + assert [obs.name for obs in obs_list] == ["PT.401", "PT.402"] + + def test_flow_on_a_link_points_at_reach_observation(self, db, calibration_data): + with pytest.raises(ValueError, match="not 'node'"): + NodeObservation.from_multiple(data=calibration_data, db=db, quantity="Flow") + + def test_unresolvable_item_raises(self, db, calibration_data): + data = calibration_data.rename(columns={"item_pressure_1": "mystery_sensor"}) + + with pytest.raises(ValueError, match="could not be resolved"): + NodeObservation.from_multiple(data=data, db=db, quantity="Pressure") + + def test_unresolvable_item_can_be_skipped(self, db, calibration_data): + data = calibration_data.rename(columns={"item_pressure_1": "mystery_sensor"}) + + obs_list = NodeObservation.from_multiple( + data=data, db=db, quantity="Pressure", on_missing="skip" + ) + + assert [obs.name for obs in obs_list] == ["LT.410"] + + def test_db_and_nodes_are_mutually_exclusive(self, db, calibration_data): + with pytest.raises(ValueError, match="mutually exclusive"): + NodeObservation.from_multiple( + data=calibration_data, db=db, nodes={1: "item_pressure_1"} + ) + + def test_db_without_data_raises(self, db): + with pytest.raises(ValueError, match="'data' is required"): + NodeObservation.from_multiple(db=db) + + def test_quantity_string_without_db_raises(self, calibration_data): + with pytest.raises(TypeError, match="must be a Quantity"): + NodeObservation.from_multiple( + data=calibration_data, + nodes={1: "item_pressure_1"}, + quantity="Pressure", + ) + + +class TestReachObservationFromDatabase: + def test_builds_reach_observations(self, db, calibration_data): + obs_list = ReachObservation.from_multiple( + data=calibration_data, db=db, quantity="Flow" + ) + + assert len(obs_list) == 1 + assert isinstance(obs_list[0], ReachObservation) + assert obs_list[0].reach == "Pipe_7" + assert obs_list[0].name == "FT.403" + assert obs_list[0].quantity.name == "Flow" + + def test_quantity_is_inferred_when_only_reaches_are_wanted( + self, db, calibration_data + ): + obs_list = ReachObservation.from_multiple(data=calibration_data, db=db) + + assert [obs.reach for obs in obs_list] == ["Pipe_7"] + + def test_pressure_on_a_node_points_at_node_observation(self, db, calibration_data): + with pytest.raises(ValueError, match="not 'reach'"): + ReachObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + def test_db_and_reaches_are_mutually_exclusive(self, db, calibration_data): + with pytest.raises(ValueError, match="mutually exclusive"): + ReachObservation.from_multiple( + data=calibration_data, db=db, reaches={"r1": "item_flow_1"} + ) diff --git a/tests/test_network.py b/tests/test_network.py index a41fc997b..83822d03b 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -2,39 +2,39 @@ # ruff: noqa: E402 import sys -from pathlib import Path import pytest -pytest.importorskip("networkx") +pytest.importorskip("mikeio1d.network") import pandas as pd import xarray as xr import numpy as np import modelskill as ms +from mikeio1d.network import Network, BasicNode, BasicReach, ReachBreakPoint from modelskill.model.network import ( NetworkModelResult, NodeModelResult, ) -from modelskill.model.adapters._inp import read_pipe_lengths, read_sections -from modelskill.model.adapters._res1d import ( - Res1DNode, - Res1DReach, - _simplify_colnames, -) -from modelskill.network import ( - Network, - BasicNode, - BasicReach, - NetworkReach, - ReachBreakPoint, - _EPANET_EXTENSIONS, - _MIKE_EXTENSIONS, - _UNSUPPORTED_EXTENSIONS, -) -from modelskill.obs import NodeObservation +from modelskill.obs import NodeObservation, ReachObservation from modelskill.quantity import Quantity +class BreakPoint(ReachBreakPoint): + """A break point at a known distance along a reach.""" + + def __init__(self, reach, distance, data): + self._id = (reach, distance) + self._data = data + + @property + def id(self): + return self._id + + @property + def data(self): + return self._data + + def _make_network(node_ids, time, data, quantity="WaterLevel"): nodes = [ BasicNode(nid, pd.DataFrame({quantity: data[:, i]}, index=time)) @@ -123,6 +123,23 @@ def dataset_without_node(): return ds +@pytest.fixture +def breakpoint_network(): + """A one-reach network whose data sits on a break point, not on the nodes.""" + time = pd.date_range("2010-01-01", periods=10, freq="h") + np.random.seed(42) + values = pd.DataFrame({"WaterLevel": np.random.randn(10)}, index=time) + empty = pd.DataFrame() + reach = BasicReach( + "r1", + BasicNode("start", empty), + BasicNode("end", empty), + length=100.0, + breakpoints=[BreakPoint("r1", 50.0, values)], + ) + return Network([reach]) + + @pytest.fixture def sample_node_data(): """Sample node observation data""" @@ -154,6 +171,36 @@ def test_init_with_network(self, sample_network): assert isinstance(nmr.time, pd.DatetimeIndex) assert len(nmr.nodes) == 3 + def test_quantity_name_survives_to_the_model_result(self, sample_network): + """The network knows its quantity by name even without a unit.""" + nmr = NetworkModelResult(sample_network) + + assert nmr.quantity.name == "WaterLevel" + assert nmr.quantity != Quantity.undefined() + + def test_quantity_carries_into_extracted_node(self, sample_network): + nmr = NetworkModelResult(sample_network) + obs_data = pd.DataFrame({"sensor": np.zeros(len(nmr.time))}, index=nmr.time) + extracted = nmr.extract(NodeObservation(obs_data, at="123")) + + assert extracted.quantity.name == "WaterLevel" + + def test_explicit_quantity_wins(self, sample_network): + given = Quantity(name="Water Level", unit="meter") + nmr = NetworkModelResult(sample_network, quantity=given) + + assert nmr.quantity == given + + def test_unit_is_used_when_the_data_carries_one(self, sample_network): + network = sample_network.copy() + ds = network.to_dataset() + ds["WaterLevel"].attrs["units"] = "meter" + network.to_dataset = lambda: ds # type: ignore[method-assign] + + nmr = NetworkModelResult(network) + + assert nmr.quantity == Quantity(name="WaterLevel", unit="meter") + def test_init_with_name(self, sample_network): """Test initialization with explicit name""" nmr = NetworkModelResult(sample_network, name="Test_Network") @@ -185,7 +232,7 @@ def test_repr(self, sample_network): def test_extract_valid_node(self, sample_network, sample_node_data): """Test extraction of a valid node""" nmr = NetworkModelResult(sample_network) - node_id = sample_network.find(node="123") + node_id = "123" obs = NodeObservation(sample_node_data, at=node_id, name="Node_123") extracted = nmr.extract(obs) @@ -197,9 +244,9 @@ def test_extract_valid_node(self, sample_network, sample_node_data): def test_extract_invalid_node(self, sample_network, sample_node_data): """Test extraction of a node not present in the network""" nmr = NetworkModelResult(sample_network) - obs = NodeObservation(sample_node_data, at=999, name="Node_999") + obs = NodeObservation(sample_node_data, at="999", name="Node_999") - with pytest.raises(ValueError, match="Node 999 not found"): + with pytest.raises(ValueError, match="not found"): nmr.extract(obs) def test_extract_wrong_observation_type(self, sample_network): @@ -236,26 +283,26 @@ def test_init_with_df(self, sample_node_data): """Test initialization with pandas DataFrame""" obs = NodeObservation( - sample_node_data, at=123, name="Sensor_1", item="WaterLevel" + sample_node_data, at="123", name="Sensor_1", item="WaterLevel" ) - assert obs.at == 123 + assert obs.at == "123" assert obs.name == "Sensor_1" assert len(obs.time) == 10 assert isinstance(obs.time, pd.DatetimeIndex) def test_init_with_series(self, sample_series): """Test initialization with pandas Series""" - obs = NodeObservation(sample_series, at=456, name="Node_456") + obs = NodeObservation(sample_series, at="456", name="Node_456") - assert obs.at == 456 + assert obs.at == "456" assert obs.name == "Node_456" assert len(obs.time) == 10 def test_node_attrs(self, sample_node_data): """Test attrs property""" attrs = {"source": "test", "version": "1.0"} - obs = NodeObservation(sample_node_data, at=123, attrs=attrs, weight=2.5) + obs = NodeObservation(sample_node_data, at="123", attrs=attrs, weight=2.5) assert obs.attrs["source"] == "test" assert obs.attrs["version"] == "1.0" @@ -266,7 +313,7 @@ def test_multiple_nodes_returns_list_of_observations(self, multi_data): """Test that from_multiple returns a list of NodeObservation objects""" obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={123: "station_0", 456: "station_1", 789: "station_2"}, + nodes={"123": "station_0", "456": "station_1", "789": "station_2"}, ) assert len(obs_list) == 3 @@ -275,17 +322,17 @@ def test_multiple_nodes_returns_list_of_observations(self, multi_data): def test_node_ids_are_assigned_correctly(self, multi_data): obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={123: "station_0", 456: "station_1", 789: "station_2"}, + nodes={"123": "station_0", "456": "station_1", "789": "station_2"}, ) - assert obs_list[0].node == 123 - assert obs_list[1].node == 456 - assert obs_list[2].node == 789 + assert obs_list[0].node == "123" + assert obs_list[1].node == "456" + assert obs_list[2].node == "789" def test_names_derived_from_column_names(self, multi_data): obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={123: "station_0", 456: "station_1", 789: "station_2"}, + nodes={"123": "station_0", "456": "station_1", "789": "station_2"}, ) assert obs_list[0].name == "station_0" @@ -301,12 +348,12 @@ def test_from_xarray_dataset(self, sample_node_data): coords={"time": sample_node_data.index}, ) obs_list = NodeObservation.from_multiple( - data=ds, nodes={123: "station_0", 456: "station_1"} + data=ds, nodes={"123": "station_0", "456": "station_1"} ) assert len(obs_list) == 2 - assert obs_list[0].node == 123 - assert obs_list[1].node == 456 + assert obs_list[0].node == "123" + assert obs_list[1].node == "456" def test_nodes_must_be_dict(self, multi_data): with pytest.raises(TypeError, match="'nodes' must be a dict"): @@ -316,7 +363,7 @@ def test_attrs_propagated_to_all_observations(self, multi_data): attrs = {"source": "sensor_array", "version": 2} obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={1: "station_0", 2: "station_1", 3: "station_2"}, + nodes={"1": "station_0", "2": "station_1", "3": "station_2"}, attrs=attrs, ) @@ -326,38 +373,38 @@ def test_attrs_propagated_to_all_observations(self, multi_data): def test_init_from_csv(self): obs = NodeObservation( - "tests/testdata/network_sensor_1.csv", at=1, item="water_level@sens1" + "tests/testdata/network_sensor_1.csv", at="1", item="water_level@sens1" ) - assert obs.at == 1 + assert obs.at == "1" assert len(obs.time) == 110 assert isinstance(obs.time, pd.DatetimeIndex) def test_from_multiple_csvs_via_dict(self): obs_list = NodeObservation.from_multiple( nodes={ - 1: "tests/testdata/network_sensor_1.csv", - 2: "tests/testdata/network_sensor_2.csv", - 3: "tests/testdata/network_sensor_3.csv", + "1": "tests/testdata/network_sensor_1.csv", + "2": "tests/testdata/network_sensor_2.csv", + "3": "tests/testdata/network_sensor_3.csv", } ) assert len(obs_list) == 3 assert all(isinstance(obs, NodeObservation) for obs in obs_list) - assert obs_list[0].node == 1 - assert obs_list[1].node == 2 - assert obs_list[2].node == 3 + assert obs_list[0].node == "1" + assert obs_list[1].node == "2" + assert obs_list[2].node == "3" for obs in obs_list: assert len(obs.time) > 0 def test_nodes_dict_maps_node_to_item(self, multi_data): obs_list = NodeObservation.from_multiple( - data=multi_data, nodes={123: "station_0", 456: "station_1"} + data=multi_data, nodes={"123": "station_0", "456": "station_1"} ) assert len(obs_list) == 2 - assert obs_list[0].node == 123 - assert obs_list[1].node == 456 + assert obs_list[0].node == "123" + assert obs_list[1].node == "456" assert obs_list[0].name == "station_0" assert obs_list[1].name == "station_1" @@ -367,12 +414,77 @@ def test_nodes_none_raises(self, multi_data): def test_single_node_dict(self, sample_node_data): obs_list = NodeObservation.from_multiple( - data=sample_node_data, nodes={123: "WaterLevel"} + data=sample_node_data, nodes={"123": "WaterLevel"} ) assert len(obs_list) == 1 assert isinstance(obs_list[0], NodeObservation) - assert obs_list[0].node == 123 + assert obs_list[0].node == "123" + + def test_nodes_keys_accept_aliases(self, multi_data): + obs_list = NodeObservation.from_multiple( + data=multi_data, nodes={"node_A": "station_0", "node_B": "station_1"} + ) + + assert [obs.at for obs in obs_list] == ["node_A", "node_B"] + + def test_nodes_keys_accept_breakpoints(self, multi_data): + obs_list = NodeObservation.from_multiple( + data=multi_data, + nodes={("reach_1", 24.5): "station_0", ("reach_1", 50.0): "station_1"}, + ) + + assert [obs.at for obs in obs_list] == [("reach_1", 24.5), ("reach_1", 50.0)] + + +class TestReachObservationFromMultiple: + @pytest.fixture + def multi_data(self, sample_node_data): + return pd.DataFrame( + { + "station_0": sample_node_data["WaterLevel"].values, + "station_1": sample_node_data["WaterLevel"].values + 0.1, + }, + index=sample_node_data.index, + ) + + def test_returns_list_of_reach_observations(self, multi_data): + obs_list = ReachObservation.from_multiple( + data=multi_data, reaches={"reach_1": "station_0", "reach_2": "station_1"} + ) + + assert len(obs_list) == 2 + assert all(isinstance(obs, ReachObservation) for obs in obs_list) + assert [obs.reach for obs in obs_list] == ["reach_1", "reach_2"] + assert [obs.name for obs in obs_list] == ["station_0", "station_1"] + + def test_separate_data_sources(self): + obs_list = ReachObservation.from_multiple( + reaches={ + "reach_1": "tests/testdata/network_sensor_1.csv", + "reach_2": "tests/testdata/network_sensor_2.csv", + } + ) + + assert [obs.reach for obs in obs_list] == ["reach_1", "reach_2"] + assert all(len(obs.time) > 0 for obs in obs_list) + + def test_attrs_propagated(self, multi_data): + obs_list = ReachObservation.from_multiple( + data=multi_data, + reaches={"reach_1": "station_0"}, + attrs={"source": "sensor_array"}, + ) + + assert obs_list[0].attrs["source"] == "sensor_array" + + def test_reaches_none_raises(self, multi_data): + with pytest.raises(ValueError, match="'reaches' argument is required"): + ReachObservation.from_multiple(data=multi_data, reaches=None) + + def test_reaches_must_be_dict(self, multi_data): + with pytest.raises(TypeError, match="'reaches' must be a dict"): + ReachObservation.from_multiple(data=multi_data, reaches="reach_1") class TestNodeModelResult: @@ -382,9 +494,9 @@ class TestNodeModelResult: def test_init_(self, request, fixture_name): """Test initialization with pandas DataFrame""" data = request.getfixturevalue(fixture_name) - nmr = NodeModelResult(data, node=123, name="Node_123_Model") + nmr = NodeModelResult(data, node="123", name="Node_123_Model") - assert nmr.node == 123 + assert nmr.node == "123" assert nmr.name == "Node_123_Model" assert len(nmr.time) == 10 @@ -395,7 +507,7 @@ class TestNetworkIntegration: def test_network_to_node_extraction(self, sample_network, sample_node_data): """Test complete workflow from network model to node extraction""" nmr = NetworkModelResult(sample_network, name="Network_Model") - node_id = sample_network.find(node="123") + node_id = "123" obs = NodeObservation(sample_node_data, at=node_id, name="Node_123_Obs") extracted = nmr.extract(obs) @@ -408,7 +520,7 @@ def test_network_to_node_extraction(self, sample_network, sample_node_data): def test_matching_workflow(self, sample_network, sample_node_data): """Test matching workflow with network data""" nmr = NetworkModelResult(sample_network, name="Network_Model") - node_id = sample_network.find(node="123") + node_id = "123" obs = NodeObservation(sample_node_data, at=node_id, name="Node_123_Obs") comparer = ms.match(obs, nmr) @@ -429,9 +541,9 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data } ) - node_0 = sample_network.find(node="123") - node_1 = sample_network.find(node="456") - node_2 = sample_network.find(node="789") + node_0 = "123" + node_1 = "456" + node_2 = "789" # Create multiple NodeObservations using .from_multiple obs_list = NodeObservation.from_multiple( @@ -453,10 +565,11 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data @pytest.mark.skipif( sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" ) -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 +def test_a_model_result_can_be_built_from_a_result_file(): + mr = NetworkModelResult("./tests/testdata/network.res1d", item="WaterLevel") + + assert mr.quantity.name == "WaterLevel" + assert len(mr.nodes) > 0 @pytest.mark.skipif( @@ -464,7 +577,7 @@ def test_open_res1d(): ) def test_extract_reach_observation_happy_path(sample_node_data): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file) + network = Network.open(path_to_file) nmr = NetworkModelResult(network, item="Discharge", name="network_model") obs_data = sample_node_data.rename(columns={"WaterLevel": "Discharge"}) obs = ms.ReachObservation(obs_data, reach="100l1", item="Discharge") @@ -473,7 +586,8 @@ def test_extract_reach_observation_happy_path(sample_node_data): assert isinstance(extracted, NodeModelResult) assert extracted.name == "network_model" - assert extracted.node in nmr.nodes + reach, _ = extracted.node + assert reach == "100l1" @pytest.mark.skipif( @@ -481,7 +595,7 @@ def test_extract_reach_observation_happy_path(sample_node_data): ) def test_extract_reach_observation_non_equivalent_breakpoints_raises(sample_node_data): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file) + network = Network.open(path_to_file) nmr = NetworkModelResult(network, item="Discharge") obs_data = sample_node_data.rename(columns={"WaterLevel": "Discharge"}) obs = ms.ReachObservation(obs_data, reach="113l1", item="Discharge") @@ -497,7 +611,7 @@ def test_extract_reach_observation_with_reaches_not_populated_raises_valueerror( sample_node_data, ): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file, reaches=[]) + network = Network.open(path_to_file, reaches=[]) nmr = NetworkModelResult(network, item="WaterLevel") obs = ms.ReachObservation(sample_node_data, reach="100l1", item="WaterLevel") @@ -512,17 +626,13 @@ def test_extract_reach_observation_breakpoint_node_missing_raises_valueerror( sample_node_data, ): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file) + network = Network.open(path_to_file) nmr = NetworkModelResult(network, item="Discharge") obs_data = sample_node_data.rename(columns={"WaterLevel": "Discharge"}) - baseline_obs = ms.ReachObservation(obs_data, reach="100l1", item="Discharge") - node_id = nmr.extract(baseline_obs).node - remaining_nodes = [] - for node in nmr.data.node.values: - node_int = int(node) - if node_int != node_id: - remaining_nodes.append(node_int) - nmr.data = nmr.data.sel(node=remaining_nodes) + on_reach = set(nmr.data.node.values[nmr.data["reach"].values == "100l1"]) + nmr.data = nmr.data.sel( + node=[int(node) for node in nmr.data.node.values if node not in on_reach] + ) obs = ms.ReachObservation(obs_data, reach="100l1", item="Discharge") @@ -530,315 +640,13 @@ def test_extract_reach_observation_breakpoint_node_missing_raises_valueerror( nmr.extract(obs) -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_nodes_filter_creates_full_network(): - """When nodes is specified, the full network topology is created.""" - path_to_file = "./tests/testdata/network.res1d" - full_network = Network.from_mike(path_to_file) - - selected_nodes = ["1", "108"] - partial_network = Network.from_mike(path_to_file, nodes=selected_nodes) - - # Full topology is preserved - assert ( - partial_network.graph.number_of_nodes() == full_network.graph.number_of_nodes() - ) - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_nodes_filter_only_selected_have_data(): - """When nodes is specified, only selected nodes contain non-empty data.""" - path_to_file = "./tests/testdata/network.res1d" - - selected_nodes = ["1", "108"] - network = Network.from_mike(path_to_file, nodes=selected_nodes, reaches=[]) - g = network.graph.copy() - - n_nodes = network.graph.number_of_nodes() - assert sum([g.nodes[n]["data"].empty for n in g.nodes]) == n_nodes - 2 - for n in selected_nodes: - assert not g.nodes[network.find(n)]["data"].empty - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_nodes_single_string(): - """nodes argument accepts a single string (not just a list).""" - path_to_file = "./tests/testdata/network.res1d" - full_network = Network.from_mike(path_to_file) - - network = Network.from_mike(path_to_file, nodes="108", reaches=[]) - g = network.graph.copy() - - assert g.number_of_nodes() == full_network.graph.number_of_nodes() - - nodes_with_data = [n for n in g.nodes if not g.nodes[n]["data"].empty] - nodes_with_data = [network.recall(n)["node"] for n in nodes_with_data] - assert nodes_with_data == ["108"] - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_dataframe_from_partial_network(): - """nodes argument accepts a single string (not just a list).""" - path_to_file = "./tests/testdata/network.res1d" - selected_nodes = ["108", "101"] - network = Network.from_mike(path_to_file, nodes=selected_nodes, reaches=[]) - nodes_in_df = network.to_dataframe().droplevel(axis=1, level=1).columns - - assert set(nodes_in_df) == set([network.find(n) for n in selected_nodes]) - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_nodes_filtered_network_keeps_datetime_index(): - """Topology-only nodes must not degrade the time index to object dtype. - - A nodes-filtered network keeps the full topology, storing empty data for - the unselected nodes. Concatenating those empty (RangeIndex) frames must - not corrupt the DatetimeIndex, otherwise ms.match() later fails with - "time must be datetime". - """ - path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file, nodes=["108", "101"], reaches=[]) - - assert isinstance(network._df.index, pd.DatetimeIndex) - assert network._df.index.dtype == "datetime64[ns]" - assert network.to_dataset()["time"].dtype == np.dtype("datetime64[ns]") - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_res1d_empty_nodes_and_reaches_keeps_topology_and_empty_outputs(): - path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file, nodes=["108", "101"], reaches=[]) - - assert isinstance(network._df.index, pd.DatetimeIndex) - assert network._df.index.dtype == "datetime64[ns]" - assert network.to_dataset()["time"].dtype == np.dtype("datetime64[ns]") - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_empty_nodes_and_reaches_keeps_topology_and_empty_outputs(): - path_to_file = "./tests/testdata/network.res1d" - full_network = Network.from_mike(path_to_file) - network = Network.from_mike(path_to_file, nodes=[], reaches=[]) - - assert network.graph.number_of_nodes() == full_network.graph.number_of_nodes() - - df = network.to_dataframe() - assert df.empty - assert isinstance(df.columns, pd.MultiIndex) - assert df.columns.names == ["node", "quantity"] - assert df.index.name == "time" - - ds = network.to_dataset() - assert isinstance(ds, xr.Dataset) - assert len(ds.data_vars) == 0 - - -# --------------------------------------------------------------------------- -# Optional reach length -# --------------------------------------------------------------------------- - - -class _StubBreakPoint(ReachBreakPoint): - """Minimal concrete ReachBreakPoint for building reaches by hand.""" - - def __init__(self, reach_id, distance, data=None): - self._id = (reach_id, distance) - self._data = pd.DataFrame() if data is None else data - - @property - def id(self): - return self._id - - @property - def data(self): - return self._data - - -def _two_node_pair(): - time = pd.date_range("2020", periods=3, freq="h") - df = pd.DataFrame({"WaterLevel": [1.0, 1.1, 1.2]}, index=time) - return BasicNode("a", df), BasicNode("b", df.copy()) - - -class TestOptionalReachLength: - """Reach length is undefined in some domains, so it must be omittable.""" - - def test_subclass_may_omit_length(self): - class LengthlessReach(NetworkReach): - def __init__(self, id, start, end): - self._id, self._start, self._end = id, start, end - - @property - def id(self): - return self._id - - @property - def start(self): - return self._start - - @property - def end(self): - return self._end - - @property - def breakpoints(self): - return [] - - a, b = _two_node_pair() - reach = LengthlessReach("r1", a, b) - - assert reach.length is None - assert Network([reach]).graph.number_of_nodes() == 2 - - def test_basic_reach_length_defaults_to_none(self): - a, b = _two_node_pair() - - assert BasicReach("r1", a, b).length is None - - def test_edge_length_is_none_when_undefined(self): - a, b = _two_node_pair() - - network = Network([BasicReach("r1", a, b)]) - - assert [d["length"] for *_, d in network.graph.edges(data=True)] == [None] - - def test_breakpoint_distances_survive_an_undefined_length(self): - """Only the final segment needs the total, so the rest keep real lengths.""" - a, b = _two_node_pair() - breakpoints = [_StubBreakPoint("r1", d) for d in (30.0, 70.0)] - - network = Network([BasicReach("r1", a, b, breakpoints=breakpoints)]) - - lengths = sorted( - (d["length"] for *_, d in network.graph.edges(data=True)), - key=lambda v: (v is None, v), - ) - assert lengths == [30.0, 40.0, None] - - def test_length_weighted_algorithms_fail_loudly(self): - """Storing None keeps networkx honest. - - Omitting the attribute instead would let networkx default the weight to - 1, so every call below would return a plausible but meaningless number. - With None, shortest-path treats the edge as hidden and the arithmetic - consumers raise. - """ - import networkx as nx - - a, b = _two_node_pair() - g = Network([BasicReach("r1", a, b)]).graph - - with pytest.raises(nx.NetworkXNoPath): - nx.shortest_path_length(g, 0, 1, weight="length") - - with pytest.raises(TypeError): - g.size(weight="length") - - def test_known_length_is_unchanged(self): - a, b = _two_node_pair() - breakpoints = [_StubBreakPoint("r1", 40.0)] - - network = Network([BasicReach("r1", a, b, 100.0, breakpoints)]) - - assert sorted(d["length"] for *_, d in network.graph.edges(data=True)) == [ - 40.0, - 60.0, - ] - - -# --------------------------------------------------------------------------- -# Which extensions each constructor accepts, and why the rest are refused -# --------------------------------------------------------------------------- - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -class TestExtensionPolicy: - @pytest.mark.parametrize("suffix", [".res1d", ".res11", ".RES1D"]) - def test_from_mike_accepts_mike_extensions(self, tmp_path, suffix): - """The file does not exist, so mikeio1d - not the guard - is what complains.""" - with pytest.raises((FileExistsError, FileNotFoundError)): - Network.from_mike(tmp_path / f"network{suffix}") - - def test_error_lists_only_readable_extensions(self): - with pytest.raises(NotImplementedError) as excinfo: - Network.from_mike("network.nc") - - message = str(excinfo.value) - for extension in _MIKE_EXTENSIONS | _EPANET_EXTENSIONS: - assert extension in message - for extension in _UNSUPPORTED_EXTENSIONS: - assert extension not in message - - def test_swmm_refusal_names_the_companion_inp(self): - """A real file, so this fails the day SWMM support lands.""" - with pytest.raises(NotImplementedError, match=r"companion '\.inp'"): - Network.from_mike("./tests/testdata/swmm.out") - - def test_resx_refusal_points_at_the_resx_argument(self): - """'.resx' is a companion, so the message must name what to do instead.""" - with pytest.raises( - NotImplementedError, match=r"from_epanet\(res, resx=\.\.\.\)" - ): - Network.from_mike("./tests/testdata/epanet.resx") - - @pytest.mark.parametrize("suffix", [".prf", ".crf", ".xrf", ".whr"]) - def test_formats_without_a_fixture_are_refused(self, tmp_path, suffix): - with pytest.raises(NotImplementedError, match="no test fixture"): - Network.from_mike(tmp_path / f"network{suffix}") - - def test_every_mikeio1d_extension_is_accounted_for(self): - """A new mikeio1d format must be read or explicitly refused, never ignored.""" - from mikeio1d import Res1D - - accounted_for = ( - _MIKE_EXTENSIONS | _EPANET_EXTENSIONS | set(_UNSUPPORTED_EXTENSIONS) - ) - - assert accounted_for == Res1D.get_supported_file_extensions() - - def test_res1d_opened_with_a_path_is_refused(self): - """mikeio1d calls str.endswith on file_path, so a Path breaks it later on.""" - from mikeio1d import Res1D - - res = Res1D(Path("./tests/testdata/network.res1d")) - - with pytest.raises(TypeError, match="file_path"): - Network.from_mike(res) - - -# --------------------------------------------------------------------------- -# NodeObservation — alias / breakpoint node forms -# --------------------------------------------------------------------------- - - class TestNodeObservationAliases: - """NodeObservation accepts int, str alias, and (reach, distance) tuple.""" - - def test_integer_node_unchanged(self, sample_node_data): - obs = NodeObservation(sample_node_data, at=42) - assert obs.at == 42 - assert isinstance(obs.at, int) + """NodeObservation accepts a node name or a (reach, distance) tuple.""" - def test_integer_node_coord(self, sample_node_data): - obs = NodeObservation(sample_node_data, at=42) - assert "node" in obs.data.coords - assert int(obs.data.coords["node"].item()) == 42 + @pytest.mark.parametrize("at", [42, np.int64(42)]) + def test_an_integer_is_refused(self, sample_node_data, at): + with pytest.raises(TypeError, match="not an integer"): + NodeObservation(sample_node_data, at=at) def test_string_alias_stored(self, sample_node_data): obs = NodeObservation(sample_node_data, at="node_A", name="test") @@ -891,107 +699,74 @@ def test_string_roundtrip_via_create_new_instance(self, sample_node_data): class TestNetworkModelResultAliasResolution: - """NetworkModelResult.extract() resolves str and tuple aliases via alias_map.""" + """extract() resolves a node name or a (reach, distance) pair to a location.""" - def test_network_stored(self, sample_network): + def test_the_network_is_kept_as_given(self, sample_network): nmr = NetworkModelResult(sample_network) - assert hasattr(nmr, "network") - assert "123" in nmr.network._alias_map - assert "456" in nmr.network._alias_map - assert "789" in nmr.network._alias_map + + assert nmr.network is sample_network def test_extract_with_string_alias(self, sample_network, sample_node_data): nmr = NetworkModelResult(sample_network) obs = NodeObservation(sample_node_data, at="123", name="Node_123") + extracted = nmr.extract(obs) - expected_id = sample_network.find(node="123") + assert isinstance(extracted, NodeModelResult) - assert extracted.node == expected_id + assert extracted.node == "123" def test_extract_string_alias_wrong_key_raises( self, sample_network, sample_node_data ): nmr = NetworkModelResult(sample_network) obs = NodeObservation(sample_node_data, at="nonexistent_node") + with pytest.raises(ValueError, match="not found"): nmr.extract(obs) - def test_extract_with_tuple_breakpoint(self, sample_network, sample_node_data): - """Tuple alias is resolved via _alias_map (mapping injected for this test).""" - nmr = NetworkModelResult(sample_network) - existing_int = int(sample_network.find(node="123")) - nmr.network._alias_map[("reach_test", 10.0)] = existing_int - obs = NodeObservation(sample_node_data, at=("reach_test", 10.0)) - extracted = nmr.extract(obs) - assert extracted.node == existing_int - - def test_extract_with_tuple_breakpoint_tolerance( + def test_a_failed_lookup_names_the_near_misses( self, sample_network, sample_node_data ): nmr = NetworkModelResult(sample_network) - existing_int = int(sample_network.find(node="123")) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - nmr.network._alias_map[("reach_test", base_distance)] = existing_int - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol / 2) - ) - extracted = nmr.extract(obs) - assert extracted.node == existing_int + obs = NodeObservation(sample_node_data, at="124") - def test_extract_with_tuple_breakpoint_outside_tolerance_raises( - self, sample_network, sample_node_data - ): - nmr = NetworkModelResult(sample_network) - existing_int = int(sample_network.find(node="123")) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - nmr.network._alias_map[("reach_test", base_distance)] = existing_int - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol + 1e-4) - ) - with pytest.raises(ValueError, match="not found"): + with pytest.raises(ValueError, match="123"): nmr.extract(obs) - def test_extract_with_tuple_breakpoint_uses_closest_within_tolerance( - self, sample_network, sample_node_data - ): - nmr = NetworkModelResult(sample_network) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - node_a = int(sample_network.find(node="123")) - node_b = int(sample_network.find(node="456")) - nmr.network._alias_map[("reach_test", base_distance + 2e-4)] = node_a - nmr.network._alias_map[("reach_test", base_distance + 8e-4)] = node_b + def test_extract_with_tuple_breakpoint(self, breakpoint_network, sample_node_data): + nmr = NetworkModelResult(breakpoint_network) + obs = NodeObservation(sample_node_data, at=("r1", 50.0)) - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol * 0.6) - ) extracted = nmr.extract(obs) - assert extracted.node == node_b - def test_extract_with_tuple_breakpoint_tie_uses_smallest_node_id( - self, sample_network, sample_node_data + assert extracted.node == ("r1", 50.0) + + def test_extract_with_tuple_breakpoint_tolerance( + self, breakpoint_network, sample_node_data ): - nmr = NetworkModelResult(sample_network) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - node_a = int(sample_network.find(node="123")) - node_b = int(sample_network.find(node="456")) - nmr.network._alias_map[("reach_test", base_distance + 4e-4)] = node_a - nmr.network._alias_map[("reach_test", base_distance + 8e-4)] = node_b + nmr = NetworkModelResult(breakpoint_network) + obs = NodeObservation(sample_node_data, at=("r1", 50.0 + 5e-4)) - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol * 0.6) - ) extracted = nmr.extract(obs) - assert extracted.node == min(node_a, node_b) + + # The distance recorded is the network's own, not the one typed. + assert extracted.node == ("r1", 50.0) + + def test_extract_with_tuple_breakpoint_outside_tolerance_raises( + self, breakpoint_network, sample_node_data + ): + nmr = NetworkModelResult(breakpoint_network) + obs = NodeObservation(sample_node_data, at=("r1", 50.0 + 2e-3)) + + with pytest.raises(ValueError, match="not found"): + nmr.extract(obs) def test_extract_tuple_alias_wrong_key_raises( self, sample_network, sample_node_data ): nmr = NetworkModelResult(sample_network) obs = NodeObservation(sample_node_data, at=("nonexistent_reach", 0.0)) + with pytest.raises(ValueError, match="not found"): nmr.extract(obs) @@ -999,416 +774,41 @@ def test_match_with_string_alias(self, sample_network, sample_node_data): """Full ms.match() workflow works end-to-end with a string alias.""" nmr = NetworkModelResult(sample_network, name="Network_Model") obs = NodeObservation(sample_node_data, at="123", name="Node_123") + comparer = ms.match(obs, nmr) + assert comparer.n_points > 0 assert "Network_Model" in comparer.mod_names -# --------------------------------------------------------------------------- -# Res1D adapter — no mikeio1d required, the adapter is duck-typed -# --------------------------------------------------------------------------- - - -class _StubLocation: - """Stands in for a mikeio1d ResultNode / ResultGridPoint.""" - - def __init__(self, quantities, df=None): - self.quantities = quantities - self._df = df +# ======================== location identity ======================== - def to_dataframe(self): - if self._df is None: - raise AssertionError("to_dataframe() should not be called") - return self._df +class TestLocationIdentity: + """A network timeseries is identified by the name its network gave it.""" -class TestSimplifyColnames: - def test_location_without_quantities_gives_empty_frame(self): - """MIKE 11 keeps its data on gridpoints, leaving nodes with no quantities.""" - df = _simplify_colnames(_StubLocation(quantities=[])) + def test_breakpoint_observation_converts_to_a_dataframe(self, sample_node_data): + obs = ms.NodeObservation(sample_node_data, at=("r1", 24.5), item="WaterLevel") - assert df.empty - assert list(df.columns) == [] - - def test_quantity_columns_are_stripped_of_location_suffix(self): - time = pd.date_range("2020", periods=2, freq="h") - raw = pd.DataFrame({"WaterLevel:node_1": [1.0, 2.0]}, index=time) - - df = _simplify_colnames(_StubLocation(quantities=["WaterLevel"], df=raw)) + df = obs.to_dataframe() assert list(df.columns) == ["WaterLevel"] + assert len(df) == len(sample_node_data) + def test_reach_observation_converts_to_a_dataframe(self, sample_node_data): + obs = ms.ReachObservation(sample_node_data, reach="r1", item="WaterLevel") -class _StubReach: - """Stands in for a mikeio1d ResultReach.""" - - def __init__(self, name="r1", start_node="a", end_node="b", length=100.0): - self.name = name - self.start_node = start_node - self.end_node = end_node - self.length = length - self.gridpoints = [] - - -class TestRes1DReachConnectivity: - """Formats that expose no reach connectivity must fail with a clear message.""" - - @pytest.mark.parametrize("missing", ["start_node", "end_node"]) - def test_missing_node_raises(self, missing): - reach = _StubReach(**{missing: None}) - - with pytest.raises(ValueError, match="no start/end node for reach 'r1'"): - Res1DReach(reach, Res1DNode("a"), Res1DNode("b")) - - def test_both_nodes_missing_raises(self): - """.resx reports None for both, which the identity checks alone would allow.""" - reach = _StubReach(start_node=None, end_node=None) - - with pytest.raises(ValueError, match="no start/end node"): - Res1DReach(reach, Res1DNode(None), Res1DNode(None)) # type: ignore[arg-type] - - def test_mismatched_start_node_still_raises(self): - with pytest.raises(ValueError, match="Incorrect starting node"): - Res1DReach(_StubReach(), Res1DNode("wrong"), Res1DNode("b")) - - -class TestRes1DReachLength: - """mikeio1d returns 0 when it cannot read a length; that is not a real zero.""" - - @pytest.mark.parametrize("reported", [0, 0.0]) - def test_zero_becomes_undefined(self, reported): - reach = Res1DReach(_StubReach(length=reported), Res1DNode("a"), Res1DNode("b")) - - assert reach.length is None - - def test_real_length_passes_through(self): - reach = Res1DReach(_StubReach(length=47.5), Res1DNode("a"), Res1DNode("b")) - - assert reach.length == 47.5 - - -# --------------------------------------------------------------------------- -# from_mike / from_epanet -# --------------------------------------------------------------------------- - -requires_mikeio1d = pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) - - -@requires_mikeio1d -class TestFromMike: - def test_res1d(self): - network = Network.from_mike("./tests/testdata/network.res1d") - - assert network.graph.number_of_nodes() == 259 - - 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 - assert set(network.quantities) == {"Discharge", "Water Level"} - assert [r.n_breakpoints for r in network._reaches.values()] == [23, 21, 23] - - def test_res11_reaches_have_real_lengths(self): - network = Network.from_mike("./tests/testdata/network_cali.res11") + df = obs.to_dataframe() - lengths = [d["length"] for *_, d in network.graph.edges(data=True)] - assert all(length > 0 for length in lengths) - - def test_open_res1d_object(self): - from mikeio1d import Res1D - - res = Res1D("./tests/testdata/network.res1d") - - network = Network.from_mike(res, nodes=[], reaches=[]) - - assert network.graph.number_of_nodes() == 259 - - def test_epanet_file_is_redirected(self): - with pytest.raises(ValueError, match=r"Use Network\.from_epanet\(\)"): - Network.from_mike("./tests/testdata/epanet.res") - - def test_unknown_extension(self): - with pytest.raises(NotImplementedError, match="Unsupported file extension"): - Network.from_mike("./tests/testdata/obs.dfs0") - - def test_unsupported_type(self): - with pytest.raises(TypeError, match="Expected a str, Path or Res1D object"): - Network.from_mike(42) # type: ignore[arg-type] - - -@requires_mikeio1d -class TestFromEpanet: - def test_epanet(self): - network = Network.from_epanet("./tests/testdata/epanet.res") - - assert network.graph.number_of_nodes() == 11 - assert len(network._reaches) == 13 - assert set(network.quantities) == { - "Demand", - "Head", - "Pressure", - "WaterQuality", - } - assert not network.to_dataframe().empty - - def test_link_node_reaches_have_no_length_or_breakpoints(self): - """Without inp=, mikeio1d reports neither - documented in the docstring.""" - network = Network.from_epanet("./tests/testdata/epanet.res") - - lengths = [d["length"] for *_, d in network.graph.edges(data=True)] - assert lengths and all(length is None for length in lengths) - assert all(r.n_breakpoints == 0 for r in network._reaches.values()) - - def test_reach_observation_cannot_be_matched(self, sample_node_data): - """Follows from having no breakpoints; also documented in the docstring.""" - network = Network.from_epanet("./tests/testdata/epanet.res") - nmr = NetworkModelResult(network, item="Pressure") - obs = ms.ReachObservation(sample_node_data, reach="10", item="WaterLevel") - - with pytest.raises(ValueError, match="breakpoints"): - nmr.extract(obs) - - def test_mike_file_is_redirected(self): - with pytest.raises(ValueError, match=r"Use Network\.from_mike\(\)"): - Network.from_epanet("./tests/testdata/network.res1d") - - def test_open_res1d_object_is_validated(self): - from mikeio1d import Res1D - - res = Res1D("./tests/testdata/network.res1d") - - with pytest.raises(ValueError, match=r"Use Network\.from_mike\(\)"): - Network.from_epanet(res) - - @pytest.mark.parametrize("suffix", [".res", ".RES"]) - def test_extension_is_case_insensitive(self, tmp_path, suffix): - with pytest.raises((FileExistsError, FileNotFoundError)): - Network.from_epanet(tmp_path / f"network{suffix}") - - -# --------------------------------------------------------------------------- -# EPANET companion files: .inp for reach lengths, .resx for extra quantities -# --------------------------------------------------------------------------- - -_EPANET_RES = "./tests/testdata/epanet.res" -_EPANET_RESX = "./tests/testdata/epanet.resx" -_EPANET_INP = "./tests/testdata/epanet.inp" - -# The 12 [PIPES] entries; reach "9" is the pump, which carries no length. -_PUMP_REACH = "9" - - -@requires_mikeio1d -class TestEpanetCompanionInp: - """`.inp` is the only one of the three files carrying reach lengths.""" - - def test_pipe_reaches_get_real_lengths(self): - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - lengths = {r.id: r.length for r in network._reaches.values()} - assert lengths["10"] == pytest.approx(3209.544) - assert lengths["110"] == pytest.approx(60.96) - - def test_pump_reach_stays_undefined(self): - """[PIPES] is the only section with lengths, so pumps keep None.""" - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - lengths = {r.id: r.length for r in network._reaches.values()} - assert lengths[_PUMP_REACH] is None - assert sum(v is None for v in lengths.values()) == 1 - - def test_graph_edges_carry_the_lengths(self): - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - lengths = [d["length"] for *_, d in network.graph.edges(data=True)] - assert sum(v is not None for v in lengths) == 12 - - def test_node_ids_overlapping_reach_ids_are_not_confused(self): - """Most IDs here name both a node and a reach, e.g. '9', '10', '21'.""" - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - assert set(network._reaches) & set(network._alias_map) # they do overlap - # Reach "10" is 3209.544 long; node "10" is untouched by the length map. - assert network._reaches["10"].length == pytest.approx(3209.544) - node_10 = network.find(node="10") - assert "Head" in network.to_dataframe()[node_10].columns - - def test_wrong_suffix_is_refused(self): - with pytest.raises(ValueError, match=r"Expected an EPANET '\.inp'"): - Network.from_epanet(_EPANET_RES, inp=_EPANET_RESX) - - def test_file_without_a_pipes_section_is_refused(self, tmp_path): - other = tmp_path / "not-epanet.inp" - other.write_text("[JUNCTIONS]\n;;Name\n9 1000\n") - - with pytest.raises(ValueError, match=r"no \[PIPES\] section"): - Network.from_epanet(_EPANET_RES, inp=other) - - -@requires_mikeio1d -class TestEpanetCompanionResx: - """`.resx` holds extra results for the network defined in the sibling `.res`.""" - - def test_extra_node_quantities_are_merged(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX) - - assert set(network.quantities) == { - "Demand", - "Head", - "Pressure", - "WaterQuality", - "Volume", - "Volume Percentage", - } - - def test_only_the_nodes_present_in_the_resx_gain_them(self): - """The .resx covers the tank and the reservoir, not all eleven nodes.""" - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX) - df = network.to_dataframe() - - with_volume = { - node - for node in df.columns.get_level_values("node").unique() - if "Volume" in df[node].columns - } - # Node IDs are re-indexed to integers, so recall the original labels. - assert {network.recall(node)["node"] for node in with_volume} == {"2", "9"} - - def test_values_come_through(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX) - - reservoir = network.find(node="9") - volume = network.to_dataframe()[(reservoir, "Volume Percentage")] - assert len(volume) == 25 - assert volume.notna().all() - - def test_selective_loading_still_governs_what_is_read(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX, nodes=["2"]) - - df = network.to_dataframe() - tank = network.find(node="2") - assert set(df.columns.get_level_values("node").unique()) == {tank} - assert "Volume" in df[tank].columns - - def test_both_companions_together(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX, inp=_EPANET_INP) - - assert "Volume" in network.quantities - assert network._reaches["10"].length == pytest.approx(3209.544) - - def test_an_open_res1d_object_is_accepted(self): - from mikeio1d import Res1D - - network = Network.from_epanet(_EPANET_RES, resx=Res1D(_EPANET_RESX)) - - assert "Volume" in network.quantities - - def test_wrong_suffix_is_refused(self): - with pytest.raises(ValueError, match=r"Expected an EPANET '\.resx'"): - Network.from_epanet(_EPANET_RES, resx=_EPANET_RES) - - def test_a_result_file_of_another_format_is_refused(self): - from mikeio1d import Res1D - - other = Res1D("./tests/testdata/network.res1d") - - with pytest.raises(ValueError, match=r"Expected an EPANET '\.resx'"): - Network.from_epanet(_EPANET_RES, resx=other) - - def test_a_companion_from_another_run_is_refused(self, monkeypatch): - """Merging two runs would line up silently and give a wrong network.""" - from mikeio1d import Res1D - - res = Res1D(_EPANET_RES) - resx = Res1D(_EPANET_RESX) - shifted = resx.time_index + pd.Timedelta("1D") - - # Both objects share the Res1D class, so shift only this one instance. - original = type(resx).time_index.fget - monkeypatch.setattr( - type(resx), - "time_index", - property(lambda self: shifted if self is resx else original(self)), - ) - - with pytest.raises(ValueError, match="does not share a time axis"): - Network.from_epanet(res, resx=resx) - - def test_a_companion_naming_an_unknown_node_is_refused(self, monkeypatch): - """A node the .res has never heard of means these are different models.""" - from mikeio1d import Res1D - - res = Res1D(_EPANET_RES) - resx = Res1D(_EPANET_RESX) - strangers = dict(resx.nodes) | {"not_in_the_res": None} - - original = type(resx).nodes.fget - monkeypatch.setattr( - type(resx), - "nodes", - property(lambda self: strangers if self is resx else original(self)), - ) - - with pytest.raises(ValueError, match="not_in_the_res"): - Network.from_epanet(res, resx=resx) - - def test_unsupported_type_is_refused(self): - with pytest.raises(TypeError, match="Expected a str, Path or Res1D object"): - Network.from_epanet(_EPANET_RES, resx=42) # type: ignore[arg-type] - - -class TestReadInp: - """Minimal .inp reader - see modelskill/model/adapters/_inp.py.""" - - def _write(self, tmp_path, text): - path = tmp_path / "model.inp" - path.write_text(text) - return path - - def test_sections_are_keyed_without_brackets_and_upper_cased(self, tmp_path): - path = self._write(tmp_path, "[Pipes]\n1 a b 10\n[TANKS]\n2 5\n") - - assert set(read_sections(path)) == {"PIPES", "TANKS"} - - def test_comment_and_blank_lines_are_dropped(self, tmp_path): - path = self._write( - tmp_path, - ";a leading banner\n\n[PIPES]\n" - ";;ID Node1 Node2 Length\n" - ";;-- ----- ----- ------\n" - "1 a b 10\n\n", - ) - - assert read_sections(path) == {"PIPES": [["1", "a", "b", "10"]]} - - def test_trailing_comment_is_stripped_from_a_data_row(self, tmp_path): - path = self._write(tmp_path, "[PIPES]\n1 a b 10 ; the short one\n") - - assert read_sections(path)["PIPES"] == [["1", "a", "b", "10"]] - - def test_rows_before_any_section_are_ignored(self, tmp_path): - path = self._write(tmp_path, "stray row\n[PIPES]\n1 a b 10\n") - - assert read_sections(path) == {"PIPES": [["1", "a", "b", "10"]]} - - def test_lengths_are_read_from_the_fourth_field(self, tmp_path): - path = self._write(tmp_path, "[PIPES]\n1 a b 10.5 300 100\n") - - assert read_pipe_lengths(path) == {"1": 10.5} - - def test_a_short_row_raises_rather_than_dropping_a_length(self, tmp_path): - path = self._write(tmp_path, "[PIPES]\n1 a b\n") + assert list(df.columns) == ["WaterLevel"] - with pytest.raises(ValueError, match="Cannot read a pipe length"): - read_pipe_lengths(path) + def test_a_named_node_survives_trimming(self, sample_network, sample_node_data): + nmr = NetworkModelResult(sample_network) + extracted = nmr.extract(ms.NodeObservation(sample_node_data, at="123")) - def test_a_repeated_section_header_accumulates(self, tmp_path): - path = self._write( - tmp_path, "[PIPES]\n1 a b 10\n[TANKS]\n2 5\n[PIPES]\n3 c d 20\n" + trimmed = extracted.trim( + start_time=extracted.time[1], end_time=extracted.time[-1] ) - assert read_pipe_lengths(path) == {"1": 10.0, "3": 20.0} + assert trimmed.node == extracted.node + assert len(trimmed) == len(extracted) - 1 diff --git a/tests/testdata/README.md b/tests/testdata/README.md index a6f4a71c6..63bb46db9 100644 --- a/tests/testdata/README.md +++ b/tests/testdata/README.md @@ -10,16 +10,20 @@ These network files come from | File | Format | Used for | |---|---|---| -| `network_cali.res11` | MIKE 11 | `Network.from_mike` coverage for `.res11` | -| `epanet.res` | EPANET | `Network.from_epanet` coverage | -| `epanet.resx` | EPANET (MIKE+) | the `resx=` companion — extra node quantities merged onto the `.res` network | -| `epanet.inp` | EPANET input | the `inp=` companion — real pipe lengths, which the `.res` does not carry | -| `swmm.out` | SWMM | asserting `.out` is refused — its reach connectivity lives in a companion `.inp` we do not read yet (#689) | +| `network_cali.res11` | MIKE 11 | nothing here any more — see below | +| `epanet.res` | EPANET | nothing here any more — see below | +| `epanet.resx` | EPANET (MIKE+) | extra node quantities, merged onto the `.res` network | +| `epanet.inp` | EPANET input | real pipe lengths, which the `.res` does not carry | +| `swmm.out` | SWMM | nothing here any more — see below | + +Reading these formats moved to mikeio1d with the rest of the topology layer +(ADR-013), and the tests that covered it moved with it. The files are kept because +mikeio1d has the same copies and modelskill may want EPANET-side coverage of its +own; nothing in this repository reads them today except `network.res1d`. `epanet.resx` and `epanet.inp` pair with `epanet.res`: same run, same IDs. The `.resx` node and reach IDs are a strict subset of the `.res` ones, and the `.inp` `[PIPES]` IDs cover every `.res` reach except the pump. -`swmm.out` is kept without its `.inp` on purpose. It pins the refusal, so the test -fails the day we add SWMM support or a future mikeio1d starts reporting reach -connectivity for it. +`swmm.out` is kept without its `.inp` on purpose: the refusal it used to pin is +mikeio1d's now, and the file is the fixture that refusal needs. diff --git a/tests/testdata/network_sensor_1.csv b/tests/testdata/network_sensor_1.csv index 904d9eb79..6f46c2869 100644 --- a/tests/testdata/network_sensor_1.csv +++ b/tests/testdata/network_sensor_1.csv @@ -1,111 +1,111 @@ ,water_level@sens1 -1994-08-07 16:35:06.721389014,193.7479319011718 -1994-08-07 16:36:11.808982110,193.9276622504125 -1994-08-07 16:36:58.463517098,193.73969537883863 -1994-08-07 16:38:50.136489724,193.5324026294447 -1994-08-07 16:39:54.184260240,193.75098664628783 -1994-08-07 16:41:02.301898383,193.9631823043365 -1994-08-07 16:41:48.047551850,193.88949067602914 -1994-08-07 16:43:03.765627271,193.73298338692013 -1994-08-07 16:43:59.271576674,193.518740505735 -1994-08-07 16:44:53.976575879,193.80052813920184 -1994-08-07 16:45:52.150380498,193.76709749688646 -1994-08-07 16:46:59.335689619,193.87266429057766 -1994-08-07 16:47:48.671800096,193.61027606890661 -1994-08-07 16:49:09.441634441,193.90646493021583 -1994-08-07 16:50:05.221428246,193.68537026321115 -1994-08-07 16:51:31.750429245,194.00527903620747 -1994-08-07 16:52:44.709396591,193.960610633433 -1994-08-07 16:54:15.295748944,193.87369664367992 -1994-08-07 16:56:09.081416788,193.74406275881358 -1994-08-07 16:57:14.043033644,193.71501017501876 -1994-08-07 16:58:18.210601321,193.83703675670696 -1994-08-07 16:59:03.257072206,194.06250124233108 -1994-08-07 17:00:06.081835904,193.97168058658363 -1994-08-07 17:01:06.426608705,193.6410669817052 -1994-08-07 17:02:22.837775497,193.7119913501634 -1994-08-07 17:03:18.768918912,193.8826429315821 -1994-08-07 17:04:17.424400499,193.76142364154504 -1994-08-07 17:05:06.371871595,193.82686832219773 -1994-08-07 17:06:17.991770538,193.7814248098547 -1994-08-07 17:07:14.600956935,193.747104244197 -1994-08-07 17:08:19.929202980,193.88962326399343 -1994-08-07 17:09:18.863933688,193.8894988894418 -1994-08-07 17:10:21.785300698,193.7678915506987 -1994-08-07 17:11:22.760047207,193.8350592978198 -1994-08-07 17:12:16.293904286,193.76937160755946 -1994-08-07 17:13:18.937531227,193.7072710276047 -1994-08-07 17:14:09.393470503,194.01678510826014 -1994-08-07 17:15:16.341863122,193.81790025709154 -1994-08-07 17:16:17.315241669,193.96796138622275 -1994-08-07 17:17:15.246401107,193.93776810871083 -1994-08-07 17:18:05.749523838,193.92373793354915 -1994-08-07 17:19:22.112742914,193.75041032904946 -1994-08-07 17:20:31.310425275,193.92249310948324 -1994-08-07 17:21:21.982712671,193.82335772625748 -1994-08-07 17:22:23.767907448,193.95466062588378 -1994-08-07 17:23:39.680152861,194.013618376674 -1994-08-07 17:24:38.147955485,194.11815372525726 -1994-08-07 17:25:38.420371252,194.50584562429492 -1994-08-07 17:26:24.408303070,194.54446646687336 -1994-08-07 17:27:31.105998416,194.46853129987517 -1994-08-07 17:28:34.880232331,194.55187457703428 -1994-08-07 17:29:37.175071072,194.86809034869842 -1994-08-07 17:30:35.271697419,194.70284194184958 -1994-08-07 17:31:31.204858260,194.98822903414495 -1994-08-07 17:32:24.847235710,195.24737706568624 -1994-08-07 17:33:36.679829931,195.2715904795984 -1994-08-07 17:34:37.932637257,195.1555004434547 -1994-08-07 17:35:25.487179907,195.11808508664626 -1994-08-07 17:36:22.047650391,195.35302938305526 -1994-08-07 17:37:22.665545301,195.058608262039 -1994-08-07 17:38:23.922713966,195.03890774364643 -1994-08-07 17:39:37.300808590,195.10925487796052 -1994-08-07 17:40:39.123378882,194.9197940042712 -1994-08-07 17:41:39.736323741,194.91541376013848 -1994-08-07 17:42:32.624612495,194.84419544155747 -1994-08-07 17:43:38.386604464,194.91238993528924 -1994-08-07 17:44:35.752954642,194.80146002502337 -1994-08-07 17:45:47.706770126,194.91559552756155 -1994-08-07 17:46:56.228029771,194.72765509600865 -1994-08-07 17:47:50.302639903,194.72477357208479 -1994-08-07 17:48:51.313688841,194.64138661647883 -1994-08-07 17:50:04.027931558,194.66788700646532 -1994-08-07 17:50:59.170111019,194.69887586125873 -1994-08-07 17:52:19.507804755,194.75091927194543 -1994-08-07 17:53:36.244289704,194.73563801241843 -1994-08-07 17:54:46.006725041,194.35800960937343 -1994-08-07 17:55:50.875697661,194.41711389439024 -1994-08-07 17:57:01.668197445,194.29313729304636 -1994-08-07 17:58:16.481604045,194.45199484204932 -1994-08-07 17:59:47.768779742,194.45872420226013 -1994-08-07 18:00:49.317493448,194.4314547834637 -1994-08-07 18:02:02.027423669,194.2515095971401 -1994-08-07 18:03:55.326990060,194.2601910363553 -1994-08-07 18:05:08.677524139,194.09049632407513 -1994-08-07 18:05:55.807125909,194.25764674606657 -1994-08-07 18:07:06.508171149,194.15893464151893 -1994-08-07 18:08:14.768585338,194.32278841101814 -1994-08-07 18:08:59.434113874,194.1892503649891 -1994-08-07 18:10:10.361033654,194.3360223971569 -1994-08-07 18:11:39.416513356,193.91053863482347 -1994-08-07 18:13:12.292137298,194.03847881603537 -1994-08-07 18:14:50.579821036,194.19255380323284 -1994-08-07 18:16:11.445107220,194.2372052362117 -1994-08-07 18:17:13.979038396,194.02910039993844 -1994-08-07 18:19:11.411173338,194.1543403568542 -1994-08-07 18:20:05.747471067,194.28718925009687 -1994-08-07 18:21:08.770390114,194.2290999628811 -1994-08-07 18:22:04.993112618,193.88244373099988 -1994-08-07 18:23:12.416131227,194.02896457246328 -1994-08-07 18:24:13.427829087,193.99948814393267 -1994-08-07 18:25:12.565706666,194.16456490763096 -1994-08-07 18:26:07.842114358,194.02641628418803 -1994-08-07 18:26:58.397587323,194.16132614507512 -1994-08-07 18:28:03.529864903,194.15134556849915 -1994-08-07 18:29:00.650668046,193.92727557471548 -1994-08-07 18:30:03.066222312,193.9766219050112 -1994-08-07 18:31:10.120818363,194.06760532977663 -1994-08-07 18:32:09.431674937,193.95571034292806 -1994-08-07 18:33:00.389496491,194.03147735060986 -1994-08-07 18:35:01.353919658,193.94705444753936 +1994-08-07 16:35:00.776781603,194.32011320654263 +1994-08-07 16:36:09.729399842,194.7470367441099 +1994-08-07 16:37:10.325784362,194.67395882505454 +1994-08-07 16:38:54.294488082,194.61153571139567 +1994-08-07 16:39:49.893755801,194.54321065864184 +1994-08-07 16:40:49.464208760,194.51251435556324 +1994-08-07 16:41:54.155002671,194.48729978930177 +1994-08-07 16:42:47.858648484,194.58252622043406 +1994-08-07 16:43:48.114422841,194.4304369580146 +1994-08-07 16:44:50.213843207,194.38249215797805 +1994-08-07 16:45:52.389905612,194.64429343992802 +1994-08-07 16:47:02.765925660,194.53358432734336 +1994-08-07 16:47:47.544625374,194.60385269292348 +1994-08-07 16:49:02.637927182,194.59824639141928 +1994-08-07 16:50:12.152163291,194.64549922015675 +1994-08-07 16:51:38.335652213,194.20982648777377 +1994-08-07 16:52:40.498338592,194.65174104529223 +1994-08-07 16:54:29.296070178,194.67321466962673 +1994-08-07 16:56:16.843462211,194.70496214061026 +1994-08-07 16:57:19.546830813,194.57169766844956 +1994-08-07 16:58:21.508555037,194.66168658625153 +1994-08-07 16:59:19.782410316,194.55758442776926 +1994-08-07 17:00:21.921517678,194.5576186499002 +1994-08-07 17:01:20.092192674,194.81469647880382 +1994-08-07 17:02:17.746355889,194.70522414915595 +1994-08-07 17:03:13.166714757,194.60789232032135 +1994-08-07 17:04:12.749365769,194.79521007424793 +1994-08-07 17:05:10.304197359,194.42783733284318 +1994-08-07 17:06:04.189757936,194.5555761260468 +1994-08-07 17:07:12.765391276,194.73618898202943 +1994-08-07 17:08:12.365563077,194.6375905289089 +1994-08-07 17:09:15.491917299,194.57025641473498 +1994-08-07 17:10:06.493562414,194.4688605015372 +1994-08-07 17:11:07.187363310,194.75550986631575 +1994-08-07 17:12:09.160016532,194.61054169889053 +1994-08-07 17:13:21.469083676,194.6253361248603 +1994-08-07 17:14:17.930689144,194.70277955607804 +1994-08-07 17:15:17.279332650,194.56556903513305 +1994-08-07 17:16:08.640601075,194.50005512303613 +1994-08-07 17:17:07.068658303,194.65868598122688 +1994-08-07 17:18:09.766449327,194.6653618297461 +1994-08-07 17:19:20.161218787,194.74595890778755 +1994-08-07 17:20:18.992883026,194.4980021093954 +1994-08-07 17:21:30.086313691,194.55154639192463 +1994-08-07 17:22:28.651457434,194.57671325756172 +1994-08-07 17:23:40.633424866,194.69867899539543 +1994-08-07 17:24:37.117548132,194.82545584348597 +1994-08-07 17:25:30.448984712,195.0279680264088 +1994-08-07 17:26:30.029453346,195.07988551475916 +1994-08-07 17:27:32.245829383,194.92487401587312 +1994-08-07 17:28:30.078420729,195.3240098122494 +1994-08-07 17:29:38.136013235,195.47706773119452 +1994-08-07 17:30:35.734525134,195.77572434729703 +1994-08-07 17:31:34.656548288,196.34019205600237 +1994-08-07 17:32:31.554119147,196.4872903805679 +1994-08-07 17:33:34.533280257,196.31028793328298 +1994-08-07 17:34:21.642437078,196.39518666193 +1994-08-07 17:35:37.901281041,196.23731771908797 +1994-08-07 17:36:31.067494778,196.2907368565569 +1994-08-07 17:37:26.536405793,196.05114435497984 +1994-08-07 17:38:26.179123415,196.23182104355894 +1994-08-07 17:39:34.480757192,195.7356264141028 +1994-08-07 17:40:32.367919827,195.76434390248752 +1994-08-07 17:41:29.068741892,195.387522485378 +1994-08-07 17:42:25.963454370,195.26662774076652 +1994-08-07 17:43:43.256506377,195.1620181140931 +1994-08-07 17:44:48.923258096,194.99956715610247 +1994-08-07 17:45:48.951022779,194.803275106843 +1994-08-07 17:46:51.832758663,194.62647855997503 +1994-08-07 17:47:53.011655455,194.840056508079 +1994-08-07 17:48:53.291279628,194.7191954018589 +1994-08-07 17:49:45.414193152,194.72130314272985 +1994-08-07 17:51:06.934395423,194.736784985074 +1994-08-07 17:52:14.283447737,194.57160881923406 +1994-08-07 17:53:31.345360278,194.83788750770336 +1994-08-07 17:54:45.878612606,194.6186418522351 +1994-08-07 17:55:54.526498381,194.60992402778382 +1994-08-07 17:57:07.804714354,194.70930496247433 +1994-08-07 17:58:29.732584061,194.631433387878 +1994-08-07 17:59:51.646966493,194.7453412546349 +1994-08-07 18:00:49.479370729,194.63355314090856 +1994-08-07 18:02:05.027988263,194.54741392208302 +1994-08-07 18:04:07.168692247,194.66260603569324 +1994-08-07 18:05:02.408720278,194.65222312074025 +1994-08-07 18:05:59.994427311,194.7324924261196 +1994-08-07 18:06:58.002591414,194.59584590330348 +1994-08-07 18:08:12.257364299,194.7322344755338 +1994-08-07 18:08:56.371471124,194.7565388217572 +1994-08-07 18:09:59.424399444,194.68480423777225 +1994-08-07 18:11:43.381217236,194.4815298273368 +1994-08-07 18:13:18.462469421,194.72667934520882 +1994-08-07 18:14:45.523662018,194.6906565875005 +1994-08-07 18:16:02.135996224,194.65676781090227 +1994-08-07 18:17:12.775638626,194.43981653379436 +1994-08-07 18:19:04.224160802,194.55663239846368 +1994-08-07 18:20:01.156801276,194.65240550437673 +1994-08-07 18:21:04.005495270,194.74085520785582 +1994-08-07 18:22:07.212758918,194.54846322157974 +1994-08-07 18:23:17.581805886,194.5943242421595 +1994-08-07 18:24:09.834797808,194.66609677586615 +1994-08-07 18:25:02.157922163,194.64754442371688 +1994-08-07 18:26:00.013570112,194.58158453962835 +1994-08-07 18:26:58.607951371,194.61501209771856 +1994-08-07 18:28:09.760211999,194.52247158113664 +1994-08-07 18:29:04.676695951,194.54233718320697 +1994-08-07 18:29:58.126126307,194.4578251058232 +1994-08-07 18:30:58.188406457,194.6101479534574 +1994-08-07 18:32:08.511690435,194.52181232461433 +1994-08-07 18:33:05.469289719,194.63804807700458 +1994-08-07 18:34:50.281906950,194.5500288327867 diff --git a/tests/testdata/network_sensor_2.csv b/tests/testdata/network_sensor_2.csv index 9eddb84df..403d0b069 100644 --- a/tests/testdata/network_sensor_2.csv +++ b/tests/testdata/network_sensor_2.csv @@ -1,81 +1,81 @@ ,water_level@sens2 -1994-08-07 17:08:19.453000537,193.69907521870385 -1994-08-07 17:09:11.667777579,193.53254848297152 -1994-08-07 17:10:17.713878006,193.37840712805215 -1994-08-07 17:11:14.377409723,193.36046774853432 -1994-08-07 17:12:19.607715440,193.35883525251685 -1994-08-07 17:13:16.506158153,193.54074175140104 -1994-08-07 17:14:22.442398906,193.5636244747378 -1994-08-07 17:15:07.096815541,193.3936963704199 -1994-08-07 17:16:10.480296727,193.48972566299682 -1994-08-07 17:17:22.450643797,193.4587060771225 -1994-08-07 17:18:21.490266204,193.35182993861991 -1994-08-07 17:19:19.872035872,193.45517089047667 -1994-08-07 17:20:18.551963043,193.39190620106453 -1994-08-07 17:21:37.487970642,193.65287311723839 -1994-08-07 17:22:38.893023517,193.51519324042974 -1994-08-07 17:23:37.808072814,193.72342214376903 -1994-08-07 17:24:30.088355655,193.42926966972004 -1994-08-07 17:25:22.809359233,193.373787100516 -1994-08-07 17:26:33.203907398,193.87313878617707 -1994-08-07 17:27:24.450142559,193.77977426912494 -1994-08-07 17:28:34.256134409,193.87776964481588 -1994-08-07 17:29:29.162052421,193.74593301162298 -1994-08-07 17:30:40.417250997,194.06335624478052 -1994-08-07 17:31:36.292748137,194.0891460493891 -1994-08-07 17:32:22.577927686,193.93598437841732 -1994-08-07 17:33:35.944430514,193.89206968675506 -1994-08-07 17:34:23.631420564,194.29720825961996 -1994-08-07 17:35:33.310491457,193.94006446417492 -1994-08-07 17:36:36.768648209,193.94301852816398 -1994-08-07 17:37:41.256034582,193.93359649072713 -1994-08-07 17:38:27.439954370,193.99934207664205 -1994-08-07 17:39:32.423879950,194.0276140940857 -1994-08-07 17:40:32.505523785,193.75309351356177 -1994-08-07 17:41:26.182311995,193.86393199710076 -1994-08-07 17:42:31.811747815,193.86698395764947 -1994-08-07 17:43:43.977586264,193.79824583031655 -1994-08-07 17:44:32.820391407,193.88413939303942 -1994-08-07 17:45:39.780028021,193.82682735759107 -1994-08-07 17:46:45.520148467,193.64527654802706 -1994-08-07 17:47:47.632936535,193.79625317554138 -1994-08-07 17:48:57.346727826,193.6655550615617 -1994-08-07 17:49:49.253930336,193.78374770218835 -1994-08-07 17:51:02.833869005,193.49014557011174 -1994-08-07 17:52:08.948334997,193.5521603282343 -1994-08-07 17:53:32.956569310,193.42249475180054 -1994-08-07 17:54:40.776321387,193.41421417275032 -1994-08-07 17:55:45.154182165,193.7623513346016 -1994-08-07 17:57:01.877564139,193.71602664387882 -1994-08-07 17:58:27.973645801,193.6626855905494 -1994-08-07 17:59:48.164323924,193.58427431473757 -1994-08-07 18:00:49.608896563,193.81199176289348 -1994-08-07 18:02:06.114975563,193.64886741921137 -1994-08-07 18:04:10.676323539,193.719005472149 -1994-08-07 18:05:07.173323943,193.96465013641256 -1994-08-07 18:06:11.346838731,193.68426045579662 -1994-08-07 18:07:15.138616621,193.88023114770002 -1994-08-07 18:08:12.352725832,193.73742809783437 -1994-08-07 18:09:09.040990372,193.95542280957721 -1994-08-07 18:10:05.444299339,193.72699587134503 -1994-08-07 18:11:43.548122207,193.64415106941962 -1994-08-07 18:13:19.975340480,193.61679887917686 -1994-08-07 18:15:00.099149664,193.7092729650918 -1994-08-07 18:15:58.266937956,193.51481360263026 -1994-08-07 18:17:11.010370099,193.88621915401467 -1994-08-07 18:19:00.194728453,193.70300139682695 -1994-08-07 18:20:01.268579900,193.74549285164244 -1994-08-07 18:20:59.085548638,193.61744713398235 -1994-08-07 18:22:04.935328179,193.73830581406855 -1994-08-07 18:23:02.479745169,193.64939163691596 -1994-08-07 18:24:03.446628434,193.70495758379232 -1994-08-07 18:25:06.549919135,193.8685145360975 -1994-08-07 18:26:03.183612415,193.76014328305922 -1994-08-07 18:27:13.078601240,193.970374402854 -1994-08-07 18:28:04.443206888,193.861958294037 -1994-08-07 18:29:11.413727234,193.7661905820629 -1994-08-07 18:30:08.277252518,193.82534783818286 -1994-08-07 18:31:15.483217962,193.74254129620306 -1994-08-07 18:32:16.040549977,193.6307058726291 -1994-08-07 18:33:10.182896344,193.70636292657173 -1994-08-07 18:34:50.194959733,193.5921011184813 +1994-08-07 17:08:16.746982777,193.46666085110937 +1994-08-07 17:09:15.911869348,193.5553573859252 +1994-08-07 17:10:12.195124338,193.68937807365793 +1994-08-07 17:11:04.448876310,193.45076123271946 +1994-08-07 17:12:21.097623039,193.35810147147876 +1994-08-07 17:13:10.410972001,193.2465448797826 +1994-08-07 17:14:18.997462489,193.3968538310765 +1994-08-07 17:15:03.516275677,193.4281083125626 +1994-08-07 17:16:19.363113442,193.41499628403477 +1994-08-07 17:17:21.535598304,193.5666798285079 +1994-08-07 17:18:06.703804784,193.39019715759977 +1994-08-07 17:19:07.113924200,193.38622798499898 +1994-08-07 17:20:33.249205987,193.44059499667398 +1994-08-07 17:21:31.188910307,193.39014297074812 +1994-08-07 17:22:25.449777484,193.5135983423928 +1994-08-07 17:23:34.351449340,193.44326026160877 +1994-08-07 17:24:36.704856539,193.64662660593314 +1994-08-07 17:25:23.749227916,193.68181603286484 +1994-08-07 17:26:25.413103928,193.65784040523326 +1994-08-07 17:27:34.119977569,193.6594899766634 +1994-08-07 17:28:38.077895472,193.56136289039708 +1994-08-07 17:29:28.892229227,193.88248108364874 +1994-08-07 17:30:37.381056452,193.879931506782 +1994-08-07 17:31:22.016878283,193.9764859878361 +1994-08-07 17:32:24.820104399,194.0092368597367 +1994-08-07 17:33:30.644397706,193.88064299765335 +1994-08-07 17:34:33.346912592,194.05445097743723 +1994-08-07 17:35:23.787289189,193.82172014137683 +1994-08-07 17:36:27.366039084,194.11063686379669 +1994-08-07 17:37:21.887545915,194.0337211037484 +1994-08-07 17:38:24.492378576,193.97610821824 +1994-08-07 17:39:30.357983784,193.8996749540457 +1994-08-07 17:40:32.873187909,193.92570259171478 +1994-08-07 17:41:34.362113670,194.00499314349867 +1994-08-07 17:42:37.953467214,193.97506638859474 +1994-08-07 17:43:42.534176765,193.8375936679057 +1994-08-07 17:44:46.286409008,193.8822436003635 +1994-08-07 17:45:38.814041258,193.92934125470285 +1994-08-07 17:46:46.299281342,193.8427036608706 +1994-08-07 17:47:54.794002989,193.67733464061652 +1994-08-07 17:48:47.411067897,193.7657885903237 +1994-08-07 17:49:54.806563276,193.79932081862353 +1994-08-07 17:51:07.203432962,193.6679871844179 +1994-08-07 17:52:24.175267637,193.66515188457322 +1994-08-07 17:53:38.221315864,193.47159887553875 +1994-08-07 17:54:47.955110981,193.3670697177164 +1994-08-07 17:55:57.151866554,193.2148360925973 +1994-08-07 17:57:08.560582293,193.62690790451714 +1994-08-07 17:58:23.735060106,193.72418492900746 +1994-08-07 17:59:55.978275973,193.6697424454863 +1994-08-07 18:00:56.860847094,193.862786559526 +1994-08-07 18:02:08.048762300,193.5319389365475 +1994-08-07 18:04:00.764336576,193.87660770279663 +1994-08-07 18:05:03.913437188,193.60076940202146 +1994-08-07 18:06:13.261131339,193.6366841968641 +1994-08-07 18:07:06.157111035,193.59798175417382 +1994-08-07 18:08:04.896493562,193.68986271298314 +1994-08-07 18:09:08.807194603,193.75154771138716 +1994-08-07 18:10:01.992525026,193.59058976854448 +1994-08-07 18:11:47.873996513,194.03607519614027 +1994-08-07 18:13:19.705641908,193.85331823073562 +1994-08-07 18:15:01.527177197,193.82125166357054 +1994-08-07 18:16:06.112479066,193.6735111347705 +1994-08-07 18:17:16.685286166,193.73108188615356 +1994-08-07 18:19:17.074371614,193.8626267277998 +1994-08-07 18:20:10.845364231,193.7936194327107 +1994-08-07 18:21:12.902532477,193.75779898411886 +1994-08-07 18:22:05.155728075,193.7031060506949 +1994-08-07 18:22:58.734020179,193.5646247175248 +1994-08-07 18:24:13.186786829,193.73911466320203 +1994-08-07 18:25:01.856294891,193.84057875255806 +1994-08-07 18:26:15.909490510,193.59172917653063 +1994-08-07 18:26:59.409353061,193.729350832721 +1994-08-07 18:28:14.140616186,193.6950562602535 +1994-08-07 18:29:12.131829961,193.56685946901322 +1994-08-07 18:30:15.997926093,193.7309558657659 +1994-08-07 18:31:00.070062248,193.77991569884506 +1994-08-07 18:31:58.657467012,193.65439446319758 +1994-08-07 18:33:12.430771829,193.7274017925486 +1994-08-07 18:35:06.217438898,193.7440013043444 diff --git a/tests/testdata/network_sensor_3.csv b/tests/testdata/network_sensor_3.csv index 540162613..b15854108 100644 --- a/tests/testdata/network_sensor_3.csv +++ b/tests/testdata/network_sensor_3.csv @@ -1,91 +1,91 @@ ,water_level@sens3 -1994-08-07 16:34:59.749185049,193.65573611633096 -1994-08-07 16:36:08.234735831,193.5492676961432 -1994-08-07 16:37:10.476205369,193.44270461528237 -1994-08-07 16:38:56.739070973,193.7316050738842 -1994-08-07 16:39:48.448422501,193.46705769407055 -1994-08-07 16:41:00.899011077,193.60328571871497 -1994-08-07 16:41:57.674627567,193.35125246300828 -1994-08-07 16:42:47.462417744,193.5185512837486 -1994-08-07 16:44:05.707731356,193.59592502393136 -1994-08-07 16:44:47.395900520,193.66394020062216 -1994-08-07 16:45:54.846537383,193.62178032405015 -1994-08-07 16:46:48.526040668,193.77009561152101 -1994-08-07 16:48:00.550698110,193.54903378032205 -1994-08-07 16:49:06.813081870,193.5248851167554 -1994-08-07 16:50:10.392793101,193.4807046599272 -1994-08-07 16:51:20.373948386,193.50658954793624 -1994-08-07 16:52:42.364153730,193.58489517430476 -1994-08-07 16:54:24.475220308,193.50643945831553 -1994-08-07 16:56:03.429894489,193.72466197230418 -1994-08-07 16:57:07.522109743,193.66315601778547 -1994-08-07 16:58:19.771112168,193.6526056046781 -1994-08-07 16:59:12.330382377,193.5774691241722 -1994-08-07 17:00:15.682992521,193.57194585146243 -1994-08-07 17:01:06.996793691,193.776140134919 -1994-08-07 17:02:03.506371148,193.68766157959166 -1994-08-07 17:03:10.614276582,193.49255884053937 -1994-08-07 17:04:12.713137359,193.62602129546661 -1994-08-07 17:05:11.105347604,193.6977653873034 -1994-08-07 17:06:08.694168494,193.76860864084824 -1994-08-07 17:07:10.279609860,193.50288362365427 -1994-08-07 17:08:21.003764660,193.55578257769696 -1994-08-07 17:09:06.412524613,193.56869342489048 -1994-08-07 17:10:15.705612895,193.40978399466348 -1994-08-07 17:11:09.451766070,193.60182994885278 -1994-08-07 17:12:08.055520793,193.51766966463958 -1994-08-07 17:13:10.657325255,193.7243146064135 -1994-08-07 17:14:21.633020060,193.51257532827768 -1994-08-07 17:15:09.075371450,193.55232084181247 -1994-08-07 17:16:17.914468302,193.62712317582472 -1994-08-07 17:17:16.975978261,193.5158279508316 -1994-08-07 17:18:08.275302169,193.52467436568807 -1994-08-07 17:19:15.119707735,193.8068739097595 -1994-08-07 17:20:17.654157988,193.58466106079132 -1994-08-07 17:21:35.874256489,193.6432198883477 -1994-08-07 17:22:26.201697028,193.7402389587467 -1994-08-07 17:23:40.614190845,193.8251455313248 -1994-08-07 17:24:35.163885201,194.0484457054399 -1994-08-07 17:25:33.831846465,194.2188581110414 -1994-08-07 17:26:29.463057842,194.14930206264734 -1994-08-07 17:27:32.301951282,194.26559908122894 -1994-08-07 17:48:51.253848509,194.47916510244187 -1994-08-07 17:49:47.468746981,194.53818636632545 -1994-08-07 17:51:17.048530468,194.42192673115431 -1994-08-07 17:52:06.196063531,194.3566111817392 -1994-08-07 17:53:33.571594531,194.49275563859712 -1994-08-07 17:54:40.295857745,194.24161289020807 -1994-08-07 17:55:51.426795930,194.32646211685966 -1994-08-07 17:57:07.010027886,194.3129625711656 -1994-08-07 17:58:14.788227728,194.21563049881922 -1994-08-07 17:59:55.817232777,193.97104689092097 -1994-08-07 18:01:00.899387468,194.01433322885484 -1994-08-07 18:02:11.092720572,194.06259026020842 -1994-08-07 18:04:08.113392108,194.0429608417371 -1994-08-07 18:05:13.679114222,193.96529261399613 -1994-08-07 18:05:59.122553354,194.15157054129583 -1994-08-07 18:06:57.704020361,194.05899018808853 -1994-08-07 18:08:00.962755607,193.87481824713652 -1994-08-07 18:09:12.803710813,193.94393360920478 -1994-08-07 18:09:55.783676414,193.90634365346295 -1994-08-07 18:11:38.994491765,194.00426585723756 -1994-08-07 18:13:23.817088485,194.21330958450045 -1994-08-07 18:15:02.660036684,193.89671511569932 -1994-08-07 18:16:07.012693812,193.78174880032458 -1994-08-07 18:17:20.710118446,193.86633562744598 -1994-08-07 18:19:15.130507240,194.0741744560302 -1994-08-07 18:20:15.800301822,194.00207588928566 -1994-08-07 18:21:05.594143504,193.98954078505082 -1994-08-07 18:22:10.672244133,193.96015892979668 -1994-08-07 18:22:59.116797345,193.8059099694073 -1994-08-07 18:24:17.782794557,193.83533534410043 -1994-08-07 18:25:04.518698881,193.9507667786435 -1994-08-07 18:26:01.010477471,193.74729023512035 -1994-08-07 18:26:58.886134140,194.11217785860217 -1994-08-07 18:28:09.564788837,193.8869974441292 -1994-08-07 18:29:08.171733686,193.8225247414004 -1994-08-07 18:30:08.862763988,193.94471797299423 -1994-08-07 18:30:58.204733811,193.73271910461622 -1994-08-07 18:32:15.465370257,193.6686396836888 -1994-08-07 18:33:11.959829548,193.89010296389915 -1994-08-07 18:35:04.487313817,193.81745709215483 +1994-08-07 16:34:53.680090784,195.93216076519226 +1994-08-07 16:36:03.016073867,195.9345555668001 +1994-08-07 16:37:03.615114632,195.87220444573137 +1994-08-07 16:39:04.169996900,196.07260811118314 +1994-08-07 16:40:05.088750158,196.01833164040877 +1994-08-07 16:40:58.934617468,195.7868431574667 +1994-08-07 16:41:46.633021730,196.07718129064628 +1994-08-07 16:42:54.313644581,195.9604742525487 +1994-08-07 16:44:01.994806709,195.82502054758228 +1994-08-07 16:45:05.716604054,195.8614853805758 +1994-08-07 16:46:05.078540769,195.94226830524835 +1994-08-07 16:47:04.659109174,196.13169890225316 +1994-08-07 16:48:04.071253636,196.0508294592809 +1994-08-07 16:48:55.856609530,195.8157297978531 +1994-08-07 16:50:20.836102217,195.78676980238802 +1994-08-07 16:51:27.259242998,196.0502612429115 +1994-08-07 16:52:46.613962431,195.90082751638676 +1994-08-07 16:54:14.361648370,195.82840913303832 +1994-08-07 16:56:09.602491818,195.86111093441735 +1994-08-07 16:57:07.509307885,196.08105725975832 +1994-08-07 16:58:04.607812159,195.91595807409047 +1994-08-07 16:59:06.162651347,196.046190892334 +1994-08-07 17:00:04.860410721,195.93309106576953 +1994-08-07 17:01:19.693130234,195.989758713676 +1994-08-07 17:02:17.013786542,196.03859678014445 +1994-08-07 17:03:21.921253632,195.9350327844052 +1994-08-07 17:04:21.306422808,196.0611642713905 +1994-08-07 17:05:19.649468214,195.99686776883638 +1994-08-07 17:06:03.336005403,195.7951648783128 +1994-08-07 17:07:08.175640300,196.03696226597071 +1994-08-07 17:08:13.223933084,196.04961642590735 +1994-08-07 17:09:20.896721614,195.86822876151624 +1994-08-07 17:10:12.692196265,195.93634924463356 +1994-08-07 17:11:21.281490027,195.95654321002246 +1994-08-07 17:12:09.750840411,195.88120744267295 +1994-08-07 17:13:19.174570528,195.69717438944858 +1994-08-07 17:14:11.448114976,196.1061718342362 +1994-08-07 17:15:07.570426731,196.09399840812893 +1994-08-07 17:16:06.885048483,195.85406340253886 +1994-08-07 17:17:22.662212163,196.0792883943752 +1994-08-07 17:18:22.246108903,196.12897187602258 +1994-08-07 17:19:12.398538344,195.96210045263325 +1994-08-07 17:20:32.008320960,196.01346569313253 +1994-08-07 17:21:31.501188032,195.97332807650434 +1994-08-07 17:22:35.058031998,196.0923133910623 +1994-08-07 17:23:24.124859305,195.93741310885218 +1994-08-07 17:24:38.659325565,196.00513593642532 +1994-08-07 17:25:35.358147024,196.06989936406853 +1994-08-07 17:26:22.438476497,195.95165645941802 +1994-08-07 17:27:37.111814779,196.1077539353862 +1994-08-07 17:48:59.845122779,196.06867177276968 +1994-08-07 17:49:59.732989933,196.0571296425243 +1994-08-07 17:51:15.496873472,195.8685146657441 +1994-08-07 17:52:14.096936412,196.14841260340083 +1994-08-07 17:53:40.763706788,195.93029445362168 +1994-08-07 17:54:39.549902410,196.01744835625516 +1994-08-07 17:55:52.701116337,195.96104178186428 +1994-08-07 17:56:59.300944272,195.80391343108298 +1994-08-07 17:58:15.648708976,196.04582044920252 +1994-08-07 17:59:55.609780366,195.73148703736967 +1994-08-07 18:00:48.491480170,196.0329238945659 +1994-08-07 18:02:05.832518720,195.94609041324372 +1994-08-07 18:04:01.981196118,196.0870217358456 +1994-08-07 18:05:06.385341376,195.82819669263213 +1994-08-07 18:06:02.100215510,195.97316503312695 +1994-08-07 18:07:09.809500401,196.04851254822992 +1994-08-07 18:08:02.507913856,195.93280039947714 +1994-08-07 18:09:09.478070425,196.07991903067744 +1994-08-07 18:10:12.897665524,195.8858685223849 +1994-08-07 18:11:42.297675514,195.85546581194953 +1994-08-07 18:13:09.578201802,196.03228099205927 +1994-08-07 18:14:58.536619975,195.9259991178699 +1994-08-07 18:16:06.565053613,195.8178981389149 +1994-08-07 18:17:14.826306388,195.88467512468196 +1994-08-07 18:19:09.806901698,195.8420830166265 +1994-08-07 18:19:58.851825129,195.88215275337 +1994-08-07 18:21:01.335159759,195.96773411751616 +1994-08-07 18:22:16.682911258,195.9911857524558 +1994-08-07 18:23:07.233670407,196.0512707039425 +1994-08-07 18:24:11.527824425,195.9524087710378 +1994-08-07 18:25:01.436698737,195.89337228514202 +1994-08-07 18:26:06.247244282,195.8784401317867 +1994-08-07 18:27:05.656973313,196.05157296880046 +1994-08-07 18:28:00.856102141,195.9754065310726 +1994-08-07 18:29:00.407347532,195.97144918429876 +1994-08-07 18:30:13.017417982,195.99000755334848 +1994-08-07 18:31:10.919329130,195.83631114492073 +1994-08-07 18:32:00.620127477,196.06952449706685 +1994-08-07 18:33:10.975642642,195.9252297985391 +1994-08-07 18:34:56.951901187,195.98766363899963 diff --git a/tests/testdata/node_comparer_1.4.0a3.nc b/tests/testdata/node_comparer_1.4.0a3.nc new file mode 100644 index 000000000..78c8a2751 Binary files /dev/null and b/tests/testdata/node_comparer_1.4.0a3.nc differ