pycphy 0.1.0__py3-none-any.whl

pycphy/foamCaseDeveloper/core/block_mesh_developer.py

@@ -0,0 +1,101 @@
+# block_mesh_developer.py
+
+from ..writers.block_mesh_writer import BlockMeshWriter
+
+class BlockMeshDeveloper:
+    """
+    A high-level class to generate data for simple geometries and write
+    a blockMeshDict file. It now accepts custom patch names.
+    """
+    def __init__(self, p0, p1, cells, patch_names, scale=1.0):
+        """
+        Initializes the developer for a simple cuboid.
+
+        Args:
+            p0 (tuple): The minimum corner of the cube (x0, y0, z0).
+            p1 (tuple): The maximum corner of the cube (x1, y1, z1).
+            cells (tuple): Number of cells in each direction (nx, ny, nz).
+            patch_names (dict): A dictionary mapping face identifiers to custom names.
+                                e.g., {'minX': 'inlet', 'maxX': 'outlet', ...}
+            scale (float): The scaling factor for the mesh.
+        """
+        self.p0 = p0
+        self.p1 = p1
+        self.cells = cells
+        self.patch_names = patch_names
+        self.scale = scale
+        
+        # Data structures for the writer
+        self.vertices = []
+        self.blocks = []
+        self.boundary = []
+        self.edges = [] # Empty for a simple cube
+
+    def _generate_data(self):
+        """Generates the vertex, block, and boundary data for the cube."""
+        x0, y0, z0 = self.p0
+        x1, y1, z1 = self.p1
+        
+        # 1. Generate Vertices (OpenFOAM ordering)
+        self.vertices = [
+            (x0, y0, z0),  # 0
+            (x1, y0, z0),  # 1
+            (x1, y1, z0),  # 2
+            (x0, y1, z0),  # 3
+            (x0, y0, z1),  # 4
+            (x1, y0, z1),  # 5
+            (x1, y1, z1),  # 6
+            (x0, y1, z1)   # 7
+        ]
+        
+        # 2. Generate Blocks (only one for a simple cube)
+        self.blocks = [
+            ('hex', [0, 1, 2, 3, 4, 5, 6, 7], self.cells, 'simpleGrading', [1, 1, 1])
+        ]
+        
+        # 3. Generate Boundary Patches using custom names
+        self.boundary = [
+            {
+                'name': self.patch_names.get('minX', 'minX_default'), 'type': 'patch',
+                'faces': [[0, 4, 7, 3]]
+            },
+            {
+                'name': self.patch_names.get('maxX', 'maxX_default'), 'type': 'patch',
+                'faces': [[1, 2, 6, 5]]
+            },
+            {
+                'name': self.patch_names.get('minY', 'minY_default'), 'type': 'patch',
+                'faces': [[0, 1, 5, 4]]
+            },
+            {
+                'name': self.patch_names.get('maxY', 'maxY_default'), 'type': 'patch',
+                'faces': [[2, 3, 7, 6]]
+            },
+            {
+                'name': self.patch_names.get('minZ', 'minZ_default'), 'type': 'patch',
+                'faces': [[0, 3, 2, 1]]
+            },
+            {
+                'name': self.patch_names.get('maxZ', 'maxZ_default'), 'type': 'patch',
+                'faces': [[4, 5, 6, 7]]
+            }
+        ]
+        
+    def create_blockmesh_dict(self, file_path):
+        """
+        Generates the geometry data and writes the blockMeshDict file.
+        
+        Args:
+            file_path (str): The location to save the blockMeshDict file.
+        """
+        self._generate_data()
+        
+        writer = BlockMeshWriter(
+            file_path=file_path,
+            scale=1.0, # Scale is typically 1 when specifying absolute coords
+            vertices=self.vertices,
+            blocks=self.blocks,
+            edges=self.edges,
+            boundary=self.boundary
+        )
+        writer.write()

pycphy/foamCaseDeveloper/core/control_dict_writer.py

@@ -0,0 +1,55 @@
+# control_dict_writer.py
+
+from ..writers.control_dict_writer import ControlDictWriter as BaseControlDictWriter
+
+class ControlDictWriter(BaseControlDictWriter):
+    """
+    Extended ControlDictWriter with additional functionality for case management.
+    """
+    
+    def __init__(self, file_path, params):
+        """
+        Initializes the ControlDictWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'controlDict'.
+            params (dict): A dictionary containing the key-value pairs for the controlDict.
+                           e.g., {'application': 'icoFoam', 'deltaT': 0.001}
+        """
+        super().__init__(file_path, params)
+    
+    def validate_params(self):
+        """
+        Validates the control parameters for common issues.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        required_params = ['application', 'startFrom', 'stopAt']
+        
+        for param in required_params:
+            if param not in self.params:
+                print(f"Warning: Required parameter '{param}' is missing from control parameters.")
+                return False
+        
+        # Validate application
+        valid_applications = [
+            'icoFoam', 'simpleFoam', 'pimpleFoam', 'interFoam', 
+            'rhoSimpleFoam', 'rhoPimpleFoam', 'buoyantFoam'
+        ]
+        
+        if self.params.get('application') not in valid_applications:
+            print(f"Warning: Application '{self.params.get('application')}' may not be a valid OpenFOAM solver.")
+        
+        # Validate time step
+        if 'deltaT' in self.params:
+            try:
+                delta_t = float(self.params['deltaT'])
+                if delta_t <= 0:
+                    print("Warning: deltaT should be positive.")
+                    return False
+            except (ValueError, TypeError):
+                print("Warning: deltaT should be a valid number.")
+                return False
+        
+        return True

pycphy/foamCaseDeveloper/core/foam_case_manager.py

@@ -0,0 +1,195 @@
+# foam_case_manager.py
+
+import os
+from .block_mesh_developer import BlockMeshDeveloper
+from .control_dict_writer import ControlDictWriter
+from .turbulence_properties_writer import TurbulencePropertiesWriter
+
+class FoamCaseManager:
+    """
+    A comprehensive manager for creating and setting up OpenFOAM cases.
+    
+    This class provides a high-level interface for creating complete OpenFOAM
+    case directories with all necessary configuration files.
+    """
+    
+    def __init__(self, case_name):
+        """
+        Initialize the FoamCaseManager.
+        
+        Args:
+            case_name (str): The name of the OpenFOAM case directory.
+        """
+        self.case_name = case_name
+        self.system_dir = os.path.join(case_name, "system")
+        self.constant_dir = os.path.join(case_name, "constant")
+        
+        # Ensure directories exist
+        os.makedirs(self.system_dir, exist_ok=True)
+        os.makedirs(self.constant_dir, exist_ok=True)
+    
+    def setup_geometry(self, p0, p1, cells, patch_names, scale=1.0):
+        """
+        Set up the geometry and mesh configuration.
+        
+        Args:
+            p0 (tuple): The minimum corner of the cube (x0, y0, z0).
+            p1 (tuple): The maximum corner of the cube (x1, y1, z1).
+            cells (tuple): Number of cells in each direction (nx, ny, nz).
+            patch_names (dict): A dictionary mapping face identifiers to custom names.
+            scale (float): The scaling factor for the mesh.
+        """
+        self.geometry_config = {
+            'p0': p0,
+            'p1': p1,
+            'cells': cells,
+            'patch_names': patch_names,
+            'scale': scale
+        }
+    
+    def setup_control(self, control_params):
+        """
+        Set up the control dictionary parameters.
+        
+        Args:
+            control_params (dict): Dictionary containing control parameters.
+        """
+        self.control_config = control_params
+    
+    def setup_turbulence(self, simulation_type, model_properties):
+        """
+        Set up the turbulence model configuration.
+        
+        Args:
+            simulation_type (str): The simulation type ('RAS', 'LES', 'laminar').
+            model_properties (dict): Properties for the turbulence model.
+        """
+        self.turbulence_config = {
+            'simulation_type': simulation_type,
+            'model_properties': model_properties
+        }
+    
+    def create_blockmesh_dict(self):
+        """
+        Create the blockMeshDict file.
+        
+        Returns:
+            bool: True if successful, False otherwise.
+        """
+        if not hasattr(self, 'geometry_config'):
+            print("Error: Geometry configuration not set. Call setup_geometry() first.")
+            return False
+        
+        try:
+            developer = BlockMeshDeveloper(
+                p0=self.geometry_config['p0'],
+                p1=self.geometry_config['p1'],
+                cells=self.geometry_config['cells'],
+                patch_names=self.geometry_config['patch_names'],
+                scale=self.geometry_config.get('scale', 1.0)
+            )
+            
+            bmd_path = os.path.join(self.system_dir, "blockMeshDict")
+            developer.create_blockmesh_dict(file_path=bmd_path)
+            return True
+            
+        except Exception as e:
+            print(f"Error creating blockMeshDict: {e}")
+            return False
+    
+    def create_control_dict(self):
+        """
+        Create the controlDict file.
+        
+        Returns:
+            bool: True if successful, False otherwise.
+        """
+        if not hasattr(self, 'control_config'):
+            print("Error: Control configuration not set. Call setup_control() first.")
+            return False
+        
+        try:
+            cd_path = os.path.join(self.system_dir, "controlDict")
+            control_dict = ControlDictWriter(file_path=cd_path, params=self.control_config)
+            
+            # Validate parameters before writing
+            if not control_dict.validate_params():
+                print("Warning: Control parameters validation failed, but proceeding anyway.")
+            
+            control_dict.write()
+            return True
+            
+        except Exception as e:
+            print(f"Error creating controlDict: {e}")
+            return False
+    
+    def create_turbulence_properties(self):
+        """
+        Create the turbulenceProperties file.
+        
+        Returns:
+            bool: True if successful, False otherwise.
+        """
+        if not hasattr(self, 'turbulence_config'):
+            print("Error: Turbulence configuration not set. Call setup_turbulence() first.")
+            return False
+        
+        try:
+            tp_path = os.path.join(self.constant_dir, "turbulenceProperties")
+            turbulence_writer = TurbulencePropertiesWriter(
+                file_path=tp_path,
+                simulation_type=self.turbulence_config['simulation_type'],
+                model_properties=self.turbulence_config['model_properties']
+            )
+            
+            # Validate configuration before writing
+            if not turbulence_writer.validate_simulation_type():
+                print("Warning: Simulation type validation failed, but proceeding anyway.")
+            
+            if not turbulence_writer.validate_model_properties():
+                print("Warning: Model properties validation failed, but proceeding anyway.")
+            
+            turbulence_writer.write()
+            return True
+            
+        except Exception as e:
+            print(f"Error creating turbulenceProperties: {e}")
+            return False
+    
+    def create_full_case(self):
+        """
+        Create a complete OpenFOAM case with all configuration files.
+        
+        Returns:
+            bool: True if all files created successfully, False otherwise.
+        """
+        print(f"--- Starting full OpenFOAM case setup for '{self.case_name}' ---")
+        
+        success = True
+        
+        # Create blockMeshDict
+        print("\n[Step 1/3] Creating blockMeshDict...")
+        if not self.create_blockmesh_dict():
+            success = False
+        
+        # Create controlDict
+        print("\n[Step 2/3] Creating controlDict...")
+        if not self.create_control_dict():
+            success = False
+        
+        # Create turbulenceProperties
+        print("\n[Step 3/3] Creating turbulenceProperties...")
+        if not self.create_turbulence_properties():
+            success = False
+        
+        if success:
+            print(f"\n--- Case setup complete! ---")
+            print(f"Files written in '{self.case_name}'")
+            print(f"  - {os.path.join(self.case_name, 'system', 'blockMeshDict')}")
+            print(f"  - {os.path.join(self.case_name, 'system', 'controlDict')}")
+            print(f"  - {os.path.join(self.case_name, 'constant', 'turbulenceProperties')}")
+        else:
+            print(f"\n--- Case setup failed! ---")
+            print("Some files could not be created. Check error messages above.")
+        
+        return success

pycphy/foamCaseDeveloper/core/turbulence_properties_writer.py

@@ -0,0 +1,68 @@
+# turbulence_properties_writer.py
+
+from ..writers.turbulence_properties_writer import TurbulencePropertiesWriter as BaseTurbulencePropertiesWriter
+
+class TurbulencePropertiesWriter(BaseTurbulencePropertiesWriter):
+    """
+    Extended TurbulencePropertiesWriter with additional functionality for case management.
+    """
+    
+    def __init__(self, file_path, simulation_type, model_properties):
+        """
+        Initializes the TurbulencePropertiesWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'turbulenceProperties'.
+            simulation_type (str): The top-level simulation type (e.g., 'RAS', 'LES', 'laminar').
+            model_properties (dict): A dictionary containing the properties for the chosen model.
+                                     This dictionary can be nested.
+        """
+        super().__init__(file_path, simulation_type, model_properties)
+    
+    def validate_simulation_type(self):
+        """
+        Validates the simulation type.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        valid_types = ['RAS', 'LES', 'laminar']
+        
+        if self.simulation_type not in valid_types:
+            print(f"Warning: Invalid simulation type '{self.simulation_type}'. Valid types: {valid_types}")
+            return False
+        
+        return True
+    
+    def validate_model_properties(self):
+        """
+        Validates the model properties based on simulation type.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        if self.simulation_type == 'RAS':
+            required_keys = ['RASModel', 'turbulence']
+            for key in required_keys:
+                if key not in self.model_properties:
+                    print(f"Warning: Required RAS parameter '{key}' is missing.")
+                    return False
+                    
+            # Validate RAS model
+            valid_ras_models = ['kEpsilon', 'realizableKE', 'kOmegaSST', 'SpalartAllmaras']
+            if self.model_properties.get('RASModel') not in valid_ras_models:
+                print(f"Warning: Unknown RAS model '{self.model_properties.get('RASModel')}'.")
+        
+        elif self.simulation_type == 'LES':
+            required_keys = ['LESModel', 'turbulence']
+            for key in required_keys:
+                if key not in self.model_properties:
+                    print(f"Warning: Required LES parameter '{key}' is missing.")
+                    return False
+                    
+            # Validate LES model
+            valid_les_models = ['Smagorinsky', 'kEqn', 'WALE', 'dynamicKEqn']
+            if self.model_properties.get('LESModel') not in valid_les_models:
+                print(f"Warning: Unknown LES model '{self.model_properties.get('LESModel')}'.")
+        
+        return True

pycphy/foamCaseDeveloper/main.py

@@ -0,0 +1,260 @@
+# main.py
+
+"""
+Main entry point for the foamCaseDeveloper module.
+
+This script provides a command-line interface for creating OpenFOAM cases
+using the foamCaseDeveloper tools.
+"""
+
+import argparse
+import sys
+import os
+
+from .core import FoamCaseManager
+from .config import global_config, block_mesh_config, control_config, turbulence_config
+
+def create_example_case():
+    """
+    Create an example OpenFOAM case with default settings from config files.
+    
+    Returns:
+        bool: True if successful, False otherwise.
+    """
+    print("Creating example OpenFOAM case from config files...")
+    
+    # Initialize case manager with global config
+    case_manager = FoamCaseManager(global_config.case_name)
+    
+    # Set up geometry from config file
+    case_manager.setup_geometry(
+        p0=block_mesh_config.p0,
+        p1=block_mesh_config.p1,
+        cells=block_mesh_config.cells,
+        patch_names=block_mesh_config.patch_names,
+        scale=block_mesh_config.scale
+    )
+    
+    # Set up control from config file
+    case_manager.setup_control(control_config.control_params)
+    
+    # Set up turbulence from config file
+    sim_type = turbulence_config.SIMULATION_TYPE
+    if sim_type == "RAS":
+        model_props = turbulence_config.RAS_PROPERTIES
+    elif sim_type == "LES":
+        model_props = turbulence_config.LES_PROPERTIES
+    elif sim_type == "laminar":
+        model_props = turbulence_config.LAMINAR_PROPERTIES
+    else:
+        print(f"Warning: Unknown simulation type '{sim_type}'. Using laminar.")
+        sim_type = "laminar"
+        model_props = {}
+    
+    case_manager.setup_turbulence(
+        simulation_type=sim_type,
+        model_properties=model_props
+    )
+    
+    # Create the complete case
+    return case_manager.create_full_case()
+
+def create_custom_case(case_name, geometry_file=None, control_file=None, turbulence_file=None):
+    """
+    Create a custom OpenFOAM case from configuration files.
+    
+    Args:
+        case_name (str): Name of the case directory.
+        geometry_file (str): Path to geometry configuration file.
+        control_file (str): Path to control configuration file.
+        turbulence_file (str): Path to turbulence configuration file.
+    
+    Returns:
+        bool: True if successful, False otherwise.
+    """
+    print(f"Creating custom OpenFOAM case '{case_name}'...")
+    
+    # Initialize case manager
+    case_manager = FoamCaseManager(case_name)
+    
+    # Load geometry configuration
+    if geometry_file and os.path.exists(geometry_file):
+        try:
+            # Import the geometry configuration
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("geometry_config", geometry_file)
+            geometry_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(geometry_module)
+            
+            geometry_config = BlockMeshConfig(
+                p0=geometry_module.p0,
+                p1=geometry_module.p1,
+                cells=geometry_module.cells,
+                patch_names=geometry_module.patch_names,
+                scale=getattr(geometry_module, 'scale', 1.0)
+            )
+            
+            case_manager.setup_geometry(
+                p0=geometry_config.p0,
+                p1=geometry_config.p1,
+                cells=geometry_config.cells,
+                patch_names=geometry_config.patch_names,
+                scale=geometry_config.scale
+            )
+            
+        except Exception as e:
+            print(f"Error loading geometry configuration: {e}")
+            return False
+    else:
+        print("No geometry configuration file provided, using defaults.")
+        geometry_config = BlockMeshConfig()
+        case_manager.setup_geometry(
+            p0=geometry_config.p0,
+            p1=geometry_config.p1,
+            cells=geometry_config.cells,
+            patch_names=geometry_config.patch_names,
+            scale=geometry_config.scale
+        )
+    
+    # Load control configuration
+    if control_file and os.path.exists(control_file):
+        try:
+            # Import the control configuration
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("control_config", control_file)
+            control_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(control_module)
+            
+            case_manager.setup_control(control_module.control_params)
+            
+        except Exception as e:
+            print(f"Error loading control configuration: {e}")
+            return False
+    else:
+        print("No control configuration file provided, using defaults.")
+        control_config = ControlConfig()
+        case_manager.setup_control(control_config.get_parameters())
+    
+    # Load turbulence configuration
+    if turbulence_file and os.path.exists(turbulence_file):
+        try:
+            # Import the turbulence configuration
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("turbulence_config", turbulence_file)
+            turbulence_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(turbulence_module)
+            
+            sim_type = turbulence_module.SIMULATION_TYPE
+            if sim_type == "RAS":
+                model_props = turbulence_module.RAS_PROPERTIES
+            elif sim_type == "LES":
+                model_props = turbulence_module.LES_PROPERTIES
+            elif sim_type == "laminar":
+                model_props = turbulence_module.LAMINAR_PROPERTIES
+            else:
+                print(f"Warning: Unknown simulation type '{sim_type}'. Using laminar.")
+                sim_type = "laminar"
+                model_props = {}
+            
+            case_manager.setup_turbulence(
+                simulation_type=sim_type,
+                model_properties=model_props
+            )
+            
+        except Exception as e:
+            print(f"Error loading turbulence configuration: {e}")
+            return False
+    else:
+        print("No turbulence configuration file provided, using defaults.")
+        turbulence_config = TurbulenceConfig()
+        case_manager.setup_turbulence(
+            simulation_type=turbulence_config.get_simulation_type(),
+            model_properties=turbulence_config.get_model_properties()
+        )
+    
+    # Create the complete case
+    return case_manager.create_full_case()
+
+def main():
+    """
+    Main entry point for the command-line interface.
+    """
+    parser = argparse.ArgumentParser(
+        description="OpenFOAM Case Developer - Create OpenFOAM cases with Python",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Create an example case
+  pycphy-foam --example
+  
+  # Create a custom case from configuration files
+  pycphy-foam --case myCase --geometry configBlockMesh.py --control configControl.py --turbulence configTurbulence.py
+  
+  # Create a case with just geometry configuration
+  pycphy-foam --case myCase --geometry configBlockMesh.py
+        """
+    )
+    
+    parser.add_argument(
+        "--example",
+        action="store_true",
+        help="Create an example OpenFOAM case with default settings"
+    )
+    
+    parser.add_argument(
+        "--case",
+        type=str,
+        help="Name of the OpenFOAM case directory to create"
+    )
+    
+    parser.add_argument(
+        "--geometry",
+        type=str,
+        help="Path to geometry configuration file (Python module)"
+    )
+    
+    parser.add_argument(
+        "--control",
+        type=str,
+        help="Path to control configuration file (Python module)"
+    )
+    
+    parser.add_argument(
+        "--turbulence",
+        type=str,
+        help="Path to turbulence configuration file (Python module)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Validate arguments
+    if args.example and args.case:
+        print("Error: Cannot specify both --example and --case options.")
+        sys.exit(1)
+    
+    if not args.example and not args.case:
+        print("Error: Must specify either --example or --case option.")
+        sys.exit(1)
+    
+    # Create the case
+    success = False
+    
+    if args.example:
+        success = create_example_case()
+    else:
+        success = create_custom_case(
+            case_name=args.case,
+            geometry_file=args.geometry,
+            control_file=args.control,
+            turbulence_file=args.turbulence
+        )
+    
+    if success:
+        print("\nOpenFOAM case creation completed successfully!")
+        sys.exit(0)
+    else:
+        print("\nOpenFOAM case creation failed!")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

pycphy/foamCaseDeveloper/writers/__init__.py

@@ -0,0 +1,18 @@
+"""
+OpenFOAM dictionary writers for various file types.
+
+This module contains the base FoamWriter class and specific writers
+for different OpenFOAM dictionary files.
+"""
+
+from .foam_writer import FoamWriter
+from .block_mesh_writer import BlockMeshWriter
+from .control_dict_writer import ControlDictWriter
+from .turbulence_properties_writer import TurbulencePropertiesWriter
+
+__all__ = [
+    "FoamWriter",
+    "BlockMeshWriter", 
+    "ControlDictWriter",
+    "TurbulencePropertiesWriter",
+]