ras-commander 0.45.0__py3-none-any.whl → 0.47.0__py3-none-any.whl

ras_commander/HdfBndry.py

@@ -70,9 +70,9 @@ class HdfBndry:
                 return gpd.GeoDataFrame(
                     {
                         "bc_line_id": bc_line_ids,
-                        "name": names,
+                        "Name": names,
                         "mesh_name": mesh_names,
-                        "type": types,
+                        "Type": types,
                         "geometry": geoms,
                     },
                     geometry="geometry",
@@ -110,7 +110,7 @@ class HdfBndry:
                 )
                 geoms = HdfBndry._get_polylines(hdf_file, breaklines_path)
                 return gpd.GeoDataFrame(
-                    {"bl_id": bl_line_ids, "name": names, "geometry": geoms},
+                    {"bl_id": bl_line_ids, "Name": names, "geometry": geoms},
                     geometry="geometry",
                     crs=HdfUtils.projection(hdf_file),
                 )
@@ -158,7 +158,7 @@ class HdfBndry:
                             )
                         )
                 return gpd.GeoDataFrame(
-                    {"rr_id": rr_ids, "name": names, "geometry": geoms},
+                    {"rr_id": rr_ids, "Name": names, "geometry": geoms},
                     geometry="geometry",
                     crs=HdfUtils.projection(hdf_file),
                 )
@@ -242,9 +242,9 @@ class HdfBndry:
                 return gpd.GeoDataFrame(
                     {
                         "refln_id": refline_ids,
-                        "refln_name": names,
-                        "mesh_name": mesh_names,
-                        "type": types,
+                        "Name": names,
+                        "mesh-name": mesh_names,
+                        "Type": types,
                         "geometry": geoms,
                     },
                     geometry="geometry",
@@ -286,9 +286,9 @@ class HdfBndry:
                 return gpd.GeoDataFrame(
                     {
                         "refpt_id": range(attributes.shape[0]),
-                        "refpt_name": names,
+                        "Name": names,
                         "mesh_name": mesh_names,
-                        "cell_id": cell_id,
+                        "Cell Index": cell_id,
                         "geometry": list(map(Point, points)),
                     },
                     geometry="geometry",

ras_commander/HdfFluvialPluvial.py

@@ -0,0 +1,317 @@
+from typing import Dict, List, Tuple
+import pandas as pd
+import geopandas as gpd
+import matplotlib.pyplot as plt
+from collections import defaultdict
+from rtree import index
+from shapely.geometry import LineString, MultiLineString
+from tqdm import tqdm
+
+from .HdfMesh import HdfMesh
+from .HdfUtils import HdfUtils
+
+class HdfFluvialPluvial:
+    """
+    A class for analyzing and visualizing fluvial-pluvial boundaries in HEC-RAS 2D model results.
+
+    This class provides methods to process and visualize HEC-RAS 2D model outputs,
+    specifically focusing on the delineation of fluvial and pluvial flood areas.
+    It includes functionality for plotting maximum water surface elevations,
+    extracting cell polygons, and calculating fluvial-pluvial boundaries based on
+    the timing of maximum water surface elevations.
+
+    Key Features:
+    - Plotting maximum water surface elevations and their timing
+    - Extracting and visualizing 2D flow area cell polygons
+    - Calculating and visualizing fluvial-pluvial boundaries
+
+    Data Requirements:
+    1. For plotting maximum water surface:
+       - Use HdfResultsMesh.mesh_max_ws(hdf_path) to get max_ws_df
+       - Use HdfResultsMesh.mesh_timeseries_output(hdf_path, mesh_name, 'water_surface') 
+         to get time series data
+
+    2. For extracting cell polygons:
+       - Use HdfMesh.mesh_cell_polygons(geom_hdf_path) to get cell_polygons_df
+       - Use HdfUtils.projection(hdf_path) to get the projection
+
+    3. For calculating fluvial-pluvial boundary:
+       - Requires cell_polygons_gdf (from step 2)
+       - Requires max_ws_df with 'cell_id' and 'max_wsel_time' columns
+         (can be derived from HdfResultsMesh.mesh_max_ws(hdf_path))
+
+    Usage:
+    To use this class effectively, first initialize a RasPrj object and load the
+    necessary HDF files. Then, use the methods provided to analyze and visualize
+    the fluvial-pluvial characteristics of your 2D model results.
+
+    Example:
+        ras = RasPrj()
+        ras = init_ras_project(project_path, ras_version)
+        hdf_path = ras.get_plan_value(plan_number, 'Results_Output')
+        
+        # Get maximum water surface data
+        max_ws_df = HdfResultsMesh.mesh_max_ws(hdf_path)
+        
+        # Plot maximum water surface
+        HdfFluvialPluvial.plot_max_water_surface(max_ws_df)
+        
+        # Extract cell polygons
+        cell_polygons_df = HdfMesh.mesh_cell_polygons(hdf_path)
+        projection = HdfUtils.projection(hdf_path)
+        cell_polygons_gdf = HdfFluvialPluvial.plot_cell_polygons(cell_polygons_df, projection)
+        
+        # Calculate fluvial-pluvial boundary
+        boundary_gdf = HdfFluvialPluvial.calculate_fluvial_pluvial_boundary(cell_polygons_gdf, max_ws_df)
+
+    Note: Ensure that you have the necessary permissions and have initialized
+    the RAS project correctly before attempting to access HDF files.
+    """
+
+    @staticmethod
+    def plot_max_water_surface(max_ws_df):
+        """
+        Plots the maximum water surface elevation per cell.
+
+        Parameters:
+        - max_ws_df: DataFrame containing merged data with coordinates and max water surface.
+
+        Returns:
+        - None
+        """
+        # Extract x and y coordinates from the geometry column
+        max_ws_df['x'] = max_ws_df['geometry'].apply(lambda geom: geom.x if geom is not None else None)
+        max_ws_df['y'] = max_ws_df['geometry'].apply(lambda geom: geom.y if geom is not None else None)
+
+        # Check if 'x' and 'y' columns exist in max_ws_df
+        if 'x' not in max_ws_df.columns or 'y' not in max_ws_df.columns:
+            print("Error: 'x' or 'y' columns not found in the merged dataframe.")
+            print("Available columns:", max_ws_df.columns.tolist())
+            return
+
+        # Create the plot
+        fig, ax = plt.subplots(figsize=(12, 8))
+        scatter = ax.scatter(max_ws_df['x'], max_ws_df['y'], c=max_ws_df['maximum_water_surface'], cmap='viridis', s=10)
+
+        # Customize the plot
+        ax.set_title('Max Water Surface per Cell')
+        ax.set_xlabel('X Coordinate')
+        ax.set_ylabel('Y Coordinate')
+        plt.colorbar(scatter, label='Max Water Surface (ft)')
+
+        # Add grid lines
+        ax.grid(True, linestyle='--', alpha=0.7)
+
+        # Increase font size for better readability
+        plt.rcParams.update({'font.size': 12})
+
+        # Adjust layout to prevent cutting off labels
+        plt.tight_layout()
+
+        # Show the plot
+        plt.show()
+    
+    
+    
+
+    @staticmethod
+    def plot_max_wsel_time(max_ws_df: pd.DataFrame) -> None:
+        """
+        Plots the time of the maximum water surface elevation (WSEL) per cell.
+
+        Parameters:
+        - max_ws_df: DataFrame containing merged data with coordinates and max water surface.
+
+        Returns:
+        - None
+        """
+        max_ws_df['max_wsel_time'] = pd.to_datetime(max_ws_df['maximum_water_surface_time'])
+        HdfFluvialPluvial._extract_coordinates(max_ws_df)
+
+        if 'x' not in max_ws_df.columns or 'y' not in max_ws_df.columns:
+            raise ValueError("x and y coordinates are missing from the DataFrame. Make sure the 'face_point' column exists and contains valid coordinate data.")
+
+        fig, ax = plt.subplots(figsize=(12, 8))
+
+        min_time = max_ws_df['max_wsel_time'].min()
+        color_values = (max_ws_df['max_wsel_time'] - min_time).dt.total_seconds() / 3600
+
+        scatter = ax.scatter(max_ws_df['x'], max_ws_df['y'], c=color_values, cmap='viridis', s=10)
+
+        ax.set_title('Time of Maximum Water Surface Elevation per Cell')
+        ax.set_xlabel('X Coordinate')
+        ax.set_ylabel('Y Coordinate')
+
+        cbar = plt.colorbar(scatter)
+        cbar.set_label('Hours since simulation start')
+        cbar.set_ticks(range(0, int(color_values.max()) + 1, 6))
+        cbar.set_ticklabels([f'{h}h' for h in range(0, int(color_values.max()) + 1, 6)])
+
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.rcParams.update({'font.size': 12})
+        plt.tight_layout()
+        plt.show()
+
+        HdfFluvialPluvial._print_max_wsel_info(max_ws_df, min_time)
+
+    @staticmethod
+    def plot_cell_polygons(cell_polygons_df: pd.DataFrame, projection: str) -> gpd.GeoDataFrame:
+        """
+        Plots the cell polygons from the provided DataFrame and returns the GeoDataFrame.
+
+        Args:
+            cell_polygons_df (pd.DataFrame): DataFrame containing cell polygons.
+            projection (str): The coordinate reference system to assign to the GeoDataFrame.
+
+        Returns:
+            gpd.GeoDataFrame: GeoDataFrame containing the cell polygons.
+        """
+        if cell_polygons_df.empty:
+            print("No Cell Polygons found.")
+            return None
+
+        cell_polygons_gdf = HdfFluvialPluvial._convert_to_geodataframe(cell_polygons_df, projection)
+
+        print("Cell Polygons CRS:", cell_polygons_gdf.crs)
+        display(cell_polygons_gdf.head())
+
+        fig, ax = plt.subplots(figsize=(12, 8))
+        cell_polygons_gdf.plot(ax=ax, edgecolor='blue', facecolor='none')
+        ax.set_xlabel('X Coordinate')
+        ax.set_ylabel('Y Coordinate')
+        ax.set_title('2D Flow Area Cell Polygons')
+        ax.grid(True)
+        plt.tight_layout()
+        plt.show()
+
+        return cell_polygons_gdf
+
+    @staticmethod
+    def calculate_fluvial_pluvial_boundary(cell_polygons_gdf: gpd.GeoDataFrame, max_ws_df: pd.DataFrame, delta_t: float = 12) -> gpd.GeoDataFrame:
+        """
+        Calculate the fluvial-pluvial boundary based on cell polygons and maximum water surface elevation times.
+
+        Args:
+            cell_polygons_gdf (gpd.GeoDataFrame): GeoDataFrame containing cell polygons with 'cell_id' and 'geometry' columns.
+            max_ws_df (pd.DataFrame): DataFrame containing 'cell_id' and 'max_wsel_time' columns.
+            delta_t (float): Threshold time difference in hours. Default is 12 hours.
+
+        Returns:
+            gpd.GeoDataFrame: GeoDataFrame containing the fluvial-pluvial boundary as simple LineStrings.
+        """
+        cell_adjacency, common_edges = HdfFluvialPluvial._process_cell_adjacencies(cell_polygons_gdf)
+        cell_times = max_ws_df.set_index('cell_id')['max_wsel_time'].to_dict()
+        boundary_edges = HdfFluvialPluvial._identify_boundary_edges(cell_adjacency, common_edges, cell_times, delta_t)
+
+        # Join adjacent LineStrings into simple LineStrings
+        joined_lines = []
+        current_line = []
+
+        for edge in boundary_edges:
+            if not current_line:
+                current_line.append(edge)
+            else:
+                if current_line[-1].coords[-1] == edge.coords[0]:  # Check if the last point of the current line matches the first point of the new edge
+                    current_line.append(edge)
+                else:
+                    # Create a simple LineString from the current line and reset
+                    joined_lines.append(LineString([point for line in current_line for point in line.coords]))
+                    current_line = [edge]
+
+        # Add the last collected line if exists
+        if current_line:
+            joined_lines.append(LineString([point for line in current_line for point in line.coords]))
+
+        boundary_gdf = gpd.GeoDataFrame(geometry=joined_lines, crs=cell_polygons_gdf.crs)
+        return boundary_gdf
+
+    @staticmethod
+    def _print_max_wsel_info(max_ws_df: pd.DataFrame, min_time: pd.Timestamp) -> None:
+        max_wsel_row = max_ws_df.loc[max_ws_df['maximum_water_surface'].idxmax()]
+        hours_since_start = (max_wsel_row['max_wsel_time'] - min_time).total_seconds() / 3600
+        print(f"\nOverall Maximum WSEL: {max_wsel_row['maximum_water_surface']:.2f} ft")
+        print(f"Time of Overall Maximum WSEL: {max_wsel_row['max_wsel_time']}")
+        print(f"Hours since simulation start: {hours_since_start:.2f} hours")
+        print(f"Location of Overall Maximum WSEL: X={max_wsel_row['x']}, Y={max_wsel_row['y']}")
+
+    @staticmethod
+    def _process_cell_adjacencies(cell_polygons_gdf: gpd.GeoDataFrame) -> Tuple[Dict[int, List[int]], Dict[int, Dict[int, LineString]]]:
+        cell_adjacency = defaultdict(list)
+        common_edges = defaultdict(dict)
+        idx = index.Index()
+        for i, geom in enumerate(cell_polygons_gdf.geometry):
+            idx.insert(i, geom.bounds)
+
+        with tqdm(total=len(cell_polygons_gdf), desc="Processing cell adjacencies") as pbar:
+            for idx1, row1 in cell_polygons_gdf.iterrows():
+                cell_id1 = row1['cell_id']
+                poly1 = row1['geometry']
+                potential_neighbors = list(idx.intersection(poly1.bounds))
+                
+                for idx2 in potential_neighbors:
+                    if idx1 >= idx2:
+                        continue
+                    
+                    row2 = cell_polygons_gdf.iloc[idx2]
+                    cell_id2 = row2['cell_id']
+                    poly2 = row2['geometry']
+                    
+                    if poly1.touches(poly2):
+                        intersection = poly1.intersection(poly2)
+                        if isinstance(intersection, LineString):
+                            cell_adjacency[cell_id1].append(cell_id2)
+                            cell_adjacency[cell_id2].append(cell_id1)
+                            common_edges[cell_id1][cell_id2] = intersection
+                            common_edges[cell_id2][cell_id1] = intersection
+                
+                pbar.update(1)
+        
+        return cell_adjacency, common_edges
+
+    @staticmethod
+    def _identify_boundary_edges(cell_adjacency: Dict[int, List[int]], common_edges: Dict[int, Dict[int, LineString]], cell_times: Dict[int, pd.Timestamp], delta_t: float) -> List[LineString]:
+        boundary_edges = []
+        with tqdm(total=len(cell_adjacency), desc="Processing cell adjacencies") as pbar:
+            for cell_id, neighbors in cell_adjacency.items():
+                cell_time = cell_times[cell_id]
+                
+                for neighbor_id in neighbors:
+                    neighbor_time = cell_times[neighbor_id]
+                    time_diff = abs((cell_time - neighbor_time).total_seconds() / 3600)
+                    
+                    if time_diff >= delta_t:
+                        boundary_edges.append(common_edges[cell_id][neighbor_id])
+                
+                pbar.update(1)
+        return boundary_edges
+
+    @staticmethod
+    def _extract_coordinates(df: pd.DataFrame) -> None:
+        """
+        Extract x and y coordinates from the 'face_point' column.
+
+        Parameters:
+        - df: DataFrame containing the 'face_point' column.
+
+        Returns:
+        - None (modifies the DataFrame in-place)
+        """
+        if 'face_point' in df.columns:
+            df[['x', 'y']] = df['face_point'].str.strip('()').str.split(',', expand=True).astype(float)
+        else:
+            print("Warning: 'face_point' column not found in the DataFrame.")
+
+    @staticmethod
+    def _convert_to_geodataframe(df: pd.DataFrame, projection: str) -> gpd.GeoDataFrame:
+        """
+        Convert a DataFrame to a GeoDataFrame.
+
+        Parameters:
+        - df: DataFrame containing 'geometry' column.
+        - projection: The coordinate reference system to assign to the GeoDataFrame.
+
+        Returns:
+        - GeoDataFrame with the specified projection.
+        """
+        gdf = gpd.GeoDataFrame(df, geometry='geometry', crs=projection)
+        return gdf

ras_commander/HdfMesh.py

@@ -39,8 +39,6 @@ class HdfMesh:
     Note: This class relies on HdfBase and HdfUtils for some underlying operations.
     """
 
-    FLOW_AREA_2D_PATH = "Geometry/2D Flow Areas"
-
     def __init__(self):
         self.logger = logging.getLogger(__name__)
 
@@ -62,12 +60,12 @@ class HdfMesh:
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                if HdfMesh.FLOW_AREA_2D_PATH not in hdf_file:
+                if "Geometry/2D Flow Areas" not in hdf_file:
                     return list()
                 return list(
                     [
-                        HdfUtils.convert_ras_hdf_string(n)
-                        for n in hdf_file[f"{HdfMesh.FLOW_AREA_2D_PATH}/Attributes"][()]["Name"]
+                        HdfUtils.convert_ras_hdf_string(n.decode('utf-8'))  # Decode as UTF-8
+                        for n in hdf_file["Geometry/2D Flow Areas/Attributes"][()]["Name"]
                     ]
                 )
         except Exception as e:
@@ -96,7 +94,7 @@ class HdfMesh:
                 if not mesh_area_names:
                     return GeoDataFrame()
                 mesh_area_polygons = [
-                    Polygon(hdf_file[f"{HdfMesh.FLOW_AREA_2D_PATH}/{n}/Perimeter"][()])
+                    Polygon(hdf_file["Geometry/2D Flow Areas/{}/Perimeter".format(n)][()])
                     for n in mesh_area_names
                 ]
                 return GeoDataFrame(
@@ -134,13 +132,13 @@ class HdfMesh:
 
                 cell_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
                 for i, mesh_name in enumerate(mesh_area_names):
-                    cell_cnt = hdf_file[f"{HdfMesh.FLOW_AREA_2D_PATH}/Cell Info"][()][i][1]
+                    cell_cnt = hdf_file["Geometry/2D Flow Areas/Cell Info"][()][i][1]
                     cell_ids = list(range(cell_cnt))
                     cell_face_info = hdf_file[
-                        f"{HdfMesh.FLOW_AREA_2D_PATH}/{mesh_name}/Cells Face and Orientation Info"
+                        "Geometry/2D Flow Areas/{}/Cells Face and Orientation Info".format(mesh_name)
                     ][()]
                     cell_face_values = hdf_file[
-                        f"{HdfMesh.FLOW_AREA_2D_PATH}/{mesh_name}/Cells Face and Orientation Values"
+                        "Geometry/2D Flow Areas/{}/Cells Face and Orientation Values".format(mesh_name)
                     ][()][:, 0]
                     face_id_lists = list(
                         np.vectorize(
@@ -176,12 +174,11 @@ class HdfMesh:
         except Exception as e:
             logger.error(f"Error reading mesh cell polygons from {hdf_path}: {str(e)}")
             return GeoDataFrame()
-
     @staticmethod
     @standardize_input(file_type='plan_hdf')
     def mesh_cell_points(hdf_path: Path) -> GeoDataFrame:
         """
-        Return 2D flow mesh cell points.
+        Return 2D flow mesh cell center points.
 
         Parameters
         ----------
@@ -191,29 +188,29 @@ class HdfMesh:
         Returns
         -------
         GeoDataFrame
-            A GeoDataFrame containing the 2D flow mesh cell points.
+            A GeoDataFrame containing the 2D flow mesh cell center points.
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
                 mesh_area_names = HdfMesh.mesh_area_names(hdf_path)
                 if not mesh_area_names:
                     return GeoDataFrame()
+                
                 pnt_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
-                for i, mesh_name in enumerate(mesh_area_names):
-                    starting_row, count = hdf_file[f"{HdfMesh.FLOW_AREA_2D_PATH}/Cell Info"][()][i]
-                    cell_pnt_coords = hdf_file[f"{HdfMesh.FLOW_AREA_2D_PATH}/Cell Points"][()][
-                        starting_row : starting_row + count
-                    ]
-                    pnt_dict["mesh_name"] += [mesh_name] * cell_pnt_coords.shape[0]
-                    pnt_dict["cell_id"] += range(count)
+                for mesh_name in mesh_area_names:
+                    cell_center_coords = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Cells Center Coordinate"][()]
+                    cell_count = len(cell_center_coords)
+                    
+                    pnt_dict["mesh_name"] += [mesh_name] * cell_count
+                    pnt_dict["cell_id"] += range(cell_count)
                     pnt_dict["geometry"] += list(
                         np.vectorize(lambda coords: Point(coords), signature="(n)->()")(
-                            cell_pnt_coords
+                            cell_center_coords
                         )
                     )
                 return GeoDataFrame(pnt_dict, geometry="geometry", crs=HdfUtils.projection(hdf_path))
         except Exception as e:
-            self.logger.error(f"Error reading mesh cell points from {hdf_path}: {str(e)}")
+            logger.error(f"Error reading mesh cell points from {hdf_path}: {str(e)}")
             return GeoDataFrame()
 
     @staticmethod
@@ -240,16 +237,16 @@ class HdfMesh:
                 face_dict = {"mesh_name": [], "face_id": [], "geometry": []}
                 for mesh_name in mesh_area_names:
                     facepoints_index = hdf_file[
-                        f"{HdfMesh.FLOW_AREA_2D_PATH}/{mesh_name}/Faces FacePoint Indexes"
+                        "Geometry/2D Flow Areas/{}/Faces FacePoint Indexes".format(mesh_name)
                     ][()]
                     facepoints_coordinates = hdf_file[
-                        f"{HdfMesh.FLOW_AREA_2D_PATH}/{mesh_name}/FacePoints Coordinate"
+                        "Geometry/2D Flow Areas/{}/FacePoints Coordinate".format(mesh_name)
                     ][()]
                     faces_perimeter_info = hdf_file[
-                        f"{HdfMesh.FLOW_AREA_2D_PATH}/{mesh_name}/Faces Perimeter Info"
+                        "Geometry/2D Flow Areas/{}/Faces Perimeter Info".format(mesh_name)
                     ][()]
                     faces_perimeter_values = hdf_file[
-                        f"{HdfMesh.FLOW_AREA_2D_PATH}/{mesh_name}/Faces Perimeter Values"
+                        "Geometry/2D Flow Areas/{}/Faces Perimeter Values".format(mesh_name)
                     ][()]
                     face_id = -1
                     for pnt_a_index, pnt_b_index in facepoints_index:
@@ -288,14 +285,14 @@ class HdfMesh:
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                d2_flow_area = hdf_file.get(f"{HdfMesh.FLOW_AREA_2D_PATH}/Attributes")
+                d2_flow_area = hdf_file.get("Geometry/2D Flow Areas/Attributes")
                 if d2_flow_area is not None and isinstance(d2_flow_area, h5py.Dataset):
                     result = {}
                     for name in d2_flow_area.dtype.names:
                         try:
                             value = d2_flow_area[name][()]
                             if isinstance(value, bytes):
-                                value = value.decode('utf-8')
+                                value = value.decode('utf-8')  # Decode as UTF-8
                             result[name] = value
                         except Exception as e:
                             logger.warning(f"Error converting attribute '{name}': {str(e)}")
@@ -306,3 +303,52 @@ class HdfMesh:
         except Exception as e:
             logger.error(f"Error reading 2D flow area attributes from {hdf_path}: {str(e)}")
             return {}
+
+
+    @staticmethod
+    @standardize_input(file_type='geom_hdf')
+    def get_face_property_tables(hdf_path: Path) -> Dict[str, pd.DataFrame]:
+        """
+        Extract Face Property Tables for each Face in all 2D Flow Areas.
+
+        Parameters
+        ----------
+        hdf_path : Path
+            Path to the HEC-RAS geometry HDF file.
+
+        Returns
+        -------
+        Dict[str, pd.DataFrame]
+            A dictionary where keys are mesh names and values are DataFrames
+            containing the Face Property Tables for all faces in that mesh.
+        """
+        try:
+            with h5py.File(hdf_path, 'r') as hdf_file:
+                mesh_area_names = HdfMesh.mesh_area_names(hdf_path)
+                if not mesh_area_names:
+                    return {}
+
+                result = {}
+                for mesh_name in mesh_area_names:
+                    area_elevation_info = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Faces Area Elevation Info"][()]
+                    area_elevation_values = hdf_file[f"Geometry/2D Flow Areas/{mesh_name}/Faces Area Elevation Values"][()]
+                    
+                    face_data = []
+                    for face_id, (start_index, count) in enumerate(area_elevation_info):
+                        face_values = area_elevation_values[start_index:start_index+count]
+                        for z, area, wetted_perimeter, mannings_n in face_values:
+                            face_data.append({
+                                'Face ID': face_id,
+                                'Z': z.decode('utf-8'),  # Decode as UTF-8
+                                'Area': area.decode('utf-8'),  # Decode as UTF-8
+                                'Wetted Perimeter': wetted_perimeter.decode('utf-8'),  # Decode as UTF-8
+                                "Manning's n": mannings_n.decode('utf-8')  # Decode as UTF-8
+                            })
+                    
+                    result[mesh_name] = pd.DataFrame(face_data)
+                
+                return result
+
+        except Exception as e:
+            logger.error(f"Error extracting face property tables from {hdf_path}: {str(e)}")
+            return {}