ras-commander 0.65.0__py3-none-any.whl → 0.67.0__py3-none-any.whl

ras_commander/RasPrj.py

@@ -160,101 +160,137 @@ class RasPrj:
         Load project data from the HEC-RAS project file.
 
         This method initializes DataFrames for plan, flow, unsteady, and geometry entries
-        by calling the _get_prj_entries method for each entry type.
-        Also extracts unsteady_number and geometry_number from plan files and adds them to plan_df.
-        Now includes Geom Path, Flow Path, and other required columns.
+        and ensures all required columns are present with appropriate paths.
         """
-        # Load unsteady first to ensure consistent handling of unsteady numbers
-        self.unsteady_df = self._get_prj_entries('Unsteady')
-        self.plan_df = self._get_prj_entries('Plan')
-        self.flow_df = self._get_prj_entries('Flow')
-        self.geom_df = self.get_geom_entries()
+        try:
+            # Load data frames
+            self.unsteady_df = self._get_prj_entries('Unsteady')
+            self.plan_df = self._get_prj_entries('Plan')
+            self.flow_df = self._get_prj_entries('Flow')
+            self.geom_df = self.get_geom_entries()
+            
+            # Ensure required columns exist
+            self._ensure_required_columns()
+            
+            # Set paths for geometry and flow files
+            self._set_file_paths()
+            
+            # Make sure all plan paths are properly set
+            self._set_plan_paths()
+            
+        except Exception as e:
+            logger.error(f"Error loading project data: {e}")
+            raise
+
+    def _ensure_required_columns(self):
+        """Ensure all required columns exist in plan_df."""
+        required_columns = [
+            'plan_number', 'unsteady_number', 'geometry_number',
+            'Geom File', 'Geom Path', 'Flow File', 'Flow Path', 'full_path'
+        ]
+        
+        for col in required_columns:
+            if col not in self.plan_df.columns:
+                self.plan_df[col] = None
         
-        # Set geometry and flow paths
+        if not self.plan_df['full_path'].any():
+            self.plan_df['full_path'] = self.plan_df['plan_number'].apply(
+                lambda x: str(self.project_folder / f"{self.project_name}.p{x}")
+            )
+
+    def _set_file_paths(self):
+        """Set geometry and flow paths in plan_df."""
         for idx, row in self.plan_df.iterrows():
             try:
-                # Add Geom Path
-                if row['Geom File'] is not None:
-                    geom_hdf_path = self.project_folder / f"{self.project_name}.g{row['Geom File']}"
-                    self.plan_df.at[idx, 'Geom Path'] = str(geom_hdf_path)
+                self._set_geom_path(idx, row)
+                self._set_flow_path(idx, row)
                 
-                # Add Flow Path
-                if row['Flow File'] is not None:
-                    # Determine if this is a steady or unsteady flow file
-                    if row['unsteady_number'] is not None:
-                        flow_path = self.project_folder / f"{self.project_name}.u{row['Flow File']}"
-                    else:
-                        flow_path = self.project_folder / f"{self.project_name}.f{row['Flow File']}"
-                    self.plan_df.at[idx, 'Flow Path'] = str(flow_path)
-                
-                    if not self.suppress_logging:
-                        logger.info(f"Plan {row['plan_number']} paths set up")
+                if not self.suppress_logging:
+                    logger.info(f"Plan {row['plan_number']} paths set up")
             except Exception as e:
                 logger.error(f"Error processing plan file {row['plan_number']}: {e}")
 
-    def _get_geom_file_from_plan(self, plan_file_path):
-        """
-        Extract the geometry number from a plan file by finding the Geom File value
-        and stripping the leading 'g'.
+    def _set_geom_path(self, idx: int, row: pd.Series):
+        """Set geometry path for a plan entry."""
+        if pd.notna(row['Geom File']):
+            geom_path = self.project_folder / f"{self.project_name}.g{row['Geom File']}"
+            self.plan_df.at[idx, 'Geom Path'] = str(geom_path)
+
+    def _set_flow_path(self, idx: int, row: pd.Series):
+        """Set flow path for a plan entry."""
+        if pd.notna(row['Flow File']):
+            prefix = 'u' if pd.notna(row['unsteady_number']) else 'f'
+            flow_path = self.project_folder / f"{self.project_name}.{prefix}{row['Flow File']}"
+            self.plan_df.at[idx, 'Flow Path'] = str(flow_path)
+
+    def _set_plan_paths(self):
+        """Set full path information for plan files and their associated geometry and flow files."""
+        if self.plan_df.empty:
+            logger.debug("Plan DataFrame is empty, no paths to set")
+            return
         
-        Parameters:
-        -----------
-        plan_file_path : str or Path
-            Path to the plan file.
-        
-        Returns:
-        --------
-        tuple: (str, str)
-            A tuple containing (geometry_number, full_hdf_path) or (None, None) if not found.
-            geometry_number is the number after 'g' in the Geom File value
-            full_hdf_path is the path to the geometry HDF file
-        """
-        content, encoding = read_file_with_fallback_encoding(plan_file_path)
-        
-        if content is None:
-            return None, None
+        # Ensure full path is set for all plan entries
+        if 'full_path' not in self.plan_df.columns or self.plan_df['full_path'].isna().any():
+            self.plan_df['full_path'] = self.plan_df['plan_number'].apply(
+                lambda x: str(self.project_folder / f"{self.project_name}.p{x}")
+            )
         
-        try:
-            match = re.search(r'Geom File=g(\d+)', content)
-            if match:
-                geom_number = match.group(1)  # This gets just the number after 'g'
-                geom_file = f"g{geom_number}"
-                geom_hdf_path = self.project_folder / f"{self.project_name}.{geom_file}.hdf"
-                if geom_hdf_path.exists():
-                    return geom_number, str(geom_hdf_path)
-        except Exception as e:
-            logger.error(f"Error extracting geometry number from {plan_file_path}: {e}")
+        # Create the Geom Path and Flow Path columns if they don't exist
+        if 'Geom Path' not in self.plan_df.columns:
+            self.plan_df['Geom Path'] = None
+        if 'Flow Path' not in self.plan_df.columns:
+            self.plan_df['Flow Path'] = None
         
-        return None, None
+        # Update paths for each plan entry
+        for idx, row in self.plan_df.iterrows():
+            try:
+                # Set geometry path if Geom File exists and Geom Path is missing or invalid
+                if pd.notna(row['Geom File']):
+                    geom_path = self.project_folder / f"{self.project_name}.g{row['Geom File']}"
+                    self.plan_df.at[idx, 'Geom Path'] = str(geom_path)
+                
+                # Set flow path if Flow File exists and Flow Path is missing or invalid
+                if pd.notna(row['Flow File']):
+                    # Determine the prefix (u for unsteady, f for steady flow)
+                    prefix = 'u' if pd.notna(row['unsteady_number']) else 'f'
+                    flow_path = self.project_folder / f"{self.project_name}.{prefix}{row['Flow File']}"
+                    self.plan_df.at[idx, 'Flow Path'] = str(flow_path)
+                
+                if not self.suppress_logging:
+                    logger.debug(f"Plan {row['plan_number']} paths set up")
+            except Exception as e:
+                logger.error(f"Error setting paths for plan {row.get('plan_number', idx)}: {e}")
 
-    def _get_flow_file_from_plan(self, plan_file_path):
+    def _get_geom_file_for_plan(self, plan_number):
         """
-        Extract the Flow File value from a plan file.
+        Get the geometry file path for a given plan number.
         
-        Parameters:
-        -----------
-        plan_file_path : str or Path
-            Path to the plan file.
+        Args:
+            plan_number (str): The plan number to find the geometry file for.
         
         Returns:
-        --------
-        str or None
-            The Flow File value or None if not found.
+            str: The full path to the geometry HDF file, or None if not found.
         """
+        plan_file_path = self.project_folder / f"{self.project_name}.p{plan_number}"
         content, encoding = read_file_with_fallback_encoding(plan_file_path)
         
         if content is None:
             return None
         
         try:
-            match = re.search(r'Flow File=([^\s]+)', content)
-            if match:
-                return match.group(1)
+            for line in content.splitlines():
+                if line.startswith("Geom File="):
+                    geom_file = line.strip().split('=')[1]
+                    geom_hdf_path = self.project_folder / f"{self.project_name}.{geom_file}.hdf"
+                    if geom_hdf_path.exists():
+                        return str(geom_hdf_path)
+                    else:
+                        return None
         except Exception as e:
-            logger.error(f"Error extracting Flow File from {plan_file_path}: {e}")
-        
+            logger.error(f"Error reading plan file for geometry: {e}")
         return None
 
+
     @staticmethod
     @log_call
     def get_plan_value(
@@ -439,112 +475,106 @@ class RasPrj:
         
         Returns:
             pd.DataFrame: A DataFrame containing the extracted entries.
+        
+        Raises:
+            Exception: If there's an error reading or processing the project file.
         """
         entries = []
         pattern = re.compile(rf"{entry_type} File=(\w+)")
 
         try:
-            with open(self.prj_file, 'r') as file:
+            with open(self.prj_file, 'r', encoding='utf-8') as file:
                 for line in file:
                     match = pattern.match(line.strip())
                     if match:
                         file_name = match.group(1)
                         full_path = str(self.project_folder / f"{self.project_name}.{file_name}")
-                        entry_number = file_name[1:]  # Extract number portion without prefix
+                        entry_number = file_name[1:]
                         
                         entry = {
                             f'{entry_type.lower()}_number': entry_number,
                             'full_path': full_path
                         }
                         
+                        # Handle Unsteady entries
                         if entry_type == 'Unsteady':
-                            entry['unsteady_number'] = entry_number
-                            unsteady_info = self._parse_unsteady_file(Path(full_path))
-                            entry.update(unsteady_info)
+                            entry.update(self._process_unsteady_entry(entry_number, full_path))
                         else:
-                            entry.update({
-                                'unsteady_number': None,
-                                'geometry_number': None
-                            })
+                            entry.update(self._process_default_entry())
                         
+                        # Handle Plan entries
                         if entry_type == 'Plan':
-                            plan_info = self._parse_plan_file(Path(full_path))
-                            if plan_info:
-                                # Handle Flow File (unsteady) number
-                                flow_file = plan_info.get('Flow File')
-                                if flow_file and flow_file.startswith('u'):
-                                    entry['unsteady_number'] = flow_file[1:]
-                                    entry['Flow File'] = flow_file[1:]
-                                else:
-                                    entry['unsteady_number'] = None
-                                    entry['Flow File'] = flow_file[1:] if flow_file and flow_file.startswith('f') else None
-                                    
-                                # Handle Geom File number
-                                geom_file = plan_info.get('Geom File')
-                                if geom_file and geom_file.startswith('g'):
-                                    entry['geometry_number'] = geom_file[1:]
-                                    entry['Geom File'] = geom_file[1:]
-                                else:
-                                    entry['geometry_number'] = None
-                                    entry['Geom File'] = None
-                                
-                                # Add all plan key information with exact same names
-                                for key, value in plan_info.items():
-                                    if key not in ['Flow File', 'Geom File']:
-                                        entry[key] = value
+                            entry.update(self._process_plan_entry(entry_number, full_path))
                         
-                            # Add HDF results path
-                            hdf_results_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
-                            entry['HDF_Results_Path'] = str(hdf_results_path) if hdf_results_path.exists() else None
-
                         entries.append(entry)
-        
-            df = pd.DataFrame(entries)
-            
-            if not df.empty and entry_type == 'Plan':
-                # Set required column order
-                first_cols = ['plan_number', 'unsteady_number', 'geometry_number']
-                
-                # Standard plan key columns in the exact order specified
-                plan_key_cols = [
-                    'Plan Title', 'Program Version', 'Short Identifier', 'Simulation Date',
-                    'Std Step Tol', 'Computation Interval', 'Output Interval', 'Instantaneous Interval',
-                    'Mapping Interval', 'Run HTab', 'Run UNet', 'Run Sediment', 'Run PostProcess',
-                    'Run WQNet', 'Run RASMapper', 'UNET Use Existing IB Tables', 'HDF_Results_Path',
-                    'UNET 1D Methodology', 'Write IC File', 'Write IC File at Fixed DateTime',
-                    'IC Time', 'Write IC File Reoccurance', 'Write IC File at Sim End'
-                ]
-                
-                # Additional convenience columns
-                file_path_cols = ['Geom File', 'Geom Path', 'Flow File', 'Flow Path']
-                
-                # Build the final column list
-                all_cols = first_cols.copy()
-                for col in plan_key_cols:
-                    if col in df.columns:
-                        all_cols.append(col)
-                
-                # Add any remaining columns not explicitly specified
-                other_cols = [col for col in df.columns if col not in all_cols + file_path_cols + ['full_path']]
-                all_cols.extend(other_cols)
-                all_cols.extend(file_path_cols)
-                
-                # Rename plan_number column
-                df = df.rename(columns={f'{entry_type.lower()}_number': 'plan_number'})
-                
-                # Fill in missing columns with None
-                for col in all_cols:
-                    if col not in df.columns:
-                        df[col] = None
-                
-                # Return DataFrame with specified column order
-                return df[all_cols]
             
-            return df
+            df = pd.DataFrame(entries)
+            return self._format_dataframe(df, entry_type)
+        
         except Exception as e:
             logger.error(f"Error in _get_prj_entries for {entry_type}: {e}")
             raise
 
+    def _process_unsteady_entry(self, entry_number: str, full_path: str) -> dict:
+        """Process unsteady entry data."""
+        entry = {'unsteady_number': entry_number}
+        unsteady_info = self._parse_unsteady_file(Path(full_path))
+        entry.update(unsteady_info)
+        return entry
+
+    def _process_default_entry(self) -> dict:
+        """Process default entry data."""
+        return {
+            'unsteady_number': None,
+            'geometry_number': None
+        }
+
+    def _process_plan_entry(self, entry_number: str, full_path: str) -> dict:
+        """Process plan entry data."""
+        entry = {}
+        plan_info = self._parse_plan_file(Path(full_path))
+        
+        if plan_info:
+            entry.update(self._process_flow_file(plan_info))
+            entry.update(self._process_geom_file(plan_info))
+            
+            # Add remaining plan info
+            for key, value in plan_info.items():
+                if key not in ['Flow File', 'Geom File']:
+                    entry[key] = value
+            
+            # Add HDF results path
+            hdf_results_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
+            entry['HDF_Results_Path'] = str(hdf_results_path) if hdf_results_path.exists() else None
+        
+        return entry
+
+    def _process_flow_file(self, plan_info: dict) -> dict:
+        """Process flow file information from plan info."""
+        flow_file = plan_info.get('Flow File')
+        if flow_file and flow_file.startswith('u'):
+            return {
+                'unsteady_number': flow_file[1:],
+                'Flow File': flow_file[1:]
+            }
+        return {
+            'unsteady_number': None,
+            'Flow File': flow_file[1:] if flow_file and flow_file.startswith('f') else None
+        }
+
+    def _process_geom_file(self, plan_info: dict) -> dict:
+        """Process geometry file information from plan info."""
+        geom_file = plan_info.get('Geom File')
+        if geom_file and geom_file.startswith('g'):
+            return {
+                'geometry_number': geom_file[1:],
+                'Geom File': geom_file[1:]
+            }
+        return {
+            'geometry_number': None,
+            'Geom File': None
+        }
+
     def _parse_unsteady_file(self, unsteady_file_path):
         """
         Parse an unsteady flow file and extract critical information.
@@ -935,27 +965,144 @@ class RasPrj:
         return bc_info, unparsed_lines
 
     @log_call
-    def get_unsteady_numbers_from_plans(self):
+    def _format_dataframe(self, df, entry_type):
         """
-        Get all plans that use unsteady flow files.
+        Format the DataFrame according to the desired column structure.
+        
+        Args:
+            df (pd.DataFrame): The DataFrame to format.
+            entry_type (str): The type of entry (e.g., 'Plan', 'Flow', 'Unsteady', 'Geom').
         
         Returns:
-        --------
-        pd.DataFrame
-            A DataFrame containing only plan entries that use unsteady flow files.
+            pd.DataFrame: The formatted DataFrame.
+        """
+        if df.empty:
+            return df
         
-        Raises:
-        -------
-        RuntimeError: If the project has not been initialized.
+        if entry_type == 'Plan':
+            # Set required column order
+            first_cols = ['plan_number', 'unsteady_number', 'geometry_number']
+            
+            # Standard plan key columns in the exact order specified
+            plan_key_cols = [
+                'Plan Title', 'Program Version', 'Short Identifier', 'Simulation Date',
+                'Std Step Tol', 'Computation Interval', 'Output Interval', 'Instantaneous Interval',
+                'Mapping Interval', 'Run HTab', 'Run UNet', 'Run Sediment', 'Run PostProcess',
+                'Run WQNet', 'Run RASMapper', 'UNET Use Existing IB Tables', 'HDF_Results_Path',
+                'UNET 1D Methodology', 'Write IC File', 'Write IC File at Fixed DateTime',
+                'IC Time', 'Write IC File Reoccurance', 'Write IC File at Sim End'
+            ]
+            
+            # Additional convenience columns
+            file_path_cols = ['Geom File', 'Geom Path', 'Flow File', 'Flow Path']
+            
+            # Special columns that must be preserved
+            special_cols = ['HDF_Results_Path']
+            
+            # Build the final column list
+            all_cols = first_cols.copy()
+            
+            # Add plan key columns if they exist
+            for col in plan_key_cols:
+                if col in df.columns and col not in all_cols and col not in special_cols:
+                    all_cols.append(col)
+            
+            # Add any remaining columns not explicitly specified
+            other_cols = [col for col in df.columns if col not in all_cols + file_path_cols + special_cols + ['full_path']]
+            all_cols.extend(other_cols)
+            
+            # Add HDF_Results_Path if it exists (ensure it comes before file paths)
+            for special_col in special_cols:
+                if special_col in df.columns and special_col not in all_cols:
+                    all_cols.append(special_col)
+            
+            # Add file path columns at the end
+            all_cols.extend(file_path_cols)
+            
+            # Rename plan_number column
+            df = df.rename(columns={f'{entry_type.lower()}_number': 'plan_number'})
+            
+            # Fill in missing columns with None
+            for col in all_cols:
+                if col not in df.columns:
+                    df[col] = None
+            
+            # Make sure full_path column is preserved and included
+            if 'full_path' in df.columns and 'full_path' not in all_cols:
+                all_cols.append('full_path')
+            
+            # Return DataFrame with specified column order
+            cols_to_return = [col for col in all_cols if col in df.columns]
+            return df[cols_to_return]
+        
+        return df
+
+    @log_call
+    def _get_prj_entries(self, entry_type):
         """
-        self.check_initialized()
+        Extract entries of a specific type from the HEC-RAS project file.
+        """
+        entries = []
+        pattern = re.compile(rf"{entry_type} File=(\w+)")
+
+        try:
+            with open(self.prj_file, 'r') as file:
+                for line in file:
+                    match = pattern.match(line.strip())
+                    if match:
+                        file_name = match.group(1)
+                        full_path = str(self.project_folder / f"{self.project_name}.{file_name}")
+                        entry = self._create_entry(entry_type, file_name, full_path)
+                        entries.append(entry)
         
-        # Filter plan_df to only include plans with unsteady_number not None
-        unsteady_plans = self.plan_df[self.plan_df['unsteady_number'].notna()].copy()
+            return self._format_dataframe(pd.DataFrame(entries), entry_type)
         
-        logger.info(f"Found {len(unsteady_plans)} plans using unsteady flow files")
+        except Exception as e:
+            logger.error(f"Error in _get_prj_entries for {entry_type}: {e}")
+            raise
+
+    def _create_entry(self, entry_type, file_name, full_path):
+        """Helper method to create entry dictionary."""
+        entry_number = file_name[1:]
+        entry = {
+            f'{entry_type.lower()}_number': entry_number,
+            'full_path': full_path,
+            'unsteady_number': None,
+            'geometry_number': None
+        }
+        
+        if entry_type == 'Unsteady':
+            entry['unsteady_number'] = entry_number
+            entry.update(self._parse_unsteady_file(Path(full_path)))
+        elif entry_type == 'Plan':
+            self._update_plan_entry(entry, entry_number, full_path)
         
-        return unsteady_plans
+        return entry
+
+    def _update_plan_entry(self, entry, entry_number, full_path):
+        """Helper method to update plan entry with additional information."""
+        plan_info = self._parse_plan_file(Path(full_path))
+        if plan_info:
+            # Handle Flow File
+            flow_file = plan_info.get('Flow File')
+            if flow_file:
+                if flow_file.startswith('u'):
+                    entry.update({'unsteady_number': flow_file[1:], 'Flow File': flow_file[1:]})
+                else:
+                    entry['Flow File'] = flow_file[1:] if flow_file.startswith('f') else None
+            
+            # Handle Geom File
+            geom_file = plan_info.get('Geom File')
+            if geom_file and geom_file.startswith('g'):
+                entry.update({'geometry_number': geom_file[1:], 'Geom File': geom_file[1:]})
+            
+            # Add remaining plan info
+            entry.update({k: v for k, v in plan_info.items() if k not in ['Flow File', 'Geom File']})
+            
+            # Add HDF results path
+            hdf_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
+            entry['HDF_Results_Path'] = str(hdf_path) if hdf_path.exists() else None
+
 
 # Create a global instance named 'ras'
 # Defining the global instance allows the init_ras_project function to initialize the project.
@@ -1027,7 +1174,7 @@ def get_ras_exe(ras_version=None):
     Args:
         ras_version (str, optional): Either a version number or a full path to the HEC-RAS executable.
                                      If None, the function will first check the global 'ras' object for a path.
-                                     If the global 'ras' object is not initialized or doesn't have a path, a default path will be used.
+                                     or a default path.
     
     Returns:
         str: The full path to the HEC-RAS executable.

ras_commander/RasUtils.py

@@ -216,30 +216,49 @@ class RasUtils:
         Returns:
         Path: Full path to the plan file
 
+        Raises:
+        ValueError: If plan number is not between 1 and 99
+        TypeError: If input type is invalid
+        FileNotFoundError: If the plan file does not exist
+
         Example:
         >>> plan_path = RasUtils.get_plan_path(1)
         >>> print(f"Plan file path: {plan_path}")
         >>> plan_path = RasUtils.get_plan_path("path/to/plan.p01")
         >>> print(f"Plan file path: {plan_path}")
         """
-        
+        # Validate RAS object
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
+        # Handle direct file path input
         plan_path = Path(current_plan_number_or_path)
         if plan_path.is_file():
             logger.info(f"Using provided plan file path: {plan_path}")
             return plan_path
         
+        # Handle plan number input
         try:
-            current_plan_number = f"{int(current_plan_number_or_path):02d}"  # Ensure two-digit format
+            plan_num = int(current_plan_number_or_path)
+            if not 1 <= plan_num <= 99:
+                raise ValueError(f"Plan number must be between 1 and 99, got: {plan_num}")
+            current_plan_number = f"{plan_num:02d}"  # Ensure two-digit format
             logger.debug(f"Converted plan number to two-digit format: {current_plan_number}")
-        except ValueError:
+        except (ValueError, TypeError) as e:
+            if isinstance(e, TypeError):
+                logger.error(f"Invalid input type: {type(current_plan_number_or_path)}. Expected string, number, or Path.")
+                raise TypeError(f"Invalid input type: {type(current_plan_number_or_path)}. Expected string, number, or Path.")
             logger.error(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
             raise ValueError(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
         
+        # Construct and validate plan path
         plan_name = f"{ras_obj.project_name}.p{current_plan_number}"
         full_plan_path = ras_obj.project_folder / plan_name
+        
+        if not full_plan_path.exists():
+            logger.error(f"Plan file does not exist: {full_plan_path}")
+            raise FileNotFoundError(f"Plan file does not exist: {full_plan_path}")
+        
         logger.info(f"Constructed plan file path: {full_plan_path}")
         return full_plan_path
 

ras_commander/__init__.py

@@ -10,7 +10,7 @@ try:
     __version__ = version("ras-commander")
 except PackageNotFoundError:
     # package is not installed
-    __version__ = "0.65.0"
+    __version__ = "0.67.0"
 
 # Set up logging
 setup_logging()

{ras_commander-0.65.0.dist-info → ras_commander-0.67.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ras-commander
-Version: 0.65.0
+Version: 0.67.0
 Summary: A Python library for automating HEC-RAS 6.x operations
 Home-page: https://github.com/gpt-cmdr/ras-commander
 Author: William M. Katzenmeyer, P.E., C.F.M.