ras-commander 0.1.0__tar.gz

ras_commander-0.1.0/LICENSE

@@ -0,0 +1,5 @@
+MIT License
+
+Copyright (c) 2024 William M. Katzenmeyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.

ras_commander-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.1
+Name: ras_commander
+Version: 0.1.0
+Summary: A library for automating HEC-RAS operations using python functions.
+Home-page: https://github.com/yourusername/ras_commander
+Author: William Katzenmeyer, P.E., C.F.M.
+Author-email: heccommander@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+
+## RAS-Commander Library Organization
+
+| Directory/File | Purpose |
+|---|---|
+| ras_commander/__init__.py | Initializes the library and defines the public API. |
+| ras_commander/execution.py | Handles execution of HEC-RAS simulations. |
+| ras_commander/file_operations.py | Provides functions for reading and parsing HEC-RAS project files. |
+| ras_commander/geometry_operations.py | Provides functions for manipulating geometry files. |
+| ras_commander/plan_operations.py | Provides functions for modifying and updating plan files. |
+| ras_commander/project_config.py | Defines the ProjectConfig class for managing project-level information. |
+| ras_commander/project_init.py | Provides the `init_ras_project` function to initialize a project. |
+| ras_commander/project_management.py | Provides functions for managing HEC-RAS projects (e.g., copying files, updating project file). |
+| ras_commander/project_setup.py | Provides helper functions for project setup (e.g., finding project file, loading project data). |
+| ras_commander/unsteady_operations.py | Provides functions for manipulating unsteady flow files. |
+| ras_commander/utilities.py | Provides general utility functions (e.g., file backup, directory creation). |
+
+
+## Project Organization Diagram
+
+```
+ras_commander
+├── execution.py
+├── file_operations.py
+├── geometry_operations.py
+├── plan_operations.py
+├── project_config.py
+├── project_init.py
+├── project_management.py
+├── project_setup.py
+├── unsteady_operations.py
+└── utilities.py
+```
+
+## Functions Overview
+
+| Function | Arguments | Purpose |
+|---|---|---|
+| `init_ras_project` | `ras_project_folder`, `hecras_exe_path` | Initializes a HEC-RAS project by setting up the `ProjectConfig` with project details. |
+| `compute_hecras_plan` | `plan_file` | Executes a HEC-RAS plan file. |
+| `compute_hecras_plan_from_folder` | `test_plan_file`, `test_folder_path` | Execute a single HEC-RAS plan from a folder other than the project path.
+| `recreate_test_function` | `project_folder` | Recreates the -test function from the HEC-RAS interface, primarily by copying the project directory, forcing recomputation, and running each plan. |
+| `run_plans_parallel` | `config`, `max_workers`, `cores_per_run` | Run HEC-RAS plans in parallel. |
+| `run_all_plans_parallel` | `project_folder`, `hecras_exe_path` | Run all HEC-RAS plans in parallel from a project folder path. | 
+| `find_hecras_project_file` | `folder_path` | Locates the HEC-RAS project file (.prj) within a given folder. |
+| `get_project_name` | `project_path` | Extracts the project name from the project file path. |
+| `get_plan_entries` | `project_file` | Parses the project file to extract plan file information into a DataFrame. |
+| `get_flow_entries` | `project_file` | Parses the project file to extract steady flow file information into a DataFrame. |
+| `get_unsteady_entries` | `project_file` | Parses the project file to extract unsteady flow file information into a DataFrame. |
+| `get_geom_entries` | `project_file` | Parses the project file to extract geometry file information into a DataFrame. |
+| `clear_geometry_preprocessor_files` | `plan_file` | Deletes the geometry preprocessor files (.cXX) associated with a plan file. |
+| `clear_geometry_preprocessor_files_for_all_plans` |  | Deletes geometry preprocessor files for all plans in the project directory. |
+| `copy_geometry_files` | `dst_folder`, `template_geom` | Copies geometry files from a template to a destination folder, assigning the next available geometry number. |
+| `rename_geometry_files` | `old_number`, `new_number` | Renames geometry files (both .gXX and .gXX.hdf) in the project folder. |
+| `update_geometry_reference_in_plan` | `plan_file`, `new_geometry_number` | Updates the "Geom File=" entry in a plan file to reference a new geometry number. |
+| `apply_geometry_to_plan` | `plan_file`, `geometry_number` | Sets the geometry file used by a plan file. |
+| `apply_flow_to_plan` | `plan_file`, `flow_number` | Sets the steady flow file used by a plan file. |
+| `copy_plan_from_template` | `template_plan` | Creates a new plan file by copying a template and updates the project file with the new plan entry. |
+| `get_next_available_number` | `existing_numbers` | Finds the next available number (e.g., for plans, unsteady flows) based on existing ones. |
+| `apply_unsteady_to_plan` | `plan_file`, `unsteady_number` | Sets the unsteady flow file used by a plan file. |
+| `set_num_cores` | `plan_file`, `num_cores` | Sets the maximum number of cores to be used for a plan file. |
+| `update_geompre_flags` | `file_path`, `run_htab_value`, `use_ib_tables_value` | Updates the geometry preprocessor flags in a plan file. |
+| `get_plan_full_path` | `plan_number` | Returns the full path to a plan file based on its number. |
+| `get_results_full_path` | `plan_number` | Returns the full path to a plan's results file (.hdf) based on its number. |
+| `get_flow_full_path` | `flow_number` | Returns the full path to a steady flow file based on its number. |
+| `get_unsteady_full_path` | `unsteady_number` | Returns the full path to an unsteady flow file based on its number. |
+| `get_geom_full_path` | `geometry_number` | Returns the full path to a geometry file based on its number. |
+| `copy_unsteady_files` | `dst_folder`, `template_unsteady` | Copies unsteady flow files from a template to a destination folder, assigning the next available unsteady number. |
+| `rename_unsteady_files` | `old_number`, `new_number` | Renames unsteady flow files (both .uXX and .uXX.hdf) in the project folder. |
+| `update_unsteady_reference_in_plan` | `plan_file`, `new_unsteady_number` | Updates the "Unsteady File=" entry in a plan file to reference a new unsteady flow number. |
+| `modify_unsteady_flow_parameters` | `unsteady_file`, `modifications` | Modifies parameters within an unsteady flow file based on a dictionary of changes. |
+| `create_backup` | `file_path`, `backup_suffix` | Creates a backup copy of a file. |
+| `restore_from_backup` | `backup_path`, `remove_backup` | Restores a file from a backup copy. |
+| `safe_remove` | `file_path` | Removes a file if it exists, handling potential errors. |
+| `ensure_directory` | `directory_path` | Creates a directory if it does not exist. |
+| `list_files_with_extension` | `extension` | Lists files with a specific extension in the project directory. |
+| `get_file_size` | `file_path` | Returns the size of a file in bytes. |
+| `get_modification_time` | `file_path` | Returns the last modification time of a file. |
+| `get_plan_path` | `current_plan_number` | Returns the full path to a plan file based on its number. |
+| `retry_remove_folder` | `folder_path`, `max_attempts`, `initial_delay` | Attempts to remove a folder with retry and a delay. |
+
+
+
+## Potential Uses of RAS-Commander Functions
+
+The RAS-Commander library offers a wide range of functionalities that can be used to automate various aspects of HEC-RAS modeling workflows. Here are some potential uses:
+
+**1. Automated Plan Creation and Execution:**
+
+* **Batch processing of multiple scenarios:** RAS-Commander allows you to create new plan files based on templates, modify plan parameters (e.g., geometry, flow, unsteady flow files, number of cores), and execute them in parallel. This can be useful for analyzing multiple scenarios with different inputs or model configurations.
+* **Sensitivity analysis and optimization:** By combining RAS-Commander with other libraries (e.g., for parameter sampling or optimization), you can automate sensitivity analysis and parameter optimization studies.
+* **Monte Carlo simulations:** RAS-Commander can be used to automate the execution of Monte Carlo simulations by creating multiple plan files with randomly sampled input parameters.
+
+**2. Project Management and Organization:**
+
+* **Automated file management:** Functions for copying, renaming, and updating file references help maintain consistency and organization within your HEC-RAS project.
+* **Backup and restore functionalities:** Ensure project integrity by creating backups of project files and restoring them when needed.
+* **Project setup and initialization:** Streamline the process of setting up new HEC-RAS projects with standardized configurations.
+
+**3. Advanced Modeling Techniques:**
+
+* **Coupled modeling:** RAS-Commander can be used to automate the setup and execution of coupled models (e.g., HEC-RAS with other hydrodynamic or hydrologic models).
+* **Data assimilation and calibration:** By integrating RAS-Commander with data assimilation or calibration tools, you can automate the process of updating model parameters based on observed data.
+* **Post-processing and analysis:** RAS-Commander can be used to extract results from HEC-RAS output files and perform post-processing and analysis tasks.
+
+
+**4. Integration with Other Tools:**
+
+* **Python scripting and automation:** RAS-Commander can be easily integrated into Python scripts and workflows for more complex automation tasks.
+* **Web applications and dashboards:** Develop web applications and dashboards that allow users to interact with HEC-RAS models and visualize results through a user-friendly interface.
+* **Integration with GIS software:** RAS-Commander can be used to link HEC-RAS models with GIS software for spatial analysis and visualization.
+
+
+**Examples:**
+
+* **Floodplain mapping:** Automate the creation of floodplain maps for different return periods by creating and executing multiple plan files with varying flow conditions.
+* **Dam break analysis:** Automate the setup and execution of dam break simulations by modifying unsteady flow parameters and boundary conditions.
+* **Bridge scour analysis:** Automate the assessment of bridge scour potential by integrating HEC-RAS with bridge scour analysis tools.
+
+
+By automating repetitive tasks and providing a framework for managing complex workflows, RAS-Commander can significantly improve the efficiency and reproducibility of HEC-RAS modeling projects. This can lead to better decision-making and more accurate and reliable results. 

ras_commander-0.1.0/README.md

@@ -0,0 +1,120 @@
+## RAS-Commander Library Organization
+
+| Directory/File | Purpose |
+|---|---|
+| ras_commander/__init__.py | Initializes the library and defines the public API. |
+| ras_commander/execution.py | Handles execution of HEC-RAS simulations. |
+| ras_commander/file_operations.py | Provides functions for reading and parsing HEC-RAS project files. |
+| ras_commander/geometry_operations.py | Provides functions for manipulating geometry files. |
+| ras_commander/plan_operations.py | Provides functions for modifying and updating plan files. |
+| ras_commander/project_config.py | Defines the ProjectConfig class for managing project-level information. |
+| ras_commander/project_init.py | Provides the `init_ras_project` function to initialize a project. |
+| ras_commander/project_management.py | Provides functions for managing HEC-RAS projects (e.g., copying files, updating project file). |
+| ras_commander/project_setup.py | Provides helper functions for project setup (e.g., finding project file, loading project data). |
+| ras_commander/unsteady_operations.py | Provides functions for manipulating unsteady flow files. |
+| ras_commander/utilities.py | Provides general utility functions (e.g., file backup, directory creation). |
+
+
+## Project Organization Diagram
+
+```
+ras_commander
+├── execution.py
+├── file_operations.py
+├── geometry_operations.py
+├── plan_operations.py
+├── project_config.py
+├── project_init.py
+├── project_management.py
+├── project_setup.py
+├── unsteady_operations.py
+└── utilities.py
+```
+
+## Functions Overview
+
+| Function | Arguments | Purpose |
+|---|---|---|
+| `init_ras_project` | `ras_project_folder`, `hecras_exe_path` | Initializes a HEC-RAS project by setting up the `ProjectConfig` with project details. |
+| `compute_hecras_plan` | `plan_file` | Executes a HEC-RAS plan file. |
+| `compute_hecras_plan_from_folder` | `test_plan_file`, `test_folder_path` | Execute a single HEC-RAS plan from a folder other than the project path.
+| `recreate_test_function` | `project_folder` | Recreates the -test function from the HEC-RAS interface, primarily by copying the project directory, forcing recomputation, and running each plan. |
+| `run_plans_parallel` | `config`, `max_workers`, `cores_per_run` | Run HEC-RAS plans in parallel. |
+| `run_all_plans_parallel` | `project_folder`, `hecras_exe_path` | Run all HEC-RAS plans in parallel from a project folder path. | 
+| `find_hecras_project_file` | `folder_path` | Locates the HEC-RAS project file (.prj) within a given folder. |
+| `get_project_name` | `project_path` | Extracts the project name from the project file path. |
+| `get_plan_entries` | `project_file` | Parses the project file to extract plan file information into a DataFrame. |
+| `get_flow_entries` | `project_file` | Parses the project file to extract steady flow file information into a DataFrame. |
+| `get_unsteady_entries` | `project_file` | Parses the project file to extract unsteady flow file information into a DataFrame. |
+| `get_geom_entries` | `project_file` | Parses the project file to extract geometry file information into a DataFrame. |
+| `clear_geometry_preprocessor_files` | `plan_file` | Deletes the geometry preprocessor files (.cXX) associated with a plan file. |
+| `clear_geometry_preprocessor_files_for_all_plans` |  | Deletes geometry preprocessor files for all plans in the project directory. |
+| `copy_geometry_files` | `dst_folder`, `template_geom` | Copies geometry files from a template to a destination folder, assigning the next available geometry number. |
+| `rename_geometry_files` | `old_number`, `new_number` | Renames geometry files (both .gXX and .gXX.hdf) in the project folder. |
+| `update_geometry_reference_in_plan` | `plan_file`, `new_geometry_number` | Updates the "Geom File=" entry in a plan file to reference a new geometry number. |
+| `apply_geometry_to_plan` | `plan_file`, `geometry_number` | Sets the geometry file used by a plan file. |
+| `apply_flow_to_plan` | `plan_file`, `flow_number` | Sets the steady flow file used by a plan file. |
+| `copy_plan_from_template` | `template_plan` | Creates a new plan file by copying a template and updates the project file with the new plan entry. |
+| `get_next_available_number` | `existing_numbers` | Finds the next available number (e.g., for plans, unsteady flows) based on existing ones. |
+| `apply_unsteady_to_plan` | `plan_file`, `unsteady_number` | Sets the unsteady flow file used by a plan file. |
+| `set_num_cores` | `plan_file`, `num_cores` | Sets the maximum number of cores to be used for a plan file. |
+| `update_geompre_flags` | `file_path`, `run_htab_value`, `use_ib_tables_value` | Updates the geometry preprocessor flags in a plan file. |
+| `get_plan_full_path` | `plan_number` | Returns the full path to a plan file based on its number. |
+| `get_results_full_path` | `plan_number` | Returns the full path to a plan's results file (.hdf) based on its number. |
+| `get_flow_full_path` | `flow_number` | Returns the full path to a steady flow file based on its number. |
+| `get_unsteady_full_path` | `unsteady_number` | Returns the full path to an unsteady flow file based on its number. |
+| `get_geom_full_path` | `geometry_number` | Returns the full path to a geometry file based on its number. |
+| `copy_unsteady_files` | `dst_folder`, `template_unsteady` | Copies unsteady flow files from a template to a destination folder, assigning the next available unsteady number. |
+| `rename_unsteady_files` | `old_number`, `new_number` | Renames unsteady flow files (both .uXX and .uXX.hdf) in the project folder. |
+| `update_unsteady_reference_in_plan` | `plan_file`, `new_unsteady_number` | Updates the "Unsteady File=" entry in a plan file to reference a new unsteady flow number. |
+| `modify_unsteady_flow_parameters` | `unsteady_file`, `modifications` | Modifies parameters within an unsteady flow file based on a dictionary of changes. |
+| `create_backup` | `file_path`, `backup_suffix` | Creates a backup copy of a file. |
+| `restore_from_backup` | `backup_path`, `remove_backup` | Restores a file from a backup copy. |
+| `safe_remove` | `file_path` | Removes a file if it exists, handling potential errors. |
+| `ensure_directory` | `directory_path` | Creates a directory if it does not exist. |
+| `list_files_with_extension` | `extension` | Lists files with a specific extension in the project directory. |
+| `get_file_size` | `file_path` | Returns the size of a file in bytes. |
+| `get_modification_time` | `file_path` | Returns the last modification time of a file. |
+| `get_plan_path` | `current_plan_number` | Returns the full path to a plan file based on its number. |
+| `retry_remove_folder` | `folder_path`, `max_attempts`, `initial_delay` | Attempts to remove a folder with retry and a delay. |
+
+
+
+## Potential Uses of RAS-Commander Functions
+
+The RAS-Commander library offers a wide range of functionalities that can be used to automate various aspects of HEC-RAS modeling workflows. Here are some potential uses:
+
+**1. Automated Plan Creation and Execution:**
+
+* **Batch processing of multiple scenarios:** RAS-Commander allows you to create new plan files based on templates, modify plan parameters (e.g., geometry, flow, unsteady flow files, number of cores), and execute them in parallel. This can be useful for analyzing multiple scenarios with different inputs or model configurations.
+* **Sensitivity analysis and optimization:** By combining RAS-Commander with other libraries (e.g., for parameter sampling or optimization), you can automate sensitivity analysis and parameter optimization studies.
+* **Monte Carlo simulations:** RAS-Commander can be used to automate the execution of Monte Carlo simulations by creating multiple plan files with randomly sampled input parameters.
+
+**2. Project Management and Organization:**
+
+* **Automated file management:** Functions for copying, renaming, and updating file references help maintain consistency and organization within your HEC-RAS project.
+* **Backup and restore functionalities:** Ensure project integrity by creating backups of project files and restoring them when needed.
+* **Project setup and initialization:** Streamline the process of setting up new HEC-RAS projects with standardized configurations.
+
+**3. Advanced Modeling Techniques:**
+
+* **Coupled modeling:** RAS-Commander can be used to automate the setup and execution of coupled models (e.g., HEC-RAS with other hydrodynamic or hydrologic models).
+* **Data assimilation and calibration:** By integrating RAS-Commander with data assimilation or calibration tools, you can automate the process of updating model parameters based on observed data.
+* **Post-processing and analysis:** RAS-Commander can be used to extract results from HEC-RAS output files and perform post-processing and analysis tasks.
+
+
+**4. Integration with Other Tools:**
+
+* **Python scripting and automation:** RAS-Commander can be easily integrated into Python scripts and workflows for more complex automation tasks.
+* **Web applications and dashboards:** Develop web applications and dashboards that allow users to interact with HEC-RAS models and visualize results through a user-friendly interface.
+* **Integration with GIS software:** RAS-Commander can be used to link HEC-RAS models with GIS software for spatial analysis and visualization.
+
+
+**Examples:**
+
+* **Floodplain mapping:** Automate the creation of floodplain maps for different return periods by creating and executing multiple plan files with varying flow conditions.
+* **Dam break analysis:** Automate the setup and execution of dam break simulations by modifying unsteady flow parameters and boundary conditions.
+* **Bridge scour analysis:** Automate the assessment of bridge scour potential by integrating HEC-RAS with bridge scour analysis tools.
+
+
+By automating repetitive tasks and providing a framework for managing complex workflows, RAS-Commander can significantly improve the efficiency and reproducibility of HEC-RAS modeling projects. This can lead to better decision-making and more accurate and reliable results. 

ras_commander-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

ras_commander-0.1.0/ras_commander/__init__.py

@@ -0,0 +1,24 @@
+"""
+ras_commander
+A library for automating HEC-RAS operations.
+"""
+from .project_init import init_ras_project
+from .file_operations import FileOperations
+from .project_management import ProjectManager
+from .plan_operations import PlanOperations
+from .geometry_operations import GeometryOperations
+from .unsteady_operations import UnsteadyOperations
+from .execution import RasExecutor
+from .utilities import Utilities
+
+__all__ = [
+    'init_ras_project',
+    'FileOperations',
+    'ProjectManager',
+    'PlanOperations',
+    'GeometryOperations',
+    'UnsteadyOperations',
+    'RasExecutor',
+    'Utilities'
+]
+__version__ = "0.1.0"

ras_commander-0.1.0/ras_commander/execution.py

@@ -0,0 +1,315 @@
+"""
+Execution operations for runningHEC-RAS simulations using subprocess.
+Based on the HEC-Commander project's "Command Line is All You Need" approach, leveraging the -c compute flag to run HEC-RAS and orchestrating changes directly in the RAS input files to achieve automation outcomes. 
+"""
+
+import os
+import subprocess
+import shutil
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from .file_operations import FileOperations
+from .plan_operations import PlanOperations
+import subprocess
+import os
+import logging
+import time
+from .project_config import ProjectConfig
+import pandas as pd
+
+class RasExecutor:
+
+    @staticmethod
+    def compute_hecras_plan(compute_plan_file):
+        """
+        Compute a HEC-RAS plan using the provided plan file.
+
+        This method executes a HEC-RAS plan by running the HEC-RAS executable
+        with the specified plan file. It uses the plan file's path to determine
+        the corresponding project file path.
+
+        Args:
+            compute_plan_file (str): The full path to the HEC-RAS plan file (.p**)
+
+        Returns:
+            bool: True if the plan computation was successful, False otherwise.
+
+        Raises:
+            subprocess.CalledProcessError: If the HEC-RAS execution fails.
+
+        Note:
+            This method assumes that the project file (.prj) is in the same
+            directory as the plan file and has the same name (different extension).
+        """
+        config = ProjectConfig()
+        config.check_initialized()
+
+        # Derive the project file path from the plan file path
+        compute_project_file = Path(compute_plan_file).with_suffix('.prj')
+
+        cmd = f'"{config.hecras_exe_path}" -c "{compute_project_file}" "{compute_plan_file}"'
+        print(f"Running command: {cmd}")
+        try:
+            subprocess.run(cmd, check=True, shell=True, capture_output=True, text=True)
+            logging.info(f"HEC-RAS execution completed for plan: {Path(compute_plan_file).name}")
+            return True
+        except subprocess.CalledProcessError as e:
+            logging.error(f"Error running plan: {Path(compute_plan_file).name}")
+            logging.error(f"Error message: {e.output}")
+            return False
+        
+        
+    @staticmethod
+    def compute_hecras_plan_from_folder(plan_for_compute, folder_for_compute):
+        """
+        Compute a HEC-RAS plan from a specified folder.
+
+        This function allows running a plan directly from a different folder than the project folder,
+        which is useful for the -test function and parallel runs. It uses the HEC-RAS executable path
+        from the ProjectConfig, but derives other paths from the provided arguments.
+
+        Args:
+            plan_for_compute (str): The full path to the HEC-RAS plan file (.p**) to be computed.
+            folder_for_compute (str): The folder containing the HEC-RAS project files.
+
+        Returns:
+            bool: True if the plan computation was successful, False otherwise.
+
+        Raises:
+            subprocess.CalledProcessError: If the HEC-RAS execution fails.
+
+        Note:
+            This function uses the ProjectConfig only to get the hecras_exe_path.
+            Other paths are derived from plan_for_compute and folder_for_compute.
+        """
+        config = ProjectConfig()
+        config.check_initialized()
+        compute_project_file = FileOperations.find_hecras_project_file(folder_for_compute)
+        cmd = f'"{config.hecras_exe_path}" -c "{compute_project_file}" "{plan_for_compute}"'
+        print(f"Running command: {cmd}")
+        try:
+            subprocess.run(cmd, check=True, shell=True, capture_output=True, text=True)
+            logging.info(f"HEC-RAS execution completed for plan: {Path(plan_for_compute).name}")
+            return True
+        except subprocess.CalledProcessError as e:
+            logging.error(f"Error running plan: {Path(plan_for_compute).name}")
+            logging.error(f"Error message: {e.output}")
+            return False 
+
+
+    @staticmethod
+    def recreate_test_function(project_folder):
+        """
+        Recreate the -test function of HEC-RAS command line.
+        
+        Parameters:
+        project_folder (str): Path to the HEC-RAS project folder
+        
+        Returns:
+        None
+        
+        
+        This function executes all ras plans in a separate folder defined by compute_folder='[Test]', so we need to call the individual functions and use distinct variable names
+        For this function, we are using "compute" in the varable names as these are the values used for the compute operations in a separate copy of the ras project folder
+     
+        """
+        print("Starting the recreate_test_function...")
+
+        # Create the test folder path
+        compute_folder='[Test]'
+        folder_for_compute = Path(project_folder).parent / f"{Path(project_folder).name} {compute_folder}"
+        print(f"Creating the test folder: {folder_for_compute}...")
+
+        # Copy the project folder to the test folder
+        print("Copying project folder to the test folder...")
+        shutil.copytree(project_folder, folder_for_compute, dirs_exist_ok=True)
+        print(f"Test folder created at: {folder_for_compute}")
+
+        # Find the project file
+        print("Finding the project file...")
+        compute_project_file = FileOperations.find_hecras_project_file(folder_for_compute)
+
+        if not compute_project_file:
+            print("Project file not found.")
+            return
+        print(f"Project file found: {compute_project_file}")
+
+        # Parse the project file to get plan entries
+        print("Parsing the project file to get plan entries...")
+        ras_compute_plan_entries = FileOperations.get_plan_entries(compute_project_file)
+        print("Parsed project file successfully.")
+
+        # Enforce recomputing of geometry preprocessor and IB tables
+        print("Enforcing recomputing of geometry preprocessor and IB tables...")
+        for plan_file in ras_compute_plan_entries['full_path']:
+            PlanOperations.update_geompre_flags(plan_file, run_htab_value=-1, use_ib_tables_value=-1)
+        print("Recomputing enforced successfully.")
+
+        # Change max cores to 1
+        print("Changing max cores to 2 for all plan files...")
+        for plan_file in ras_compute_plan_entries['full_path']:
+            PlanOperations.set_num_cores(plan_file, num_cores=2)
+        print("Max cores updated successfully.")
+
+        # Run all plans sequentially
+        print("Running all plans sequentially...")
+        for _, plan in ras_compute_plan_entries.iterrows():
+            plan_for_compute = plan["full_path"]
+            RasExecutor.compute_hecras_plan_from_folder(plan_for_compute, folder_for_compute)
+
+        print("All plans have been executed.")
+        print("recreate_test_function completed.")
+        
+    @staticmethod    
+    def run_plans_parallel(config, max_workers, cores_per_run):
+        """
+        Run HEC-RAS plans in parallel using ThreadPoolExecutor.
+        
+        Parameters:
+        config (ProjectConfig): Configuration object containing project information
+        max_workers (int): Maximum number of parallel runs
+        cores_per_run (int): Number of cores to use per run
+        
+        Returns:
+        dict: Dictionary with plan numbers as keys and execution success as values
+        
+        This function executes all ras plans in separate folders defined by the max_workers and the numbering of the test folders [Test 1], [Test 2], etc. 
+        Each worker operates sequentially on its assigned folder while all workers operate in parallel.
+     
+        Revisions:
+        1. Created a pandas DataFrame to map each folder to a plan for execution.
+        2. Implemented logic to assign worker numbers and compute folders.
+        3. Used find_hecras_project_file function to get the full path of project files.
+        4. Updated plan file paths to use compute folders.
+        5. Revised the parallel execution to use separate threads for each worker.
+        6. Implemented a queue system for each worker to handle plans sequentially.
+        7. Updated the cleanup process to use the new folder structure.
+        """
+        import queue
+        from threading import Thread
+
+        project_folder = Path(config.project_file).parent
+        test_folders = []
+
+        # Create multiple copies of the project folder
+        for i in range(1, max_workers + 1):
+            folder_for_compute = project_folder.parent / f"{project_folder.name} [Test {i}]"
+            shutil.copytree(project_folder, folder_for_compute, dirs_exist_ok=True)
+            test_folders.append(folder_for_compute)
+            print(f"Created test folder: {folder_for_compute}")
+
+        compute_parallel_entries = []
+        for i, (_, plan_row) in enumerate(config.ras_plan_entries.iterrows()):
+            worker_number = i % max_workers
+            compute_folder = test_folders[worker_number]
+            compute_project_file = FileOperations.find_hecras_project_file(compute_folder)
+            compute_plan_file = compute_folder / Path(plan_row['full_path']).name
+            compute_parallel_entries.append({
+                'worker_number': worker_number,
+                'compute_folder': compute_folder,
+                'compute_project_file': compute_project_file,
+                'compute_plan_file': compute_plan_file,
+                'plan_number': plan_row['plan_number']
+            })
+
+        compute_parallel_df = pd.DataFrame(compute_parallel_entries)
+        print("compute_parallel_entries dataframe:")
+        display(compute_parallel_df)
+
+        results = {}
+        worker_queues = [queue.Queue() for _ in range(max_workers)]
+
+        def worker_thread(worker_id):
+            """
+            Execute HEC-RAS plans assigned to a specific worker thread.
+
+            This function continuously processes plans from the worker's queue until it's empty.
+            It sets the number of cores for each plan, computes the plan, and records the result.
+
+            Parameters:
+            worker_id (int): The ID of the worker thread.
+
+            Notes:
+            - Uses PlanOperations.set_num_cores to set the number of cores for each plan.
+            - Uses RasExecutor.compute_hecras_plan to execute each plan.
+            - Records success or failure in the 'results' dictionary.
+            - Prints status messages for completed or failed plans.
+            """
+            while True:
+                try:
+                    row = worker_queues[worker_id].get(block=False)
+                    PlanOperations.set_num_cores(str(row['compute_plan_file']), cores_per_run)
+                    success = RasExecutor.compute_hecras_plan(row['compute_plan_file'])
+                    results[row['plan_number']] = success
+                    print(f"Completed: Plan {row['plan_number']} in worker {worker_id}")
+                except queue.Empty:
+                    break
+                except Exception as e:
+                    results[row['plan_number']] = False
+                    print(f"Failed: Plan {row['plan_number']} in worker {worker_id}. Error: {str(e)}")
+
+        # Distribute plans to worker queues
+        for _, row in compute_parallel_df.iterrows():
+            worker_queues[row['worker_number']].put(row)
+
+        # Start worker threads
+        threads = []
+        for i in range(max_workers):
+            thread = Thread(target=worker_thread, args=(i,))
+            thread.start()
+            threads.append(thread)
+
+        # Wait for all threads to complete
+        for thread in threads:
+            thread.join()
+
+        # Clean up and consolidate results
+        time.sleep(3)  # Allow files to close
+        final_test_folder = project_folder.parent / f"{project_folder.name} [Test]"
+        final_test_folder.mkdir(exist_ok=True)
+        
+        for test_folder in test_folders:
+            for item in test_folder.iterdir():
+                dest_path = final_test_folder / item.name
+                if dest_path.exists():
+                    if dest_path.is_dir():
+                        shutil.rmtree(dest_path)
+                    else:
+                        dest_path.unlink()
+                shutil.move(str(item), final_test_folder)
+            shutil.rmtree(test_folder)
+            print(f"Moved and removed test folder: {test_folder}")
+
+        return results
+    
+    @staticmethod    
+    def run_all_plans_parallel(project_folder, hecras_exe_path):
+        """
+        Run all plans in a project folder in parallel.
+        
+        Parameters:
+        project_folder (str): The path to the project folder.
+        hecras_exe_path (str): The path to the HEC-RAS executable.
+        
+        Returns:
+        dict: A dictionary with plan numbers as keys and execution success status as values.
+        """
+        config = ProjectConfig.init_ras_project(project_folder, hecras_exe_path)
+        
+        if config:
+            print("ras_plan_entries dataframe:")
+            display(config.ras_plan_entries)
+            
+            max_workers = 2  # Number of parallel runs
+            cores_per_run = 2  # Number of cores per run
+            
+            results = RasExecutor.run_plans_parallel(config, max_workers, cores_per_run)
+            
+            print("\nExecution Results:")
+            for plan_number, success in results.items():
+                print(f"Plan {plan_number}: {'Successful' if success else 'Failed'}")
+            
+            return results
+        else:
+            print("Failed to initialize project configuration.")
+            return None