rashdf 0.3.0__tar.gz → 0.4.0__tar.gz

{rashdf-0.3.0 → rashdf-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rashdf
-Version: 0.3.0
+Version: 0.4.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py
-Requires-Dist: geopandas
+Requires-Dist: geopandas<0.15,>=0.14
 Requires-Dist: pyarrow
 Requires-Dist: xarray
 Provides-Extra: dev

{rashdf-0.3.0 → rashdf-0.4.0}/pyproject.toml

@@ -12,8 +12,8 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
 ]
-version = "0.3.0"
-dependencies = ["h5py", "geopandas", "pyarrow", "xarray"]
+version = "0.4.0"
+dependencies = ["h5py", "geopandas>=0.14,<0.15", "pyarrow", "xarray"]
 
 [project.optional-dependencies]
 dev = ["pre-commit", "ruff", "pytest", "pytest-cov"]

{rashdf-0.3.0 → rashdf-0.4.0}/src/rashdf/geom.py

@@ -1,27 +1,27 @@
 """HEC-RAS Geometry HDF class."""
 
-from .base import RasHdf
-from .utils import (
-    convert_ras_hdf_string,
-    get_first_hdf_group,
-    hdf5_attrs_to_dict,
-    convert_ras_hdf_value,
-)
+from typing import Dict, List, Optional
 
 import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from pyproj import CRS
 from shapely import (
-    Polygon,
-    Point,
     LineString,
     MultiLineString,
     MultiPolygon,
+    Point,
+    Polygon,
     polygonize_full,
 )
 
-from typing import Dict, List, Optional
+from .base import RasHdf
+from .utils import (
+    convert_ras_hdf_string,
+    convert_ras_hdf_value,
+    get_first_hdf_group,
+    hdf5_attrs_to_dict,
+)
 
 
 class RasGeomHdf(RasHdf):
@@ -465,11 +465,97 @@ class RasGeomHdf(RasHdf):
     def terrain_modifications(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
 
-    def cross_sections(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+    def cross_sections(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """Return the model 1D cross sections.
 
-    def river_reaches(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the model 1D cross sections if they exist.
+        """
+        if "/Geometry/Cross Sections" not in self:
+            return GeoDataFrame()
+
+        xs_data = self["/Geometry/Cross Sections"]
+        v_conv_val = np.vectorize(convert_ras_hdf_value)
+        xs_attrs = xs_data["Attributes"][()]
+        xs_dict = {"xs_id": range(xs_attrs.shape[0])}
+        xs_dict.update(
+            {name: v_conv_val(xs_attrs[name]) for name in xs_attrs.dtype.names}
+        )
+        geoms = list()
+        for pnt_start, pnt_cnt, part_start, part_cnt in xs_data["Polyline Info"][()]:
+            points = xs_data["Polyline Points"][()][pnt_start : pnt_start + pnt_cnt]
+            if part_cnt == 1:
+                geoms.append(LineString(points))
+            else:
+                parts = xs_data["Polyline Parts"][()][
+                    part_start : part_start + part_cnt
+                ]
+                geoms.append(
+                    MultiLineString(
+                        list(
+                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
+                            for part_pnt_start, part_pnt_cnt in parts
+                        )
+                    )
+                )
+        xs_gdf = GeoDataFrame(
+            xs_dict,
+            geometry=geoms,
+            crs=self.projection(),
+        )
+        if datetime_to_str:
+            xs_gdf["Last Edited"] = xs_gdf["Last Edited"].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+        return xs_gdf
+
+    def river_reaches(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """Return the model 1D river reach lines.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the model 1D river reach lines if they exist.
+        """
+        if "/Geometry/River Centerlines" not in self:
+            return GeoDataFrame()
+
+        river_data = self["/Geometry/River Centerlines"]
+        v_conv_val = np.vectorize(convert_ras_hdf_value)
+        river_attrs = river_data["Attributes"][()]
+        river_dict = {"river_id": range(river_attrs.shape[0])}
+        river_dict.update(
+            {name: v_conv_val(river_attrs[name]) for name in river_attrs.dtype.names}
+        )
+        geoms = list()
+        for pnt_start, pnt_cnt, part_start, part_cnt in river_data["Polyline Info"][()]:
+            points = river_data["Polyline Points"][()][pnt_start : pnt_start + pnt_cnt]
+            if part_cnt == 1:
+                geoms.append(LineString(points))
+            else:
+                parts = river_data["Polyline Parts"][()][
+                    part_start : part_start + part_cnt
+                ]
+                geoms.append(
+                    MultiLineString(
+                        list(
+                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
+                            for part_pnt_start, part_pnt_cnt in parts
+                        )
+                    )
+                )
+        river_gdf = GeoDataFrame(
+            river_dict,
+            geometry=geoms,
+            crs=self.projection(),
+        )
+        if datetime_to_str:
+            river_gdf["Last Edited"] = river_gdf["Last Edited"].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+        return river_gdf
 
     def flowpaths(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
@@ -488,3 +574,33 @@ class RasGeomHdf(RasHdf):
 
     def blocked_obstructions(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
+
+    def cross_sections_elevations(self, round_to: int = 2) -> pd.DataFrame:
+        """Return the model cross section elevation information.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the model cross section elevation information if they exist.
+        """
+        path = "/Geometry/Cross Sections"
+        if path not in self:
+            return pd.DataFrame()
+
+        xselev_data = self[path]
+        xs_df = self.cross_sections()
+        elevations = list()
+        for part_start, part_cnt in xselev_data["Station Elevation Info"][()]:
+            xzdata = xselev_data["Station Elevation Values"][()][
+                part_start : part_start + part_cnt
+            ]
+            elevations.append(xzdata)
+
+        xs_elev_df = xs_df[
+            ["xs_id", "River", "Reach", "RS", "Left Bank", "Right Bank"]
+        ].copy()
+        xs_elev_df["Left Bank"] = xs_elev_df["Left Bank"].round(round_to).astype(str)
+        xs_elev_df["Right Bank"] = xs_elev_df["Right Bank"].round(round_to).astype(str)
+        xs_elev_df["elevation info"] = elevations
+
+        return xs_elev_df

{rashdf-0.3.0 → rashdf-0.4.0}/src/rashdf/plan.py

@@ -25,6 +25,26 @@ class RasPlanHdfError(Exception):
     pass
 
 
+class XsSteadyOutputVar(Enum):
+    """Summary of steady cross section output variables."""
+
+    ENERGY_GRADE = "Energy Grade"
+    FLOW = "Flow"
+    WATER_SURFACE = "Water Surface"
+    ENCROACHMENT_STATION_LEFT = "Encroachment Station Left"
+    ENCROACHMENT_STATION_RIGHT = "Encroachment Station Right"
+    AREA_INEFFECTIVE_TOTAL = "Area including Ineffective Total"
+    VELOCITY_TOTAL = "Velocity Total"
+
+
+XS_STEADY_OUTPUT_ADDITIONAL = [
+    XsSteadyOutputVar.ENCROACHMENT_STATION_LEFT,
+    XsSteadyOutputVar.ENCROACHMENT_STATION_RIGHT,
+    XsSteadyOutputVar.AREA_INEFFECTIVE_TOTAL,
+    XsSteadyOutputVar.VELOCITY_TOTAL,
+]
+
+
 class SummaryOutputVar(Enum):
     """Summary output variables."""
 
@@ -144,6 +164,12 @@ class RasPlanHdf(RasGeomHdf):
     )
     UNSTEADY_TIME_SERIES_PATH = f"{BASE_OUTPUT_PATH}/Unsteady Time Series"
 
+    RESULTS_STEADY_PATH = "Results/Steady"
+    BASE_STEADY_PATH = f"{RESULTS_STEADY_PATH}/Output/Output Blocks/Base Output"
+    STEADY_PROFILES_PATH = f"{BASE_STEADY_PATH}/Steady Profiles"
+    STEADY_XS_PATH = f"{STEADY_PROFILES_PATH}/Cross Sections"
+    STEADY_XS_ADDITIONAL_PATH = f"{STEADY_XS_PATH}/Additional Variables"
+
     def __init__(self, name: str, **kwargs):
         """Open a HEC-RAS Plan HDF file.
 
@@ -957,3 +983,127 @@ class RasPlanHdf(RasGeomHdf):
 
     def enroachment_points(self) -> GeoDataFrame:  # noqa: D102
         raise NotImplementedError
+
+    def steady_flow_names(self) -> list:
+        """Return the profile information for each steady flow event.
+
+        Returns
+        -------
+        DataFrame
+            A Dataframe containing the profile names for each event
+        """
+        if self.STEADY_PROFILES_PATH not in self:
+            return pd.DataFrame()
+
+        profile_data = self[self.STEADY_PROFILES_PATH]
+        profile_attrs = profile_data["Profile Names"][()]
+
+        return [x.decode("utf-8") for x in profile_attrs]
+
+    def steady_profile_xs_output(
+        self, var: XsSteadyOutputVar, round_to: int = 2
+    ) -> DataFrame:
+        """Create a Dataframe from steady cross section results based on path.
+
+        Parameters
+        ----------
+        var : XsSteadyOutputVar
+            The name of the table in the steady results that information is to be retireved from.
+
+        round_to : int, optional
+            Number of decimal places to round output data to.
+
+        Returns
+        -------
+            Dataframe with desired hdf data.
+        """
+        if var in XS_STEADY_OUTPUT_ADDITIONAL:
+            path = f"{self.STEADY_XS_ADDITIONAL_PATH}/{var.value}"
+        else:
+            path = f"{self.STEADY_XS_PATH}/{var.value}"
+        if path not in self:
+            return DataFrame()
+
+        profiles = self.steady_flow_names()
+
+        steady_data = self[path]
+        df = DataFrame(steady_data, index=profiles)
+        df_t = df.T.copy()
+        for p in profiles:
+            df_t[p] = df_t[p].apply(lambda x: round(x, round_to))
+
+        return df_t
+
+    def cross_sections_wsel(self) -> DataFrame:
+        """Return the water surface elevation information for each 1D Cross Section.
+
+        Returns
+        -------
+        DataFrame
+            A Dataframe containing the water surface elevations for each cross section and event
+        """
+        return self.steady_profile_xs_output(XsSteadyOutputVar.WATER_SURFACE)
+
+    def cross_sections_flow(self) -> DataFrame:
+        """Return the Flow information for each 1D Cross Section.
+
+        Returns
+        -------
+        DataFrame
+            A Dataframe containing the flow for each cross section and event
+        """
+        return self.steady_profile_xs_output(XsSteadyOutputVar.FLOW)
+
+    def cross_sections_energy_grade(self) -> DataFrame:
+        """Return the energy grade information for each 1D Cross Section.
+
+        Returns
+        -------
+        DataFrame
+            A Dataframe containing the water surface elevations for each cross section and event
+        """
+        return self.steady_profile_xs_output(XsSteadyOutputVar.ENERGY_GRADE)
+
+    def cross_sections_additional_enc_station_left(self) -> DataFrame:
+        """Return the left side encroachment information for a floodway plan hdf.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the cross sections left side encroachment stations
+        """
+        return self.steady_profile_xs_output(
+            XsSteadyOutputVar.ENCROACHMENT_STATION_LEFT
+        )
+
+    def cross_sections_additional_enc_station_right(self) -> DataFrame:
+        """Return the right side encroachment information for a floodway plan hdf.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the cross sections right side encroachment stations
+        """
+        return self.steady_profile_xs_output(
+            XsSteadyOutputVar.ENCROACHMENT_STATION_RIGHT
+        )
+
+    def cross_sections_additional_area_total(self) -> DataFrame:
+        """Return the 1D cross section area for each profile.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the wet area inside the cross sections
+        """
+        return self.steady_profile_xs_output(XsSteadyOutputVar.AREA_INEFFECTIVE_TOTAL)
+
+    def cross_sections_additional_velocity_total(self) -> DataFrame:
+        """Return the 1D cross section velocity for each profile.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the velocity inside the cross sections
+        """
+        return self.steady_profile_xs_output(XsSteadyOutputVar.VELOCITY_TOTAL)

{rashdf-0.3.0 → rashdf-0.4.0}/src/rashdf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rashdf
-Version: 0.3.0
+Version: 0.4.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py
-Requires-Dist: geopandas
+Requires-Dist: geopandas<0.15,>=0.14
 Requires-Dist: pyarrow
 Requires-Dist: xarray
 Provides-Extra: dev

{rashdf-0.3.0 → rashdf-0.4.0}/src/rashdf.egg-info/requires.txt

@@ -1,5 +1,5 @@
 h5py
-geopandas
+geopandas<0.15,>=0.14
 pyarrow
 xarray
 

{rashdf-0.3.0 → rashdf-0.4.0}/tests/test_geom.py

@@ -1,15 +1,14 @@
-from src.rashdf import RasGeomHdf
-
+from pathlib import Path
 import h5py
-from geopandas import GeoDataFrame
 from pyproj import CRS
-from pathlib import Path
+from src.rashdf import RasGeomHdf
 
-from . import _create_hdf_with_group_attrs, _gdf_matches_json
+from . import _create_hdf_with_group_attrs, _gdf_matches_json, _gdf_matches_json_alt
 
 TEST_DATA = Path("./tests/data")
 MUNCIE_G05 = TEST_DATA / "ras/Muncie.g05.hdf"
 COAL_G01 = TEST_DATA / "ras/Coal.g01.hdf"
+BAXTER_P01 = TEST_DATA / "ras_1d/Baxter.p01.hdf"
 TEST_JSON = TEST_DATA / "json"
 
 TEST_ATTRS = {"test_attribute1": "test_str1", "test_attribute2": 500}
@@ -118,3 +117,43 @@ def test_structs():
     structs_json = TEST_JSON / "structures.json"
     with RasGeomHdf(MUNCIE_G05) as ghdf:
         assert _gdf_matches_json(ghdf.structures(datetime_to_str=True), structs_json)
+
+
+def test_structs_not_found():
+    with RasGeomHdf(COAL_G01) as ghdf:
+        assert (ghdf.structures(), None)
+
+
+def test_cross_sections():
+    cross_section_json = TEST_JSON / "cross_sections.json"
+    with RasGeomHdf(BAXTER_P01) as ghdf:
+        assert _gdf_matches_json_alt(
+            ghdf.cross_sections(datetime_to_str=True), cross_section_json
+        )
+
+
+def test_cross_sections_not_found():
+    with RasGeomHdf(COAL_G01) as ghdf:
+        assert (ghdf.cross_sections(), None)
+
+
+def test_river_reaches():
+    river_reaches_json = TEST_JSON / "river_reaches.json"
+    with RasGeomHdf(BAXTER_P01) as ghdf:
+        assert _gdf_matches_json_alt(ghdf.river_reaches(), river_reaches_json)
+
+
+def test_river_reaches_not_found():
+    with RasGeomHdf(COAL_G01) as ghdf:
+        assert (ghdf.river_reaches(), None)
+
+
+def test_cross_sections_elevations():
+    xs_elevs_json = TEST_JSON / "xs_elevations.json"
+    with RasGeomHdf(BAXTER_P01) as ghdf:
+        assert _gdf_matches_json_alt(ghdf.cross_sections_elevations(), xs_elevs_json)
+
+
+def test_cross_sections_elevations_not_found():
+    with RasGeomHdf(COAL_G01) as ghdf:
+        assert (ghdf.cross_sections_elevations(), None)

{rashdf-0.3.0 → rashdf-0.4.0}/tests/test_plan.py

@@ -12,7 +12,12 @@ import pandas as pd
 from pandas.testing import assert_frame_equal
 import pytest
 
-from . import _create_hdf_with_group_attrs, _gdf_matches_json, get_sha1_hash
+from . import (
+    _create_hdf_with_group_attrs,
+    _gdf_matches_json,
+    get_sha1_hash,
+    _gdf_matches_json_alt,
+)
 
 TEST_DATA = Path("./tests/data")
 TEST_JSON = TEST_DATA / "json"
@@ -21,6 +26,9 @@ TEST_ATTRS = {"test_attribute1": "test_str1", "test_attribute2": 500}
 BALD_EAGLE_P18 = TEST_DATA / "ras/BaldEagleDamBrk.p18.hdf"
 BALD_EAGLE_P18_TIMESERIES = TEST_DATA / "ras/BaldEagleDamBrk.p18.timeseries.hdf"
 MUNCIE_G05 = TEST_DATA / "ras/Muncie.g05.hdf"
+COAL_G01 = TEST_DATA / "ras/Coal.g01.hdf"
+BAXTER_P01 = TEST_DATA / "ras_1d/Baxter.p01.hdf"
+FLODENCR_P01 = TEST_DATA / "ras_1d/FLODENCR.p01.hdf"
 
 
 def test_get_plan_info_attrs(tmp_path):
@@ -256,3 +264,91 @@ def test_mesh_timeseries_output_faces():
             dtype={"Face Velocity": np.float32},
         )
         assert_frame_equal(df, valid_df)
+
+
+def test_cross_sections_additional_velocity_total():
+    xs_velocity_json = TEST_JSON / "xs_velocity.json"
+    with RasPlanHdf(BAXTER_P01) as phdf:
+        assert _gdf_matches_json_alt(
+            phdf.cross_sections_additional_velocity_total(), xs_velocity_json
+        )
+
+
+def test_cross_sections_additional_velocity_total_not_found():
+    with RasPlanHdf(COAL_G01) as phdf:
+        assert (phdf.cross_sections_additional_velocity_total(), None)
+
+
+def test_cross_sections_additional_area_total():
+    xs_area_json = TEST_JSON / "xs_area.json"
+    with RasPlanHdf(BAXTER_P01) as phdf:
+        assert _gdf_matches_json_alt(
+            phdf.cross_sections_additional_area_total(), xs_area_json
+        )
+
+
+def test_cross_sections_additional_area_total_not_found():
+    with RasPlanHdf(COAL_G01) as phdf:
+        assert (phdf.cross_sections_additional_area_total(), None)
+
+
+def test_steady_flow_names():
+    with RasPlanHdf(BAXTER_P01) as phdf:
+        assert phdf.steady_flow_names() == ["Big"]
+
+
+def test_steady_flow_names_not_found():
+    with RasPlanHdf(COAL_G01) as phdf:
+        assert (phdf.steady_flow_names(), None)
+
+
+def test_cross_sections_wsel():
+    xs_wsel_json = TEST_JSON / "xs_wsel.json"
+    with RasPlanHdf(BAXTER_P01) as phdf:
+        assert _gdf_matches_json_alt(phdf.cross_sections_wsel(), xs_wsel_json)
+
+
+def test_cross_sections_wsel_not_found():
+    with RasPlanHdf(COAL_G01) as phdf:
+        assert (phdf.cross_sections_wsel(), None)
+
+
+def test_cross_sections_additional_enc_station_right():
+    xs_enc_station_right_json = TEST_JSON / "xs_enc_station_right.json"
+    with RasPlanHdf(FLODENCR_P01) as phdf:
+        assert _gdf_matches_json_alt(
+            phdf.cross_sections_additional_enc_station_right(),
+            xs_enc_station_right_json,
+        )
+
+
+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)
+
+
+def test_cross_sections_additional_enc_station_left():
+    xs_enc_station_left_json = TEST_JSON / "xs_enc_station_left.json"
+    with RasPlanHdf(FLODENCR_P01) as phdf:
+        assert _gdf_matches_json_alt(
+            phdf.cross_sections_additional_enc_station_left(), xs_enc_station_left_json
+        )
+
+
+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)
+
+
+def test_cross_sections_flow():
+    xs_flow_json = TEST_JSON / "xs_flow.json"
+    with RasPlanHdf(BAXTER_P01) as phdf:
+        assert _gdf_matches_json_alt(phdf.cross_sections_flow(), xs_flow_json)
+
+
+def test_cross_sections_energy_grade():
+    xs_energy_grade_json = TEST_JSON / "xs_energy_grade.json"
+    with RasPlanHdf(BAXTER_P01) as phdf:
+        assert _gdf_matches_json_alt(
+            phdf.cross_sections_energy_grade(), xs_energy_grade_json
+        )