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

pycphy/foamCaseDeveloper/config/csv_boundary_reader.py

@@ -0,0 +1,219 @@
+"""
+CSV Boundary Condition Reader
+
+This module reads boundary condition information from patches.csv and provides
+it to the zero field writers in the correct format.
+"""
+
+import csv
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+
+
+@dataclass
+class PatchBoundaryCondition:
+    """Data structure for patch boundary conditions."""
+    region_name: str
+    patch_name: str
+    patch_type: str
+    p_type: str
+    u_type: str
+    f_type: str
+    lambda_type: str
+    p_value: Optional[str] = None
+    u_value: Optional[str] = None
+    f_value: Optional[str] = None
+    lambda_value: Optional[str] = None
+
+
+class CSVBoundaryReader:
+    """
+    Reads boundary condition information from patches.csv file.
+    """
+    
+    def __init__(self, csv_file_path: str = "Inputs/patches.csv"):
+        """
+        Initialize the CSV boundary reader.
+        
+        Args:
+            csv_file_path: Path to the patches.csv file
+        """
+        self.csv_file_path = csv_file_path
+        self.patches = {}
+        self._load_patches()
+    
+    def _load_patches(self) -> None:
+        """Load patch information from CSV file."""
+        try:
+            with open(self.csv_file_path, mode='r', newline='') as infile:
+                reader = csv.DictReader(infile)
+                
+                # Check for required columns
+                required_columns = [
+                    'RegionName', 'PatchName', 'PatchType', 
+                    'p', 'U', 'f', 'lambda'
+                ]
+                
+                if not all(col in reader.fieldnames for col in required_columns):
+                    missing = set(required_columns) - set(reader.fieldnames)
+                    raise KeyError(f"CSV file missing required columns: {missing}")
+                
+                for row in reader:
+                    patch_name = row['PatchName']
+                    
+                    # Parse boundary condition types
+                    p_type = row['p'].strip() if row['p'] else 'zeroGradient'
+                    u_type = row['U'].strip() if row['U'] else 'noSlip'
+                    f_type = row['f'].strip() if row['f'] else 'zeroGradient'
+                    lambda_type = row['lambda'].strip() if row['lambda'] else 'fixedValue'
+                    
+                    # Parse values (if provided)
+                    p_value = row.get('p-value', '').strip() or None
+                    u_value = row.get('U-value', '').strip() or None
+                    f_value = row.get('f-value', '').strip() or None
+                    lambda_value = row.get('lambda-value', '').strip() or None
+                    
+                    self.patches[patch_name] = PatchBoundaryCondition(
+                        region_name=row['RegionName'],
+                        patch_name=patch_name,
+                        patch_type=row['PatchType'],
+                        p_type=p_type,
+                        u_type=u_type,
+                        f_type=f_type,
+                        lambda_type=lambda_type,
+                        p_value=p_value,
+                        u_value=u_value,
+                        f_value=f_value,
+                        lambda_value=lambda_value
+                    )
+            
+            print(f"Loaded {len(self.patches)} patches from {self.csv_file_path}")
+            
+        except FileNotFoundError:
+            print(f"Warning: {self.csv_file_path} not found. Using default boundary conditions.")
+            self.patches = {}
+        except Exception as e:
+            print(f"Error loading patches from CSV: {e}")
+            self.patches = {}
+    
+    def get_pressure_boundary_conditions(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get pressure boundary conditions in the format expected by PFieldWriter.
+        
+        Returns:
+            Dictionary of boundary conditions for pressure field
+        """
+        boundary_conditions = {}
+        
+        for patch_name, patch in self.patches.items():
+            bc = {
+                'type': patch.p_type
+            }
+            
+            # Add value if specified
+            if patch.p_value is not None and patch.p_value != '':
+                try:
+                    bc['value'] = float(patch.p_value)
+                except ValueError:
+                    bc['value'] = patch.p_value
+            
+            boundary_conditions[patch_name] = bc
+        
+        return boundary_conditions
+    
+    def get_velocity_boundary_conditions(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get velocity boundary conditions in the format expected by UFieldWriter.
+        
+        Returns:
+            Dictionary of boundary conditions for velocity field
+        """
+        boundary_conditions = {}
+        
+        for patch_name, patch in self.patches.items():
+            bc = {
+                'type': patch.u_type
+            }
+            
+            # Add value if specified
+            if patch.u_value is not None and patch.u_value != '':
+                try:
+                    # Try to parse as vector (x, y, z)
+                    if ',' in patch.u_value:
+                        values = [float(x.strip()) for x in patch.u_value.split(',')]
+                        bc['value'] = tuple(values)
+                    else:
+                        bc['value'] = float(patch.u_value)
+                except ValueError:
+                    bc['value'] = patch.u_value
+            
+            boundary_conditions[patch_name] = bc
+        
+        return boundary_conditions
+    
+    def get_force_boundary_conditions(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get force boundary conditions in the format expected by FFieldWriter.
+        
+        Returns:
+            Dictionary of boundary conditions for force field
+        """
+        boundary_conditions = {}
+        
+        for patch_name, patch in self.patches.items():
+            bc = {
+                'type': patch.f_type
+            }
+            
+            # Add value if specified
+            if patch.f_value is not None and patch.f_value != '':
+                try:
+                    # Try to parse as vector (x, y, z)
+                    if ',' in patch.f_value:
+                        values = [float(x.strip()) for x in patch.f_value.split(',')]
+                        bc['value'] = tuple(values)
+                    else:
+                        bc['value'] = float(patch.f_value)
+                except ValueError:
+                    bc['value'] = patch.f_value
+            
+            boundary_conditions[patch_name] = bc
+        
+        return boundary_conditions
+    
+    def get_lambda_boundary_conditions(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get lambda boundary conditions in the format expected by LambdaFieldWriter.
+        
+        Returns:
+            Dictionary of boundary conditions for lambda field
+        """
+        boundary_conditions = {}
+        
+        for patch_name, patch in self.patches.items():
+            bc = {
+                'type': patch.lambda_type
+            }
+            
+            # Add value if specified
+            if patch.lambda_value is not None and patch.lambda_value != '':
+                try:
+                    bc['value'] = float(patch.lambda_value)
+                except ValueError:
+                    bc['value'] = patch.lambda_value
+            
+            boundary_conditions[patch_name] = bc
+        
+        return boundary_conditions
+    
+    def get_patch_names(self) -> List[str]:
+        """Get list of all patch names."""
+        return list(self.patches.keys())
+    
+    def get_patch_info(self, patch_name: str) -> Optional[PatchBoundaryCondition]:
+        """Get information for a specific patch."""
+        return self.patches.get(patch_name)
+
+
+# Global instance for easy access
+csv_boundary_reader = CSVBoundaryReader()

pycphy/foamCaseDeveloper/config/system/__init__.py

@@ -0,0 +1,31 @@
+# system/__init__.py
+"""
+System directory configuration modules.
+
+This package contains configuration modules for OpenFOAM system directory files:
+- blockMeshDict
+- controlDict
+- fvSchemes
+- fvOptions
+- setFieldsDict
+- decomposeParDict
+- snappyHexMeshDict
+"""
+
+from . import block_mesh_config
+from . import control_config
+from . import fv_schemes_config
+from . import fv_options_config
+from . import set_fields_config
+from . import decompose_par_config
+from . import snappy_hex_mesh_config
+
+__all__ = [
+    'block_mesh_config',
+    'control_config',
+    'fv_schemes_config',
+    'fv_options_config',
+    'set_fields_config',
+    'decompose_par_config',
+    'snappy_hex_mesh_config'
+]

pycphy/foamCaseDeveloper/config/system/block_mesh_config.py

@@ -0,0 +1,184 @@
+# block_mesh_config.py
+
+# =============================================================================
+#           *** Enhanced User Input Configuration for blockMeshDict Generation ***
+# =============================================================================
+#
+#   This enhanced configuration supports complex geometries with multiple blocks,
+#   advanced grading, and sophisticated boundary conditions based on OpenFOAM
+#   examples from Resources/Z Foam Collections.
+#
+
+# --- 1. Basic Geometry Definition ---
+
+# `p0`: The minimum corner of the computational domain (x_min, y_min, z_min).
+# This defines the bottom-left-front corner of the geometry.
+# Example: (0.0, 0.0, 0.0) for a domain starting at the origin
+p0 = (0.0, 0.0, 0.0)
+
+# `p1`: The maximum corner of the computational domain (x_max, y_max, z_max).
+# This defines the top-right-back corner of the geometry.
+# Example: (0.5, 0.2, 0.1) for a channel 0.5m long, 0.2m wide, 0.1m high
+p1 = (0.5, 0.2, 0.1)
+
+# `scale`: Scaling factor for the mesh coordinates.
+# Usually set to 1.0 for actual dimensions. Use other values to scale the entire geometry.
+# Example: 1.0 for meters, 0.001 for millimeters, 1000 for kilometers
+# Special scaling examples: 0.01 (cm to m), 0.0032 (mm to m), 1000 (m to km)
+scale = 1.0
+
+# --- 2. Mesh Complexity Level ---
+
+# `mesh_type`: Type of mesh to generate
+# Options: 'simple', 'multi_block', 'complex'
+# - 'simple': Single block with uniform or simple grading
+# - 'multi_block': Multiple blocks with different properties
+# - 'complex': Advanced multi-block with edges, grading, and special features
+mesh_type = "simple"
+
+# --- 3. Simple Mesh Configuration (when mesh_type = "simple") ---
+
+# `cells`: Number of cells in each direction (nx, ny, nz).
+# This determines the mesh resolution. Higher numbers = finer mesh = longer computation time.
+# Example: (50, 20, 50) means 50 cells in x-direction, 20 in y-direction, 50 in z-direction
+# Total cells = nx * ny * nz = 50 * 20 * 50 = 50,000 cells
+cells = (50, 20, 50)
+
+# `grading`: Cell size grading for each direction (simpleGrading).
+# Controls how cell sizes change across the domain.
+# Example: (1, 1, 1) for uniform cells, (2, 1, 0.5) for graded cells
+# Grading > 1: cells get larger in that direction
+# Grading < 1: cells get smaller in that direction
+grading = (1, 1, 1)
+
+# --- 4. Multi-Block Configuration (when mesh_type = "multi_block" or "complex") ---
+
+# `blocks`: List of block definitions for multi-block meshes
+# Each block is defined by:
+# - vertices: List of 8 vertex indices (0-7 for a hex)
+# - cells: Number of cells in each direction (nx, ny, nz)
+# - grading: Grading specification
+# - grading_type: 'simpleGrading' or 'edgeGrading'
+blocks = [
+    {
+        "name": "block1",
+        "vertices": [0, 1, 2, 3, 4, 5, 6, 7],  # Standard hex vertices
+        "cells": (40, 40, 1),
+        "grading": (1, 1, 1),
+        "grading_type": "simpleGrading"
+    }
+]
+
+# `vertices`: Custom vertex definitions for complex geometries
+# List of (x, y, z) coordinates. Vertices are referenced by index (0-based)
+# Example: [(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0), ...]
+vertices = []
+
+# `edges`: Edge definitions for curved boundaries
+# List of edge dictionaries with type and parameters
+# Example: [{"type": "arc", "points": [0, 1], "centre": [0.5, 0.5, 0]}]
+edges = []
+
+# --- 5. Boundary Patch Names ---
+
+# `patch_names`: Dictionary mapping geometric faces to boundary patch names.
+# These names will be used in boundary condition files and OpenFOAM dictionaries.
+# 
+# Face identifiers:
+#   'minX': Face at minimum X (x = p0[0])
+#   'maxX': Face at maximum X (x = p1[0])
+#   'minY': Face at minimum Y (y = p0[1])
+#   'maxY': Face at maximum Y (y = p1[1])
+#   'minZ': Face at minimum Z (z = p0[2])
+#   'maxZ': Face at maximum Z (z = p1[2])
+#
+# Common patch types in OpenFOAM:
+#   - 'patch': General boundary patch
+#   - 'wall': Solid wall boundary
+#   - 'symmetryPlane': Symmetry boundary
+#   - 'empty': 2D simulation (front/back faces)
+#   - 'cyclic': Periodic boundary condition
+#   - 'wedge': Axisymmetric simulation
+#
+# Example for channel flow:
+patch_names = {
+    'minX': 'inlet',        # Inlet face (flow enters here)
+    'maxX': 'outlet',       # Outlet face (flow exits here)
+    'minY': 'frontWall',    # Front wall (solid boundary)
+    'maxY': 'backWall',     # Back wall (solid boundary)
+    'minZ': 'floor',        # Floor (solid boundary)
+    'maxZ': 'ceiling'       # Ceiling (solid boundary)
+}
+
+# `custom_boundaries`: Custom boundary definitions for complex geometries
+# List of boundary dictionaries with faces and properties
+custom_boundaries = []
+
+# --- 6. Advanced Meshing Options ---
+
+# `merge_patch_pairs`: List of patch pairs to merge (for periodic boundaries).
+# Example: [('leftWall', 'rightWall')] to create a periodic boundary
+merge_patch_pairs = []
+
+# `preserve_cell_zones`: Whether to preserve cell zones during mesh generation
+preserve_cell_zones = False
+
+# `preserve_face_zones`: Whether to preserve face zones during mesh generation
+preserve_face_zones = False
+
+# `preserve_point_zones`: Whether to preserve point zones during mesh generation
+preserve_point_zones = False
+
+# --- 7. Predefined Geometry Templates ---
+
+# `geometry_template`: Select a predefined geometry template
+# Options: 'none', 'channel', 'pipe', 'cavity', 'backward_facing_step', 'airfoil'
+# When 'none' is selected, use custom geometry defined above
+geometry_template = "none"
+
+# `template_parameters`: Parameters for the selected template
+# These override the basic geometry parameters when a template is selected
+template_parameters = {
+    # Channel flow template
+    "channel": {
+        "length": 1.0,      # Channel length [m]
+        "height": 0.1,      # Channel height [m] 
+        "width": 0.02,      # Channel width [m] (2D: small, 3D: actual width)
+        "inlet_length": 0.2, # Inlet development length [m]
+        "outlet_length": 0.2 # Outlet development length [m]
+    },
+    # Pipe flow template
+    "pipe": {
+        "length": 2.0,      # Pipe length [m]
+        "diameter": 0.1,    # Pipe diameter [m]
+        "inlet_length": 0.5, # Inlet development length [m]
+        "outlet_length": 0.5 # Outlet development length [m]
+    },
+    # Cavity flow template
+    "cavity": {
+        "length": 1.0,      # Cavity length [m]
+        "height": 1.0,      # Cavity height [m]
+        "depth": 0.01,      # Cavity depth [m] (2D: small, 3D: actual depth)
+        "lid_velocity": 1.0 # Lid velocity [m/s]
+    }
+}
+
+# --- 8. Validation Settings ---
+
+# `min_cell_size`: Minimum allowed cell size (for validation).
+# Used to prevent extremely small cells that could cause numerical issues.
+min_cell_size = 1e-6
+
+# `max_cell_size`: Maximum allowed cell size (for validation).
+# Used to prevent extremely large cells that could cause accuracy issues.
+max_cell_size = 1.0
+
+# `max_total_cells`: Maximum allowed total number of cells (for validation).
+# Used to prevent creating meshes that are too large for available computational resources.
+max_total_cells = 1000000
+
+# `aspect_ratio_limit`: Maximum allowed cell aspect ratio
+aspect_ratio_limit = 100.0
+
+# `skewness_limit`: Maximum allowed cell skewness
+skewness_limit = 0.8

pycphy/foamCaseDeveloper/config/{control_config.py → system/control_config.py}

@@ -164,5 +164,117 @@ control_params = {
     # `pRefValue`: Reference pressure value (for pressure field).
     # The pressure value at the reference cell.
     # Example: 0.0 (atmospheric pressure reference)
-    "pRefValue": 0.0
+    "pRefValue": 0.0,
+
+    # --- Library Dependencies ---
+    
+    # `libs`: List of additional libraries to load
+    # These are required for certain solvers or function objects
+    # Example: ["interfaceTrackingFvMesh"] for interFoam with interface tracking
+    "libs": [],
+
+    # --- Advanced Time Control ---
+    
+    # `maxAlphaCo`: Maximum allowable alpha Courant number for multiphase flows
+    # Controls interface tracking stability in VOF simulations
+    # Typical range: 0.1 to 1.0
+    "maxAlphaCo": 1.0,
+
+    # `maxDi`: Maximum allowable diffusion number
+    # Used for stability control in diffusion-dominated problems
+    "maxDi": 10.0,
+
+    # `maxDeltaT`: Maximum time step limit (safety measure)
+    # Prevents time step from becoming too large
+    "maxDeltaT": 1.0,
+
+    # --- Function Objects and Monitoring ---
+    
+    # `functions`: Dictionary of function objects for monitoring and data collection
+    # These enable real-time monitoring, data sampling, and post-processing
+    "functions": {
+        # Example probes for monitoring specific locations
+        "probes": {
+            "type": "probes",
+            "libs": ["sampling"],
+            "fields": ["p", "U", "T"],
+            "probeLocations": [
+                (0.1, 0.05, 0.05),  # Near inlet
+                (0.5, 0.05, 0.05),  # Mid domain
+                (0.9, 0.05, 0.05)   # Near outlet
+            ],
+            "writeControl": "timeStep",
+            "writeInterval": 10
+        }
+    },
+
+    # --- Solver-Specific Advanced Options ---
+    
+    # `residualControl`: Convergence criteria for iterative solvers
+    # Controls when the solver considers a time step converged
+    "residualControl": {
+        "p": 1e-6,
+        "U": 1e-6,
+        "k": 1e-6,
+        "epsilon": 1e-6,
+        "omega": 1e-6,
+        "alpha.water": 1e-6
+    },
+
+    # `relaxationFactors`: Under-relaxation factors for field updates
+    # Controls stability and convergence rate
+    "relaxationFactors": {
+        "fields": {
+            "p": 0.3,
+            "pFinal": 1.0
+        },
+        "equations": {
+            "U": 0.7,
+            "k": 0.7,
+            "epsilon": 0.7,
+            "omega": 0.7
+        }
+    },
+
+    # `momentumPredictor`: Whether to use momentum predictor
+    # Improves convergence for transient simulations
+    "momentumPredictor": "yes",
+
+    # `transonic`: Whether to use transonic corrections
+    # For compressible flows near Mach 1
+    "transonic": "no",
+
+    # `consistent`: Whether to use consistent discretization
+    # For better accuracy on non-orthogonal meshes
+    "consistent": "yes",
+
+    # --- Turbulence Model Settings ---
+    
+    # `turbulence`: Turbulence model configuration
+    "turbulence": "on",
+    
+    # `printCoeffs`: Whether to print turbulence model coefficients
+    "printCoeffs": "on",
+
+    # --- Solution Control ---
+    
+    # `cacheAgglomeration`: Cache agglomeration for AMG solvers
+    "cacheAgglomeration": "on",
+    
+    # `agglomerator`: Agglomeration method for AMG
+    "agglomerator": "faceAreaPair",
+    
+    # `mergeLevels`: Number of levels to merge in AMG
+    "mergeLevels": 1,
+
+    # --- Monitoring and Output ---
+    
+    # `writeResiduals`: Whether to write residual information
+    "writeResiduals": "yes",
+    
+    # `writeMesh`: Whether to write mesh information
+    "writeMesh": "no",
+    
+    # `writeGraph`: Whether to write convergence graphs
+    "writeGraph": "yes"
 }