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

pycphy/foamCaseDeveloper/writers/system/fv_options_writer.py

@@ -0,0 +1,188 @@
+# fv_options_writer.py
+
+"""
+Finite Volume Options Writer for OpenFOAM cases.
+
+This writer handles the creation of fvOptions files with support for various
+source terms, constraints, and modifications including momentum, thermal,
+species, turbulence, and pressure sources.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class FvOptionsWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM fvOptions file.
+    
+    This writer supports comprehensive finite volume source terms and constraints
+    for various simulation types including momentum, thermal, species, and 
+    multiphase flow simulations.
+    """
+
+    def __init__(self, file_path, momentum_sources=None, thermal_sources=None,
+                 species_sources=None, turbulence_sources=None, pressure_sources=None,
+                 volume_fraction_sources=None, advanced_sources=None):
+        """
+        Initialize the FvOptionsWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'fvOptions'.
+            momentum_sources (dict, optional): Momentum sources configuration.
+            thermal_sources (dict, optional): Thermal sources configuration.
+            species_sources (dict, optional): Species sources configuration.
+            turbulence_sources (dict, optional): Turbulence sources configuration.
+            pressure_sources (dict, optional): Pressure sources configuration.
+            volume_fraction_sources (dict, optional): Volume fraction sources configuration.
+            advanced_sources (dict, optional): Advanced sources configuration.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="fvOptions")
+        self.momentum_sources = momentum_sources or {}
+        self.thermal_sources = thermal_sources or {}
+        self.species_sources = species_sources or {}
+        self.turbulence_sources = turbulence_sources or {}
+        self.pressure_sources = pressure_sources or {}
+        self.volume_fraction_sources = volume_fraction_sources or {}
+        self.advanced_sources = advanced_sources or {}
+    
+    def validate_sources(self):
+        """
+        Validate the sources configuration.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        valid = True
+        
+        # Validate momentum sources
+        if self.momentum_sources.get('enabled', False):
+            sources = self.momentum_sources.get('sources', [])
+            for source in sources:
+                if 'type' not in source or 'fields' not in source:
+                    print(f"Warning: Momentum source missing required fields: {source.get('name', 'unnamed')}")
+                    valid = False
+        
+        # Validate thermal sources
+        if self.thermal_sources.get('enabled', False):
+            sources = self.thermal_sources.get('sources', [])
+            for source in sources:
+                if 'type' not in source or 'fields' not in source:
+                    print(f"Warning: Thermal source missing required fields: {source.get('name', 'unnamed')}")
+                    valid = False
+        
+        # Validate species sources
+        if self.species_sources.get('enabled', False):
+            sources = self.species_sources.get('sources', [])
+            for source in sources:
+                if 'type' not in source or 'fields' not in source:
+                    print(f"Warning: Species source missing required fields: {source.get('name', 'unnamed')}")
+                    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_source_section(self, section_name, sources_dict):
+        """
+        Write a source section (momentum sources, thermal sources, etc.).
+
+        Args:
+            section_name (str): Name of the source section.
+            sources_dict (dict): Dictionary containing source configurations.
+        """
+        if not sources_dict.get('enabled', False):
+            return
+            
+        sources = sources_dict.get('sources', [])
+        if not sources:
+            return
+            
+        for source in sources:
+            source_name = source.get('name', 'unnamed')
+            self.file_handle.write(f"{source_name}\n")
+            self.file_handle.write("{\n")
+            
+            # Write source properties
+            for key, value in source.items():
+                if key != 'name':
+                    if isinstance(value, dict):
+                        self.file_handle.write(f"    {key}\n")
+                        self.file_handle.write("    {\n")
+                        self._write_dict_recursively(value, indent_level=2)
+                        self.file_handle.write("    }\n")
+                    elif isinstance(value, (list, tuple)):
+                        if isinstance(value, list) and value and isinstance(value[0], str):
+                            val_str = ' '.join([f'"{v}"' for v in value])
+                        else:
+                            val_str = ' '.join(map(str, value))
+                        self.file_handle.write(f"    {key:<20} ({val_str});\n")
+                    elif isinstance(value, bool):
+                        val_str = "true" if value else "false"
+                        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\n")
+
+    def _write_properties(self):
+        """Writes the main content of the fvOptions file."""
+        self._write_source_section("Momentum Sources", self.momentum_sources)
+        self._write_source_section("Thermal Sources", self.thermal_sources)
+        self._write_source_section("Species Sources", self.species_sources)
+        self._write_source_section("Turbulence Sources", self.turbulence_sources)
+        self._write_source_section("Pressure Sources", self.pressure_sources)
+        self._write_source_section("Volume Fraction Sources", self.volume_fraction_sources)
+        self._write_source_section("Advanced Sources", self.advanced_sources)
+
+    def write(self):
+        """
+        Writes the complete fvOptions file.
+        """
+        print(f"Writing fvOptions 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/system/fv_schemes_writer.py

@@ -0,0 +1,155 @@
+# fv_schemes_writer.py
+
+"""
+Finite Volume Schemes Writer for OpenFOAM cases.
+
+This writer handles the creation of fvSchemes files with support for various
+discretization schemes for time derivatives, gradients, divergence, Laplacian,
+interpolation, and surface normal gradients.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class FvSchemesWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM fvSchemes file.
+    
+    This writer supports comprehensive finite volume discretization schemes
+    for various simulation types including laminar, turbulent, and multiphase flows.
+    """
+
+    def __init__(self, file_path, ddt_schemes, grad_schemes, div_schemes, 
+                 laplacian_schemes, interpolation_schemes, sn_grad_schemes,
+                 flux_required=None):
+        """
+        Initialize the FvSchemesWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'fvSchemes'.
+            ddt_schemes (dict): Time derivative schemes configuration.
+            grad_schemes (dict): Gradient schemes configuration.
+            div_schemes (dict): Divergence schemes configuration.
+            laplacian_schemes (dict): Laplacian schemes configuration.
+            interpolation_schemes (dict): Interpolation schemes configuration.
+            sn_grad_schemes (dict): Surface normal gradient schemes configuration.
+            flux_required (dict, optional): Flux required schemes configuration.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="fvSchemes")
+        self.ddt_schemes = ddt_schemes
+        self.grad_schemes = grad_schemes
+        self.div_schemes = div_schemes
+        self.laplacian_schemes = laplacian_schemes
+        self.interpolation_schemes = interpolation_schemes
+        self.sn_grad_schemes = sn_grad_schemes
+        self.flux_required = flux_required or {}
+    
+    def validate_schemes(self):
+        """
+        Validate the schemes configuration.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        valid = True
+        
+        # Validate ddt schemes
+        valid_ddt = ['Euler', 'backward', 'CrankNicolson', 'localEuler', 
+                    'steadyState', 'localSteadyState']
+        if self.ddt_schemes.get('default') not in valid_ddt:
+            print(f"Warning: Invalid ddt scheme '{self.ddt_schemes.get('default')}'")
+            valid = False
+        
+        # Validate grad schemes
+        valid_grad = ['Gauss linear', 'Gauss linearUpwind', 'Gauss linearUpwind grad',
+                     'Gauss pointCellsLeastSquares', 'Gauss cellMDLimited', 
+                     'Gauss faceMDLimited', 'leastSquares']
+        if self.grad_schemes.get('default') not in valid_grad:
+            print(f"Warning: Invalid grad scheme '{self.grad_schemes.get('default')}'")
+            valid = False
+        
+        # Validate laplacian schemes
+        valid_laplacian = ['Gauss linear', 'Gauss linear corrected', 'Gauss linear limited',
+                          'Gauss linear limited corrected', 'Gauss linear uncorrected',
+                          'Gauss linear orthogonal']
+        if self.laplacian_schemes.get('default') not in valid_laplacian:
+            print(f"Warning: Invalid laplacian scheme '{self.laplacian_schemes.get('default')}'")
+            valid = False
+        
+        # Validate interpolation schemes
+        valid_interpolation = ['linear', 'linearUpwind', 'skewCorrected linear', 'cubic',
+                              'upwind', 'midPoint', 'harmonic', 'pointCellsLeastSquares']
+        if self.interpolation_schemes.get('default') not in valid_interpolation:
+            print(f"Warning: Invalid interpolation scheme '{self.interpolation_schemes.get('default')}'")
+            valid = False
+        
+        # Validate snGrad schemes
+        valid_sn_grad = ['corrected', 'uncorrected', 'limited', 'orthogonal', 'limited corrected']
+        if self.sn_grad_schemes.get('default') not in valid_sn_grad:
+            print(f"Warning: Invalid snGrad scheme '{self.sn_grad_schemes.get('default')}'")
+            valid = False
+        
+        return valid
+    
+    def _write_scheme_section(self, section_name, schemes_dict):
+        """
+        Write a scheme section (ddtSchemes, gradSchemes, etc.).
+
+        Args:
+            section_name (str): Name of the scheme section.
+            schemes_dict (dict): Dictionary containing scheme configurations.
+        """
+        self.file_handle.write(f"{section_name}\n")
+        self.file_handle.write("{\n")
+        
+        # Write default scheme
+        default_scheme = schemes_dict.get('default', 'none')
+        self.file_handle.write(f"    default         {default_scheme};\n")
+        
+        # Write field-specific schemes
+        field_specific = schemes_dict.get('fieldSpecific', {})
+        for field, scheme in field_specific.items():
+            self.file_handle.write(f"    {field:<20} {scheme};\n")
+        
+        self.file_handle.write("}\n\n")
+
+    def _write_flux_required(self):
+        """Write fluxRequired section if enabled."""
+        if not self.flux_required.get('enabled', False):
+            return
+            
+        self.file_handle.write("fluxRequired\n")
+        self.file_handle.write("{\n")
+        
+        fields = self.flux_required.get('fields', [])
+        for field in fields:
+            self.file_handle.write(f"    {field};\n")
+        
+        self.file_handle.write("}\n\n")
+
+    def _write_properties(self):
+        """Writes the main content of the fvSchemes file."""
+        self._write_scheme_section("ddtSchemes", self.ddt_schemes)
+        self._write_scheme_section("gradSchemes", self.grad_schemes)
+        self._write_scheme_section("divSchemes", self.div_schemes)
+        self._write_scheme_section("laplacianSchemes", self.laplacian_schemes)
+        self._write_scheme_section("interpolationSchemes", self.interpolation_schemes)
+        self._write_scheme_section("snGradSchemes", self.sn_grad_schemes)
+        self._write_flux_required()
+
+    def write(self):
+        """
+        Writes the complete fvSchemes file.
+        """
+        print(f"Writing fvSchemes 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/system/set_fields_writer.py

@@ -0,0 +1,191 @@
+# set_fields_writer.py
+
+"""
+Set Fields Writer for OpenFOAM cases.
+
+This writer handles the creation of setFieldsDict files with support for
+initializing field values in specific regions of the domain including
+cell sets, cell zones, and geometric regions.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class SetFieldsWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM setFieldsDict file.
+    
+    This writer supports comprehensive field initialization for various
+    simulation types including multiphase flows, turbulent flows, heat transfer,
+    and species transport.
+    """
+
+    def __init__(self, file_path, default_field_values=None, regions=None):
+        """
+        Initialize the SetFieldsWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'setFieldsDict'.
+            default_field_values (dict, optional): Default field values configuration.
+            regions (dict, optional): Regions configuration.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="setFieldsDict")
+        self.default_field_values = default_field_values or {}
+        self.regions = regions or {}
+    
+    def validate_field_values(self):
+        """
+        Validate the field values configuration.
+        
+        Returns:
+            bool: True if validation passes, False otherwise.
+        """
+        valid = True
+        
+        # Validate default field values
+        if self.default_field_values:
+            fields = self.default_field_values.get('fields', [])
+            for field in fields:
+                if 'type' not in field or 'field' not in field or 'value' not in field:
+                    print(f"Warning: Default field value missing required fields: {field}")
+                    valid = False
+        
+        # Validate regions
+        if self.regions:
+            regions_list = self.regions.get('regions', [])
+            for region in regions_list:
+                if 'type' not in region or 'fieldValues' not in region:
+                    print(f"Warning: Region missing required fields: {region.get('name', 'unnamed')}")
+                    valid = False
+                
+                # Validate field values in region
+                field_values = region.get('fieldValues', [])
+                for field_value in field_values:
+                    if 'type' not in field_value or 'field' not in field_value or 'value' not in field_value:
+                        print(f"Warning: Field value in region missing required fields: {field_value}")
+                        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_field_value(self, field_value):
+        """
+        Write a single field value entry.
+
+        Args:
+            field_value (dict): Field value configuration.
+        """
+        field_type = field_value.get('type', 'volScalarFieldValue')
+        field_name = field_value.get('field', 'unknown')
+        field_value_val = field_value.get('value', 0.0)
+        
+        self.file_handle.write(f"    {field_type:<25} {field_name:<15} {field_value_val};\n")
+
+    def _write_default_field_values(self):
+        """Write default field values section."""
+        if not self.default_field_values:
+            return
+            
+        fields = self.default_field_values.get('fields', [])
+        if not fields:
+            return
+            
+        self.file_handle.write("defaultFieldValues\n")
+        self.file_handle.write("(\n")
+        
+        for field in fields:
+            self._write_field_value(field)
+        
+        self.file_handle.write(")\n\n")
+
+    def _write_regions(self):
+        """Write regions section."""
+        if not self.regions:
+            return
+            
+        regions_list = self.regions.get('regions', [])
+        if not regions_list:
+            return
+            
+        self.file_handle.write("regions\n")
+        self.file_handle.write("(\n")
+        
+        for region in regions_list:
+            region_name = region.get('name', 'unnamed')
+            region_type = region.get('type', 'cellToCell')
+            region_set = region.get('set', 'unknown')
+            field_values = region.get('fieldValues', [])
+            
+            self.file_handle.write(f"    // {region_name}\n")
+            self.file_handle.write(f"    {region_type}\n")
+            self.file_handle.write("    {\n")
+            self.file_handle.write(f"        set {region_set};\n\n")
+            self.file_handle.write("        fieldValues\n")
+            self.file_handle.write("        (\n")
+            
+            for field_value in field_values:
+                self._write_field_value(field_value)
+            
+            self.file_handle.write("        );\n")
+            self.file_handle.write("    }\n\n")
+        
+        self.file_handle.write(")\n\n")
+
+    def _write_properties(self):
+        """Writes the main content of the setFieldsDict file."""
+        self._write_default_field_values()
+        self._write_regions()
+
+    def write(self):
+        """
+        Writes the complete setFieldsDict file.
+        """
+        print(f"Writing setFieldsDict 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/system/snappy_hex_mesh_writer.py

@@ -0,0 +1,123 @@
+# snappy_hex_mesh_writer.py
+
+import os
+from typing import Dict, Any, List, Optional
+from ..foam_writer import FoamWriter
+
+class SnappyHexMeshWriter(FoamWriter):
+    """
+    A writer class for OpenFOAM 'snappyHexMeshDict' files.
+    Handles complex mesh generation with geometry snapping and boundary layers.
+    """
+
+    def __init__(self, file_path: str, geometry: Dict[str, Any],
+                 castellated_mesh_controls: Dict[str, Any],
+                 snap_controls: Dict[str, Any],
+                 add_layers_controls: Optional[Dict[str, Any]] = None,
+                 mesh_quality_controls: Optional[Dict[str, Any]] = None,
+                 merged_patches: Optional[List[str]] = None,
+                 write_flags: Optional[Dict[str, Any]] = None):
+        """
+        Initializes the SnappyHexMeshWriter.
+
+        Args:
+            file_path (str): The full path to the snappyHexMeshDict file.
+            geometry (Dict[str, Any]): Dictionary containing geometry definitions.
+            castellated_mesh_controls (Dict[str, Any]): Controls for initial mesh generation.
+            snap_controls (Dict[str, Any]): Controls for mesh snapping to geometry.
+            add_layers_controls (Optional[Dict[str, Any]]): Controls for boundary layer generation.
+            mesh_quality_controls (Optional[Dict[str, Any]]): Controls for mesh quality optimization.
+            merged_patches (Optional[List[str]]): List of patches to be merged.
+            write_flags (Optional[Dict[str, Any]]): Control what files are written.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="snappyHexMeshDict")
+        self.geometry = geometry
+        self.castellated_mesh_controls = castellated_mesh_controls
+        self.snap_controls = snap_controls
+        self.add_layers_controls = add_layers_controls or {}
+        self.mesh_quality_controls = mesh_quality_controls or {}
+        self.merged_patches = merged_patches or []
+        self.write_flags = write_flags or {}
+
+    def write(self) -> None:
+        """
+        Writes the snappyHexMeshDict to the specified file.
+        """
+        with open(self.file_path, 'w') as f:
+            self.file_handle = f
+            self._write_header()
+
+            # Write geometry
+            f.write("geometry\n")
+            f.write("{\n")
+            self._write_dict_recursively(f, self.geometry, indent_level=1)
+            f.write("};\n\n")
+
+            # Write castellated mesh controls
+            f.write("castellatedMeshControls\n")
+            f.write("{\n")
+            self._write_dict_recursively(f, self.castellated_mesh_controls, indent_level=1)
+            f.write("};\n\n")
+
+            # Write snap controls
+            f.write("snapControls\n")
+            f.write("{\n")
+            self._write_dict_recursively(f, self.snap_controls, indent_level=1)
+            f.write("};\n\n")
+
+            # Write add layers controls (if provided)
+            if self.add_layers_controls:
+                f.write("addLayersControls\n")
+                f.write("{\n")
+                self._write_dict_recursively(f, self.add_layers_controls, indent_level=1)
+                f.write("};\n\n")
+
+            # Write mesh quality controls
+            if self.mesh_quality_controls:
+                f.write("meshQualityControls\n")
+                f.write("{\n")
+                self._write_dict_recursively(f, self.mesh_quality_controls, indent_level=1)
+                f.write("};\n\n")
+
+            # Write merged patches (if any)
+            if self.merged_patches:
+                f.write("mergePatchPairs\n")
+                f.write("(\n")
+                for patch in self.merged_patches:
+                    f.write(f"    {patch}\n")
+                f.write(");\n\n")
+
+            # Write flags
+            if self.write_flags:
+                self._write_dict_recursively(f, self.write_flags, indent_level=0)
+
+            self._write_footer()
+
+    def _write_dict_recursively(self, f, data_dict: Dict[str, Any], indent_level: int) -> None:
+        """
+        Recursively writes dictionary contents to the file with proper indentation.
+        """
+        indent = "    " * indent_level
+        for key, value in data_dict.items():
+            if isinstance(value, dict):
+                f.write(f"{indent}{key}\n")
+                f.write(f"{indent}{{\n")
+                self._write_dict_recursively(f, value, indent_level + 1)
+                f.write(f"{indent}}}\n")
+            elif isinstance(value, (list, tuple)):
+                if isinstance(value[0], dict):
+                    # Handle list of dictionaries (e.g., features)
+                    f.write(f"{indent}{key}\n")
+                    f.write(f"{indent}(\n")
+                    for item in value:
+                        f.write(f"{indent}    {{\n")
+                        self._write_dict_recursively(f, item, indent_level + 2)
+                        f.write(f"{indent}    }}\n")
+                    f.write(f"{indent});\n")
+                else:
+                    # Handle simple lists/tuples
+                    f.write(f"{indent}{key} (")
+                    f.write(" ".join(map(str, value)))
+                    f.write(");\n")
+            else:
+                f.write(f"{indent}{key} {value};\n")

pycphy/foamCaseDeveloper/writers/zero/__init__.py

@@ -0,0 +1,24 @@
+# zero/__init__.py
+"""
+Zero directory writer modules.
+
+This package contains writer modules for OpenFOAM 0 directory field files:
+- p (pressure field)
+- U (velocity field)
+- f (force field)
+- lambda (scalar field)
+"""
+
+from . import p_field_writer
+from . import u_field_writer
+from . import f_field_writer
+from . import lambda_field_writer
+from . import zero_field_factory
+
+__all__ = [
+    'p_field_writer',
+    'u_field_writer',
+    'f_field_writer',
+    'lambda_field_writer',
+    'zero_field_factory'
+]