ras-commander 0.48.0__py3-none-any.whl → 0.50.0__py3-none-any.whl

ras_commander/HdfResultsMesh.py

@@ -6,6 +6,61 @@ from the https://github.com/fema-ffrd/rashdf library,
 released under MIT license and Copyright (c) 2024 fema-ffrd
 
 The file has been forked and modified for use in RAS Commander.
+
+-----
+
+All methods in this class are static and designed to be used without instantiation.
+
+Public Functions:
+- get_mesh_summary(): Get summary output data for a variable 
+- get_mesh_timeseries(): Get timeseries output for a mesh and variable  
+- get_mesh_faces_timeseries(): Get timeseries for all face-based variables
+- get_mesh_cells_timeseries(): Get timeseries for mesh cells
+- get_mesh_last_iter(): Get last iteration count for cells
+- get_mesh_max_ws(): Get maximum water surface elevation at each cell   
+- get_mesh_min_ws(): Get minimum water surface elevation at each cell
+- get_mesh_max_face_v(): Get maximum face velocity at each face
+- get_mesh_min_face_v(): Get minimum face velocity at each face
+- get_mesh_max_ws_err(): Get maximum water surface error at each cell
+- get_mesh_max_iter(): Get maximum iteration count at each cell
+
+Private Functions:
+- _get_mesh_timeseries_output_path(): Get HDF path for timeseries output  #REDUNDANT??
+- _get_mesh_cells_timeseries_output(): Internal handler for cell timeseries   #REDUNDANT??
+- _get_mesh_timeseries_output(): Internal handler for mesh timeseries       # FACES?? 
+- _get_mesh_timeseries_output_values_units(): Get values and units for timeseries
+- _get_available_meshes(): Get list of available meshes in HDF            #USE HDFBASE OR HDFUTIL
+- get_mesh_summary_output(): Internal handler for summary output        
+- get_mesh_summary_output_group(): Get HDF group for summary output         #REDUNDANT??  Include in Above
+
+The class works with HEC-RAS version 6.0+ plan HDF files and uses HdfBase and 
+HdfUtils for common operations. Methods use @log_call decorator for logging and 
+@standardize_input decorator to handle different input types.
+
+
+
+
+
+
+REVISIONS MADE:
+
+Use get_ prefix for functions that return data.  
+BUT, we will never set results data, so we should use get_ for results data.
+
+Renamed functions:
+- mesh_summary_output() to get_mesh_summary()
+- mesh_timeseries_output() to get_mesh_timeseries()
+- mesh_faces_timeseries_output() to get_mesh_faces_timeseries()
+- mesh_cells_timeseries_output() to get_mesh_cells_timeseries()
+- mesh_last_iter() to get_mesh_last_iter()
+- mesh_max_ws() to get_mesh_max_ws()
+
+
+
+
+
+
+
 """
 
 import numpy as np
@@ -19,81 +74,81 @@ from .HdfBase import HdfBase
 from .HdfUtils import HdfUtils
 from .Decorators import log_call, standardize_input
 from .LoggingConfig import setup_logging, get_logger
+import geopandas as gpd
 
 logger = get_logger(__name__)
 
 class HdfResultsMesh:
     """
-    A class for handling mesh-related results from HEC-RAS HDF files.
-
-    This class provides methods to extract and analyze mesh summary outputs,
-    timeseries data, and various mesh-specific results such as water surface
-    elevations, velocities, and errors.
-
-    The class works with HEC-RAS plan HDF files and uses HdfBase and HdfUtils
-    for common operations and utilities.
+    Handles mesh-related results from HEC-RAS HDF files.
 
-    Methods in this class use the @log_call decorator for logging and the
-    @standardize_input decorator to handle different input types (e.g., 
-    plan number, file path).
+    Provides methods to extract and analyze:
+    - Mesh summary outputs
+    - Timeseries data
+    - Water surface elevations
+    - Velocities
+    - Error metrics
 
-    Attributes:
-        None
-
-    Note:
-        This class is designed to work with HEC-RAS version 6.0 and later.
+    Works with HEC-RAS 6.0+ plan HDF files.
     """
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_summary_output(hdf_path: Path, var: str, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_summary(hdf_path: Path, var: str, round_to: str = "100ms") -> pd.DataFrame:
         """
-        Return the summary output data for a given variable.
+        Get timeseries output for a specific mesh and variable.
 
         Args:
-            hdf_path (Path): Path to the HEC-RAS plan HDF file.
-            var (str): The summary output variable to retrieve.
-            round_to (str): The time unit to round the datetimes to. Default: "100ms" (100 milliseconds).
+            hdf_path (Path): Path to the HDF file
+            mesh_name (str): Name of the mesh
+            var (str): Variable to retrieve (see valid options below)
+            truncate (bool): Whether to truncate trailing zeros (default True)
 
         Returns:
-            pd.DataFrame: DataFrame containing the summary output data.
+            xr.DataArray: DataArray with dimensions:
+                - time: Timestamps
+                - face_id/cell_id: IDs for faces/cells
+                And attributes:
+                - units: Variable units
+                - mesh_name: Name of mesh
+                - variable: Variable name
 
-        Raises:
-            ValueError: If there's an error processing the summary output data.
+        Valid variables include:
+            "Water Surface", "Face Velocity", "Cell Velocity X"...
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_summary_output(hdf_file, var, round_to)
+                return HdfResultsMesh.get_mesh_summary_output(hdf_file, var, round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_summary_output: {str(e)}")
+            logger.error(f"Error in get_mesh_summary: {str(e)}")
             logger.error(f"Variable: {var}")
             raise ValueError(f"Failed to get summary output: {str(e)}")
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_timeseries_output(hdf_path: Path, mesh_name: str, var: str, truncate: bool = True) -> xr.DataArray:
+    def get_mesh_timeseries(hdf_path: Path, mesh_name: str, var: str, truncate: bool = True) -> xr.DataArray:
         """
         Get timeseries output for a specific mesh and variable.
 
         Args:
-            hdf_path (Path): Path to the HDF file.
-            mesh_name (str): Name of the mesh.
-            var (str): Variable to retrieve. Valid options include:
-                "Water Surface", "Face Velocity", "Cell Velocity X", "Cell Velocity Y",
-                "Face Flow", "Face Water Surface", "Cell Volume", "Cell Volume Error",
-                "Cell Water Surface Error", "Cell Courant", "Face Courant",
-                "Cell Hydraulic Depth", "Cell Invert Depth",
-                "Cell Cumulative Precipitation Depth", "Cell Divergence Term",
-                "Cell Eddy Viscosity X", "Cell Eddy Viscosity Y", "Cell Flow Balance",
-                "Cell Storage Term", "Cell Water Source Term", "Face Cumulative Volume",
-                "Face Eddy Viscosity", "Face Flow Period Average", "Face Friction Term",
-                "Face Pressure Gradient Term", "Face Shear Stress", "Face Tangential Velocity"
-            truncate (bool): Whether to truncate the output (default True).
+            hdf_path (Path): Path to the HDF file
+            mesh_name (str): Name of the mesh
+            var (str): Variable to retrieve (see valid options below)
+            truncate (bool): Whether to truncate trailing zeros (default True)
 
         Returns:
-            xr.DataArray: DataArray containing the timeseries output.
+            xr.DataArray: DataArray with dimensions:
+                - time: Timestamps
+                - face_id/cell_id: IDs for faces/cells
+                And attributes:
+                - units: Variable units
+                - mesh_name: Name of mesh
+                - variable: Variable name
+
+        Valid variables include:
+            "Water Surface", "Face Velocity", "Cell Velocity X"...
         """
         with h5py.File(hdf_path, 'r') as hdf_file:
             return HdfResultsMesh._get_mesh_timeseries_output(hdf_file, mesh_name, var, truncate)
@@ -101,7 +156,7 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_faces_timeseries_output(hdf_path: Path, mesh_name: str) -> xr.Dataset:
+    def get_mesh_faces_timeseries(hdf_path: Path, mesh_name: str) -> xr.Dataset:
         """
         Get timeseries output for all face-based variables of a specific mesh.
 
@@ -117,7 +172,7 @@ class HdfResultsMesh:
         
         for var in face_vars:
             try:
-                da = HdfResultsMesh.mesh_timeseries_output(hdf_path, mesh_name, var)
+                da = HdfResultsMesh.get_mesh_timeseries(hdf_path, mesh_name, var)
                 # Assign the variable name as the DataArray name
                 da.name = var.lower().replace(' ', '_')
                 datasets.append(da)
@@ -137,34 +192,34 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_cells_timeseries_output(hdf_path: Path, mesh_names: Optional[Union[str, List[str]]] = None, var: Optional[str] = None, truncate: bool = False, ras_object: Optional[Any] = None) -> Dict[str, xr.Dataset]:
+    def get_mesh_cells_timeseries(hdf_path: Path, mesh_names: Optional[Union[str, List[str]]] = None, var: Optional[str] = None, truncate: bool = False, ras_object: Optional[Any] = None) -> Dict[str, xr.Dataset]:
         """
-        Get mesh cells timeseries output for specified meshes and variables.
+        Get mesh cells timeseries output.
 
         Args:
-            hdf_path (Union[str, Path]): Path to the HDF file.
-            mesh_names (Optional[Union[str, List[str]]]): Name(s) of the mesh(es). If None, processes all available meshes.
-            var (Optional[str]): Name of the variable to retrieve. If None, retrieves all variables.
-            truncate (bool): If True, truncates the output to remove trailing zeros.
-            ras_object (Optional[Any]): RAS object, if available.
+            hdf_path (Path): Path to HDF file
+            mesh_names (str|List[str], optional): Mesh name(s). If None, processes all meshes
+            var (str, optional): Variable name. If None, retrieves all variables
+            truncate (bool): Remove trailing zeros if True
+            ras_object (Any, optional): RAS object if available
 
         Returns:
-            Dict[str, xr.Dataset]: A dictionary of xarray Datasets, one for each mesh, containing the mesh cells timeseries output.
-
-        Raises:
-            ValueError: If there's an error processing the timeseries output data.
+            Dict[str, xr.Dataset]: Dictionary mapping mesh names to datasets containing:
+                - Time-indexed variables
+                - Cell/face IDs
+                - Variable metadata
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._mesh_cells_timeseries_output(hdf_file, mesh_names, var, truncate)
+                return HdfResultsMesh._get_mesh_cells_timeseries_output(hdf_file, mesh_names, var, truncate)
         except Exception as e:
-            logger.error(f"Error in mesh_cells_timeseries_output: {str(e)}")
+            logger.error(f"Error in get_mesh_cells_timeseries: {str(e)}")
             raise ValueError(f"Error processing timeseries output data: {e}")
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_last_iter(hdf_path: Path) -> pd.DataFrame:
+    def get_mesh_last_iter(hdf_path: Path) -> pd.DataFrame:
         """
         Get last iteration count for each mesh cell.
 
@@ -174,33 +229,28 @@ class HdfResultsMesh:
         Returns:
             pd.DataFrame: DataFrame containing last iteration counts.
         """
-        return HdfResultsMesh._get_mesh_summary_output(hdf_path, "Cell Last Iteration")
+        return HdfResultsMesh.get_mesh_summary_output(hdf_path, "Cell Last Iteration")
 
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_max_ws(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_max_ws(hdf_path: Path, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
-        Get maximum iteration count for each mesh cell.
+        Get maximum water surface elevation for each mesh cell.
 
         Args:
             hdf_path (Path): Path to the HDF file.
             round_to (str): Time rounding specification (default "100ms").
 
         Returns:
-            pd.DataFrame: DataFrame containing maximum iteration counts.
-
-        Raises:
-            ValueError: If there's an error processing the maximum iteration data.
-            
-        Note: The Maximum Iteration is labeled as "Cell Last Iteration" in the HDF file 
+            gpd.GeoDataFrame: GeoDataFrame containing maximum water surface elevations with geometry.
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_summary_output(hdf_file, "Maximum Water Surface", round_to)
+                return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Maximum Water Surface", round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_max_ws: {str(e)}")
+            logger.error(f"Error in get_mesh_max_ws: {str(e)}")
             raise ValueError(f"Failed to get maximum water surface: {str(e)}")
         
 
@@ -210,7 +260,7 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_min_ws(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_min_ws(hdf_path: Path, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
         Get minimum water surface elevation for each mesh cell.
 
@@ -219,19 +269,19 @@ class HdfResultsMesh:
             round_to (str): Time rounding specification (default "100ms").
 
         Returns:
-            pd.DataFrame: DataFrame containing minimum water surface elevations.
+            gpd.GeoDataFrame: GeoDataFrame containing minimum water surface elevations with geometry.
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_summary_output(hdf_file, "Minimum Water Surface", round_to)
+                return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Minimum Water Surface", round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_min_ws: {str(e)}")
+            logger.error(f"Error in get_mesh_min_ws: {str(e)}")
             raise ValueError(f"Failed to get minimum water surface: {str(e)}")
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_max_face_v(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_max_face_v(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
         """
         Get maximum face velocity for each mesh face.
 
@@ -241,21 +291,18 @@ class HdfResultsMesh:
 
         Returns:
             pd.DataFrame: DataFrame containing maximum face velocities.
-
-        Raises:
-            ValueError: If there's an error processing the maximum face velocity data.
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_summary_output(hdf_file, "Maximum Face Velocity", round_to)
+                return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Maximum Face Velocity", round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_max_face_v: {str(e)}")
+            logger.error(f"Error in get_mesh_max_face_v: {str(e)}")
             raise ValueError(f"Failed to get maximum face velocity: {str(e)}")
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_min_face_v(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_min_face_v(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
         """
         Get minimum face velocity for each mesh cell.
 
@@ -271,15 +318,15 @@ class HdfResultsMesh:
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_summary_output(hdf_file, "Minimum Face Velocity", round_to)
+                return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Minimum Face Velocity", round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_min_face_v: {str(e)}")
+            logger.error(f"Error in get_mesh_min_face_v: {str(e)}")
             raise ValueError(f"Failed to get minimum face velocity: {str(e)}")
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_max_ws_err(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_max_ws_err(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
         """
         Get maximum water surface error for each mesh cell.
 
@@ -295,16 +342,16 @@ class HdfResultsMesh:
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_summary_output(hdf_file, "Cell Maximum Water Surface Error", round_to)
+                return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Cell Maximum Water Surface Error", round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_max_ws_err: {str(e)}")
+            logger.error(f"Error in get_mesh_max_ws_err: {str(e)}")
             raise ValueError(f"Failed to get maximum water surface error: {str(e)}")
 
 
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def mesh_max_iter(hdf_path: Path, round_to: str = "100ms") -> pd.DataFrame:
+    def get_mesh_max_iter(hdf_path: Path, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
         Get maximum iteration count for each mesh cell.
 
@@ -313,22 +360,22 @@ class HdfResultsMesh:
             round_to (str): Time rounding specification (default "100ms").
 
         Returns:
-            pd.DataFrame: DataFrame containing maximum iteration counts.
-
-        Raises:
-            ValueError: If there's an error processing the maximum iteration data.
-            
-        Note: The Maximum Iteration is labeled as "Cell Last Iteration" in the HDF file 
+            gpd.GeoDataFrame: GeoDataFrame containing maximum iteration counts with geometry.
+                Includes columns:
+                - mesh_name: Name of the mesh
+                - cell_id: ID of the cell
+                - cell_last_iteration: Maximum number of iterations
+                - cell_last_iteration_time: Time when max iterations occurred
+                - geometry: Point geometry representing cell center
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_summary_output(hdf_file, "Cell Last Iteration", round_to)
+                return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Cell Last Iteration", round_to)
         except Exception as e:
-            logger.error(f"Error in mesh_max_iter: {str(e)}")
+            logger.error(f"Error in get_mesh_max_iter: {str(e)}")
             raise ValueError(f"Failed to get maximum iteration count: {str(e)}")
         
         
-        
 
 
     @staticmethod
@@ -347,10 +394,13 @@ class HdfResultsMesh:
 
 
     @staticmethod
-    def _mesh_cells_timeseries_output(hdf_file: h5py.File, mesh_names: Optional[Union[str, List[str]]] = None, var: Optional[str] = None, truncate: bool = False) -> Dict[str, xr.Dataset]:
+    def _get_mesh_cells_timeseries_output(hdf_file: h5py.File, 
+                                         mesh_names: Optional[Union[str, List[str]]] = None,
+                                         var: Optional[str] = None, 
+                                         truncate: bool = False) -> Dict[str, xr.Dataset]:
         """
         Get mesh cells timeseries output for specified meshes and variables.
-
+        
         Args:
             hdf_file (h5py.File): Open HDF file object.
             mesh_names (Optional[Union[str, List[str]]]): Name(s) of the mesh(es). If None, processes all available meshes.
@@ -381,8 +431,8 @@ class HdfResultsMesh:
         }
 
         try:
-            start_time = HdfBase._get_simulation_start_time(hdf_file)
-            time_stamps = HdfBase._get_unsteady_datetimes(hdf_file)
+            start_time = HdfBase.get_simulation_start_time(hdf_file)
+            time_stamps = HdfBase.get_unsteady_timestamps(hdf_file)
 
             if mesh_names is None:
                 mesh_names = HdfResultsMesh._get_available_meshes(hdf_file)
@@ -470,19 +520,26 @@ class HdfResultsMesh:
             dataset = hdf_file[path]
             values = dataset[:]
             units = dataset.attrs.get("Units", "").decode("utf-8")
-            times = HdfBase._get_unsteady_datetimes(hdf_file)
+            
+            # Get start time and timesteps
+            start_time = HdfBase.get_simulation_start_time(hdf_file)
+            # Updated to use the new function name from HdfUtils
+            timesteps = HdfUtils.convert_timesteps_to_datetimes(
+                np.array(hdf_file["Results/Unsteady/Output/Output Blocks/Base Output/Unsteady Time Series/Time"][:]),
+                start_time
+            )
 
             if truncate:
                 non_zero = np.nonzero(values)[0]
                 if len(non_zero) > 0:
                     start, end = non_zero[0], non_zero[-1] + 1
                     values = values[start:end]
-                    times = times[start:end]
+                    timesteps = timesteps[start:end]
 
             # Determine if this is a face-based or cell-based variable
             id_dim = "face_id" if "Face" in var else "cell_id"
             dims = ["time", id_dim] if values.ndim == 2 else ["time"]
-            coords = {"time": times}
+            coords = {"time": timesteps}
             if values.ndim == 2:
                 coords[id_dim] = np.arange(values.shape[1])
 
@@ -530,16 +587,13 @@ class HdfResultsMesh:
         Returns:
             List[str]: A list of mesh names.
         """
-        mesh_names = []
-        base_path = "Geometry/2D Flow Areas"
-        if base_path in hdf_file:
-            for name in hdf_file[base_path]:
-                if isinstance(hdf_file[f"{base_path}/{name}"], h5py.Group):
-                    mesh_names.append(name)
-        return mesh_names
+        return HdfMesh.get_mesh_area_names(hdf_file)
+    
     
     @staticmethod
-    def _get_mesh_summary_output(hdf_file: h5py.File, var: str, round_to: str = "100ms") -> pd.DataFrame:
+    @log_call
+    @standardize_input(file_type='plan_hdf')
+    def get_mesh_summary_output(hdf_file: h5py.File, var: str, round_to: str = "100ms") -> gpd.GeoDataFrame:
         """
         Get the summary output data for a given variable from the HDF file.
 
@@ -554,8 +608,8 @@ class HdfResultsMesh:
 
         Returns
         -------
-        pd.DataFrame
-            A DataFrame containing the summary output data with attributes as metadata.
+        gpd.GeoDataFrame
+            A GeoDataFrame containing the summary output data with attributes as metadata.
 
         Raises
         ------
@@ -564,12 +618,18 @@ class HdfResultsMesh:
         """
         try:
             dfs = []
-            start_time = HdfBase._get_simulation_start_time(hdf_file)
+            start_time = HdfBase.get_simulation_start_time(hdf_file)
             
             logger.info(f"Processing summary output for variable: {var}")
-            for mesh_name, cell_count in HdfBase._get_2d_flow_area_names_and_counts(hdf_file):
+            d2_flow_areas = hdf_file.get("Geometry/2D Flow Areas/Attributes")
+            if d2_flow_areas is None:
+                return gpd.GeoDataFrame()
+
+            for d2_flow_area in d2_flow_areas[:]:
+                mesh_name = HdfUtils.convert_ras_string(d2_flow_area[0])
+                cell_count = d2_flow_area[-1]
                 logger.debug(f"Processing mesh: {mesh_name} with {cell_count} cells")
-                group = HdfResultsMesh._get_mesh_summary_output_group(hdf_file, mesh_name, var)
+                group = HdfResultsMesh.get_mesh_summary_output_group(hdf_file, mesh_name, var)
                 
                 data = group[:]
                 logger.debug(f"Data shape for {var} in {mesh_name}: {data.shape}")
@@ -585,7 +645,7 @@ class HdfResultsMesh:
                         "mesh_name": [mesh_name] * data.shape[1],
                         "cell_id" if "Face" not in var else "face_id": range(data.shape[1]),
                         f"{var.lower().replace(' ', '_')}": data[0, :],
-                        f"{var.lower().replace(' ', '_')}_time": HdfUtils._ras_timesteps_to_datetimes(
+                        f"{var.lower().replace(' ', '_')}_time": HdfUtils.convert_timesteps_to_datetimes(
                             data[1, :], start_time, time_unit="days", round_to=round_to
                         )
                     })
@@ -604,13 +664,13 @@ class HdfResultsMesh:
                 
                 # Add geometry based on variable type
                 if "Face" in var:
-                    face_df = HdfMesh.mesh_cell_faces(hdf_file)
+                    face_df = HdfMesh.get_mesh_cell_faces(hdf_file)
                     if not face_df.empty:
                         df = df.merge(face_df[['mesh_name', 'face_id', 'geometry']], 
                                     on=['mesh_name', 'face_id'], 
                                     how='left')
                 else:
-                    cell_df = HdfMesh.mesh_cell_points(hdf_file)
+                    cell_df = HdfMesh.get_mesh_cell_points(hdf_file)
                     if not cell_df.empty:
                         df = df.merge(cell_df[['mesh_name', 'cell_id', 'geometry']], 
                                     on=['mesh_name', 'cell_id'], 
@@ -628,10 +688,18 @@ class HdfResultsMesh:
                 dfs.append(df)
             
             if not dfs:
-                return pd.DataFrame()
+                return gpd.GeoDataFrame()
                 
             result = pd.concat(dfs, ignore_index=True)
             
+            # Convert to GeoDataFrame
+            gdf = gpd.GeoDataFrame(result, geometry='geometry')
+            
+            # Get CRS from HdfUtils
+            crs = HdfBase.get_projection(hdf_file)
+            if crs:
+                gdf.set_crs(crs, inplace=True)
+            
             # Combine attributes from all meshes
             combined_attrs = {}
             for df in dfs:
@@ -641,18 +709,17 @@ class HdfResultsMesh:
                     elif combined_attrs[key] != value:
                         combined_attrs[key] = f"Multiple values: {combined_attrs[key]}, {value}"
             
-            result.attrs.update(combined_attrs)
+            gdf.attrs.update(combined_attrs)
             
-            logger.info(f"Processed {len(result)} rows of summary output data")
-            return result
+            logger.info(f"Processed {len(gdf)} rows of summary output data")
+            return gdf
         
         except Exception as e:
             logger.error(f"Error processing summary output data: {e}")
             raise ValueError(f"Error processing summary output data: {e}")
-        
 
     @staticmethod
-    def _get_mesh_summary_output_group(hdf_file: h5py.File, mesh_name: str, var: str) -> Union[h5py.Group, h5py.Dataset]:
+    def get_mesh_summary_output_group(hdf_file: h5py.File, mesh_name: str, var: str) -> Union[h5py.Group, h5py.Dataset]:
         """
         Return the HDF group for a given mesh and summary output variable.
 
@@ -673,63 +740,3 @@ class HdfResultsMesh:
             raise ValueError(f"Could not find HDF group or dataset at path '{output_path}'")
         return output_item
 
-    @staticmethod
-    def plot_mesh_variable(variable_df: pd.DataFrame, variable_name: str, colormap: str = 'viridis', point_size: int = 10) -> None:
-        """
-        Plot any mesh variable with consistent styling.
-        
-        Args:
-            variable_df (pd.DataFrame): DataFrame containing the variable data
-            variable_name (str): Name of the variable (for labels)
-            colormap (str): Matplotlib colormap to use. Default: 'viridis'
-            point_size (int): Size of the scatter points. Default: 10
-
-        Returns:
-            None
-
-        Raises:
-            ImportError: If matplotlib is not installed
-            ValueError: If required columns are missing from variable_df
-        """
-        try:
-            import matplotlib.pyplot as plt
-        except ImportError:
-            logger.error("matplotlib is required for plotting. Please install it with 'pip install matplotlib'")
-            raise ImportError("matplotlib is required for plotting")
-
-        # Get cell coordinates if not in variable_df
-        if 'geometry' not in variable_df.columns:
-            cell_coords = HdfMesh.mesh_cell_points(plan_hdf_path)
-            merged_df = pd.merge(variable_df, cell_coords, on=['mesh_name', 'cell_id'])
-        else:
-            merged_df = variable_df
-            
-        # Extract coordinates, handling None values
-        merged_df = merged_df.dropna(subset=['geometry'])
-        merged_df['x'] = merged_df['geometry'].apply(lambda geom: geom.x if geom is not None else None)
-        merged_df['y'] = merged_df['geometry'].apply(lambda geom: geom.y if geom is not None else None)
-        
-        # Drop any rows with None coordinates
-        merged_df = merged_df.dropna(subset=['x', 'y'])
-        
-        if len(merged_df) == 0:
-            logger.error("No valid coordinates found for plotting")
-            raise ValueError("No valid coordinates found for plotting")
-            
-        # Create plot
-        fig, ax = plt.subplots(figsize=(12, 8))
-        scatter = ax.scatter(merged_df['x'], merged_df['y'], 
-                           c=merged_df[variable_name], 
-                           cmap=colormap, 
-                           s=point_size)
-        
-        # Customize plot
-        ax.set_title(f'{variable_name} per Cell')
-        ax.set_xlabel('X Coordinate')
-        ax.set_ylabel('Y Coordinate')
-        plt.colorbar(scatter, label=variable_name)
-        ax.grid(True, linestyle='--', alpha=0.7)
-        plt.rcParams.update({'font.size': 12})
-        plt.tight_layout()
-        plt.show()
-