ras-commander 0.47.0__py3-none-any.whl → 0.49.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
@@ -24,76 +79,75 @@ logger = get_logger(__name__)
 
 class HdfResultsMesh:
     """
-    A class for handling mesh-related results from HEC-RAS HDF files.
+    Handles 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.
+    Provides methods to extract and analyze:
+    - Mesh summary outputs
+    - Timeseries data
+    - Water surface elevations
+    - Velocities
+    - Error metrics
 
-    The class works with HEC-RAS plan HDF files and uses HdfBase and HdfUtils
-    for common operations and utilities.
-
-    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).
-
-    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 +155,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 +171,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 +191,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 +228,31 @@ 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") -> pd.DataFrame:
         """
-        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.
+            pd.DataFrame: DataFrame containing maximum water surface elevations.
 
         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 
+            ValueError: If there's an error processing the maximum water surface data.
         """
         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 +262,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") -> pd.DataFrame:
         """
         Get minimum water surface elevation for each mesh cell.
 
@@ -223,15 +275,15 @@ class HdfResultsMesh:
         """
         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 +293,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 +320,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 +344,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") -> pd.DataFrame:
         """
         Get maximum iteration count for each mesh cell.
 
@@ -313,8 +362,26 @@ class HdfResultsMesh:
             round_to (str): Time rounding specification (default "100ms").
 
         Returns:
-            pd.DataFrame: DataFrame containing maximum iteration counts.
+            pd.DataFrame: DataFrame containing maximum iteration counts with face geometry.
+
+        Raises:
+            ValueError: If there's an error processing the maximum iteration data.
+        """
+        """
+        Get maximum iteration count 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 with 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
+                
         Raises:
             ValueError: If there's an error processing the maximum iteration data.
             
@@ -322,13 +389,12 @@ class HdfResultsMesh:
         """
         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)}")
             raise ValueError(f"Failed to get maximum iteration count: {str(e)}")
         
         
-        
 
 
     @staticmethod
@@ -347,10 +413,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 +450,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 +539,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 +606,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") -> pd.DataFrame:
         """
         Get the summary output data for a given variable from the HDF file.
 
@@ -564,12 +637,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 pd.DataFrame()
+
+            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 +664,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 +683,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'], 
@@ -652,7 +731,7 @@ class HdfResultsMesh:
         
 
     @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 +752,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()
-