ras-commander 0.68.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

ras_commander/RasCmdr.py

@@ -99,23 +99,66 @@ class RasCmdr:
         overwrite_dest=False
     ):
         """
-        Execute a HEC-RAS plan.
+        Execute a single HEC-RAS plan in a specified location.
+
+        This function runs a HEC-RAS plan by launching the HEC-RAS executable through command line, 
+        allowing for destination folder specification, core count control, and geometry preprocessor management.
 
         Args:
             plan_number (str, Path): The plan number to execute (e.g., "01", "02") or the full path to the plan file.
+                Recommended to use two-digit strings for plan numbers for consistency (e.g., "01" instead of 1).
             dest_folder (str, Path, optional): Name of the folder or full path for computation.
                 If a string is provided, it will be created in the same parent directory as the project folder.
                 If a full path is provided, it will be used as is.
+                If None, computation occurs in the original project folder, modifying the original project.
             ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
+                Useful when working with multiple projects simultaneously.
             clear_geompre (bool, optional): Whether to clear geometry preprocessor files. Defaults to False.
-            num_cores (int, optional): Number of cores to use for the plan execution. If None, the current setting is not changed.
+                Set to True when geometry has been modified to force recomputation of preprocessor files.
+            num_cores (int, optional): Number of cores to use for the plan execution. 
+                If None, the current setting in the plan file is not changed.
+                Generally, 2-4 cores provides good performance for most models.
             overwrite_dest (bool, optional): If True, overwrite the destination folder if it exists. Defaults to False.
+                Set to True to replace an existing destination folder with the same name.
 
         Returns:
             bool: True if the execution was successful, False otherwise.
 
         Raises:
             ValueError: If the specified dest_folder already exists and is not empty, and overwrite_dest is False.
+            FileNotFoundError: If the plan file or project file cannot be found.
+            PermissionError: If there are issues accessing or writing to the destination folder.
+            subprocess.CalledProcessError: If the HEC-RAS execution fails.
+
+        Examples:
+            # Run a plan in the original project folder
+            RasCmdr.compute_plan("01")
+            
+            # Run a plan in a separate folder
+            RasCmdr.compute_plan("01", dest_folder="computation_folder")
+            
+            # Run a plan with a specific number of cores
+            RasCmdr.compute_plan("01", num_cores=4)
+            
+            # Run a plan in a specific folder, overwriting if it exists
+            RasCmdr.compute_plan("01", dest_folder="computation_folder", overwrite_dest=True)
+            
+            # Run a plan in a specific folder with multiple options
+            RasCmdr.compute_plan(
+                "01", 
+                dest_folder="computation_folder",
+                num_cores=2,
+                clear_geompre=True,
+                overwrite_dest=True
+            )
+            
+        Notes:
+            - For executing multiple plans, consider using compute_parallel() or compute_test_mode().
+            - Setting num_cores appropriately is important for performance:
+              * 1-2 cores: Highest efficiency per core, good for small models
+              * 3-8 cores: Good balance for most models
+              * >8 cores: May have diminishing returns due to overhead
+            - This function updates the RAS object's dataframes (plan_df, geom_df, etc.) after execution.
         """
         try:
             ras_obj = ras_object if ras_object is not None else ras
@@ -202,8 +245,6 @@ class RasCmdr:
     
 
 
-    @staticmethod
-    @log_call
     @staticmethod
     @log_call
     def compute_parallel(
@@ -216,19 +257,83 @@ class RasCmdr:
         overwrite_dest: bool = False
     ) -> Dict[str, bool]:
         """
-        Compute multiple HEC-RAS plans in parallel.
+        Execute multiple HEC-RAS plans in parallel using multiple worker instances.
+
+        This method creates separate worker folders for each parallel process, runs plans
+        in those folders, and then consolidates results to a final destination folder.
+        It's ideal for running independent plans simultaneously to make better use of system resources.
 
         Args:
-            plan_number (Union[str, List[str], None]): Plan number(s) to compute. If None, all plans are computed.
-            max_workers (int): Maximum number of parallel workers.
+            plan_number (Union[str, List[str], None]): Plan number(s) to compute. 
+                If None, all plans in the project are computed.
+                If string, only that plan will be computed.
+                If list, all specified plans will be computed.
+                Recommended to use two-digit strings for plan numbers for consistency (e.g., "01" instead of 1).
+            max_workers (int): Maximum number of parallel workers (separate HEC-RAS instances).
+                Each worker gets a separate folder with a copy of the project.
+                Optimal value depends on CPU cores and memory available.
+                A good starting point is: max_workers = floor(physical_cores / num_cores).
             num_cores (int): Number of cores to use per plan computation.
-            clear_geompre (bool): Whether to clear geometry preprocessor files.
-            ras_object (Optional[RasPrj]): RAS project object. If None, uses global instance.
+                Controls computational resources allocated to each individual HEC-RAS instance.
+                For parallel execution, 2-4 cores per worker often provides the best balance.
+            clear_geompre (bool): Whether to clear geometry preprocessor files before computation.
+                Set to True when geometry has been modified to force recomputation.
+            ras_object (Optional[RasPrj]): RAS project object. If None, uses global 'ras' instance.
+                Useful when working with multiple projects simultaneously.
             dest_folder (Union[str, Path, None]): Destination folder for computed results.
+                If None, creates a "[Computed]" folder adjacent to the project folder.
+                If string, creates folder in the project's parent directory.
+                If Path, uses the exact path provided.
             overwrite_dest (bool): Whether to overwrite existing destination folder.
+                Set to True to replace an existing destination folder with the same name.
 
         Returns:
             Dict[str, bool]: Dictionary of plan numbers and their execution success status.
+                Keys are plan numbers and values are boolean success indicators.
+
+        Raises:
+            ValueError: If the destination folder already exists, is not empty, and overwrite_dest is False.
+            FileNotFoundError: If project files cannot be found.
+            PermissionError: If there are issues accessing or writing to folders.
+            RuntimeError: If worker initialization fails.
+
+        Examples:
+            # Run all plans in parallel with default settings
+            RasCmdr.compute_parallel()
+            
+            # Run all plans with 4 workers, 2 cores per worker
+            RasCmdr.compute_parallel(max_workers=4, num_cores=2)
+            
+            # Run specific plans in parallel
+            RasCmdr.compute_parallel(plan_number=["01", "03"], max_workers=2)
+            
+            # Run all plans with dynamic worker allocation based on system resources
+            import psutil
+            physical_cores = psutil.cpu_count(logical=False)
+            cores_per_worker = 2
+            max_workers = max(1, physical_cores // cores_per_worker)
+            RasCmdr.compute_parallel(max_workers=max_workers, num_cores=cores_per_worker)
+            
+            # Run all plans in a specific destination folder
+            RasCmdr.compute_parallel(dest_folder="parallel_results", overwrite_dest=True)
+
+        Notes:
+            - Worker Assignment: Plans are assigned to workers in a round-robin fashion.
+              For example, with 3 workers and 5 plans, assignment would be:
+              Worker 1: Plans 1 & 4, Worker 2: Plans 2 & 5, Worker 3: Plan 3.
+            
+            - Resource Management: Each HEC-RAS instance (worker) typically requires:
+              * 2-4 GB of RAM
+              * 2-4 cores for optimal performance
+            
+            - When to use parallel vs. sequential:
+              * Parallel: For independent plans, faster overall completion
+              * Sequential: For dependent plans, consistent resource usage, easier debugging
+            
+            - The function creates worker folders during execution and consolidates results
+              to the destination folder upon completion.
+              
+            - This function updates the RAS object's dataframes (plan_df, geom_df, etc.) after execution.
         """
         try:
             ras_obj = ras_object or ras
@@ -251,11 +356,17 @@ class RasCmdr:
                 logger.info(f"Copied project folder to destination: {dest_folder_path}")
                 project_folder = dest_folder_path
 
+            # Store filtered plan numbers separately to ensure only these are executed
+            filtered_plan_numbers = []
+            
             if plan_number:
                 if isinstance(plan_number, str):
                     plan_number = [plan_number]
                 ras_obj.plan_df = ras_obj.plan_df[ras_obj.plan_df['plan_number'].isin(plan_number)]
-                logger.info(f"Filtered plans to execute: {plan_number}")
+                filtered_plan_numbers = list(ras_obj.plan_df['plan_number'])
+                logger.info(f"Filtered plans to execute: {filtered_plan_numbers}")
+            else:
+                filtered_plan_numbers = list(ras_obj.plan_df['plan_number'])
 
             num_plans = len(ras_obj.plan_df)
             max_workers = min(max_workers, num_plans) if num_plans > 0 else 1
@@ -282,8 +393,9 @@ class RasCmdr:
                     logger.critical(f"Failed to initialize RAS project for worker {worker_id}: {str(e)}")
                     worker_ras_objects[worker_id] = None
 
+            # Explicitly use the filtered plan numbers for assignments
             worker_cycle = cycle(range(1, max_workers + 1))
-            plan_assignments = [(next(worker_cycle), plan_num) for plan_num in ras_obj.plan_df['plan_number']]
+            plan_assignments = [(next(worker_cycle), plan_num) for plan_num in filtered_plan_numbers]
 
             execution_results: Dict[str, bool] = {}
 
@@ -397,49 +509,86 @@ class RasCmdr:
         overwrite_dest=False
     ):
         """
-        Execute HEC-RAS plans in test mode. This is a re-creation of the HEC-RAS command line -test flag, 
-        which does not work in recent versions of HEC-RAS.
-        
-        As a special-purpose function that emulates the original -test flag, it operates differently than the 
-        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 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.
+        Execute HEC-RAS plans sequentially in a separate test folder.
+
+        This function creates a separate test folder, copies the project there, and executes
+        the specified plans in sequential order. It's useful for batch processing plans that 
+        need to be run in a specific order or when you want to ensure consistent resource usage.
 
         Args:
             plan_number (str, list[str], optional): Plan number or list of plan numbers to execute. 
                 If None, all plans will be executed. Default is None.
-            dest_folder_suffix (str, optional): Suffix to append to the test folder name to create dest_folder. 
+                Recommended to use two-digit strings for plan numbers for consistency (e.g., "01" instead of 1).
+            dest_folder_suffix (str, optional): Suffix to append to the test folder name. 
                 Defaults to "[Test]".
-                dest_folder is always created in the project folder's parent directory.
+                The test folder is always created in the project folder's parent directory.
             clear_geompre (bool, optional): Whether to clear geometry preprocessor files.
                 Defaults to False.
-            num_cores (int, optional): Maximum number of cores to use for each plan.
-                If None, the current setting is not changed. Default is None.
+                Set to True when geometry has been modified to force recomputation.
+            num_cores (int, optional): Number of cores to use for each plan.
+                If None, the current setting in the plan file is not changed. Default is None.
+                For sequential execution, 4-8 cores often provides good performance.
             ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
-            overwrite_dest (bool, optional): If True, overwrite the destination folder if it exists. Defaults to False.
+                Useful when working with multiple projects simultaneously.
+            overwrite_dest (bool, optional): If True, overwrite the destination folder if it exists. 
+                Defaults to False.
+                Set to True to replace an existing test folder with the same name.
 
         Returns:
             Dict[str, bool]: Dictionary of plan numbers and their execution success status.
+                Keys are plan numbers and values are boolean success indicators.
+
+        Raises:
+            ValueError: If the destination folder already exists, is not empty, and overwrite_dest is False.
+            FileNotFoundError: If project files cannot be found.
+            PermissionError: If there are issues accessing or writing to folders.
 
-        Example:
-            Run all plans: RasCommander.compute_test_mode()
-            Run a specific plan: RasCommander.compute_test_mode(plan_number="01")
-            Run multiple plans: RasCommander.compute_test_mode(plan_number=["01", "03", "05"])
-            Run plans with a custom folder suffix: RasCommander.compute_test_mode(dest_folder_suffix="[TestRun]")
-            Run plans and clear geometry preprocessor files: RasCommander.compute_test_mode(clear_geompre=True)
-            Run plans with a specific number of cores: RasCommander.compute_test_mode(num_cores=4)
+        Examples:
+            # Run all plans sequentially
+            RasCmdr.compute_test_mode()
+            
+            # Run a specific plan
+            RasCmdr.compute_test_mode(plan_number="01")
+            
+            # Run multiple specific plans
+            RasCmdr.compute_test_mode(plan_number=["01", "03", "05"])
+            
+            # Run plans with a custom folder suffix
+            RasCmdr.compute_test_mode(dest_folder_suffix="[SequentialRun]")
+            
+            # Run plans with a specific number of cores
+            RasCmdr.compute_test_mode(num_cores=4)
             
+            # Run specific plans with multiple options
+            RasCmdr.compute_test_mode(
+                plan_number=["01", "02"],
+                dest_folder_suffix="[SpecificSequential]",
+                clear_geompre=True,
+                num_cores=6,
+                overwrite_dest=True
+            )
+
         Notes:
-            - This function executes plans in a separate folder for isolated testing.
-            - If plan_number is not provided, all plans in the project will be executed.
-            - The function does not change the geometry preprocessor and IB tables settings.  
-                - To force recomputing of geometry preprocessor and IB tables, use the clear_geompre=True option.
-            - Plans are executed sequentially.
-            - Because copying the project is implicit, only a dest_folder_suffix option is provided.
-            - For more flexible run management, use the compute_parallel or compute_sequential functions.
+            - This function was created to replicate the original HEC-RAS command line -test flag,
+              which does not work in recent versions of HEC-RAS.
+            
+            - Key differences from other compute functions:
+              * compute_plan: Runs a single plan, with option for destination folder
+              * compute_parallel: Runs multiple plans simultaneously in worker folders
+              * compute_test_mode: Runs multiple plans sequentially in a single test folder
+            
+            - Use cases:
+              * Running plans in a specific order
+              * Ensuring consistent resource usage
+              * Easier debugging (one plan at a time)
+              * Isolated test environment
+            
+            - Performance considerations:
+              * Sequential execution is generally slower overall than parallel execution
+              * Each plan gets consistent resource usage
+              * Execution time scales linearly with the number of plans
+            
+            - This function updates the RAS object's dataframes (plan_df, geom_df, etc.) after execution.
         """
         try:
             ras_obj = ras_object or ras

ras_commander/RasGeo.py

@@ -37,6 +37,7 @@ List of Functions in RasGeo:
 import os
 from pathlib import Path
 from typing import List, Union
+import pandas as pd  # Added pandas import
 from .RasPlan import RasPlan
 from .RasPrj import ras
 from .LoggingConfig import get_logger
@@ -56,13 +57,18 @@ class RasGeo:
         ras_object = None
     ) -> None:
         """
-        Clear HEC-RAS geometry preprocessor files for specified plan files or all plan files in the project directory.
-        
+        Clear HEC-RAS geometry preprocessor files for specified plan files.
+
+        Geometry preprocessor files (.c* extension) contain computed hydraulic properties derived
+        from the geometry. These should be cleared when the geometry changes to ensure that
+        HEC-RAS recomputes all hydraulic tables with updated geometry information.
+
         Limitations/Future Work:
         - This function only deletes the geometry preprocessor file.
         - It does not clear the IB tables.
         - It also does not clear geometry preprocessor tables from the geometry HDF.
-        - All of these features will need to be added to reliably remove geometry preprocessor files for 1D and 2D projects.
+        - All of these features will need to be added to reliably remove geometry preprocessor 
+          files for 1D and 2D projects.
         
         Parameters:
             plan_files (Union[str, Path, List[Union[str, Path]]], optional): 
@@ -71,20 +77,20 @@ class RasGeo:
             ras_object: An optional RAS object instance.
         
         Returns:
-            None
-        
-        Examples:
-            # Clear all geometry preprocessor files in the project directory
-            RasGeo.clear_geompre_files()
+            None: The function deletes files and updates the ras object's geometry dataframe
+
+        Example:
+            # Clone a plan and geometry
+            new_plan_number = RasPlan.clone_plan("01")
+            new_geom_number = RasPlan.clone_geom("01")
             
-            # Clear a single plan file
-            RasGeo.clear_geompre_files(r'path/to/plan.p01')
+            # Set the new geometry for the cloned plan
+            RasPlan.set_geom(new_plan_number, new_geom_number)
+            plan_path = RasPlan.get_plan_path(new_plan_number)
             
-            # Clear multiple plan files
-            RasGeo.clear_geompre_files([r'path/to/plan1.p01', r'path/to/plan2.p02'])
-
-        Note:
-            This function updates the ras object's geometry dataframe after clearing the preprocessor files.
+            # Clear geometry preprocessor files to ensure clean results
+            RasGeo.clear_geompre_files(plan_path)
+            print(f"Cleared geometry preprocessor files for plan {new_plan_number}")
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
@@ -131,8 +137,244 @@ class RasGeo:
 
 
 
+    @staticmethod
+    def get_mannings_override_tables(geom_file_path, ras_object=None):
+        """
+        Extracts Manning's override region tables from a HEC-RAS geometry file.
+        
+        Args:
+            geom_file_path (str or Path): Geometry file path or geometry number (e.g., "01").
+            ras_object (RasPrj, optional): RAS project object for context. Defaults to global 'ras'.
+        
+        Returns:
+            pd.DataFrame: DataFrame containing Manning's override region tables with columns:
+                - Region Name: Name of the override region
+                - Land Use Type: Land use type or description
+                - Mannings N Value: Manning's n value for the land use type
+                - Polygon Value: Polygon value or ID associated with the region
+                
+        Raises:
+            FileNotFoundError: If the geometry file doesn't exist.
+            ValueError: If the geometry file number is invalid.
+        """
+        # Get the full path to the geometry file if a number was provided
+        if isinstance(geom_file_path, (str, int)) and not str(geom_file_path).endswith('.g'):
+            ras_obj = ras_object or ras
+            ras_obj.check_initialized()
+            geom_file_path = RasPlan.get_geom_path(str(geom_file_path), ras_object=ras_obj)
+            if geom_file_path is None:
+                raise ValueError(f"Geometry file number '{geom_file_path}' not found in project")
+        
+        geom_file_path = Path(geom_file_path)
+        if not geom_file_path.exists():
+            raise FileNotFoundError(f"Geometry file not found: {geom_file_path}")
+        
+        # Lists for storing data
+        region_names, land_use_types, mannings_values, polygon_values = [], [], [], []
+        
+        region_name, table_value, polygon_value = "", 0, ""
+        
+        with open(geom_file_path, 'r') as file:
+            lines = file.readlines()
+            
+            i = 0  # Initialize line counter
+            while i < len(lines):
+                line = lines[i].strip()
+                
+                if "LCMann Region Name=" in line:
+                    region_name = line.split("=")[1]
+                    i += 1  # Move to the next line
+                    continue
+                    
+                if "LCMann Region Table=" in line:
+                    table_value = int(line.split("=")[1])
+                    i += 1  # Skip to the next line which starts the table entries
+                    for j in range(table_value):
+                        if i+j < len(lines):
+                            # Handle multiple commas by splitting from the right
+                            parts = lines[i+j].strip().rsplit(",", 1)
+                            if len(parts) == 2:
+                                land_use, mannings = parts
+                                try:
+                                    mannings_float = float(mannings)
+                                    region_names.append(region_name)
+                                    land_use_types.append(land_use)
+                                    mannings_values.append(mannings_float)
+                                    polygon_values.append(polygon_value)  # This will repeat the last polygon_value
+                                except ValueError:
+                                    # Skip if Manning's value is not a valid float
+                                    pass
+                    
+                    i += table_value  # Skip past the table entries
+                    continue
+                    
+                if "LCMann Region Polygon=" in line:
+                    polygon_value = line.split("=")[1]
+                    i += 1  # Move to the next line
+                    continue
+                    
+                i += 1  # Move to the next line if none of the conditions above are met
+        
+        # Create DataFrame
+        mannings_tables = pd.DataFrame({
+            "Region Name": region_names,
+            "Land Use Type": land_use_types,
+            "Mannings N Value": mannings_values,
+            "Polygon Value": polygon_values
+        })
+        
+        return mannings_tables
 
 
 
+    @staticmethod
+    @log_call
+    def set_mannings_override_tables(geom_file_path, mannings_df, ras_object=None):
+        """
+        Updates Manning's override region tables in a HEC-RAS geometry file based on provided dataframe.
+        
+        This function takes a dataframe of Manning's values (similar to the one returned by
+        extract_mannings_override_tables) and updates the corresponding values in the geometry file.
+        If Region Name is specified in the dataframe, only updates that specific region.
+        If no Region Name is given for a row, it updates all instances of the Land Use Type
+        across all regions in the geometry file.
+        
+        Args:
+            geom_file_path (str or Path): Geometry file path or geometry number (e.g., "01").
+            mannings_df (pd.DataFrame): DataFrame containing Manning's override values with columns:
+                - Land Use Type: Land use type or description (required)
+                - Mannings N Value: Manning's n value for the land use type (required)
+                - Region Name: Name of the override region (optional)
+            ras_object (RasPrj, optional): RAS project object for context. Defaults to global 'ras'.
+                    
+        Returns:
+            bool: True if successful, False otherwise.
+            
+        Raises:
+            FileNotFoundError: If the geometry file doesn't exist.
+            ValueError: If the geometry file number is invalid or required columns are missing.
+            
+        Example:
+            # Get existing Manning's tables
+            mannings_tables = RasGeo.extract_mannings_override_tables("01")
+            
+            # Update specific values
+            mannings_tables.loc[mannings_tables['Land Use Type'] == 'Open Water', 'Mannings N Value'] = 0.030
+            
+            # Update all forest types in all regions
+            forest_updates = pd.DataFrame({
+                'Land Use Type': ['Mixed Forest', 'Deciduous Forest', 'Evergreen Forest'],
+                'Mannings N Value': [0.040, 0.042, 0.045]
+            })
+            
+            # Apply the changes
+            RasGeo.set_mannings_override_tables("01", mannings_tables)
+            # Or apply just the forest updates to all regions
+            RasGeo.set_mannings_override_tables("01", forest_updates)
+        """
+        # Get the full path to the geometry file if a number was provided
+        if isinstance(geom_file_path, (str, int)) and not str(geom_file_path).endswith('.g'):
+            ras_obj = ras_object or ras
+            ras_obj.check_initialized()
+            geom_file_path = RasPlan.get_geom_path(str(geom_file_path), ras_object=ras_obj)
+            if geom_file_path is None:
+                raise ValueError(f"Geometry file number '{geom_file_path}' not found in project")
+        
+        geom_file_path = Path(geom_file_path)
+        if not geom_file_path.exists():
+            raise FileNotFoundError(f"Geometry file not found: {geom_file_path}")
+        
+        # Verify required columns exist
+        required_columns = ['Land Use Type', 'Mannings N Value']
+        if not all(col in mannings_df.columns for col in required_columns):
+            raise ValueError(f"DataFrame must contain columns: {required_columns}")
+        
+        # Create a dictionary for easier lookups
+        update_dict = {}
+        for _, row in mannings_df.iterrows():
+            land_use = row['Land Use Type']
+            manning_value = row['Mannings N Value']
+            region_name = row.get('Region Name', None)  # Optional column
+            
+            if region_name:
+                if region_name not in update_dict:
+                    update_dict[region_name] = {}
+                update_dict[region_name][land_use] = manning_value
+            else:
+                # Special key for updates that apply to all regions
+                if 'ALL_REGIONS' not in update_dict:
+                    update_dict['ALL_REGIONS'] = {}
+                update_dict['ALL_REGIONS'][land_use] = manning_value
+        
+        logger.info(f"Updating Manning's n values in geometry file: {geom_file_path}")
+        
+        # Read the entire file
+        with open(geom_file_path, 'r') as file:
+            lines = file.readlines()
+        
+        # Process the file line by line
+        modified_lines = []
+        current_region = None
+        in_table = False
+        table_start_index = -1
+        table_size = 0
+        
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            modified_lines.append(line)  # Add line by default, may modify later
+            
+            if "LCMann Region Name=" in line:
+                current_region = line.split("=")[1].strip()
+                in_table = False
+            
+            elif "LCMann Region Table=" in line:
+                in_table = True
+                table_start_index = len(modified_lines)
+                try:
+                    table_size = int(line.split("=")[1].strip())
+                except ValueError:
+                    logger.warning(f"Invalid table size at line: {line}")
+                    table_size = 0
+            
+            elif in_table and table_size > 0:
+                # We're inside a Manning's table
+                land_use_entry = line.strip()
+                if "," in land_use_entry:
+                    parts = land_use_entry.rsplit(",", 1)
+                    if len(parts) == 2:
+                        land_use, _ = parts
+                        
+                        # Check if we should update this entry
+                        update_value = None
+                        
+                        # First check region-specific updates
+                        if current_region in update_dict and land_use in update_dict[current_region]:
+                            update_value = update_dict[current_region][land_use]
+                        
+                        # Then check global updates (ALL_REGIONS)
+                        elif 'ALL_REGIONS' in update_dict and land_use in update_dict['ALL_REGIONS']:
+                            update_value = update_dict['ALL_REGIONS'][land_use]
+                        
+                        if update_value is not None:
+                            # Replace the last entry in modified_lines with updated Manning's value
+                            modified_lines[-1] = f"{land_use},{update_value}\n"
+                            logger.debug(f"Updated '{land_use}' in region '{current_region}' to {update_value}")
+                
+                # Decrement counter for table entries
+                table_size -= 1
+                if table_size == 0:
+                    in_table = False
+            
+            i += 1
+        
+        # Write the file back
+        with open(geom_file_path, 'w') as file:
+            file.writelines(modified_lines)
+        
+        logger.info(f"Successfully updated Manning's n values in geometry file: {geom_file_path}")
+        return True
+
+