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

pycphy/foamCaseDeveloper/config/__init__.py

@@ -1,26 +1,69 @@
-"""
-Configuration files for OpenFOAM case setup.
-
-This module provides configuration files for different aspects of
-OpenFOAM case setup, including geometry, control, and turbulence settings.
-Each config file contains detailed comments explaining all parameters.
-
-Usage:
-    from pycphy.foamCaseDeveloper.config import global_config
-    from pycphy.foamCaseDeveloper.config import block_mesh_config
-    from pycphy.foamCaseDeveloper.config import control_config
-    from pycphy.foamCaseDeveloper.config import turbulence_config
-"""
-
-# Import all config modules
-from . import global_config
-from . import block_mesh_config
-from . import control_config
-from . import turbulence_config
-
-__all__ = [
-    "global_config",
-    "block_mesh_config", 
-    "control_config",
-    "turbulence_config",
-]
+"""
+Configuration files for OpenFOAM case setup.
+
+This module provides configuration files for different aspects of
+OpenFOAM case setup, including geometry, control, and turbulence settings.
+Each config file contains detailed comments explaining all parameters.
+
+Usage:
+    from pycphy.foamCaseDeveloper.config import global_config
+    from pycphy.foamCaseDeveloper.config import block_mesh_config
+    from pycphy.foamCaseDeveloper.config import control_config
+    from pycphy.foamCaseDeveloper.config import turbulence_config
+"""
+
+# Import all config modules
+from . import global_config
+from . import config_hfdibdem
+from . import cad_mesh_config
+from . import csv_boundary_reader
+
+# Import config modules from subdirectories
+from .constant import (
+    turbulence_config,
+    transport_properties_config,
+    dynamic_mesh_config,
+    gravity_field_config
+)
+
+from .system import (
+    block_mesh_config,
+    control_config,
+    fv_schemes_config,
+    fv_options_config,
+    set_fields_config,
+    decompose_par_config,
+    snappy_hex_mesh_config
+)
+
+from .zero import (
+    p_config,
+    U_config,
+    f_config,
+    lambda_config
+)
+
+__all__ = [
+    "global_config",
+    "config_hfdibdem",
+    "cad_mesh_config",
+    "csv_boundary_reader",
+    # Zero directory configs
+    "p_config",
+    "U_config",
+    "f_config",
+    "lambda_config",
+    # Constant directory configs
+    "turbulence_config",
+    "transport_properties_config",
+    "dynamic_mesh_config",
+    "gravity_field_config",
+    # System directory configs
+    "block_mesh_config", 
+    "control_config",
+    "fv_schemes_config",
+    "fv_options_config",
+    "set_fields_config",
+    "decompose_par_config",
+    "snappy_hex_mesh_config",
+]

pycphy/foamCaseDeveloper/config/cad_mesh_config.py

@@ -0,0 +1,62 @@
+"""
+Configuration classes for CAD-based mesh generation.
+"""
+
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class BlockParameter:
+    """Configuration for a single block in the mesh."""
+    block_id: str
+    cells_x: int
+    cells_y: int
+    cells_z: int
+    grading: str
+    description: Optional[str] = None
+
+
+@dataclass
+class PatchParameter:
+    """Configuration for a patch boundary condition."""
+    region_name: str
+    patch_name: str
+    patch_type: str
+
+
+@dataclass
+class CADMeshConfig:
+    """Configuration for CAD-based mesh generation."""
+    
+    # File paths
+    blocks_csv_file: str = "Inputs/blocks.csv"
+    patches_csv_file: str = "Inputs/patches.csv"
+    output_path: str = "system/blockMeshDict"
+    
+    # XData configuration
+    block_xdata_app_name: str = "BLOCKDATA"
+    region_xdata_app_name: str = "REGIONDATA"
+    
+    # Processing parameters
+    tolerance: float = 1e-6
+    
+    # Mesh parameters
+    scale: float = 1.0
+    
+    # Block parameters (can be loaded from CSV or set directly)
+    block_parameters: Optional[Dict[str, BlockParameter]] = None
+    
+    # Patch parameters (can be loaded from CSV or set directly)
+    patch_parameters: Optional[Dict[str, PatchParameter]] = None
+    
+    def __post_init__(self):
+        """Initialize default values after dataclass creation."""
+        if self.block_parameters is None:
+            self.block_parameters = {}
+        if self.patch_parameters is None:
+            self.patch_parameters = {}
+
+
+# Default configuration instance
+default_cad_mesh_config = CADMeshConfig()

pycphy/foamCaseDeveloper/config/config_hfdibdem.py

@@ -0,0 +1,193 @@
+# config_hfdibdem.py
+
+# =============================================================================
+#           *** User Input for HFDIBDEMDict ***
+# =============================================================================
+
+# --- Master Control ---
+# Set to True to write 'constant/HFDIBDEMDict'.
+WRITE_HFDIBDEM_DICT = True
+
+
+# =============================================================================
+# --- 1. Global Simulation Settings ---
+# =============================================================================
+GLOBAL_SETTINGS = {
+    # `interpolationSchemes`: How fields are interpolated from mesh to IB points.
+    "interpolationSchemes": {
+        "U": "cell",         # Options: 'cell', 'cellPointFace'
+        # "method": "line"   # Optional, for some schemes
+    },
+
+    # `surfaceThreshold`: VOF value defining the fluid/solid interface.
+    "surfaceThreshold": 1e-4,
+
+    # `stepDEM`: Time step for the DEM solver. Usually smaller than fluid deltaT.
+    "stepDEM": 0.01,
+
+    # `geometricD`: Directions considered for collision (1=active, 0=ignore, -1=2D).
+    # e.g., (1 1 -1) for a 2D simulation in XY plane.
+    "geometricD": (1, 1, 1),
+
+    # `recordSimulation`: Master switch to save IB/DEM data.
+    "recordSimulation": True,
+    "recordFirstTimeStep": False,
+
+    # `nSolidsInDomain`: Max limit on particles. Optional, defaults to 1000 if omitted.
+    "nSolidsInDomain": 5000,
+
+    # `outputSetup`: Fine-grained control over what data is written.
+    "outputSetup": {
+        "basic": False,
+        "iB": False,        # Immersed Boundary data
+        "DEM": False,       # Discrete Element Method data
+        "addModel": False,  # Particle insertion data
+        "parallelDEM": False
+    }
+}
+
+# `virtualMesh`: Settings for the background mesh used for particle tracking.
+VIRTUAL_MESH_SETTINGS = {
+    "level": 4,                 # Refinement level of the virtual mesh.
+    "charCellSize": 0.001,      # Characteristic cell size.
+    "recordContact": False      # Record particle-particle/wall contacts.
+}
+
+
+# =============================================================================
+# --- 2. DEM Physics & Environment ---
+# =============================================================================
+DEM_SETTINGS = {
+    "LcCoeff": 4.0, # Collision length scale coefficient.
+    
+    # Optional rotation model (e.g., 'chen2012', 'mindlin1953'). Uncomment to use.
+    # "rotationModel": "chen2012", 
+
+    # `materials`: Material properties for particles and walls.
+    "materials": {
+        "particleMat1": {
+            "Y": 5e8,       # Young's Modulus (Pa)
+            "nu": 0.5,      # Poisson's Ratio
+            "mu": 1.0,      # Friction Coefficient
+            "adhN": 0,      # Normal Adhesion Energy
+            "eps": 0.75     # Coefficient of Restitution
+        },
+        "wallMat": {
+            "Y": 1e10, "nu": 0.5, "mu": 1.0, "adhN": 0, "eps": 0.75
+        }
+    },
+
+    # `collisionPatches`: planar walls defined by normal & point.
+    "collisionPatches": {
+        "floor": {
+            "material": "wallMat", # Must match a name in 'materials'
+            "nVec": (0, 1.0, 0),   # Normal vector pointing INTO domain
+            "planePoint": (0, 0, 0)
+        },
+        # Add more walls as needed (e.g., ceiling, side walls)
+        # "ceiling": { ... }
+    },
+    
+    # `cyclicPatches`: For periodic boundaries in DEM.
+    "cyclicPatches": {
+        # "outlet": {
+        #     "material": "wallMat",
+        #     "nVec": (0, -1, 0),
+        #     "planePoint": (0, -0.1, 0),
+        #     "neighbourPatch": "inlet"
+        # },
+        # "inlet": { ... neighbourPatch "outlet" ... }
+    }
+}
+
+
+# =============================================================================
+# --- 3. Body Definitions (The "Library" of Bodies) ---
+# =============================================================================
+# Define all potential bodies here. You select which ones to use below.
+AVAILABLE_BODIES = {
+    # --- Example A: A single falling sphere ---
+    "singleFallingSphere": {
+        # Body Type: 'fullyCoupledBody', 'staticBody', 'prescribedTransRotBody'
+        "fullyCoupledBody": {
+            "velocity": (0, -1.0, 0) # Initial velocity
+        },
+        
+        # Properties with units defined explicitly in the string
+        "rho": "rho [1 -3 0 0 0 0 0] 2500", # Density kg/m^3
+        "refineMC": 5,                      # Marching Cubes refinement
+        "U": {"BC": "noSlip"},              # Boundary Condition on body surface
+        "material": "particleMat1",         # Link to DEM.materials
+        "updateTorque": True,
+
+        # Geometry definition
+        "bodyGeom": "sphere", # 'sphere', 'convex', 'nonConvex'
+        "sphere": {
+            "radius": 0.04,
+            "startPosition": (0, 0.2, 0)
+        },
+
+        # Particle insertion model
+        "bodyAddition": {
+            "addModel": "once", # 'once', 'onceScatter', 'distribution'
+            "onceCoeffs": {}    # No extra coeffs for simple 'once'
+        },
+        
+        "timesToSetStatic": -1 # -1 = never become static
+    },
+
+    # --- Example B: A cloud of particles ("onceScatter") ---
+    "particleCloud": {
+        "fullyCoupledBody": {}, # Zero initial velocity
+        "rho": "rho [1 -3 0 0 0 0 0] 4000",
+        "material": "particleMat1",
+        
+        # For complex shapes read from STL (implied by nonConvex/convex)
+        "bodyGeom": "convex", 
+
+        "bodyAddition": {
+            "addModel": "onceScatter",
+            "onceScatterCoeffs": {
+                "addMode": "fieldBased", # Insert based on a field value (e.g. VOF)
+                "fieldBasedCoeffs": {
+                    "fieldName": "lambda", # The field name
+                    "fieldValue": 0.3      # Threshold value
+                },
+                "addDomain": "boundBox",   # Region to insert into
+                "boundBoxCoeffs": {
+                    "minBound": (-0.1, 0.0, -0.1),
+                    "maxBound": ( 0.1, 0.5,  0.1)
+                },
+                "scalingMode": "noScaling", "noScalingCoeffs": {},
+                "rotationMode": "randomRotation", "randomRotationCoeffs": {}
+            }
+        },
+        "nParticles": 500, # Optional hint, sometimes used by the solver
+        "timesToSetStatic": 1500 # Become static after this many steps
+    },
+    
+    # --- Example C: A prescribed motion rotor ---
+    "rotor": {
+        "prescribedTransRotBody": {
+            "velocity": (0,0,0),
+            "axis": (0, 1, 0), # Y-axis rotation
+            "omega": 50.0      # Rad/s
+        },
+        "rho": "rho [1 -3 0 0 0 0 0] 1000",
+        "material": "wallMat", # Acts like a moving wall
+        "bodyGeom": "nonConvex", # Read from STL (e.g., rotor.stl)
+        "bodyAddition": { "addModel": "once", "onceCoeffs": {} }
+    }
+}
+
+
+# =============================================================================
+# --- 4. Case Selection ---
+# =============================================================================
+# Select which bodies from AVAILABLE_BODIES to include in this simulation.
+# The names here MUST exist as keys in the AVAILABLE_BODIES dictionary above.
+SELECTED_BODY_NAMES = [
+    "singleFallingSphere",
+    # "particleCloud",
+    # "rotor"
+]

pycphy/foamCaseDeveloper/config/constant/__init__.py

@@ -0,0 +1,23 @@
+# constant/__init__.py
+"""
+Constant directory configuration modules.
+
+This package contains configuration modules for OpenFOAM constant directory files:
+- turbulenceProperties
+- transportProperties  
+- dynamicMeshDict
+- gravity field (g)
+- HFDIBDEMDict
+"""
+
+from . import turbulence_config
+from . import transport_properties_config
+from . import dynamic_mesh_config
+from . import gravity_field_config
+
+__all__ = [
+    'turbulence_config',
+    'transport_properties_config', 
+    'dynamic_mesh_config',
+    'gravity_field_config'
+]

pycphy/foamCaseDeveloper/config/constant/dynamic_mesh_config.py

@@ -0,0 +1,208 @@
+# config_dynamic_mesh.py
+
+# =============================================================================
+#           *** User Input for dynamicMeshDict ***
+# =============================================================================
+
+# --- Master Control ---
+# Set this to True to include a dynamicMeshDict in the case setup,
+# or False to skip it for a static mesh simulation.
+WRITE_DYNAMIC_MESH_DICT = True
+
+# --- Mesh Type Selection ---
+# Choose the type of dynamic mesh behavior you want to configure.
+# The selected dictionary below will be written to the file.
+# Options:
+#   "solidBodyMotion": For rigid body motion of a mesh zone (e.g., rotating fan).
+#   "multiBodyOverset": For overset meshes with multiple moving bodies.
+#   "adaptiveRefinement": For Adaptive Mesh Refinement (AMR) based on a field.
+#   "morphingMesh": For deforming mesh using splines (e.g., shape optimization).
+MESH_TYPE = "solidBodyMotion"
+
+
+# =============================================================================
+#           *** Pre-configured Mesh Property Dictionaries ***
+# =============================================================================
+
+# --- 1. Solid Body Motion ---
+# Use this for cases where a part of the mesh moves as a rigid body without deforming,
+# such as a propeller, fan, or stirrer.
+SOLID_BODY_MOTION_PROPS = {
+    # `dynamicFvMesh`: The top-level dynamic mesh class.
+    #   Options:
+    #     'dynamicMotionSolverFvMesh': The standard choice for mesh motion or deformation
+    #                                  driven by a specified motion solver.
+    "dynamicFvMesh": "dynamicMotionSolverFvMesh",
+
+    # `solver`: The specific type of motion solver.
+    #   Options:
+    #     'solidBody': Moves a specified cellZone as a rigid body. Mesh does not deform.
+    #     'displacementLaplacian': A common choice for deforming meshes where boundary
+    #                              motion is propagated through the mesh by solving a
+    #                              Laplacian equation for diffusivity.
+    #     'velocityComponentLaplacian': Similar, but solves for velocity instead of displacement.
+    "solver": "solidBody",
+
+    # `solidBodyCoeffs`: A sub-dictionary containing settings for the `solidBody` solver.
+    "solidBodyCoeffs": {
+        # `cellZone`: The name of the cell zone in the mesh that will move.
+        # This zone must be defined during meshing (e.g., in blockMeshDict or snappyHexMesh).
+        "cellZone": "rotatingZone",
+
+        # `solidBodyMotionFunction`: The type of rigid motion to apply.
+        #   Options:
+        #     'rotatingMotion': Pure rotation around an axis.
+        #     'linearMotion': Constant velocity translation.
+        #     'oscillatingLinearMotion': Sinusoidal back-and-forth linear movement.
+        #     'oscillatingRotatingMotion': Sinusoidal rocking/pitching motion.
+        #     'tabulated6DoFMotion': Reads 6-DoF motion (translation/rotation) from an
+        #                            external text file. Very powerful for complex prescribed motions.
+        #     'multiMotion': Allows for combining multiple motion functions.
+        "solidBodyMotionFunction": "rotatingMotion",
+
+        # `rotatingMotionCoeffs`: Sub-dictionary for the chosen motion function.
+        # Each motion function has its own `...Coeffs` dictionary.
+        "rotatingMotionCoeffs": {
+            # `origin`: The center of rotation as a vector (x y z).
+            "origin": (0, 0, 0),
+            # `axis`: The axis of rotation as a vector (x y z). Does not need to be a unit vector.
+            "axis": (0, 0, 1),
+            # `omega`: The rotational speed in radians per second. Can be a number, or a Foam::DataEntry.
+            "omega": 10.5
+        }
+    }
+}
+
+# --- 2. Multi-Body Overset Motion ---
+# Use this for overset (or Chimera) meshes where multiple independent bodies
+# move through a background mesh.
+MULTI_BODY_OVERSET_PROPS = {
+    # `dynamicFvMesh`: The required class for overset functionality.
+    #   Options:
+    #     'dynamicOversetFvMesh': For cases where the overset components move.
+    #     'staticOversetFvMesh': For cases where overset zones are stationary,
+    #                            but mesh connectivity still needs to be computed.
+    "dynamicFvMesh": "dynamicOversetFvMesh",
+
+    # `solver`: The motion solver.
+    #   Options:
+    #     'multiSolidBodyMotionSolver': Handles the motion of one or more named bodies,
+    #                                   each with its own motion function. Ideal for complex scenes.
+    #     'solidBody': Can be used if only a single overset zone is moving.
+    #     'displacementLaplacian': Can be used to deform the overset mesh component.
+    "solver": "multiSolidBodyMotionSolver",
+
+    # `multiSolidBodyMotionSolverCoeffs`: Sub-dictionary defining each moving body.
+    "multiSolidBodyMotionSolverCoeffs": {
+        # Each entry in this dictionary is a separate moving body. The key name
+        # ('movingZone1', 'propeller', etc.) must match a cellZone in the mesh.
+        "movingZone1": {
+            # `solidBodyMotionFunction`: See the list of functions in the SOLID_BODY_MOTION section.
+            "solidBodyMotionFunction": "oscillatingLinearMotion",
+            "oscillatingLinearMotionCoeffs": {
+                "amplitude": (0.035, 0, 0),
+                "omega": 2.094
+            }
+        },
+        "movingZone2": {
+            "solidBodyMotionFunction": "rotatingMotion",
+            "rotatingMotionCoeffs": {
+                "origin": (0.1, 0, 0),
+                "axis": (0, 0, 1),
+                "omega": -50.0
+            }
+        }
+    }
+}
+
+# --- 3. Adaptive Mesh Refinement (AMR) ---
+# Use this to automatically refine and unrefine the mesh in specific regions
+# during the simulation, based on a scalar field.
+ADAPTIVE_REFINEMENT_PROPS = {
+    # `dynamicFvMesh`: The required class for AMR.
+    "dynamicFvMesh": "dynamicRefineFvMesh",
+
+    # `refineInterval`: How often (in number of time steps) the refinement criteria are checked.
+    #   A value of 1 checks every time step. Larger values are more efficient but less responsive.
+    "refineInterval": 1,
+
+    # `field`: The name of the volScalarField that will drive the refinement. This field
+    #          must exist in your case.
+    #   Examples: 'alpha.water' (for VOF free surface), 'p' (pressure), 'magU' (velocity magnitude),
+    #             a custom field calculated with functionObjects.
+    "field": "alpha.water",
+
+    # `lowerRefineLevel`: If the field value in a cell is below this, the
+    #                     cell and its neighbors will be considered for un-refinement (coarsening).
+    "lowerRefineLevel": 0.001,
+
+    # `upperRefineLevel`: If the field value in a cell is above this, the
+    #                     cell will be flagged for refinement (splitting).
+    "upperRefineLevel": 0.999,
+
+    # `unrefineLevel`: A tolerance used during the un-refinement (coarsening) step.
+    #                  Cells marked for coarsening will only be merged if the field value difference
+    #                  between them is small. This prevents coarsening across sharp gradients.
+    "unrefineLevel": 0.0001,
+
+    # `nBufferLayers`: Number of extra cell layers to keep refined around the primary refinement zone.
+    #                  This is crucial for stability, preventing refinement/unrefinement from
+    #                  happening right at a sharp interface.
+    "nBufferLayers": 2,
+
+    # `maxRefinement`: The maximum number of times an initial grid cell can be split.
+    #   Level 0 = no refinement. Level 1 = split once. Level 2 = split twice (1 cell -> 8 in 3D).
+    "maxRefinement": 2,
+
+    # `maxCells`: An approximate hard limit on the total number of cells to prevent
+    #             runaway refinement from using all available memory.
+    "maxCells": 200000,
+
+    # `correctFluxes`: A list of surfaceScalarFields (fluxes) that need to be corrected
+    #                  when cell faces are created or destroyed by AMR. This is critical
+    #                  for conservation. The format is a list of lists.
+    "correctFluxes": [("phi", "U"), ("phi_0", "none")]
+}
+
+
+# --- 4. Morphing Mesh (Volumetric B-Splines) ---
+# Use for cases where the mesh deforms smoothly, often for shape optimization
+# or simulating structural deformation.
+MORPHING_MESH_PROPS = {
+    # `solver`: The motion solver for mesh deformation.
+    #   Options:
+    #     'volumetricBSplinesMotionSolver': A powerful and smooth morphing tool based on a
+    #                                       control-point lattice.
+    #     'laplacianMotionSolver': A simpler morphing solver based on solving a Laplacian
+    #                              equation for mesh displacement.
+    "solver": "volumetricBSplinesMotionSolver",
+
+    # `volumetricBSplinesMotionSolverCoeffs`: Sub-dictionary for the B-splines solver.
+    "volumetricBSplinesMotionSolverCoeffs": {
+        # Each entry is a named "control point volume" that controls a region of the mesh.
+        "airfoil": {
+            # `type`: The coordinate system for the control points.
+            #   Options: 'cartesian', 'cylindrical'.
+            "type": "cartesian",
+            # `nCPsU/V/W`: Number of control points in each direction (U,V,W map to X,Y,Z for cartesian).
+            "nCPsU": 6,
+            "nCPsV": 4,
+            "nCPsW": 3,
+            # `degreeU/V/W`: The polynomial degree of the spline curves. Higher degrees are smoother.
+            "degreeU": 3,
+            "degreeV": 3,
+            "degreeW": 2,
+            # `controlPointsDefinition`: How the initial control point positions are defined.
+            #   Options:
+            #     'axisAligned': Automatically creates a grid of points within the bounds below.
+            #     'fromFile': Reads control point coordinates from a file.
+            "controlPointsDefinition": "axisAligned",
+            # `lowerCpBounds`/`upperCpBounds`: The bounding box for the 'axisAligned' control points.
+            "lowerCpBounds": (0.1, -0.25, -0.1),
+            "upperCpBounds": (0.9, 0.25, 1.1),
+            # `confine...`: Boolean flags to restrict movement of control points.
+            "confineWMovement": "true",
+            "confineBoundaryControlPoints": "true",
+        }
+    }
+}