pycphy 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

pycphy/foamCaseDeveloper/writers/zero/zero_field_factory.py

@@ -0,0 +1,388 @@
+"""
+Zero Field Factory for OpenFOAM cases.
+
+This factory creates zero field writers using configuration files and optionally
+CSV boundary conditions. It determines which fields to write based on CSV content.
+"""
+
+import os
+from typing import Dict, Any, Optional, List
+from ..foam_writer import FoamWriter
+
+
+class ZeroFieldFactory:
+    """
+    Factory class to create zero field writers using config files and CSV data.
+    """
+    
+    def __init__(self, output_dir: str = "0", csv_file_path: str = "Inputs/patches.csv"):
+        """
+        Initialize the zero field factory.
+        
+        Args:
+            output_dir: Directory where to write the zero field files
+            csv_file_path: Path to the patches.csv file
+        """
+        self.output_dir = output_dir
+        self.csv_file_path = csv_file_path
+        self.csv_boundary_reader = None
+        
+        # Ensure output directory exists
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Load CSV boundary conditions if file exists
+        self._load_csv_boundary_conditions()
+    
+    def _load_csv_boundary_conditions(self):
+        """Load boundary conditions from CSV file if it exists."""
+        try:
+            from ...config.csv_boundary_reader import CSVBoundaryReader
+            self.csv_boundary_reader = CSVBoundaryReader(self.csv_file_path)
+            print(f"Loaded CSV boundary conditions from {self.csv_file_path}")
+        except Exception as e:
+            print(f"Could not load CSV boundary conditions: {e}")
+            self.csv_boundary_reader = None
+    
+    def _get_csv_boundary_conditions(self, field_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get boundary conditions for a specific field from CSV.
+        
+        Args:
+            field_name: Name of the field (p, U, f, lambda)
+            
+        Returns:
+            Dictionary of boundary conditions or None if not available
+        """
+        if not self.csv_boundary_reader:
+            return None
+        
+        if field_name == 'p':
+            return self.csv_boundary_reader.get_pressure_boundary_conditions()
+        elif field_name == 'U':
+            return self.csv_boundary_reader.get_velocity_boundary_conditions()
+        elif field_name == 'f':
+            return self.csv_boundary_reader.get_force_boundary_conditions()
+        elif field_name == 'lambda':
+            return self.csv_boundary_reader.get_lambda_boundary_conditions()
+        
+        return None
+    
+    def _check_field_in_csv(self, field_name: str) -> bool:
+        """
+        Check if a field is defined in the CSV file.
+        
+        Args:
+            field_name: Name of the field to check
+            
+        Returns:
+            True if field is defined in CSV, False otherwise
+        """
+        if not self.csv_boundary_reader:
+            return False
+        
+        patches = self.csv_boundary_reader.get_patch_names()
+        if not patches:
+            return False
+        
+        # Check if any patch has non-empty values for this field
+        for patch_name in patches:
+            patch_info = self.csv_boundary_reader.get_patch_info(patch_name)
+            if patch_info:
+                if field_name == 'p' and patch_info.p_type and patch_info.p_type.strip():
+                    return True
+                elif field_name == 'U' and patch_info.u_type and patch_info.u_type.strip():
+                    return True
+                elif field_name == 'f' and patch_info.f_type and patch_info.f_type.strip():
+                    return True
+                elif field_name == 'lambda' and patch_info.lambda_type and patch_info.lambda_type.strip():
+                    return True
+        
+        return False
+    
+    def create_pressure_writer(self, use_csv_boundaries: bool = True) -> Optional[Any]:
+        """
+        Create a pressure field writer using config and optionally CSV boundaries.
+        
+        Args:
+            use_csv_boundaries: If True, use CSV boundary conditions if available
+            
+        Returns:
+            PFieldWriter instance or None if pressure field not configured
+        """
+        from ...config.zero import p_config
+        
+        # Check if pressure field should be written
+        if not p_config.WRITE_P_FIELD:
+            return None
+        
+        # Check if field is defined in CSV (if using CSV boundaries)
+        if use_csv_boundaries and not self._check_field_in_csv('p'):
+            print("Pressure field not found in CSV, skipping...")
+            return None
+        
+        # Import the writer
+        from .p_field_writer import PFieldWriter
+        
+        # Get boundary conditions
+        if use_csv_boundaries and self.csv_boundary_reader:
+            boundary_conditions = self._get_csv_boundary_conditions('p')
+            if boundary_conditions:
+                print(f"Using CSV boundary conditions for pressure field ({len(boundary_conditions)} patches)")
+            else:
+                print("No CSV boundary conditions found for pressure field, using config defaults")
+                boundary_conditions = {}  # Will use template or default
+        else:
+            boundary_conditions = {}  # Will use template or default
+        
+        # Use template if no boundary conditions and template is selected
+        if not boundary_conditions and p_config.SELECTED_TEMPLATE:
+            template = p_config.TEMPLATE_CONFIGS.get(p_config.SELECTED_TEMPLATE)
+            if template:
+                boundary_conditions = template.get('boundary_conditions', {})
+                print(f"Using template '{p_config.SELECTED_TEMPLATE}' for pressure field")
+        
+        # Create writer
+        file_path = os.path.join(self.output_dir, "p")
+        writer = PFieldWriter(
+            file_path=file_path,
+            internal_pressure=p_config.INTERNAL_PRESSURE,
+            boundary_conditions=boundary_conditions,
+            ref_pressure_cell=p_config.REF_PRESSURE_CELL,
+            ref_pressure_value=p_config.REF_PRESSURE_VALUE,
+            pressure_dimensions=p_config.PRESSURE_DIMENSIONS
+        )
+        
+        return writer
+    
+    def create_velocity_writer(self, use_csv_boundaries: bool = True) -> Optional[Any]:
+        """
+        Create a velocity field writer using config and optionally CSV boundaries.
+        
+        Args:
+            use_csv_boundaries: If True, use CSV boundary conditions if available
+            
+        Returns:
+            UFieldWriter instance or None if velocity field not configured
+        """
+        from ...config.zero import U_config
+        
+        # Check if velocity field should be written
+        if not U_config.WRITE_U_FIELD:
+            return None
+        
+        # Check if field is defined in CSV (if using CSV boundaries)
+        if use_csv_boundaries and not self._check_field_in_csv('U'):
+            print("Velocity field not found in CSV, skipping...")
+            return None
+        
+        # Import the writer
+        from .u_field_writer import UFieldWriter
+        
+        # Get boundary conditions
+        if use_csv_boundaries and self.csv_boundary_reader:
+            boundary_conditions = self._get_csv_boundary_conditions('U')
+            if boundary_conditions:
+                print(f"Using CSV boundary conditions for velocity field ({len(boundary_conditions)} patches)")
+            else:
+                print("No CSV boundary conditions found for velocity field, using config defaults")
+                boundary_conditions = {}
+        else:
+            boundary_conditions = {}
+        
+        # Use template if no boundary conditions and template is selected
+        if not boundary_conditions and U_config.SELECTED_TEMPLATE:
+            template = U_config.TEMPLATE_CONFIGS.get(U_config.SELECTED_TEMPLATE)
+            if template:
+                boundary_conditions = template.get('boundary_conditions', {})
+                print(f"Using template '{U_config.SELECTED_TEMPLATE}' for velocity field")
+        
+        # Create writer
+        file_path = os.path.join(self.output_dir, "U")
+        writer = UFieldWriter(
+            file_path=file_path,
+            internal_velocity=U_config.INTERNAL_VELOCITY,
+            boundary_conditions=boundary_conditions,
+            velocity_dimensions=U_config.VELOCITY_DIMENSIONS
+        )
+        
+        return writer
+    
+    def create_force_writer(self, use_csv_boundaries: bool = True) -> Optional[Any]:
+        """
+        Create a force field writer using config and optionally CSV boundaries.
+        
+        Args:
+            use_csv_boundaries: If True, use CSV boundary conditions if available
+            
+        Returns:
+            FFieldWriter instance or None if force field not configured
+        """
+        from ...config.zero import f_config
+        
+        # Check if force field should be written
+        if not f_config.WRITE_F_FIELD:
+            return None
+        
+        # Check if field is defined in CSV (if using CSV boundaries)
+        if use_csv_boundaries and not self._check_field_in_csv('f'):
+            print("Force field not found in CSV, skipping...")
+            return None
+        
+        # Import the writer
+        from .f_field_writer import FFieldWriter
+        
+        # Get boundary conditions
+        if use_csv_boundaries and self.csv_boundary_reader:
+            boundary_conditions = self._get_csv_boundary_conditions('f')
+            if boundary_conditions:
+                print(f"Using CSV boundary conditions for force field ({len(boundary_conditions)} patches)")
+            else:
+                print("No CSV boundary conditions found for force field, using config defaults")
+                boundary_conditions = {}
+        else:
+            boundary_conditions = {}
+        
+        # Use template if no boundary conditions and template is selected
+        if not boundary_conditions and f_config.SELECTED_TEMPLATE:
+            template = f_config.TEMPLATE_CONFIGS.get(f_config.SELECTED_TEMPLATE)
+            if template:
+                boundary_conditions = template.get('boundary_conditions', {})
+                print(f"Using template '{f_config.SELECTED_TEMPLATE}' for force field")
+        
+        # Create writer
+        file_path = os.path.join(self.output_dir, "f")
+        writer = FFieldWriter(
+            file_path=file_path,
+            internal_force=f_config.INTERNAL_FORCE,
+            boundary_conditions=boundary_conditions,
+            force_dimensions=f_config.FORCE_DIMENSIONS
+        )
+        
+        return writer
+    
+    def create_lambda_writer(self, use_csv_boundaries: bool = True) -> Optional[Any]:
+        """
+        Create a lambda field writer using config and optionally CSV boundaries.
+        
+        Args:
+            use_csv_boundaries: If True, use CSV boundary conditions if available
+            
+        Returns:
+            LambdaFieldWriter instance or None if lambda field not configured
+        """
+        from ...config.zero import lambda_config
+        
+        # Check if lambda field should be written
+        if not lambda_config.WRITE_LAMBDA_FIELD:
+            return None
+        
+        # Check if field is defined in CSV (if using CSV boundaries)
+        if use_csv_boundaries and not self._check_field_in_csv('lambda'):
+            print("Lambda field not found in CSV, skipping...")
+            return None
+        
+        # Import the writer
+        from .lambda_field_writer import LambdaFieldWriter
+        
+        # Get boundary conditions
+        if use_csv_boundaries and self.csv_boundary_reader:
+            boundary_conditions = self._get_csv_boundary_conditions('lambda')
+            if boundary_conditions:
+                print(f"Using CSV boundary conditions for lambda field ({len(boundary_conditions)} patches)")
+            else:
+                print("No CSV boundary conditions found for lambda field, using config defaults")
+                boundary_conditions = {}
+        else:
+            boundary_conditions = {}
+        
+        # Use template if no boundary conditions and template is selected
+        if not boundary_conditions and lambda_config.SELECTED_TEMPLATE:
+            template = lambda_config.TEMPLATE_CONFIGS.get(lambda_config.SELECTED_TEMPLATE)
+            if template:
+                boundary_conditions = template.get('boundary_conditions', {})
+                print(f"Using template '{lambda_config.SELECTED_TEMPLATE}' for lambda field")
+        
+        # Create writer
+        file_path = os.path.join(self.output_dir, "lambda")
+        writer = LambdaFieldWriter(
+            file_path=file_path,
+            internal_lambda=lambda_config.INTERNAL_LAMBDA,
+            boundary_conditions=boundary_conditions,
+            lambda_dimensions=lambda_config.LAMBDA_DIMENSIONS
+        )
+        
+        return writer
+    
+    def write_all_fields(self, use_csv_boundaries: bool = True) -> List[str]:
+        """
+        Write all configured zero field files.
+        
+        Args:
+            use_csv_boundaries: If True, use CSV boundary conditions if available
+            
+        Returns:
+            List of field names that were written
+        """
+        written_fields = []
+        
+        print("Writing zero field files using config + CSV boundary conditions...")
+        print("=" * 60)
+        
+        # Write pressure field
+        p_writer = self.create_pressure_writer(use_csv_boundaries)
+        if p_writer:
+            p_writer.write()
+            written_fields.append('p')
+        
+        # Write velocity field
+        u_writer = self.create_velocity_writer(use_csv_boundaries)
+        if u_writer:
+            u_writer.write()
+            written_fields.append('U')
+        
+        # Write force field
+        f_writer = self.create_force_writer(use_csv_boundaries)
+        if f_writer:
+            f_writer.write()
+            written_fields.append('f')
+        
+        # Write lambda field
+        lambda_writer = self.create_lambda_writer(use_csv_boundaries)
+        if lambda_writer:
+            lambda_writer.write()
+            written_fields.append('lambda')
+        
+        print("=" * 60)
+        print(f"Written {len(written_fields)} zero field files: {', '.join(written_fields)}")
+        
+        return written_fields
+    
+    def get_available_fields(self) -> Dict[str, bool]:
+        """
+        Get information about which fields are available in CSV and config.
+        
+        Returns:
+            Dictionary with field availability information
+        """
+        return {
+            'p': {
+                'csv_available': self._check_field_in_csv('p'),
+                'config_enabled': False,  # Will be set by checking config
+                'boundary_conditions': self._get_csv_boundary_conditions('p')
+            },
+            'U': {
+                'csv_available': self._check_field_in_csv('U'),
+                'config_enabled': False,
+                'boundary_conditions': self._get_csv_boundary_conditions('U')
+            },
+            'f': {
+                'csv_available': self._check_field_in_csv('f'),
+                'config_enabled': False,
+                'boundary_conditions': self._get_csv_boundary_conditions('f')
+            },
+            'lambda': {
+                'csv_available': self._check_field_in_csv('lambda'),
+                'config_enabled': False,
+                'boundary_conditions': self._get_csv_boundary_conditions('lambda')
+            }
+        }

{pycphy-0.1.0.dist-info → pycphy-0.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pycphy
-Version: 0.1.0
-Summary: Python: Computational Physics - Tools for physics dynamics simulation
+Version: 0.2.0
+Summary: Python: Computational Physics - Tools for physics dynamics simulation with CAD-based OpenFOAM case generation
 Home-page: https://github.com/SanjeevBashyal/pycphy
 Author: Sanjeev Bashyal
 Author-email: Sanjeev Bashyal <sanjeev.bashyal@example.com>
@@ -11,10 +11,10 @@ Project-URL: Homepage, https://github.com/SanjeevBashyal/pycphy
 Project-URL: Repository, https://github.com/SanjeevBashyal/pycphy
 Project-URL: Documentation, https://github.com/SanjeevBashyal/pycphy#readme
 Project-URL: Bug Tracker, https://github.com/SanjeevBashyal/pycphy/issues
-Keywords: computational physics,simulation,openfoam,cfd,physics
+Keywords: computational physics,simulation,openfoam,cfd,physics,autocad,cad,mesh generation,blockmesh
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
-Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
@@ -23,12 +23,15 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.19.0
 Requires-Dist: scipy>=1.6.0
 Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: pandas>=1.3.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -38,6 +41,12 @@ Requires-Dist: mypy; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Provides-Extra: cad
+Requires-Dist: pyautocad>=0.2.0; extra == "cad"
+Requires-Dist: pywin32>=304; extra == "cad"
+Provides-Extra: all
+Requires-Dist: pyautocad>=0.2.0; extra == "all"
+Requires-Dist: pywin32>=304; extra == "all"
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file
@@ -63,8 +72,10 @@ A comprehensive Python package for computational physics simulations and tools,
 The `foamCaseDeveloper` module provides:
 
 - **BlockMesh Generation**: Create OpenFOAM blockMeshDict files with custom geometries
+- **CAD-based Mesh Generation**: Generate blockMeshDict directly from AutoCAD CAD files with XData annotations
 - **Control Dictionary Setup**: Configure solver settings, time control, and output parameters
 - **Turbulence Model Configuration**: Set up RAS, LES, and laminar turbulence models
+- **Zero Field Generation**: Create initial field files (p, U, f, lambda) with CSV-based boundary conditions
 - **Complete Case Management**: Automatically create complete OpenFOAM case directories
 - **Validation and Error Checking**: Built-in validation for all configuration parameters
 
@@ -78,6 +89,14 @@ cd pycphy
 pip install -e .
 ```
 
+### With CAD Support (Recommended)
+
+```bash
+git clone https://github.com/SanjeevBashyal/pycphy.git
+cd pycphy
+pip install -e ".[cad]"
+```
+
 ### Development Installation
 
 ```bash
@@ -86,16 +105,39 @@ cd pycphy
 pip install -e ".[dev]"
 ```
 
+### Full Installation (All Features)
+
+```bash
+git clone https://github.com/SanjeevBashyal/pycphy.git
+cd pycphy
+pip install -e ".[all]"
+```
+
 ## Quick Start
 
 ### Using the Command Line Interface
 
 ```bash
-# Create an example case
+# Create an example case (traditional CLI)
 pycphy-foam --example
 
-# Create a custom case from configuration files
+# Create a custom case from configuration files (traditional CLI)
 pycphy-foam --case myCase --geometry configBlockMesh.py --control configControl.py --turbulence configTurbulence.py
+
+# Create a case with CAD-based mesh generation (default behavior)
+python pycphy/foamCaseDeveloper/develop_case.py
+# OR after installation:
+pycphy-develop
+
+# Create a case with traditional config-based generation
+python pycphy/foamCaseDeveloper/develop_case.py --config-mode
+# OR after installation:
+pycphy-develop --config-mode
+
+# Create a case with CAD-based mesh generation and debug output
+python pycphy/foamCaseDeveloper/develop_case.py --cad-debug --cad-tolerance 1e-6
+# OR after installation:
+pycphy-develop --cad-debug --cad-tolerance 1e-6
 ```
 
 ### Using Python API
@@ -148,6 +190,32 @@ case_manager.setup_turbulence(
 case_manager.create_full_case()
 ```
 
+### CAD-based Mesh Generation
+
+```python
+from pycphy.foamCaseDeveloper import CADBlockMeshDeveloper, cad_mesh_config
+
+# Create CAD-based mesh developer
+cad_developer = CADBlockMeshDeveloper(
+    blocks_csv_file="Inputs/blocks.csv",
+    patches_csv_file="Inputs/patches.csv",
+    tolerance=1e-6,
+    block_xdata_app_name="BLOCKDATA",
+    region_xdata_app_name="REGIONDATA"
+)
+
+# Process CAD file and generate complete OpenFOAM case
+success = cad_developer.process_cad_file(
+    output_path="system/blockMeshDict",
+    debug=True
+)
+
+if success:
+    summary = cad_developer.get_summary()
+    print(f"Generated mesh with {summary['total_blocks']} blocks and {summary['total_patches']} patches")
+    print("Zero field files created with CSV boundary conditions")
+```
+
 ## Package Structure
 
 ```
@@ -279,11 +347,91 @@ case_manager.create_full_case()
 
 ## Requirements
 
+### Basic Requirements
 - Python >= 3.7
 - NumPy >= 1.19.0
 - SciPy >= 1.6.0
 - Matplotlib >= 3.3.0
 
+### CAD-based Generation Requirements
+- AutoCAD (with COM automation support)
+- Windows operating system (for AutoCAD COM interface)
+- pyautocad >= 0.2.0
+- win32com (included with pywin32)
+
+### CAD Setup for Mesh Generation
+
+To use CAD-based mesh generation:
+
+1. **Prepare your CAD file**:
+   - Create 3DSOLID entities for mesh blocks
+   - Create REGION entities for boundary patches
+   - Add XData to entities with block/patch information
+
+2. **Create CSV configuration files**:
+   - `blocks.csv`: Define block parameters (ID, cells, grading, etc.)
+   - `patches.csv`: Define boundary conditions for each patch
+
+3. **XData Format**:
+   - Blocks: Use "BLOCKDATA" app with block ID and description
+   - Regions: Use "REGIONDATA" app with region name
+
+4. **Run the generation**:
+   ```bash
+   # CAD-based case generation with all OpenFOAM files (default)
+   python pycphy/foamCaseDeveloper/develop_case.py
+   # OR after installation:
+   pycphy-develop
+   
+   # Traditional config-based case generation
+   python pycphy/foamCaseDeveloper/develop_case.py --config-mode
+   # OR after installation:
+   pycphy-develop --config-mode
+   ```
+
+## Integrated Workflow
+
+The `develop_case.py` script now supports both traditional config-based and CAD-based OpenFOAM case generation:
+
+### CAD-based Generation
+- **Mesh**: Generated directly from AutoCAD CAD files using XData annotations
+- **Zero fields**: Created with boundary conditions from CSV files
+- **Other files**: Generated from configuration files (control, turbulence, etc.)
+
+### Traditional Generation
+- **Mesh**: Generated from geometry configuration files
+- **Zero fields**: Generated from configuration files with hardcoded boundary conditions
+- **Other files**: Generated from configuration files
+
+### Command Line Options
+
+```bash
+# Basic usage (CAD-based generation is now default)
+python pycphy/foamCaseDeveloper/develop_case.py
+# OR after installation:
+pycphy-develop
+
+# Traditional config-based generation
+python pycphy/foamCaseDeveloper/develop_case.py --config-mode
+# OR after installation:
+pycphy-develop --config-mode
+
+# CAD-based with custom CSV files
+python pycphy/foamCaseDeveloper/develop_case.py --blocks-csv my_blocks.csv --patches-csv my_patches.csv
+# OR after installation:
+pycphy-develop --blocks-csv my_blocks.csv --patches-csv my_patches.csv
+
+# CAD-based with debug output
+python pycphy/foamCaseDeveloper/develop_case.py --cad-debug
+# OR after installation:
+pycphy-develop --cad-debug
+
+# CAD-based with custom tolerance and XData app names
+python pycphy/foamCaseDeveloper/develop_case.py --cad-tolerance 1e-5 --block-xdata-app MYBLOCKDATA --region-xdata-app MYREGIONDATA
+# OR after installation:
+pycphy-develop --cad-tolerance 1e-5 --block-xdata-app MYBLOCKDATA --region-xdata-app MYREGIONDATA
+```
+
 ## Development
 
 ### Running Tests