ras-commander 0.44.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

ras_commander/HdfResultsXsec.py

@@ -8,20 +8,21 @@ released under MIT license and Copyright (c) 2024 fema-ffrd
 The file has been forked and modified for use in RAS Commander.
 """
 
+from pathlib import Path
+from typing import Union, Optional, List, Dict, Tuple
+
 import h5py
 import numpy as np
 import pandas as pd
-from pathlib import Path
-from typing import Union, Optional, List
+import xarray as xr
+
 from .HdfBase import HdfBase
 from .HdfUtils import HdfUtils
 from .Decorators import standardize_input, log_call
-from .LoggingConfig import setup_logging, get_logger
-import xarray as xr
+from .LoggingConfig import get_logger
 
 logger = get_logger(__name__)
 
-
 class HdfResultsXsec:
     """
     A class for handling cross-section results from HEC-RAS HDF files.
@@ -36,202 +37,236 @@ class HdfResultsXsec:
     Attributes:
         None
 
-    Methods:
-        steady_profile_xs_output: Extract steady profile cross-section output for a specified variable.
-        cross_sections_wsel: Get water surface elevation data for cross-sections.
-        cross_sections_flow: Get flow data for cross-sections.
-        cross_sections_energy_grade: Get energy grade data for cross-sections.
-        cross_sections_additional_enc_station_left: Get left encroachment station data for cross-sections.
-        cross_sections_additional_enc_station_right: Get right encroachment station data for cross-sections.
-        cross_sections_additional_area_total: Get total ineffective area data for cross-sections.
-        cross_sections_additional_velocity_total: Get total velocity data for cross-sections.
+    
     """
 
+
+
+
+
+
+
+
+
+
+
+
     @staticmethod
+    @log_call
     @standardize_input(file_type='plan_hdf')
-    def steady_profile_xs_output(hdf_path: Path, var: str, round_to: int = 2) -> pd.DataFrame:
+    def get_pump_station_profile_output(hdf_path: Path) -> pd.DataFrame:
         """
-        Create a DataFrame from steady cross section results based on the specified variable.
+        Extract pump station profile output data from the HDF file.
 
-        Parameters:
-        ----------
-        hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
-        var : str
-            The variable to extract from the steady cross section results.
-        round_to : int, optional
-            Number of decimal places to round the results to (default is 2).
+        Args:
+            hdf_path (Path): Path to the HDF file.
 
         Returns:
-        -------
-        pd.DataFrame
-            DataFrame containing the steady cross section results for the specified variable.
+            pd.DataFrame: DataFrame containing pump station profile output data.
+
+        Raises:
+            KeyError: If the required datasets are not found in the HDF file.
         """
-        XS_STEADY_OUTPUT_ADDITIONAL = [
-            "Additional Encroachment Station Left",
-            "Additional Encroachment Station Right",
-            "Additional Area Ineffective Total",
-            "Additional Velocity Total",
-        ]
-                
         try:
-            with h5py.File(hdf_path, 'r') as hdf_file:
-                # Determine the correct path based on the variable
-                if var in XS_STEADY_OUTPUT_ADDITIONAL:
-                    path = f"/Results/Steady/Cross Sections/Additional Output/{var}"
-                else:
-                    path = f"/Results/Steady/Cross Sections/{var}"
-                
-                # Check if the path exists in the HDF file
-                if path not in hdf_file:
+            with h5py.File(hdf_path, 'r') as hdf:
+                # Extract profile output data
+                profile_path = "/Results/Unsteady/Output/Output Blocks/DSS Profile Output/Unsteady Time Series/Pumping Stations"
+                if profile_path not in hdf:
+                    logger.warning("Pump Station profile output data not found in HDF file")
                     return pd.DataFrame()
 
-                # Get the profile names
-                profiles = HdfBase.steady_flow_names(hdf_path)
-                
-                # Extract the steady data
-                steady_data = hdf_file[path]
-                
-                # Create a DataFrame with profiles as index
-                df = pd.DataFrame(steady_data, index=profiles)
-                
-                # Transpose the DataFrame and round values
-                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
+                # Initialize an empty list to store data from all pump stations
+                all_data = []
+
+                # Iterate through all pump stations
+                for station in hdf[profile_path].keys():
+                    station_path = f"{profile_path}/{station}/Structure Variables"
+                    
+                    data = hdf[station_path][()]
+                    
+                    # Create a DataFrame for this pump station
+                    df = pd.DataFrame(data, columns=['Flow', 'Stage HW', 'Stage TW', 'Pump Station', 'Pumps on'])
+                    df['Station'] = station
+                    
+                    all_data.append(df)
+
+                # Concatenate all DataFrames
+                result_df = pd.concat(all_data, ignore_index=True)
+
+                # Add time information
+                time = HdfBase._get_unsteady_datetimes(hdf)
+                result_df['Time'] = [time[i] for i in result_df.index]
+
+                return result_df
+
+        except KeyError as e:
+            logger.error(f"Required dataset not found in HDF file: {e}")
+            raise
         except Exception as e:
-            HdfUtils.logger.error(f"Failed to get steady profile cross section output: {str(e)}")
-            return pd.DataFrame()
+            logger.error(f"Error extracting pump station profile output data: {e}")
+            raise
+
 
-    @staticmethod
-    @standardize_input(file_type='plan_hdf')
-    def cross_sections_wsel(hdf_path: Path) -> pd.DataFrame:
-        """
-        Return the water surface elevation information for each 1D Cross Section.
 
-        Parameters:
-        ----------
-        hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
 
-        Returns:
-        -------
-        pd.DataFrame
-            A DataFrame containing the water surface elevations for each cross section and event.
-        """
-        return HdfResultsXsec.steady_profile_xs_output(hdf_path, "Water Surface")
 
-    @staticmethod
-    @standardize_input(file_type='plan_hdf')
-    def cross_sections_flow(hdf_path: Path) -> pd.DataFrame:
-        """
-        Return the Flow information for each 1D Cross Section.
 
-        Parameters:
-        ----------
-        hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
 
-        Returns:
-        -------
-        pd.DataFrame
-            A DataFrame containing the flow for each cross section and event.
-        """
-        return HdfResultsXsec.steady_profile_xs_output(hdf_path, "Flow")
 
-    @staticmethod
-    @standardize_input(file_type='plan_hdf')
-    def cross_sections_energy_grade(hdf_path: Path) -> pd.DataFrame:
-        """
-        Return the energy grade information for each 1D Cross Section.
 
-        Parameters:
-        ----------
-        hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
 
-        Returns:
-        -------
-        pd.DataFrame
-            A DataFrame containing the energy grade for each cross section and event.
-        """
-        return HdfResultsXsec.steady_profile_xs_output(hdf_path, "Energy Grade")
 
-    @staticmethod
-    @standardize_input(file_type='plan_hdf')
-    def cross_sections_additional_enc_station_left(hdf_path: Path) -> pd.DataFrame:
-        """
-        Return the left side encroachment information for a floodway plan hdf.
 
-        Parameters:
-        ----------
-        hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
 
-        Returns:
-        -------
-        pd.DataFrame
-            A DataFrame containing the cross sections left side encroachment stations.
-        """
-        return HdfResultsXsec.steady_profile_xs_output(
-            hdf_path, "Encroachment Station Left"
-        )
 
-    @staticmethod
-    @standardize_input(file_type='plan_hdf')
-    def cross_sections_additional_enc_station_right(hdf_path: Path) -> pd.DataFrame:
-        """
-        Return the right side encroachment information for a floodway plan hdf.
 
-        Parameters:
-        ----------
-        hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
 
-        Returns:
-        -------
-        pd.DataFrame
-            A DataFrame containing the cross sections right side encroachment stations.
-        """
-        return HdfResultsXsec.steady_profile_xs_output(
-            hdf_path, "Encroachment Station Right"
-        )
 
     @staticmethod
+    @log_call
     @standardize_input(file_type='plan_hdf')
-    def cross_sections_additional_area_total(hdf_path: Path) -> pd.DataFrame:
+    def get_pump_station_summary(hdf_path: Path) -> pd.DataFrame:
         """
-        Return the 1D cross section area for each profile.
+        Extract summary data for pump stations from the HDF file.
 
-        Parameters:
-        ----------
-        hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
+        Args:
+            hdf_path (Path): Path to the HDF file.
 
         Returns:
-        -------
-        pd.DataFrame
-            A DataFrame containing the wet area inside the cross sections.
+            pd.DataFrame: DataFrame containing pump station summary data.
+
+        Raises:
+            KeyError: If the required datasets are not found in the HDF file.
         """
-        return HdfResultsXsec.steady_profile_xs_output(hdf_path, "Area Ineffective Total")
+        try:
+            with h5py.File(hdf_path, 'r') as hdf:
+                # Extract summary data
+                summary_path = "/Results/Unsteady/Summary/Pump Station"
+                if summary_path not in hdf:
+                    logger.warning("Pump Station summary data not found in HDF file")
+                    return pd.DataFrame()
+
+                summary_data = hdf[summary_path][()]
+                
+                # Create DataFrame
+                df = pd.DataFrame(summary_data)
+
+                # Convert column names
+                df.columns = [col.decode('utf-8') if isinstance(col, bytes) else col for col in df.columns]
+
+                # Convert byte string values to regular strings
+                for col in df.columns:
+                    if df[col].dtype == object:
+                        df[col] = df[col].apply(lambda x: x.decode('utf-8') if isinstance(x, bytes) else x)
+
+                return df
+
+        except KeyError as e:
+            logger.error(f"Required dataset not found in HDF file: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error extracting pump station summary data: {e}")
+            raise
+
+
+
+
+# Tested functions from AWS webinar where the code was developed
+# Need to add examples
+
 
     @staticmethod
+    @log_call
     @standardize_input(file_type='plan_hdf')
-    def cross_sections_additional_velocity_total(hdf_path: Path) -> pd.DataFrame:
+    def extract_cross_section_results(hdf_path: Path) -> xr.Dataset:
         """
-        Return the 1D cross section velocity for each profile.
+        Extract Water Surface, Velocity Total, Velocity Channel, Flow Lateral, and Flow data from HEC-RAS HDF file.
+        Includes Cross Section Only and Cross Section Attributes as coordinates in the xarray.Dataset.
+        Also calculates maximum values for key parameters.
 
         Parameters:
-        ----------
+        -----------
         hdf_path : Path
-            Path to the HEC-RAS plan HDF file.
+            Path to the HEC-RAS results HDF file
 
         Returns:
-        -------
-        pd.DataFrame
-            A DataFrame containing the velocity inside the cross sections.
+        --------
+        xr.Dataset
+            Xarray Dataset containing the extracted cross-section results with appropriate coordinates and attributes.
+            Includes maximum values for Water Surface, Flow, Channel Velocity, Total Velocity, and Lateral Flow.
         """
-        return HdfResultsXsec.steady_profile_xs_output(hdf_path, "Velocity Total")
+        try:
+            with h5py.File(hdf_path, 'r') as hdf_file:
+                # Define base paths
+                base_output_path = "/Results/Unsteady/Output/Output Blocks/Base Output/Unsteady Time Series/Cross Sections/"
+                time_stamp_path = "/Results/Unsteady/Output/Output Blocks/Base Output/Unsteady Time Series/Time Date Stamp (ms)"
+                
+                # Extract Cross Section Attributes
+                attrs_dataset = hdf_file[f"{base_output_path}Cross Section Attributes"][:]
+                rivers = [attr['River'].decode('utf-8').strip() for attr in attrs_dataset]
+                reaches = [attr['Reach'].decode('utf-8').strip() for attr in attrs_dataset]
+                stations = [attr['Station'].decode('utf-8').strip() for attr in attrs_dataset]
+                names = [attr['Name'].decode('utf-8').strip() for attr in attrs_dataset]
+                
+                # Extract Cross Section Only (Unique Names)
+                cross_section_only_dataset = hdf_file[f"{base_output_path}Cross Section Only"][:]
+                cross_section_names = [cs.decode('utf-8').strip() for cs in cross_section_only_dataset]
+                
+                # Extract Time Stamps and convert to datetime
+                time_stamps = hdf_file[time_stamp_path][:]
+                if any(isinstance(ts, bytes) for ts in time_stamps):
+                    time_stamps = [ts.decode('utf-8') for ts in time_stamps]
+                # Convert RAS format timestamps to datetime
+                times = pd.to_datetime(time_stamps, format='%d%b%Y %H:%M:%S:%f')
+                
+                # Extract Required Datasets
+                water_surface = hdf_file[f"{base_output_path}Water Surface"][:]
+                velocity_total = hdf_file[f"{base_output_path}Velocity Total"][:]
+                velocity_channel = hdf_file[f"{base_output_path}Velocity Channel"][:]
+                flow_lateral = hdf_file[f"{base_output_path}Flow Lateral"][:]
+                flow = hdf_file[f"{base_output_path}Flow"][:]
+                
+                # Calculate maximum values along time axis
+                max_water_surface = np.max(water_surface, axis=0)
+                max_flow = np.max(flow, axis=0)
+                max_velocity_channel = np.max(velocity_channel, axis=0)
+                max_velocity_total = np.max(velocity_total, axis=0)
+                max_flow_lateral = np.max(flow_lateral, axis=0)
+                
+                # Create Xarray Dataset
+                ds = xr.Dataset(
+                    {
+                        'Water_Surface': (['time', 'cross_section'], water_surface),
+                        'Velocity_Total': (['time', 'cross_section'], velocity_total),
+                        'Velocity_Channel': (['time', 'cross_section'], velocity_channel),
+                        'Flow_Lateral': (['time', 'cross_section'], flow_lateral),
+                        'Flow': (['time', 'cross_section'], flow),
+                    },
+                    coords={
+                        'time': times,
+                        'cross_section': cross_section_names,
+                        'River': ('cross_section', rivers),
+                        'Reach': ('cross_section', reaches),
+                        'Station': ('cross_section', stations),
+                        'Name': ('cross_section', names),
+                        'Maximum_Water_Surface': ('cross_section', max_water_surface),
+                        'Maximum_Flow': ('cross_section', max_flow),
+                        'Maximum_Channel_Velocity': ('cross_section', max_velocity_channel),
+                        'Maximum_Velocity_Total': ('cross_section', max_velocity_total),
+                        'Maximum_Flow_Lateral': ('cross_section', max_flow_lateral)
+                    },
+                    attrs={
+                        'description': 'Cross-section results extracted from HEC-RAS HDF file',
+                        'source_file': str(hdf_path)
+                    }
+                )
+                
+                return ds
+
+        except KeyError as e:
+            logger.error(f"Required dataset not found in HDF file: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error extracting cross section results: {e}")
+            raise
 

ras_commander/HdfStruc.py

@@ -38,79 +38,177 @@ class HdfStruc:
 
     Note: This class contains static methods and does not require instantiation.
     """
-
-    GEOM_STRUCTURES_PATH = "Geometry/Structures"
-
+    
     @staticmethod
     @log_call
     @standardize_input(file_type='geom_hdf')
     def structures(hdf_path: Path, datetime_to_str: bool = False) -> GeoDataFrame:
         """
-        Return the model structures.
+        Extracts structure data from a HEC-RAS geometry HDF5 file and returns it as a GeoDataFrame.
 
-        This method extracts structure data from the HDF file, including geometry
-        and attributes, and returns it as a GeoDataFrame.
+        This function excludes Property Tables, Pier and Abutment Data/Attributes, and Gate Groups.
+        It includes Table Info, Centerlines as LineStrings, Structures Attributes, Bridge Coefficient Attributes,
+        and Profile Data (as a list of station and elevation values for each structure).
 
         Parameters
         ----------
         hdf_path : Path
-            Path to the HEC-RAS geometry HDF file.
+            Path to the HEC-RAS geometry HDF5 file.
         datetime_to_str : bool, optional
-            If True, convert datetime objects to strings. Default is False.
+            Convert datetime objects to strings, by default False.
 
         Returns
         -------
         GeoDataFrame
-            A GeoDataFrame containing the structures, with columns for attributes
-            and geometry.
-
-        Raises
-        ------
-        Exception
-            If there's an error reading the structures data from the HDF file.
+            A GeoDataFrame containing all relevant structure data with geometries and attributes.
         """
         try:
-            with h5py.File(hdf_path, 'r') as hdf_file:
-                # Check if the structures path exists in the HDF file
-                if HdfStruc.GEOM_STRUCTURES_PATH not in hdf_file:
-                    logger.info(f"No structures found in the geometry file: {hdf_path}")
+            with h5py.File(hdf_path, 'r') as hdf:
+                if "Geometry/Structures" not in hdf:
+                    logger.info(f"No structures found in: {hdf_path}")
                     return GeoDataFrame()
+
+                def get_dataset_df(path: str) -> pd.DataFrame:
+                    """
+                    Helper function to convert an HDF5 dataset to a pandas DataFrame.
+
+                    Parameters
+                    ----------
+                    path : str
+                        The path to the dataset within the HDF5 file.
+
+                    Returns
+                    -------
+                    pd.DataFrame
+                        DataFrame representation of the dataset.
+                    """
+                    if path not in hdf:
+                        logger.warning(f"Dataset not found: {path}")
+                        return pd.DataFrame()
+
+                    data = hdf[path][()]
+                    
+                    if data.dtype.names:
+                        df = pd.DataFrame(data)
+                        # Decode byte strings to UTF-8
+                        for col in df.columns:
+                            if df[col].dtype.kind in {'S', 'a'}:  # Byte strings
+                                df[col] = df[col].str.decode('utf-8', errors='ignore')
+                        return df
+                    else:
+                        # If no named fields, assign generic column names
+                        return pd.DataFrame(data, columns=[f'Value_{i}' for i in range(data.shape[1])])
+
+                # Extract relevant datasets
+                struct_attrs = get_dataset_df("Geometry/Structures/Attributes")
+                bridge_coef = get_dataset_df("Geometry/Structures/Bridge Coefficient Attributes")
+                table_info = get_dataset_df("Geometry/Structures/Table Info")
+                profile_data = get_dataset_df("Geometry/Structures/Profile Data")
+
+                # Assign 'Structure ID' based on index (starting from 1)
+                struct_attrs.reset_index(drop=True, inplace=True)
+                struct_attrs['Structure ID'] = range(1, len(struct_attrs) + 1)
+                logger.debug(f"Assigned Structure IDs: {struct_attrs['Structure ID'].tolist()}")
+
+                # Check if 'Structure ID' was successfully assigned
+                if 'Structure ID' not in struct_attrs.columns:
+                    logger.error("'Structure ID' column could not be assigned to Structures/Attributes.")
+                    return GeoDataFrame()
+
+                # Get centerline geometry
+                centerline_info = hdf["Geometry/Structures/Centerline Info"][()]
+                centerline_points = hdf["Geometry/Structures/Centerline Points"][()]
                 
-                struct_data = hdf_file[HdfStruc.GEOM_STRUCTURES_PATH]
-                v_conv_val = np.vectorize(HdfUtils._convert_ras_hdf_value)
-                sd_attrs = struct_data["Attributes"][()]
-                
-                # Create a dictionary to store structure data
-                struct_dict = {"struct_id": range(sd_attrs.shape[0])}
-                struct_dict.update(
-                    {name: v_conv_val(sd_attrs[name]) for name in sd_attrs.dtype.names}
-                )
-                
-                # Get structure geometries
-                geoms = HdfXsec._get_polylines(
-                    hdf_path,
-                    HdfStruc.GEOM_STRUCTURES_PATH,
-                    info_name="Centerline Info",
-                    parts_name="Centerline Parts",
-                    points_name="Centerline Points"
-                )
-                
-                # Create GeoDataFrame
+                # Create LineString geometries for each structure
+                geoms = []
+                for i in range(len(centerline_info)):
+                    start_idx = centerline_info[i][0]  # Point Starting Index
+                    point_count = centerline_info[i][1]  # Point Count
+                    points = centerline_points[start_idx:start_idx + point_count]
+                    if len(points) >= 2:
+                        geoms.append(LineString(points))
+                    else:
+                        logger.warning(f"Insufficient points for LineString in structure index {i}.")
+                        geoms.append(None)
+
+                # Create base GeoDataFrame with Structures Attributes and geometries
                 struct_gdf = GeoDataFrame(
-                    struct_dict,
+                    struct_attrs,
                     geometry=geoms,
-                    crs=HdfUtils.projection(hdf_path),
+                    crs=HdfUtils.projection(hdf_path)
                 )
-                
-                # Convert datetime to string if requested
-                if datetime_to_str:
-                    struct_gdf["Last Edited"] = struct_gdf["Last Edited"].apply(
-                        lambda x: pd.Timestamp.isoformat(x) if pd.notnull(x) else None
+
+                # Drop entries with invalid geometries
+                initial_count = len(struct_gdf)
+                struct_gdf = struct_gdf.dropna(subset=['geometry']).reset_index(drop=True)
+                final_count = len(struct_gdf)
+                if final_count < initial_count:
+                    logger.warning(f"Dropped {initial_count - final_count} structures due to invalid geometries.")
+
+                # Merge Bridge Coefficient Attributes on 'Structure ID'
+                if not bridge_coef.empty and 'Structure ID' in bridge_coef.columns:
+                    struct_gdf = struct_gdf.merge(
+                        bridge_coef,
+                        on='Structure ID',
+                        how='left',
+                        suffixes=('', '_bridge_coef')
                     )
-                
+                    logger.debug("Merged Bridge Coefficient Attributes successfully.")
+                else:
+                    logger.warning("Bridge Coefficient Attributes missing or 'Structure ID' not present.")
+
+                # Merge Table Info based on the DataFrame index (one-to-one correspondence)
+                if not table_info.empty:
+                    if len(table_info) != len(struct_gdf):
+                        logger.warning("Table Info count does not match Structures count. Skipping merge.")
+                    else:
+                        struct_gdf = pd.concat([struct_gdf, table_info.reset_index(drop=True)], axis=1)
+                        logger.debug("Merged Table Info successfully.")
+                else:
+                    logger.warning("Table Info dataset is empty or missing.")
+
+                # Process Profile Data based on Table Info
+                if not profile_data.empty and not table_info.empty:
+                    # Assuming 'Centerline Profile (Index)' and 'Centerline Profile (Count)' are in 'Table Info'
+                    if ('Centerline Profile (Index)' in table_info.columns and
+                        'Centerline Profile (Count)' in table_info.columns):
+                        struct_gdf['Profile_Data'] = struct_gdf.apply(
+                            lambda row: [
+                                {'Station': float(profile_data.iloc[i, 0]),
+                                 'Elevation': float(profile_data.iloc[i, 1])}
+                                for i in range(
+                                    int(row['Centerline Profile (Index)']),
+                                    int(row['Centerline Profile (Index)']) + int(row['Centerline Profile (Count)'])
+                                )
+                            ],
+                            axis=1
+                        )
+                        logger.debug("Processed Profile Data successfully.")
+                    else:
+                        logger.warning("Required columns for Profile Data not found in Table Info.")
+                else:
+                    logger.warning("Profile Data dataset is empty or Table Info is missing.")
+
+                # Convert datetime columns to string if requested
+                if datetime_to_str:
+                    datetime_cols = struct_gdf.select_dtypes(include=['datetime64']).columns
+                    for col in datetime_cols:
+                        struct_gdf[col] = struct_gdf[col].dt.isoformat()
+                        logger.debug(f"Converted datetime column '{col}' to string.")
+
+                # Ensure all byte strings are decoded (if any remain)
+                for col in struct_gdf.columns:
+                    if struct_gdf[col].dtype == object:
+                        struct_gdf[col] = struct_gdf[col].apply(
+                            lambda x: x.decode('utf-8', errors='ignore') if isinstance(x, bytes) else x
+                        )
+
+                # Final GeoDataFrame
+                logger.info("Successfully extracted structures GeoDataFrame.")
                 return struct_gdf
+
         except Exception as e:
-            logger.error(f"Error reading structures: {str(e)}")
+            logger.error(f"Error reading structures from {hdf_path}: {str(e)}")
             raise
 
     @staticmethod
@@ -138,10 +236,10 @@ class HdfStruc:
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
-                if HdfStruc.GEOM_STRUCTURES_PATH not in hdf_file:
+                if "Geometry/Structures" not in hdf_file:
                     logger.info(f"No structures found in the geometry file: {hdf_path}")
                     return {}
-                return HdfUtils.get_attrs(hdf_file, HdfStruc.GEOM_STRUCTURES_PATH)
+                return HdfUtils.get_attrs(hdf_file, "Geometry/Structures")
         except Exception as e:
             logger.error(f"Error reading geometry structures attributes: {str(e)}")
             return {}