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

pycphy/foamCaseDeveloper/writers/constant/hfdibdem_dict_writer.py

@@ -0,0 +1,81 @@
+# hfdibdem_dict_writer.py
+
+from ..foam_writer import FoamWriter
+
+class HFDIBDEMDictWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM HFDIBDEMDict file.
+
+    Handles complex, nested structures and dynamic body definitions
+    by recursively processing a complete property dictionary.
+    """
+
+    def __init__(self, file_path, properties):
+        """
+        Initializes the HFDIBDEMDictWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'constant/HFDIBDEMDict'.
+            properties (dict): A dictionary containing the full content of the file.
+        """
+        # Note: location is "constant" for this file type.
+        super().__init__(file_path, foam_class="dictionary", foam_object="HFDIBDEMDict")
+        self.properties = properties
+
+    def _write_recursively(self, data, indent_level):
+        """
+        Recursively writes dictionary contents, handling nested dictionaries,
+        lists, and tuples (vectors/tensors).
+        """
+        indent = "    " * indent_level
+        
+        # Pre-calculate padding for neat alignment
+        keys_to_pad = [k for k, v in data.items() if not isinstance(v, dict)]
+        max_key_len = max((len(k) for k in keys_to_pad), default=0)
+
+        for key, value in data.items():
+            if isinstance(value, dict):
+                # Write a sub-dictionary
+                self.file_handle.write(f"\n{indent}{key}\n")
+                self.file_handle.write(f"{indent}{{\n")
+                self._write_recursively(value, indent_level + 1)
+                self.file_handle.write(f"{indent}}}\n")
+            elif isinstance(value, (list, tuple)):
+                # Write a list or vector: (item1 item2 ...)
+                # Check if it's a list of strings (like bodyNames) to add quotes
+                if isinstance(value, list) and value and isinstance(value[0], str):
+                    # Quote string items: ("body1" "body2")
+                    val_str = ' '.join([f'"{v}"' for v in value])
+                else:
+                    # Standard numbers/vectors: (1 0 0)
+                    val_str = ' '.join(map(str, value))
+                
+                self.file_handle.write(f"{indent}{key:<{max_key_len}} ({val_str});\n")
+            elif isinstance(value, bool):
+                # Write booleans as 'true' or 'false'
+                val_str = "true" if value else "false"
+                self.file_handle.write(f"{indent}{key:<{max_key_len}} {val_str};\n")
+            else:
+                # Write simple key-value pairs (numbers, strings with units)
+                self.file_handle.write(f"{indent}{key:<{max_key_len}} {value};\n")
+
+    def _write_properties(self):
+        """Writes the main content of the HFDIBDEMDict file."""
+        self._write_recursively(self.properties, indent_level=0)
+        
+    def write(self):
+        """Writes the complete file."""
+        print(f"Writing HFDIBDEMDict to: {self.file_path}")
+        with open(self.file_path, 'w') as f:
+            self.file_handle = f
+            # Note: This file type often has 'location "constant";' in header.
+            # The base FoamWriter handles class/object. 
+            self._write_header()
+            self._write_foamfile_dict()
+            self._write_separator()
+            
+            self._write_properties()
+
+            self._write_footer()
+        self.file_handle = None
+        print("...Done")

pycphy/foamCaseDeveloper/writers/constant/transport_properties_writer.py

@@ -0,0 +1,202 @@
+# transport_properties_writer.py
+
+"""
+Transport Properties Writer for OpenFOAM cases.
+
+This writer handles the creation of transportProperties files with support for
+Newtonian and non-Newtonian fluids, thermal properties, and species transport.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class TransportPropertiesWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM transportProperties file.
+    
+    This writer supports various transport models including Newtonian and 
+    non-Newtonian fluids, thermal properties, and species transport.
+    """
+
+    def __init__(self, file_path, transport_model, model_properties, 
+                 thermal_properties=None, species_properties=None, 
+                 advanced_properties=None):
+        """
+        Initialize the TransportPropertiesWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'transportProperties'.
+            transport_model (str): The transport model ('Newtonian', 'NonNewtonian', etc.).
+            model_properties (dict): Properties for the transport model.
+            thermal_properties (dict, optional): Thermal transport properties.
+            species_properties (dict, optional): Species transport properties.
+            advanced_properties (dict, optional): Advanced transport properties.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="transportProperties")
+        self.transport_model = transport_model
+        self.model_properties = model_properties
+        self.thermal_properties = thermal_properties or {}
+        self.species_properties = species_properties or {}
+        self.advanced_properties = advanced_properties or {}
+    
+    def validate_transport_model(self):
+        """
+        Validate the transport model.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        valid_models = [
+            'Newtonian', 'NonNewtonian', 'BirdCarreau', 'CrossPowerLaw',
+            'HerschelBulkley', 'PowerLaw', 'Casson', 'GeneralizedNewtonian'
+        ]
+        
+        if self.transport_model not in valid_models:
+            print(f"Warning: Invalid transport model '{self.transport_model}'. Valid models: {valid_models}")
+            return False
+        
+        return True
+    
+    def validate_model_properties(self):
+        """
+        Validate the model properties based on transport model.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        if self.transport_model == 'Newtonian':
+            if 'nu' not in self.model_properties:
+                print("Warning: Newtonian model requires 'nu' (kinematic viscosity)")
+                return False
+                
+        elif self.transport_model in ['NonNewtonian', 'BirdCarreau', 'CrossPowerLaw', 
+                                     'HerschelBulkley', 'PowerLaw', 'Casson']:
+            if 'nu' not in self.model_properties:
+                print("Warning: Non-Newtonian models require 'nu' (reference viscosity)")
+                return False
+                
+            if 'modelCoeffs' not in self.model_properties:
+                print("Warning: Non-Newtonian models require 'modelCoeffs'")
+                return False
+        
+        return True
+    
+    def _write_dict_recursively(self, data_dict, indent_level):
+        """
+        Recursively writes a dictionary's contents, handling nested dictionaries.
+
+        Args:
+            data_dict (dict): The dictionary to write.
+            indent_level (int): The current level of indentation.
+        """
+        indent = "    " * indent_level
+        # Calculate padding for alignment within the current dictionary level
+        max_key_len = max((len(k) for k in data_dict.keys()), default=0)
+
+        for key, value in data_dict.items():
+            if isinstance(value, dict):
+                # If the value is another dictionary, start a new block
+                self.file_handle.write(f"{indent}{key}\n")
+                self.file_handle.write(f"{indent}{{\n")
+                self._write_dict_recursively(value, indent_level + 1)
+                self.file_handle.write(f"{indent}}}\n\n")
+            elif isinstance(value, (list, tuple)):
+                # Write lists and tuples
+                if isinstance(value, list) and value and isinstance(value[0], str):
+                    # Quote string items
+                    val_str = ' '.join([f'"{v}"' for v in value])
+                else:
+                    # Standard numbers
+                    val_str = ' '.join(map(str, value))
+                
+                self.file_handle.write(f"{indent}{key:<{max_key_len}} ({val_str});\n")
+            else:
+                # Otherwise, it's a simple key-value pair
+                padded_key = f"{key:<{max_key_len}}"
+                self.file_handle.write(f"{indent}{padded_key}    {value};\n")
+
+    def _write_transport_model(self):
+        """Write the transport model configuration."""
+        self.file_handle.write(f"transportModel      {self.transport_model};\n\n")
+        
+        # Write model-specific properties
+        if self.transport_model == 'Newtonian':
+            # Write simple Newtonian properties
+            for key, value in self.model_properties.items():
+                self.file_handle.write(f"{key:<20}    {value};\n")
+                
+        elif self.transport_model in ['NonNewtonian', 'BirdCarreau', 'CrossPowerLaw', 
+                                     'HerschelBulkley', 'PowerLaw', 'Casson']:
+            # Write non-Newtonian properties
+            for key, value in self.model_properties.items():
+                if key != 'modelCoeffs':
+                    self.file_handle.write(f"{key:<20}    {value};\n")
+                else:
+                    # Write model coefficients as a sub-dictionary
+                    self.file_handle.write(f"\n{self.transport_model}Coeffs\n")
+                    self.file_handle.write("{\n")
+                    self._write_dict_recursively(value, indent_level=1)
+                    self.file_handle.write("}\n")
+        
+        self.file_handle.write("\n")
+
+    def _write_thermal_properties(self):
+        """Write thermal properties if enabled."""
+        if not self.thermal_properties.get('enableThermal', False):
+            return
+            
+        self.file_handle.write("// Thermal properties\n")
+        for key, value in self.thermal_properties.items():
+            if key != 'enableThermal':
+                self.file_handle.write(f"{key:<20}    {value};\n")
+        self.file_handle.write("\n")
+
+    def _write_species_properties(self):
+        """Write species properties if enabled."""
+        if not self.species_properties.get('enableSpecies', False):
+            return
+            
+        self.file_handle.write("// Species transport properties\n")
+        for key, value in self.species_properties.items():
+            if key != 'enableSpecies':
+                if isinstance(value, list):
+                    val_str = ' '.join(map(str, value))
+                    self.file_handle.write(f"{key:<20}    ({val_str});\n")
+                else:
+                    self.file_handle.write(f"{key:<20}    {value};\n")
+        self.file_handle.write("\n")
+
+    def _write_advanced_properties(self):
+        """Write advanced properties if enabled."""
+        if not self.advanced_properties.get('enableAdvanced', False):
+            return
+            
+        self.file_handle.write("// Advanced properties\n")
+        for key, value in self.advanced_properties.items():
+            if key != 'enableAdvanced':
+                self.file_handle.write(f"{key:<20}    {value};\n")
+        self.file_handle.write("\n")
+
+    def _write_properties(self):
+        """Writes the main content of the transportProperties file."""
+        self._write_transport_model()
+        self._write_thermal_properties()
+        self._write_species_properties()
+        self._write_advanced_properties()
+
+    def write(self):
+        """
+        Writes the complete transportProperties file.
+        """
+        print(f"Writing transportProperties to: {self.file_path}")
+        with open(self.file_path, 'w') as f:
+            self.file_handle = f
+            self._write_header()
+            self._write_foamfile_dict()
+            self._write_separator()
+            
+            self._write_properties()
+
+            self._write_footer()
+        self.file_handle = None
+        print("...Done")

pycphy/foamCaseDeveloper/writers/{turbulence_properties_writer.py → constant/turbulence_properties_writer.py}

@@ -1,6 +1,6 @@
 # turbulence_properties_writer.py
 
-from .foam_writer import FoamWriter
+from ..foam_writer import FoamWriter
 
 class TurbulencePropertiesWriter(FoamWriter):
     """
@@ -23,6 +23,54 @@ class TurbulencePropertiesWriter(FoamWriter):
         super().__init__(file_path, foam_class="dictionary", foam_object="turbulenceProperties")
         self.simulation_type = simulation_type
         self.model_properties = 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
 
     def _write_dict_recursively(self, data_dict, indent_level):
         """

pycphy/foamCaseDeveloper/writers/system/__init__.py

@@ -0,0 +1,31 @@
+# system/__init__.py
+"""
+System directory writer modules.
+
+This package contains writer modules for OpenFOAM system directory files:
+- blockMeshDict
+- controlDict
+- fvSchemes
+- fvOptions
+- setFieldsDict
+- decomposeParDict
+- snappyHexMeshDict
+"""
+
+from . import block_mesh_writer
+from . import control_dict_writer
+from . import fv_schemes_writer
+from . import fv_options_writer
+from . import set_fields_writer
+from . import decompose_par_writer
+from . import snappy_hex_mesh_writer
+
+__all__ = [
+    'block_mesh_writer',
+    'control_dict_writer',
+    'fv_schemes_writer',
+    'fv_options_writer',
+    'set_fields_writer',
+    'decompose_par_writer',
+    'snappy_hex_mesh_writer'
+]

pycphy/foamCaseDeveloper/writers/{block_mesh_writer.py → system/block_mesh_writer.py}

@@ -1,6 +1,6 @@
 # block_mesh_writer.py
 
-from .foam_writer import FoamWriter
+from ..foam_writer import FoamWriter
 
 class BlockMeshWriter(FoamWriter):
     """

pycphy/foamCaseDeveloper/writers/{control_dict_writer.py → system/control_dict_writer.py}

@@ -1,6 +1,6 @@
 # control_dict_writer.py
 
-from .foam_writer import FoamWriter
+from ..foam_writer import FoamWriter
 
 class ControlDictWriter(FoamWriter):
     """
@@ -21,6 +21,42 @@ class ControlDictWriter(FoamWriter):
         """
         super().__init__(file_path, foam_class="dictionary", foam_object="controlDict")
         self.params = 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
 
     def _write_parameters(self):
         """Writes the control parameters from the dictionary."""

pycphy/foamCaseDeveloper/writers/system/decompose_par_writer.py

@@ -0,0 +1,228 @@
+# decompose_par_writer.py
+
+"""
+Decompose Par Writer for OpenFOAM cases.
+
+This writer handles the creation of decomposeParDict files with support for
+various decomposition methods and load balancing strategies for parallel processing.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class DecomposeParWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM decomposeParDict file.
+    
+    This writer supports comprehensive decomposition configurations for various
+    simulation types and parallel processing scenarios.
+    """
+
+    def __init__(self, file_path, number_of_subdomains, method, coeffs=None, 
+                 options=None, fields=None, preserve_patches=None, 
+                 preserve_cell_zones=None, preserve_face_zones=None, 
+                 preserve_point_zones=None):
+        """
+        Initialize the DecomposeParWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'decomposeParDict'.
+            number_of_subdomains (int): Number of domains to decompose into.
+            method (str): Decomposition method.
+            coeffs (dict, optional): Decomposition coefficients.
+            options (dict, optional): Additional decomposition options.
+            fields (list, optional): Fields to decompose.
+            preserve_patches (list, optional): Patches to preserve.
+            preserve_cell_zones (list, optional): Cell zones to preserve.
+            preserve_face_zones (list, optional): Face zones to preserve.
+            preserve_point_zones (list, optional): Point zones to preserve.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="decomposeParDict")
+        self.number_of_subdomains = number_of_subdomains
+        self.method = method
+        self.coeffs = coeffs or {}
+        self.options = options or {}
+        self.fields = fields or []
+        self.preserve_patches = preserve_patches or []
+        self.preserve_cell_zones = preserve_cell_zones or []
+        self.preserve_face_zones = preserve_face_zones or []
+        self.preserve_point_zones = preserve_point_zones or []
+    
+    def validate_decomposition(self):
+        """
+        Validate the decomposition configuration.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        valid = True
+        
+        # Validate number of subdomains
+        if not isinstance(self.number_of_subdomains, int) or self.number_of_subdomains < 1:
+            print("Warning: numberOfSubdomains must be a positive integer")
+            valid = False
+        
+        # Validate method
+        valid_methods = [
+            'simple', 'hierarchical', 'scotch', 'metis', 'manual',
+            'multiLevel', 'structured', 'kahip', 'ptscotch'
+        ]
+        if self.method not in valid_methods:
+            print(f"Warning: Invalid decomposition method '{self.method}'. Valid methods: {valid_methods}")
+            valid = False
+        
+        # Validate coefficients based on method
+        if self.method == 'simple' and 'simpleCoeffs' not in self.coeffs:
+            print("Warning: Simple method requires simpleCoeffs")
+            valid = False
+        
+        if self.method == 'scotch' and 'scotchCoeffs' not in self.coeffs:
+            print("Warning: Scotch method requires scotchCoeffs")
+            valid = False
+        
+        return valid
+    
+    def _write_dict_recursively(self, data_dict, indent_level):
+        """
+        Recursively writes a dictionary's contents, handling nested dictionaries.
+
+        Args:
+            data_dict (dict): The dictionary to write.
+            indent_level (int): The current level of indentation.
+        """
+        indent = "    " * indent_level
+        # Calculate padding for alignment within the current dictionary level
+        max_key_len = max((len(k) for k in data_dict.keys()), default=0)
+
+        for key, value in data_dict.items():
+            if isinstance(value, dict):
+                # If the value is another dictionary, start a new block
+                self.file_handle.write(f"{indent}{key}\n")
+                self.file_handle.write(f"{indent}{{\n")
+                self._write_dict_recursively(value, indent_level + 1)
+                self.file_handle.write(f"{indent}}}\n\n")
+            elif isinstance(value, (list, tuple)):
+                # Write lists and tuples
+                if isinstance(value, list) and value and isinstance(value[0], str):
+                    # Quote string items
+                    val_str = ' '.join([f'"{v}"' for v in value])
+                else:
+                    # Standard numbers
+                    val_str = ' '.join(map(str, value))
+                
+                self.file_handle.write(f"{indent}{key:<{max_key_len}} ({val_str});\n")
+            elif isinstance(value, bool):
+                # Write booleans as 'true' or 'false'
+                val_str = "true" if value else "false"
+                self.file_handle.write(f"{indent}{key:<{max_key_len}} {val_str};\n")
+            else:
+                # Otherwise, it's a simple key-value pair
+                padded_key = f"{key:<{max_key_len}}"
+                self.file_handle.write(f"{indent}{padded_key}    {value};\n")
+
+    def _write_coeffs(self):
+        """Write decomposition coefficients section."""
+        if not self.coeffs:
+            return
+            
+        # Write method-specific coefficients
+        method_coeffs = self.coeffs.get(f"{self.method}Coeffs", {})
+        if method_coeffs:
+            self.file_handle.write(f"{self.method}Coeffs\n")
+            self.file_handle.write("{\n")
+            self._write_dict_recursively(method_coeffs, indent_level=1)
+            self.file_handle.write("}\n\n")
+
+    def _write_options(self):
+        """Write decomposition options section."""
+        if not self.options:
+            return
+            
+        self.file_handle.write("options\n")
+        self.file_handle.write("{\n")
+        self._write_dict_recursively(self.options, indent_level=1)
+        self.file_handle.write("}\n\n")
+
+    def _write_fields(self):
+        """Write fields section."""
+        if not self.fields:
+            return
+            
+        self.file_handle.write("fields\n")
+        self.file_handle.write("(\n")
+        
+        for field in self.fields:
+            self.file_handle.write(f'    "{field}"\n')
+        
+        self.file_handle.write(")\n\n")
+
+    def _write_preserve_sections(self):
+        """Write preserve sections."""
+        # Write preserve patches
+        if self.preserve_patches:
+            self.file_handle.write("preservePatches\n")
+            self.file_handle.write("(\n")
+            for patch in self.preserve_patches:
+                self.file_handle.write(f'    "{patch}"\n')
+            self.file_handle.write(")\n\n")
+        
+        # Write preserve cell zones
+        if self.preserve_cell_zones:
+            self.file_handle.write("preserveCellZones\n")
+            self.file_handle.write("(\n")
+            for zone in self.preserve_cell_zones:
+                self.file_handle.write(f'    "{zone}"\n')
+            self.file_handle.write(")\n\n")
+        
+        # Write preserve face zones
+        if self.preserve_face_zones:
+            self.file_handle.write("preserveFaceZones\n")
+            self.file_handle.write("(\n")
+            for zone in self.preserve_face_zones:
+                self.file_handle.write(f'    "{zone}"\n')
+            self.file_handle.write(")\n\n")
+        
+        # Write preserve point zones
+        if self.preserve_point_zones:
+            self.file_handle.write("preservePointZones\n")
+            self.file_handle.write("(\n")
+            for zone in self.preserve_point_zones:
+                self.file_handle.write(f'    "{zone}"\n')
+            self.file_handle.write(")\n\n")
+
+    def _write_properties(self):
+        """Writes the main content of the decomposeParDict file."""
+        # Write number of subdomains
+        self.file_handle.write(f"numberOfSubdomains    {self.number_of_subdomains};\n\n")
+        
+        # Write method
+        self.file_handle.write(f"method                 {self.method};\n\n")
+        
+        # Write coefficients
+        self._write_coeffs()
+        
+        # Write options
+        self._write_options()
+        
+        # Write fields
+        self._write_fields()
+        
+        # Write preserve sections
+        self._write_preserve_sections()
+
+    def write(self):
+        """
+        Writes the complete decomposeParDict file.
+        """
+        print(f"Writing decomposeParDict to: {self.file_path}")
+        with open(self.file_path, 'w') as f:
+            self.file_handle = f
+            self._write_header()
+            self._write_foamfile_dict()
+            self._write_separator()
+            
+            self._write_properties()
+
+            self._write_footer()
+        self.file_handle = None
+        print("...Done")