ras-commander 0.51.0__py3-none-any.whl → 0.53.0__py3-none-any.whl

ras_commander/HdfXsec.py

@@ -5,7 +5,7 @@ Attribution: A substantial amount of code in this file is sourced or derived
 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.
+This source code has been forked and modified for use in RAS Commander.
 
 -----
 
@@ -99,7 +99,7 @@ class HdfXsec:
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf:
-                # Extract datasets
+                # Extract required datasets
                 poly_info = hdf['/Geometry/Cross Sections/Polyline Info'][:]
                 poly_parts = hdf['/Geometry/Cross Sections/Polyline Parts'][:]
                 poly_points = hdf['/Geometry/Cross Sections/Polyline Points'][:]
@@ -182,43 +182,61 @@ class HdfXsec:
                         else:
                             ineffective_blocks.append([])
                 
-                # Create GeoDataFrame
-                if geometries:
-                    # Create DataFrame from attributes
-                    data = {
-                        'geometry': geometries,
-                        'station_elevation': station_elevations,
-                        'mannings_n': mannings_n,
-                        'ineffective_blocks': ineffective_blocks,
-                        'River': [x['River'].decode('utf-8').strip() for x in xs_attrs],
-                        'Reach': [x['Reach'].decode('utf-8').strip() for x in xs_attrs],
-                        'RS': [x['RS'].decode('utf-8').strip() for x in xs_attrs],
-                        'Name': [x['Name'].decode('utf-8').strip() for x in xs_attrs],
-                        'Description': [x['Description'].decode('utf-8').strip() for x in xs_attrs],
-                        'Len Left': xs_attrs['Len Left'],
-                        'Len Channel': xs_attrs['Len Channel'],
-                        'Len Right': xs_attrs['Len Right'], 
-                        'Left Bank': xs_attrs['Left Bank'],
-                        'Right Bank': xs_attrs['Right Bank'],
-                        'Friction Mode': [x['Friction Mode'].decode('utf-8').strip() for x in xs_attrs],
-                        'Contr': xs_attrs['Contr'],
-                        'Expan': xs_attrs['Expan'],
-                        'Left Levee Sta': xs_attrs['Left Levee Sta'],
-                        'Left Levee Elev': xs_attrs['Left Levee Elev'],
-                        'Right Levee Sta': xs_attrs['Right Levee Sta'],
-                        'Right Levee Elev': xs_attrs['Right Levee Elev'],
-                        'HP Count': xs_attrs['HP Count'],
-                        'HP Start Elev': xs_attrs['HP Start Elev'],
-                        'HP Vert Incr': xs_attrs['HP Vert Incr'],
-                        'HP LOB Slices': xs_attrs['HP LOB Slices'],
-                        'HP Chan Slices': xs_attrs['HP Chan Slices'],
-                        'HP ROB Slices': xs_attrs['HP ROB Slices'],
-                        'Ineff Block Mode': xs_attrs['Ineff Block Mode'],
-                        'Obstr Block Mode': xs_attrs['Obstr Block Mode'],
-                        'Default Centerline': xs_attrs['Default Centerline'],
-                        'Last Edited': [x['Last Edited'].decode('utf-8').strip() for x in xs_attrs]
-                    }
+                # Create base dictionary with required fields
+                data = {
+                    'geometry': geometries,
+                    'station_elevation': station_elevations,
+                    'mannings_n': mannings_n,
+                    'ineffective_blocks': ineffective_blocks,
+                }
+                
+                # Define field mappings with default values
+                field_mappings = {
+                    'River': ('River', ''),
+                    'Reach': ('Reach', ''),
+                    'RS': ('RS', ''),
+                    'Name': ('Name', ''),
+                    'Description': ('Description', ''),
+                    'Len Left': ('Len Left', 0.0),
+                    'Len Channel': ('Len Channel', 0.0),
+                    'Len Right': ('Len Right', 0.0),
+                    'Left Bank': ('Left Bank', 0.0),
+                    'Right Bank': ('Right Bank', 0.0),
+                    'Friction Mode': ('Friction Mode', ''),
+                    'Contr': ('Contr', 0.0),
+                    'Expan': ('Expan', 0.0),
+                    'Left Levee Sta': ('Left Levee Sta', None),
+                    'Left Levee Elev': ('Left Levee Elev', None),
+                    'Right Levee Sta': ('Right Levee Sta', None),
+                    'Right Levee Elev': ('Right Levee Elev', None),
+                    'HP Count': ('HP Count', 0),
+                    'HP Start Elev': ('HP Start Elev', 0.0),
+                    'HP Vert Incr': ('HP Vert Incr', 0.0),
+                    'HP LOB Slices': ('HP LOB Slices', 0),
+                    'HP Chan Slices': ('HP Chan Slices', 0),
+                    'HP ROB Slices': ('HP ROB Slices', 0),
+                    'Ineff Block Mode': ('Ineff Block Mode', 0),
+                    'Obstr Block Mode': ('Obstr Block Mode', 0),
+                    'Default Centerline': ('Default Centerline', 0),
+                    'Last Edited': ('Last Edited', '')
+                }
                 
+                # Add fields that exist in xs_attrs
+                for field_name, (attr_name, default_value) in field_mappings.items():
+                    if attr_name in xs_attrs.dtype.names:
+                        if xs_attrs[attr_name].dtype.kind == 'S':
+                            # Handle string fields
+                            data[field_name] = [x[attr_name].decode('utf-8').strip() 
+                                              for x in xs_attrs]
+                        else:
+                            # Handle numeric fields
+                            data[field_name] = xs_attrs[attr_name]
+                    else:
+                        # Use default value if field doesn't exist
+                        data[field_name] = [default_value] * len(geometries)
+                        logger.debug(f"Field {attr_name} not found in attributes, using default value")
+                
+                if geometries:
                     gdf = gpd.GeoDataFrame(data)
                     
                     # Set CRS if available
@@ -233,7 +251,7 @@ class HdfXsec:
                 return gpd.GeoDataFrame()
                 
         except Exception as e:
-            logging.error(f"Error processing cross-section data: {str(e)}")
+            logger.error(f"Error processing cross-section data: {str(e)}")
             return gpd.GeoDataFrame()
 
     @staticmethod
@@ -391,7 +409,7 @@ class HdfXsec:
                 result_gdf.at[idx, 'points'] = points
                 
                 # Add stationing direction based on upstream/downstream info
-                if row['upstream_type'] == 'Junction' and row['downstream_type'] != 'Junction':
+                if row['US Type'] == 'Junction' and row['DS Type'] != 'Junction':
                     # Reverse stationing if upstream is junction
                     result_gdf.at[idx, 'station_start'] = total_length
                     result_gdf.at[idx, 'station_end'] = 0.0

ras_commander/LoggingConfig.py

@@ -23,7 +23,8 @@ def setup_logging(log_file=None, log_level=logging.INFO):
     
     # Define log format
     log_format = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
     )
 
     # Configure console handler

ras_commander/RasCmdr.py

@@ -271,13 +271,13 @@ class RasCmdr:
                 logger.info(f"Created worker folder: {worker_folder}")
 
                 try:
-                    ras_instance = RasPrj()
-                    worker_ras_instance = init_ras_project(
+                    worker_ras = RasPrj()
+                    worker_ras_object = init_ras_project(
                         ras_project_folder=worker_folder,
                         ras_version=ras_obj.ras_exe_path,
-                        ras_instance=ras_instance
+                        ras_object=worker_ras
                     )
-                    worker_ras_objects[worker_id] = worker_ras_instance
+                    worker_ras_objects[worker_id] = worker_ras_object
                 except Exception as e:
                     logger.critical(f"Failed to initialize RAS project for worker {worker_id}: {str(e)}")
                     worker_ras_objects[worker_id] = None
@@ -317,28 +317,53 @@ class RasCmdr:
                     continue
                 worker_folder = Path(worker_ras.project_folder)
                 try:
-                    for item in worker_folder.iterdir():
-                        dest_path = final_dest_folder / item.name
-                        if dest_path.exists():
-                            if dest_path.is_dir():
-                                shutil.rmtree(dest_path)
-                                logger.debug(f"Removed existing directory at {dest_path}")
-                            else:
-                                dest_path.unlink()
-                                logger.debug(f"Removed existing file at {dest_path}")
-                        shutil.move(str(item), final_dest_folder)
-                        logger.debug(f"Moved {item} to {final_dest_folder}")
-                    shutil.rmtree(worker_folder)
-                    logger.info(f"Removed worker folder: {worker_folder}")
+                    # First, close any open resources in the worker RAS object
+                    worker_ras.close() if hasattr(worker_ras, 'close') else None
+                    
+                    # Add a small delay to ensure file handles are released
+                    time.sleep(1)
+                    
+                    # Move files with retry mechanism
+                    max_retries = 3
+                    for retry in range(max_retries):
+                        try:
+                            for item in worker_folder.iterdir():
+                                dest_path = final_dest_folder / item.name
+                                if dest_path.exists():
+                                    if dest_path.is_dir():
+                                        shutil.rmtree(dest_path)
+                                    else:
+                                        dest_path.unlink()
+                                # Use copy instead of move for more reliability
+                                if item.is_dir():
+                                    shutil.copytree(item, dest_path)
+                                else:
+                                    shutil.copy2(item, dest_path)
+                            
+                            # Add another small delay before removal
+                            time.sleep(1)
+                            
+                            # Try to remove the worker folder
+                            if worker_folder.exists():
+                                shutil.rmtree(worker_folder)
+                            break  # If successful, break the retry loop
+                            
+                        except PermissionError as pe:
+                            if retry == max_retries - 1:  # If this was the last retry
+                                logger.error(f"Failed to move/remove files after {max_retries} attempts: {str(pe)}")
+                                raise
+                            time.sleep(2 ** retry)  # Exponential backoff
+                            continue
+                            
                 except Exception as e:
                     logger.error(f"Error moving results from {worker_folder} to {final_dest_folder}: {str(e)}")
 
             try:
-                final_dest_folder_ras_obj = RasPrj()
+                final_dest_folder_ras = RasPrj()
                 final_dest_folder_ras_obj = init_ras_project(
                     ras_project_folder=final_dest_folder, 
                     ras_version=ras_obj.ras_exe_path,
-                    ras_instance=final_dest_folder_ras_obj
+                    ras_object=final_dest_folder_ras
                 )
                 final_dest_folder_ras_obj.check_initialized()
             except Exception as e:
@@ -379,7 +404,7 @@ class RasCmdr:
         other two compute_ functions. Per the original HEC-RAS test flag, it creates a separate test folder,
         copies the project there, and executes the specified plans in sequential order.
         
-        For most purposes, just copying a the project folder, initing that new folder, then running each plan 
+        For most purposes, just copying the project folder, initing that new folder, then running each plan 
         with compute_plan is a simpler and more flexible approach.  This is shown in the examples provided
         in the ras-commander library.
 

ras_commander/RasPlan.py

@@ -249,7 +249,6 @@ class RasPlan:
     def _update_unsteady_in_file(lines, new_unsteady_flow_number):
         return [f"Unsteady File=u{new_unsteady_flow_number}\n" if line.startswith("Unsteady File=u") else line for line in lines]
     
-    
     @staticmethod
     @log_call
     def set_num_cores(plan_number, num_cores, ras_object=None):
@@ -264,6 +263,16 @@ class RasPlan:
         Returns:
         None
 
+        Number of cores is controlled by the following parameters in the plan file corresponding to 1D, 2D, Pipe Systems and Pump Stations:
+        UNET D1 Cores=  
+        UNET D2 Cores=
+        PS Cores=
+
+        Where a value of "0" is used for "All Available" cores, and values of 1 or more are used to specify the number of cores to use.
+        For complex 1D/2D models with pipe systems, a more complex approach may be needed to optimize performance.  (Suggest writing a custom function based on this code).
+        This function simply sets the "num_cores" parameter for ALL instances of the above parameters in the plan file.
+
+
         Notes on setting num_cores in HEC-RAS:
         The recommended setting for num_cores is 2 (most efficient) to 8 (most performant)
         More details in the HEC-Commander Repository Blog "Benchmarking is All You Need"
@@ -290,9 +299,9 @@ class RasPlan:
         def update_num_cores(lines):
             updated_lines = []
             for line in lines:
-                if "UNET D1 Cores=" in line:
-                    parts = line.split("=")
-                    updated_lines.append(f"{parts[0]}= {num_cores}\n")
+                if any(param in line for param in ["UNET D1 Cores=", "UNET D2 Cores=", "PS Cores="]):
+                    param_name = line.split("=")[0]
+                    updated_lines.append(f"{param_name}= {num_cores}\n")
                 else:
                     updated_lines.append(line)
             return updated_lines
@@ -840,7 +849,7 @@ class RasPlan:
         - 'Plan File' (str): Name of the plan file
         - 'Plan Title' (str): Title of the simulation plan
         - 'Program Version' (str): Version number of HEC-RAS
-        - 'Run HTAB' (int): Flag to run HTab module (-1 or 1)
+        - 'Run HTab' (int): Flag to run HTab module (-1 or 1)
         - 'Run Post Process' (int): Flag to run post-processing (-1 or 1)
         - 'Run Sediment' (int): Flag to run sediment transport module (0 or 1)
         - 'Run UNET' (int): Flag to run unsteady network module (-1 or 1)
@@ -848,13 +857,14 @@ class RasPlan:
         - 'Short Identifier' (str): Short name or ID for the plan
         - 'Simulation Date' (str): Start and end dates/times for simulation
         - 'UNET D1 Cores' (int): Number of cores used in 1D calculations
+        - 'UNET D2 Cores' (int): Number of cores used in 2D calculations
+        - 'PS Cores' (int): Number of cores used in parallel simulation
         - 'UNET Use Existing IB Tables' (int): Flag for using existing internal boundary tables (-1, 0, or 1)
         - 'UNET 1D Methodology' (str): 1D calculation methodology
         - 'UNET D2 Solver Type' (str): 2D solver type
         - 'UNET D2 Name' (str): Name of the 2D area
         - 'Run RASMapper' (int): Flag to run RASMapper for floodplain mapping (-1 for off, 0 for on)
         
-        
         Note: 
         Writing Multi line keys like 'Description' are not supported by this function.
 
@@ -868,9 +878,10 @@ class RasPlan:
         supported_plan_keys = {
             'Description', 'Computation Interval', 'DSS File', 'Flow File', 'Friction Slope Method',
             'Geom File', 'Mapping Interval', 'Plan File', 'Plan Title', 'Program Version',
-            'Run HTAB', 'Run Post Process', 'Run Sediment', 'Run UNET', 'Run WQNET',
-            'Short Identifier', 'Simulation Date', 'UNET D1 Cores', 'UNET Use Existing IB Tables',
-            'UNET 1D Methodology', 'UNET D2 Solver Type', 'UNET D2 Name', 'Run RASMapper'
+            'Run HTab', 'Run Post Process', 'Run Sediment', 'Run UNET', 'Run WQNET',
+            'Short Identifier', 'Simulation Date', 'UNET D1 Cores', 'UNET D2 Cores', 'PS Cores',
+            'UNET Use Existing IB Tables', 'UNET 1D Methodology', 'UNET D2 Solver Type', 
+            'UNET D2 Name', 'Run RASMapper', 'Run HTab', 'Run UNET'
         }
 
         if key not in supported_plan_keys:
@@ -891,7 +902,23 @@ class RasPlan:
             logger.error(f"Error reading plan file {plan_file_path}: {e}")
             raise
 
-        if key == 'Description':
+        # Handle core settings specially to convert to integers
+        core_keys = {'UNET D1 Cores', 'UNET D2 Cores', 'PS Cores'}
+        if key in core_keys:
+            pattern = f"{key}=(.*)"
+            match = re.search(pattern, content)
+            if match:
+                try:
+                    return int(match.group(1).strip())
+                except ValueError:
+                    logger = logging.getLogger(__name__)
+                    logger.error(f"Could not convert {key} value to integer")
+                    return None
+            else:
+                logger = logging.getLogger(__name__)
+                logger.error(f"Key '{key}' not found in the plan file.")
+                return None
+        elif key == 'Description':
             match = re.search(r'Begin DESCRIPTION(.*?)END DESCRIPTION', content, re.DOTALL)
             return match.group(1).strip() if match else None
         else:
@@ -1060,81 +1087,63 @@ class RasPlan:
     @log_call
     def update_plan_description(plan_number_or_path: Union[str, Path], description: str, ras_object: Optional['RasPrj'] = None) -> None:
         """
-        Update the description in the plan file.
+        Update the description block in a HEC-RAS plan file.
 
         Args:
-            plan_number_or_path (Union[str, Path]): The plan number or path to the plan file.
-            description (str): The new description to be written to the plan file.
-            ras_object (Optional[RasPrj]): The RAS project object. If None, uses the global 'ras' object.
+            plan_number_or_path (Union[str, Path]): The plan number or full path to the plan file
+            description (str): The new description text to set
+            ras_object (Optional[RasPrj]): Specific RAS object to use. If None, uses the global ras instance.
 
         Raises:
-            ValueError: If the plan file is not found.
-            IOError: If there's an error reading from or writing to the plan file.
+            ValueError: If the plan file is not found
+            IOError: If there's an error reading or writing the plan file
         """
-        logger = logging.getLogger(__name__)
+        logger = get_logger(__name__)
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
 
         plan_file_path = Path(plan_number_or_path)
         if not plan_file_path.is_file():
-            plan_file_path = RasPlan.get_plan_path(plan_number_or_path, ras_object)
-            if plan_file_path is None or not Path(plan_file_path).exists():
+            plan_file_path = RasUtils.get_plan_path(plan_number_or_path, ras_object)
+            if not plan_file_path.exists():
+                logger.error(f"Plan file not found: {plan_file_path}")
                 raise ValueError(f"Plan file not found: {plan_file_path}")
 
         try:
             with open(plan_file_path, 'r') as file:
-                lines = file.readlines()
-        except IOError as e:
-            logger.error(f"Error reading plan file {plan_file_path}: {e}")
-            raise
+                content = file.read()
 
-        start_index = None
-        end_index = None
-        comp_interval_index = None
-        for i, line in enumerate(lines):
-            if line.strip() == "BEGIN DESCRIPTION:":
-                start_index = i
-            elif line.strip() == "END DESCRIPTION:":
-                end_index = i
-            elif line.strip().startswith("Computation Interval="):
-                comp_interval_index = i
-
-        if start_index is not None and end_index is not None:
-            # Description exists, update it
-            new_lines = lines[:start_index + 1]
-            if description:
-                new_lines.extend(description.split('\n'))
-            else:
-                new_lines.append('\n')
-            new_lines.extend(lines[end_index:])
-        else:
-            # Description doesn't exist, insert before Computation Interval
-            if comp_interval_index is None:
-                logger.warning("Neither description tags nor Computation Interval found in plan file. Appending to end of file.")
-                comp_interval_index = len(lines)
-            
-            new_lines = lines[:comp_interval_index]
-            new_lines.append("BEGIN DESCRIPTION:\n")
-            if description:
-                new_lines.extend(f"{line}\n" for line in description.split('\n'))
+            # Find the description block
+            desc_pattern = r'Begin DESCRIPTION.*?END DESCRIPTION'
+            new_desc_block = f'Begin DESCRIPTION\n{description}\nEND DESCRIPTION'
+
+            if re.search(desc_pattern, content, re.DOTALL):
+                # Replace existing description block
+                new_content = re.sub(desc_pattern, new_desc_block, content, flags=re.DOTALL)
             else:
-                new_lines.append('\n')
-            new_lines.append("END DESCRIPTION:\n")
-            new_lines.extend(lines[comp_interval_index:])
+                # Add new description block at the start of the file
+                new_content = new_desc_block + '\n' + content
 
-        try:
+            # Write the updated content back to the file
             with open(plan_file_path, 'w') as file:
-                file.writelines(new_lines)
+                file.write(new_content)
+
             logger.info(f"Updated description in plan file: {plan_file_path}")
+
+            # Update the dataframes in the RAS object to reflect changes
+            if ras_object:
+                ras_object.plan_df = ras_object.get_plan_entries()
+                ras_object.geom_df = ras_object.get_geom_entries()
+                ras_object.flow_df = ras_object.get_flow_entries()
+                ras_object.unsteady_df = ras_object.get_unsteady_entries()
+
         except IOError as e:
-            logger.error(f"Error writing to plan file {plan_file_path}: {e}")
+            logger.error(f"Error updating plan description in {plan_file_path}: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error updating plan description: {e}")
             raise
 
-        # Refresh RasPrj dataframes
-        if ras_object:
-            ras_object.plan_df = ras_object.get_plan_entries()
-            ras_object.geom_df = ras_object.get_geom_entries()
-            ras_object.flow_df = ras_object.get_flow_entries()
-            ras_object.unsteady_df = ras_object.get_unsteady_entries()
-            
     @staticmethod
     @log_call
     def read_plan_description(plan_number_or_path: Union[str, Path], ras_object: Optional['RasPrj'] = None) -> str: