ras-commander 0.70.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

ras_commander/RasGeo.py

@@ -24,19 +24,19 @@ Example:
         # Function logic here
         
         
-        
------
-
 All of the methods in this class are static and are designed to be used without instantiation.
 
 List of Functions in RasGeo:
-- clear_geompre_files()
-        
-        
+- clear_geompre_files(): Clears geometry preprocessor files for specified plan files
+- get_mannings_baseoverrides(): Reads base Manning's n table from a geometry file
+- get_mannings_regionoverrides(): Reads Manning's n region overrides from a geometry file
+- set_mannings_baseoverrides(): Writes base Manning's n values to a geometry file
+- set_mannings_regionoverrides(): Writes regional Manning's n overrides to a geometry file
 """
 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 +56,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 +76,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()
@@ -129,6 +134,256 @@ class RasGeo:
             logger.error(f"Failed to update geometry dataframe: {str(e)}")
             raise
 
+    @log_call
+    def get_mannings_baseoverrides(geom_file_path):
+        """
+        Reads the base Manning's n table from a HEC-RAS geometry file.
+        
+        Parameters:
+        -----------
+        geom_file_path : str or Path
+            Path to the geometry file (.g##)
+        
+        Returns:
+        --------
+        pandas.DataFrame
+            DataFrame with Table Number, Land Cover Name, and Base Manning's n Value
+        """
+        import pandas as pd
+        from pathlib import Path
+        
+        # Convert to Path object if it's a string
+        if isinstance(geom_file_path, str):
+            geom_file_path = Path(geom_file_path)
+        
+        base_table_rows = []
+        table_number = None
+        
+        # Read the geometry file
+        with open(geom_file_path, 'r') as f:
+            lines = f.readlines()
+        
+        # Parse the file
+        reading_base_table = False
+        for line in lines:
+            line = line.strip()
+            
+            # Find the table number
+            if line.startswith('LCMann Table='):
+                table_number = line.split('=')[1]
+                reading_base_table = True
+                continue
+            
+            # Stop reading when we hit a line without a comma or starting with LCMann
+            if reading_base_table and (not ',' in line or line.startswith('LCMann')):
+                reading_base_table = False
+                continue
+                
+            # Parse data rows in base table
+            if reading_base_table and ',' in line:
+                # Check if there are multiple commas in the line
+                parts = line.split(',')
+                if len(parts) > 2:
+                    # Handle case where land cover name contains commas
+                    name = ','.join(parts[:-1])
+                    value = parts[-1]
+                else:
+                    name, value = parts
+                
+                try:
+                    base_table_rows.append([table_number, name, float(value)])
+                except ValueError:
+                    # Log the error and continue
+                    print(f"Error parsing line: {line}")
+                    continue
+        
+        # Create DataFrame
+        if base_table_rows:
+            df = pd.DataFrame(base_table_rows, columns=['Table Number', 'Land Cover Name', 'Base Manning\'s n Value'])
+            return df
+        else:
+            return pd.DataFrame(columns=['Table Number', 'Land Cover Name', 'Base Manning\'s n Value'])
+
+
+    @log_call
+    def get_mannings_regionoverrides(geom_file_path):
+        """
+        Reads the Manning's n region overrides from a HEC-RAS geometry file.
+        
+        Parameters:
+        -----------
+        geom_file_path : str or Path
+            Path to the geometry file (.g##)
+        
+        Returns:
+        --------
+        pandas.DataFrame
+            DataFrame with Table Number, Land Cover Name, MainChannel value, and region name
+        """
+        import pandas as pd
+        from pathlib import Path
+        
+        # Convert to Path object if it's a string
+        if isinstance(geom_file_path, str):
+            geom_file_path = Path(geom_file_path)
+        
+        region_rows = []
+        current_region = None
+        current_table = None
+        
+        # Read the geometry file
+        with open(geom_file_path, 'r') as f:
+            lines = f.readlines()
+        
+        # Parse the file
+        reading_region_table = False
+        for line in lines:
+            line = line.strip()
+            
+            # Find region name
+            if line.startswith('LCMann Region Name='):
+                current_region = line.split('=')[1]
+                continue
+                
+            # Find region table number
+            if line.startswith('LCMann Region Table='):
+                current_table = line.split('=')[1]
+                reading_region_table = True
+                continue
+            
+            # Stop reading when we hit a line without a comma or starting with LCMann
+            if reading_region_table and (not ',' in line or line.startswith('LCMann')):
+                reading_region_table = False
+                continue
+                
+            # Parse data rows in region table
+            if reading_region_table and ',' in line and current_region is not None:
+                # Check if there are multiple commas in the line
+                parts = line.split(',')
+                if len(parts) > 2:
+                    # Handle case where land cover name contains commas
+                    name = ','.join(parts[:-1])
+                    value = parts[-1]
+                else:
+                    name, value = parts
+                
+                try:
+                    region_rows.append([current_table, name, float(value), current_region])
+                except ValueError:
+                    # Log the error and continue
+                    print(f"Error parsing line: {line}")
+                    continue
+        
+        # Create DataFrame
+        if region_rows:
+            return pd.DataFrame(region_rows, columns=['Table Number', 'Land Cover Name', 'MainChannel', 'Region Name'])
+        else:
+            return pd.DataFrame(columns=['Table Number', 'Land Cover Name', 'MainChannel', 'Region Name'])
+        
+
+
+    @staticmethod
+    @log_call
+    def set_mannings_baseoverrides(geom_file_path, mannings_data):
+        """
+        Writes base Manning's n values to a HEC-RAS geometry file.
+        
+        Parameters:
+        -----------
+        geom_file_path : str or Path
+            Path to the geometry file (.g##)
+        mannings_data : DataFrame
+            DataFrame with columns 'Table Number', 'Land Cover Name', and 'Base Manning\'s n Value'
+        
+        Returns:
+        --------
+        bool
+            True if successful
+        """
+        from pathlib import Path
+        import shutil
+        import pandas as pd
+        import datetime
+        
+        # Convert to Path object if it's a string
+        if isinstance(geom_file_path, str):
+            geom_file_path = Path(geom_file_path)
+        
+        # Create backup
+        backup_path = geom_file_path.with_suffix(geom_file_path.suffix + '.bak')
+        shutil.copy2(geom_file_path, backup_path)
+        
+        # Read the entire file
+        with open(geom_file_path, 'r') as f:
+            lines = f.readlines()
+        
+        # Find the Manning's table section
+        table_number = str(mannings_data['Table Number'].iloc[0])
+        start_idx = None
+        end_idx = None
+        
+        for i, line in enumerate(lines):
+            if line.strip() == f"LCMann Table={table_number}":
+                start_idx = i
+                # Find the end of this table (next LCMann directive or end of file)
+                for j in range(i+1, len(lines)):
+                    if lines[j].strip().startswith('LCMann'):
+                        end_idx = j
+                        break
+                if end_idx is None:  # If we reached the end of the file
+                    end_idx = len(lines)
+                break
+        
+        if start_idx is None:
+            raise ValueError(f"Manning's table {table_number} not found in the geometry file")
+        
+        # Extract existing land cover names from the file
+        existing_landcover = []
+        for i in range(start_idx+1, end_idx):
+            line = lines[i].strip()
+            if ',' in line:
+                parts = line.split(',')
+                if len(parts) > 2:
+                    # Handle case where land cover name contains commas
+                    name = ','.join(parts[:-1])
+                else:
+                    name = parts[0]
+                existing_landcover.append(name)
+        
+        # Check if all land cover names in the dataframe match the file
+        df_landcover = mannings_data['Land Cover Name'].tolist()
+        if set(df_landcover) != set(existing_landcover):
+            missing = set(existing_landcover) - set(df_landcover)
+            extra = set(df_landcover) - set(existing_landcover)
+            error_msg = "Land cover names don't match between file and dataframe.\n"
+            if missing:
+                error_msg += f"Missing in dataframe: {missing}\n"
+            if extra:
+                error_msg += f"Extra in dataframe: {extra}"
+            raise ValueError(error_msg)
+        
+        # Create new content for the table
+        new_content = [f"LCMann Table={table_number}\n"]
+        
+        # Add base table entries
+        for _, row in mannings_data.iterrows():
+            new_content.append(f"{row['Land Cover Name']},{row['Base Manning\'s n Value']}\n")
+        
+        # Replace the section in the original file
+        updated_lines = lines[:start_idx] + new_content + lines[end_idx:]
+        
+        # Update the time stamp
+        current_time = datetime.datetime.now().strftime("%b/%d/%Y %H:%M:%S")
+        for i, line in enumerate(updated_lines):
+            if line.strip().startswith("LCMann Time="):
+                updated_lines[i] = f"LCMann Time={current_time}\n"
+                break
+        
+        # Write the updated file
+        with open(geom_file_path, 'w') as f:
+            f.writelines(updated_lines)
+        
+        return True
 
 
 
@@ -136,3 +391,134 @@ class RasGeo:
 
 
 
+    @staticmethod
+    @log_call
+    def set_mannings_regionoverrides(geom_file_path, mannings_data):
+        """
+        Writes regional Manning's n overrides to a HEC-RAS geometry file.
+        
+        Parameters:
+        -----------
+        geom_file_path : str or Path
+            Path to the geometry file (.g##)
+        mannings_data : DataFrame
+            DataFrame with columns 'Table Number', 'Land Cover Name', 'MainChannel', and 'Region Name'
+        
+        Returns:
+        --------
+        bool
+            True if successful
+        """
+        from pathlib import Path
+        import shutil
+        import pandas as pd
+        import datetime
+        
+        # Convert to Path object if it's a string
+        if isinstance(geom_file_path, str):
+            geom_file_path = Path(geom_file_path)
+        
+        # Create backup
+        backup_path = geom_file_path.with_suffix(geom_file_path.suffix + '.bak')
+        shutil.copy2(geom_file_path, backup_path)
+        
+        # Read the entire file
+        with open(geom_file_path, 'r') as f:
+            lines = f.readlines()
+        
+        # Group data by region
+        regions = mannings_data.groupby('Region Name')
+        
+        # Find the Manning's region sections
+        for region_name, region_data in regions:
+            table_number = str(region_data['Table Number'].iloc[0])
+            
+            # Find the region section
+            region_start_idx = None
+            region_table_idx = None
+            region_end_idx = None
+            region_polygon_line = None
+            
+            for i, line in enumerate(lines):
+                if line.strip() == f"LCMann Region Name={region_name}":
+                    region_start_idx = i
+                
+                if region_start_idx is not None and line.strip() == f"LCMann Region Table={table_number}":
+                    region_table_idx = i
+                    
+                    # Find the end of this region (next LCMann Region or end of file)
+                    for j in range(i+1, len(lines)):
+                        if lines[j].strip().startswith('LCMann Region Name=') or lines[j].strip().startswith('LCMann Region Polygon='):
+                            if lines[j].strip().startswith('LCMann Region Polygon='):
+                                region_polygon_line = lines[j]
+                            region_end_idx = j
+                            break
+                    if region_end_idx is None:  # If we reached the end of the file
+                        region_end_idx = len(lines)
+                    break
+            
+            if region_start_idx is None or region_table_idx is None:
+                raise ValueError(f"Region {region_name} with table {table_number} not found in the geometry file")
+            
+            # Extract existing land cover names from the file
+            existing_landcover = []
+            for i in range(region_table_idx+1, region_end_idx):
+                line = lines[i].strip()
+                if ',' in line and not line.startswith('LCMann'):
+                    parts = line.split(',')
+                    if len(parts) > 2:
+                        # Handle case where land cover name contains commas
+                        name = ','.join(parts[:-1])
+                    else:
+                        name = parts[0]
+                    existing_landcover.append(name)
+            
+            # Check if all land cover names in the dataframe match the file
+            df_landcover = region_data['Land Cover Name'].tolist()
+            if set(df_landcover) != set(existing_landcover):
+                missing = set(existing_landcover) - set(df_landcover)
+                extra = set(df_landcover) - set(existing_landcover)
+                error_msg = f"Land cover names for region {region_name} don't match between file and dataframe.\n"
+                if missing:
+                    error_msg += f"Missing in dataframe: {missing}\n"
+                if extra:
+                    error_msg += f"Extra in dataframe: {extra}"
+                raise ValueError(error_msg)
+            
+            # Create new content for the region
+            new_content = [
+                f"LCMann Region Name={region_name}\n",
+                f"LCMann Region Table={table_number}\n"
+            ]
+            
+            # Add region table entries
+            for _, row in region_data.iterrows():
+                new_content.append(f"{row['Land Cover Name']},{row['MainChannel']}\n")
+            
+            # Add the region polygon line if it exists
+            if region_polygon_line:
+                new_content.append(region_polygon_line)
+            
+            # Replace the section in the original file
+            if region_polygon_line:
+                # If we have a polygon line, include it in the replacement
+                updated_lines = lines[:region_start_idx] + new_content + lines[region_end_idx+1:]
+            else:
+                # If no polygon line, just replace up to the end index
+                updated_lines = lines[:region_start_idx] + new_content + lines[region_end_idx:]
+            
+            # Update the lines for the next region
+            lines = updated_lines
+        
+        # Update the time stamp
+        current_time = datetime.datetime.now().strftime("%b/%d/%Y %H:%M:%S")
+        for i, line in enumerate(lines):
+            if line.strip().startswith("LCMann Region Time="):
+                lines[i] = f"LCMann Region Time={current_time}\n"
+                break
+        
+        # Write the updated file
+        with open(geom_file_path, 'w') as f:
+            f.writelines(lines)
+        
+        return True