rashdf 0.7.1__tar.gz → 0.8.0__tar.gz

{rashdf-0.7.1 → rashdf-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: rashdf
-Version: 0.7.1
+Version: 0.8.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -23,15 +23,17 @@ Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: kerchunk; extra == "dev"
-Requires-Dist: zarr; extra == "dev"
+Requires-Dist: zarr==2.18.2; extra == "dev"
 Requires-Dist: dask; extra == "dev"
 Requires-Dist: fsspec; extra == "dev"
 Requires-Dist: s3fs; extra == "dev"
 Requires-Dist: fiona==1.9.6; extra == "dev"
+Requires-Dist: numcodecs<0.16; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Dynamic: license-file
 
 # rashdf
 [![CI](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml/badge.svg?branch=main)](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml)

{rashdf-0.7.1 → rashdf-0.8.0}/pyproject.toml

@@ -12,11 +12,23 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
 ]
-version = "0.7.1"
+version = "0.8.0"
 dependencies = ["h5py", "geopandas>=1.0,<2.0", "pyarrow", "xarray"]
 
 [project.optional-dependencies]
-dev = ["pre-commit", "ruff", "pytest", "pytest-cov", "kerchunk", "zarr", "dask", "fsspec", "s3fs", "fiona==1.9.6"]
+dev = [
+    "pre-commit",
+    "ruff",
+    "pytest",
+    "pytest-cov",
+    "kerchunk",
+    "zarr==2.18.2",
+    "dask",
+    "fsspec",
+    "s3fs",
+    "fiona==1.9.6",
+    "numcodecs<0.16"
+]
 docs = ["sphinx", "numpydoc", "sphinx_rtd_theme"]
 
 [project.urls]

{rashdf-0.7.1 → rashdf-0.8.0}/src/cli.py

@@ -21,6 +21,7 @@ COMMANDS = [
     "mesh_cell_faces",
     "refinement_regions",
     "bc_lines",
+    "ic_points",
     "breaklines",
     "reference_lines",
     "reference_points",

{rashdf-0.7.1 → rashdf-0.8.0}/src/rashdf/geom.py

@@ -41,6 +41,7 @@ class RasGeomHdf(RasHdf):
     GEOM_STRUCTURES_PATH = f"{GEOM_PATH}/Structures"
     FLOW_AREA_2D_PATH = f"{GEOM_PATH}/2D Flow Areas"
     BC_LINES_PATH = f"{GEOM_PATH}/Boundary Condition Lines"
+    IC_POINTS_PATH = f"{GEOM_PATH}/IC Points"
     BREAKLINES_PATH = f"{GEOM_PATH}/2D Flow Area Break Lines"
     REFERENCE_LINES_PATH = f"{GEOM_PATH}/Reference Lines"
     REFERENCE_POINTS_PATH = f"{GEOM_PATH}/Reference Points"
@@ -408,7 +409,10 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the model structures if they exist.
         """
-        if self.GEOM_STRUCTURES_PATH not in self:
+        if (
+            self.GEOM_STRUCTURES_PATH not in self
+            or f"{self.GEOM_STRUCTURES_PATH}/Attributes" not in self
+        ):
             return GeoDataFrame()
         struct_data = self[self.GEOM_STRUCTURES_PATH]
         v_conv_val = np.vectorize(convert_ras_hdf_value)
@@ -438,7 +442,32 @@ class RasGeomHdf(RasHdf):
         raise NotImplementedError
 
     def ic_points(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+        """Return initial conditions points.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the initial condition points if they exist.
+        """
+        if self.IC_POINTS_PATH not in self:
+            return GeoDataFrame()
+        ic_data = self[self.IC_POINTS_PATH]
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = v_conv_str(ic_data["Attributes"][()]["Name"])
+        mesh_names = v_conv_str(ic_data["Attributes"][()]["SA/2D"])
+        cell_ids = ic_data["Attributes"][()]["Cell Index"]
+        points = ic_data["Points"][()]
+        return GeoDataFrame(
+            {
+                "icpt_id": range(len(names)),
+                "icpt_name": names,
+                "mesh_name": mesh_names,
+                "cell_id": cell_ids,
+                "geometry": list(map(Point, points)),
+            },
+            geometry="geometry",
+            crs=self.projection(),
+        )
 
     def _reference_lines_points_names(
         self, reftype: str = "lines", mesh_name: Optional[str] = None

{rashdf-0.7.1 → rashdf-0.8.0}/src/rashdf/plan.py

@@ -160,7 +160,7 @@ class RasPlanHdf(RasGeomHdf):
     OBS_DATA_PATH = "Event Conditions/Observed Data"
     RESULTS_UNSTEADY_PATH = "Results/Unsteady"
     RESULTS_UNSTEADY_SUMMARY_PATH = f"{RESULTS_UNSTEADY_PATH}/Summary"
-    VOLUME_ACCOUNTING_PATH = f"{RESULTS_UNSTEADY_PATH}/Volume Accounting"
+    VOLUME_ACCOUNTING_PATH = f"{RESULTS_UNSTEADY_SUMMARY_PATH}/Volume Accounting"
     BASE_OUTPUT_PATH = f"{RESULTS_UNSTEADY_PATH}/Output/Output Blocks/Base Output"
     SUMMARY_OUTPUT_2D_FLOW_AREAS_PATH = (
         f"{BASE_OUTPUT_PATH}/Summary Output/2D Flow Areas"
@@ -168,6 +168,7 @@ class RasPlanHdf(RasGeomHdf):
     UNSTEADY_TIME_SERIES_PATH = f"{BASE_OUTPUT_PATH}/Unsteady Time Series"
     REFERENCE_LINES_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Lines"
     REFERENCE_POINTS_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Points"
+    BOUNDARY_CONDITIONS_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Boundary Conditions"
     OBS_FLOW_OUTPUT_PATH = f"{OBS_DATA_PATH}/Flow"
     OBS_STAGE_OUTPUT_PATH = f"{OBS_DATA_PATH}/Stage"
 
@@ -1121,6 +1122,81 @@ class RasPlanHdf(RasGeomHdf):
         """
         return self.reference_timeseries_output(reftype="lines")
 
+    def bc_line_timeseries_output(self, bc_line_name: str) -> xr.Dataset:
+        """Return timeseries output data for a specific boundary condition line from a HEC-RAS HDF plan file.
+
+        Parameters
+        ----------
+        bc_line_name : str
+            The name of the boundary condition line.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with timeseries output data for the specified boundary condition line.
+        """
+        path = f"{self.BOUNDARY_CONDITIONS_OUTPUT_PATH}/{bc_line_name}"
+        dataset = self.get(path)
+        if dataset is None:
+            raise RasPlanHdfError(
+                f"Could not find HDF group at path '{path}'."
+                f" Does the Plan HDF file contain boundary condition output data for '{bc_line_name}'?"
+            )
+        columns = [c.decode("utf-8") for c in dataset.attrs["Columns"]]
+        ds = xr.Dataset()
+        try:
+            import dask.array as da
+
+            # TODO: user-specified chunks?
+            values = da.from_array(dataset, chunks=dataset.chunks)
+        except ImportError:
+            values = dataset[:]
+        for i, col in enumerate(columns):
+            units = dataset.attrs.get(col, None)
+            if units is not None:
+                units = units.decode("utf-8")
+            da = xr.DataArray(
+                values[:, i],
+                name=col,
+                dims=["time"],
+                coords={
+                    "time": self.unsteady_datetimes(),
+                },
+                attrs={
+                    "units": units,
+                    "hdf_path": f"{path}",
+                },
+            )
+            ds[col] = da
+        return ds
+
+    def bc_lines_timeseries_output(self) -> xr.Dataset:
+        """Return timeseries output data for boundary conditions lines from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with timeseries output data for boundary conditions lines.
+        """
+        df_bc_lines = self.bc_lines()
+        bc_lines_names = df_bc_lines["name"]
+        datasets = []
+        for bc_line_name in bc_lines_names:
+            ds_bc_line = self.bc_line_timeseries_output(bc_line_name)
+            datasets.append(ds_bc_line)
+        bc_line_ids = df_bc_lines["bc_line_id"].values
+        ds: xr.Dataset = xr.concat(
+            datasets, dim=pd.Index(bc_line_ids, name="bc_line_id")
+        )
+        ds = ds.assign_coords(
+            {
+                "bc_line_name": ("bc_line_id", bc_lines_names),
+                "bc_line_type": ("bc_line_id", df_bc_lines["type"]),
+                "mesh_name": ("bc_line_id", df_bc_lines["mesh_name"]),
+            }
+        )
+        return ds
+
     def observed_timeseries_input(self, vartype: str = "Flow") -> xr.DataArray:
         """Return observed timeseries input data for reference lines and points from a HEC-RAS HDF plan file.
 
@@ -1381,10 +1457,49 @@ class RasPlanHdf(RasGeomHdf):
         """
         return self.get_attrs(self.VOLUME_ACCOUNTING_PATH)
 
-    def enroachment_points(self) -> GeoDataFrame:  # noqa: D102
-        raise NotImplementedError
+    def encroachment_points(self, profile_name: str) -> GeoDataFrame:
+        """Return encroachment points from a HEC-RAS plan HDF file based on a user-specified flow profile.
+
+        Returns
+        -------
+        GeoDataframe
+            A GeoDataFrame with cross-section encroachments represented as Point geometry features along with pertinent attributes.
+        """
+        cross_sections = self.cross_sections()
+        cross_sections["Enc_Profile"] = profile_name
+
+        leftmost_sta = self.cross_sections_elevations()["elevation info"].apply(
+            lambda x: x[0][0]
+        )
+        left_enc_sta = self.cross_sections_additional_enc_station_left()[profile_name]
+        left_enc_points = GeoDataFrame(
+            pd.concat(
+                [
+                    cross_sections[["River", "Reach", "RS", "Enc_Profile"]],
+                    left_enc_sta.rename("Enc_Sta", inplace=False),
+                ],
+                axis=1,
+            ),
+            geometry=cross_sections.geometry.interpolate(left_enc_sta - leftmost_sta),
+        )
+        left_enc_points["Side"] = "Left"
+
+        right_enc_sta = self.cross_sections_additional_enc_station_right()[profile_name]
+        right_enc_points = GeoDataFrame(
+            pd.concat(
+                [
+                    cross_sections[["River", "Reach", "RS", "Enc_Profile"]],
+                    right_enc_sta.rename("Enc_Sta", inplace=False),
+                ],
+                axis=1,
+            ),
+            geometry=cross_sections.geometry.interpolate(right_enc_sta - leftmost_sta),
+        )
+        right_enc_points["Side"] = "Right"
+
+        return GeoDataFrame(pd.concat([left_enc_points, right_enc_points]))
 
-    def steady_flow_names(self) -> list:
+    def steady_flow_names(self) -> List[str]:
         """Return the profile information for each steady flow event.
 
         Returns
@@ -1393,7 +1508,7 @@ class RasPlanHdf(RasGeomHdf):
             A Dataframe containing the profile names for each event
         """
         if self.STEADY_PROFILES_PATH not in self:
-            return pd.DataFrame()
+            return []
 
         profile_data = self[self.STEADY_PROFILES_PATH]
         profile_attrs = profile_data["Profile Names"][()]
@@ -1511,7 +1626,7 @@ class RasPlanHdf(RasGeomHdf):
     def _zmeta(self, ds: xr.Dataset) -> Dict:
         """Given a xarray Dataset, return kerchunk-style zarr reference metadata."""
         from kerchunk.hdf import SingleHdf5ToZarr
-        import zarr
+        from zarr.storage import MemoryStore
         import base64
 
         encoding = {}
@@ -1546,7 +1661,7 @@ class RasPlanHdf(RasGeomHdf):
                 chunk_meta[chunk_key] = [str(self._loc), value["offset"], value["size"]]
         # "Write" the Dataset to a temporary in-memory zarr store (which
         # is the same a Python dictionary)
-        zarr_tmp = zarr.MemoryStore()
+        zarr_tmp = MemoryStore()
         # Use compute=False here because we don't _actually_ want to write
         # the data to the zarr store, we just want to generate the metadata.
         ds.to_zarr(zarr_tmp, mode="w", compute=False, encoding=encoding)

{rashdf-0.7.1 → rashdf-0.8.0}/src/rashdf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: rashdf
-Version: 0.7.1
+Version: 0.8.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -23,15 +23,17 @@ Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: kerchunk; extra == "dev"
-Requires-Dist: zarr; extra == "dev"
+Requires-Dist: zarr==2.18.2; extra == "dev"
 Requires-Dist: dask; extra == "dev"
 Requires-Dist: fsspec; extra == "dev"
 Requires-Dist: s3fs; extra == "dev"
 Requires-Dist: fiona==1.9.6; extra == "dev"
+Requires-Dist: numcodecs<0.16; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Dynamic: license-file
 
 # rashdf
 [![CI](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml/badge.svg?branch=main)](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml)

{rashdf-0.7.1 → rashdf-0.8.0}/src/rashdf.egg-info/requires.txt

@@ -9,11 +9,12 @@ ruff
 pytest
 pytest-cov
 kerchunk
-zarr
+zarr==2.18.2
 dask
 fsspec
 s3fs
 fiona==1.9.6
+numcodecs<0.16
 
 [docs]
 sphinx

{rashdf-0.7.1 → rashdf-0.8.0}/tests/test_geom.py

@@ -1,7 +1,9 @@
+import geopandas as gpd
 from pathlib import Path
 import h5py
 from pyproj import CRS
 from src.rashdf import RasGeomHdf
+from pandas.testing import assert_frame_equal
 
 from . import _create_hdf_with_group_attrs, _gdf_matches_json, _gdf_matches_json_alt
 
@@ -11,6 +13,8 @@ COAL_G01 = TEST_DATA / "ras/Coal.g01.hdf"
 BAXTER_P01 = TEST_DATA / "ras_1d/Baxter.p01.hdf"
 TEST_JSON = TEST_DATA / "json"
 BALD_EAGLE_P18_REF = TEST_DATA / "ras/BaldEagleDamBrk.reflines-refpts.p18.hdf"
+LOWER_KANAWHA_P01_IC_POINTS = TEST_DATA / "ras/LowerKanawha.p01.icpoints.hdf"
+LOWER_KANAWHA_P01_IC_POINTS_JSON = TEST_JSON / "LowerKanawha.p01.icpoints.geojson"
 
 TEST_ATTRS = {"test_attribute1": "test_str1", "test_attribute2": 500}
 
@@ -151,7 +155,7 @@ def test_reference_points_names():
 
 def test_structs_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.structures(), None)
+        assert ghdf.structures().empty
 
 
 def test_cross_sections():
@@ -164,7 +168,7 @@ def test_cross_sections():
 
 def test_cross_sections_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.cross_sections(), None)
+        assert ghdf.cross_sections().empty
 
 
 def test_river_reaches():
@@ -175,7 +179,7 @@ def test_river_reaches():
 
 def test_river_reaches_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.river_reaches(), None)
+        assert ghdf.river_reaches().empty
 
 
 def test_cross_sections_elevations():
@@ -186,4 +190,18 @@ def test_cross_sections_elevations():
 
 def test_cross_sections_elevations_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.cross_sections_elevations(), None)
+        assert ghdf.cross_sections_elevations().empty
+
+
+def test_ic_points():
+    with RasGeomHdf(LOWER_KANAWHA_P01_IC_POINTS) as ghdf:
+        gdf_ic_points = ghdf.ic_points()
+        valid_gdf = gpd.read_file(
+            LOWER_KANAWHA_P01_IC_POINTS_JSON,
+            crs=ghdf.projection(),
+        )
+        assert_frame_equal(
+            gdf_ic_points,
+            valid_gdf,
+            check_dtype=False,
+        )

{rashdf-0.7.1 → rashdf-0.8.0}/tests/test_plan.py

@@ -5,9 +5,11 @@ from src.rashdf.plan import (
     TimeSeriesOutputVar,
 )
 
+import builtins
 import filecmp
 import json
 from pathlib import Path
+from unittest import mock
 
 import numpy as np
 import pandas as pd
@@ -32,6 +34,7 @@ BALD_EAGLE_P18_REF = TEST_DATA / "ras/BaldEagleDamBrk.reflines-refpts.p18.hdf"
 DENTON = TEST_DATA / "ras/Denton.hdf"
 MUNCIE_G05 = TEST_DATA / "ras/Muncie.g05.hdf"
 COAL_G01 = TEST_DATA / "ras/Coal.g01.hdf"
+LOWER_KANAWHA_P01_BC_LINES = TEST_DATA / "ras/LowerKanawha.p01.bclines.hdf"
 BAXTER_P01 = TEST_DATA / "ras_1d/Baxter.p01.hdf"
 FLODENCR_P01 = TEST_DATA / "ras_1d/FLODENCR.p01.hdf"
 
@@ -322,6 +325,59 @@ def test_reference_lines_timeseries(tmp_path: Path):
     assert_frame_equal(df, valid_df)
 
 
+def test_bc_lines_timeseries(tmp_path: Path):
+    plan_hdf = RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES)
+    ds = plan_hdf.bc_lines_timeseries_output()
+    assert "time" in ds.coords
+    assert "bc_line_id" in ds.coords
+    assert "bc_line_name" in ds.coords
+    assert "mesh_name" in ds.coords
+    assert "Flow" in ds.variables
+    assert "Stage" in ds.variables
+
+    q = ds["Flow"]
+    assert q.chunks is not None  # Ensure Dask chunks are set
+    assert q.shape == (10, 577)
+    assert q.attrs["units"] == "cfs"
+
+    stage = ds["Stage"]
+    assert stage.chunks is not None  # Ensure Dask chunks are set
+    assert stage.shape == (10, 577)
+    assert stage.attrs["units"] == "ft"
+
+    df = ds.sel(bc_line_id=7).to_dataframe()
+    valid_df = pd.read_csv(
+        TEST_CSV / "LowerKanawha.p01.bclines.7.csv",
+        index_col="time",
+        parse_dates=True,
+        dtype={"Flow": np.float32, "Stage": np.float32},
+    )
+    assert_frame_equal(df, valid_df)
+
+
+def test_bc_lines_timeseries_no_dask(monkeypatch):
+    """Test that the bc_lines_timeseries_output method works without Dask."""
+    original_import = builtins.__import__
+
+    def mocked_import(name, *args, **kwargs):
+        if name == "dask.array":
+            raise ImportError("Dask is not available")
+        return original_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", mocked_import)
+
+    plan_hdf = RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES)
+    ds = plan_hdf.bc_lines_timeseries_output()
+    assert ds["Flow"].chunks is None  # Ensure no Dask chunks are set
+    assert ds["Stage"].chunks is None
+
+
+def test_bc_line_timeseries_error():
+    plan_hdf = RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES)
+    with pytest.raises(RasPlanHdfError):
+        plan_hdf.bc_line_timeseries_output("asdf")
+
+
 def test_reference_points(tmp_path: Path):
     plan_hdf = RasPlanHdf(BALD_EAGLE_P18_REF)
     gdf = plan_hdf.reference_points(datetime_to_str=True)
@@ -371,7 +427,7 @@ def test_cross_sections_additional_velocity_total():
 
 def test_cross_sections_additional_velocity_total_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_velocity_total(), None)
+        assert phdf.cross_sections_additional_velocity_total().empty
 
 
 def test_cross_sections_additional_area_total():
@@ -384,7 +440,7 @@ def test_cross_sections_additional_area_total():
 
 def test_cross_sections_additional_area_total_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_area_total(), None)
+        assert phdf.cross_sections_additional_area_total().empty
 
 
 def test_steady_flow_names():
@@ -394,7 +450,7 @@ def test_steady_flow_names():
 
 def test_steady_flow_names_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.steady_flow_names(), None)
+        assert phdf.steady_flow_names() == []
 
 
 def test_cross_sections_wsel():
@@ -405,7 +461,7 @@ def test_cross_sections_wsel():
 
 def test_cross_sections_wsel_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_wsel(), None)
+        assert phdf.cross_sections_wsel().empty
 
 
 def test_cross_sections_additional_enc_station_right():
@@ -419,7 +475,7 @@ def test_cross_sections_additional_enc_station_right():
 
 def test_cross_sections_additional_enc_station_right_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_enc_station_right(), None)
+        assert phdf.cross_sections_additional_enc_station_right().empty
 
 
 def test_cross_sections_additional_enc_station_left():
@@ -432,7 +488,7 @@ def test_cross_sections_additional_enc_station_left():
 
 def test_cross_sections_additional_enc_station_left_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_enc_station_left(), None)
+        assert phdf.cross_sections_additional_enc_station_left().empty
 
 
 def test_cross_sections_flow():
@@ -650,3 +706,12 @@ def test_observed_timeseries_input_rasplanhdf_error():
     with RasPlanHdf(BALD_EAGLE_P18) as phdf:
         with pytest.raises(RasPlanHdfError):
             phdf.observed_timeseries_input(vartype="Flow")
+
+
+def test_encroachment_points():
+    enc_pnts_json = TEST_JSON / "encroachment_points.json"
+    with RasPlanHdf(FLODENCR_P01) as phdf:
+        assert _gdf_matches_json_alt(
+            phdf.encroachment_points(profile_name="PF#2"),
+            enc_pnts_json,
+        )