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

pycphy/foamCaseDeveloper/writers/zero/f_field_writer.py

@@ -0,0 +1,89 @@
+# f_field_writer.py
+
+"""
+Force Field Writer for OpenFOAM cases.
+
+This writer handles the creation of force field (f) files in the 0 directory
+with support for various body force configurations.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class FFieldWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM force field (f) file.
+    
+    This writer supports various body forces including gravity, buoyancy,
+    centrifugal, electromagnetic, and other force configurations.
+    """
+
+    def __init__(self, file_path, internal_force, boundary_conditions,
+                 force_dimensions=[0, 1, -2, 0, 0, 0, 0]):
+        """
+        Initialize the FFieldWriter.
+
+        Args:
+            file_path (str): The full path to the output file '0/f'.
+            internal_force (tuple): Internal field force vector (fx, fy, fz).
+            boundary_conditions (dict): Boundary conditions for each patch.
+            force_dimensions (list): Force field dimensions.
+        """
+        super().__init__(file_path, foam_class="volVectorField", foam_object="f")
+        self.internal_force = internal_force
+        self.boundary_conditions = boundary_conditions
+        self.force_dimensions = force_dimensions
+
+    def _write_dimensions(self):
+        """Write the dimensions section."""
+        dims_str = ' '.join(map(str, self.force_dimensions))
+        self.file_handle.write(f"dimensions      [{dims_str}];\n\n")
+
+    def _write_internal_field(self):
+        """Write the internal field section."""
+        force_str = ' '.join(map(str, self.internal_force))
+        self.file_handle.write(f"internalField   uniform ({force_str});\n\n")
+
+    def _write_boundary_field(self):
+        """Write the boundary field section."""
+        self.file_handle.write("boundaryField\n")
+        self.file_handle.write("{\n")
+        
+        for patch_name, bc in self.boundary_conditions.items():
+            self.file_handle.write(f"    {patch_name}\n")
+            self.file_handle.write("    {\n")
+            self.file_handle.write(f"        type            {bc['type']};\n")
+            
+            if 'value' in bc:
+                if isinstance(bc['value'], (list, tuple)):
+                    val_str = ' '.join(map(str, bc['value']))
+                    self.file_handle.write(f"        value           uniform ({val_str});\n")
+                else:
+                    self.file_handle.write(f"        value           uniform {bc['value']};\n")
+            
+            self.file_handle.write("    }\n")
+        
+        self.file_handle.write("}\n\n")
+
+    def _write_properties(self):
+        """Write the main content of the force field file."""
+        self._write_dimensions()
+        self._write_internal_field()
+        self._write_boundary_field()
+
+    def write(self):
+        """
+        Writes the complete force field file.
+        """
+        print(f"Writing force field (f) 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/zero/lambda_field_writer.py

@@ -0,0 +1,84 @@
+# lambda_field_writer.py
+
+"""
+Lambda Field Writer for OpenFOAM cases.
+
+This writer handles the creation of lambda field (λ) files in the 0 directory
+with support for level set functions, phase fields, and scalar transport.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class LambdaFieldWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM lambda field (λ) file.
+    
+    This writer supports various scalar field configurations including
+    level set functions, phase fields, and general scalar transport.
+    """
+
+    def __init__(self, file_path, internal_lambda, boundary_conditions,
+                 lambda_dimensions=[0, 0, 0, 0, 0, 0, 0]):
+        """
+        Initialize the LambdaFieldWriter.
+
+        Args:
+            file_path (str): The full path to the output file '0/lambda'.
+            internal_lambda (float): Internal field lambda value.
+            boundary_conditions (dict): Boundary conditions for each patch.
+            lambda_dimensions (list): Lambda field dimensions.
+        """
+        super().__init__(file_path, foam_class="volScalarField", foam_object="lambda")
+        self.internal_lambda = internal_lambda
+        self.boundary_conditions = boundary_conditions
+        self.lambda_dimensions = lambda_dimensions
+
+    def _write_dimensions(self):
+        """Write the dimensions section."""
+        dims_str = ' '.join(map(str, self.lambda_dimensions))
+        self.file_handle.write(f"dimensions      [{dims_str}];\n\n")
+
+    def _write_internal_field(self):
+        """Write the internal field section."""
+        self.file_handle.write(f"internalField   uniform {self.internal_lambda};\n\n")
+
+    def _write_boundary_field(self):
+        """Write the boundary field section."""
+        self.file_handle.write("boundaryField\n")
+        self.file_handle.write("{\n")
+        
+        for patch_name, bc in self.boundary_conditions.items():
+            self.file_handle.write(f"    {patch_name}\n")
+            self.file_handle.write("    {\n")
+            self.file_handle.write(f"        type            {bc['type']};\n")
+            
+            if 'value' in bc:
+                self.file_handle.write(f"        value           uniform {bc['value']};\n")
+            
+            self.file_handle.write("    }\n")
+        
+        self.file_handle.write("}\n\n")
+
+    def _write_properties(self):
+        """Write the main content of the lambda field file."""
+        self._write_dimensions()
+        self._write_internal_field()
+        self._write_boundary_field()
+
+    def write(self):
+        """
+        Writes the complete lambda field file.
+        """
+        print(f"Writing lambda field (λ) 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/zero/p_field_writer.py

@@ -0,0 +1,89 @@
+# p_field_writer.py
+
+"""
+Pressure Field Writer for OpenFOAM cases.
+
+This writer handles the creation of pressure field (p) files in the 0 directory
+with support for various boundary conditions and field configurations.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class PFieldWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM pressure field (p) file.
+    
+    This writer supports various boundary conditions including fixedValue,
+    zeroGradient, and other pressure-specific conditions.
+    """
+
+    def __init__(self, file_path, internal_pressure, boundary_conditions, 
+                 ref_pressure_cell=0, ref_pressure_value=0.0, 
+                 pressure_dimensions=[0, 2, -2, 0, 0, 0, 0]):
+        """
+        Initialize the PFieldWriter.
+
+        Args:
+            file_path (str): The full path to the output file '0/p'.
+            internal_pressure (float): Internal field pressure value.
+            boundary_conditions (dict): Boundary conditions for each patch.
+            ref_pressure_cell (int): Reference pressure cell for pressure correction.
+            ref_pressure_value (float): Reference pressure value.
+            pressure_dimensions (list): Pressure field dimensions.
+        """
+        super().__init__(file_path, foam_class="volScalarField", foam_object="p")
+        self.internal_pressure = internal_pressure
+        self.boundary_conditions = boundary_conditions
+        self.ref_pressure_cell = ref_pressure_cell
+        self.ref_pressure_value = ref_pressure_value
+        self.pressure_dimensions = pressure_dimensions
+
+    def _write_dimensions(self):
+        """Write the dimensions section."""
+        dims_str = ' '.join(map(str, self.pressure_dimensions))
+        self.file_handle.write(f"dimensions      [{dims_str}];\n\n")
+
+    def _write_internal_field(self):
+        """Write the internal field section."""
+        self.file_handle.write(f"internalField   uniform {self.internal_pressure};\n\n")
+
+    def _write_boundary_field(self):
+        """Write the boundary field section."""
+        self.file_handle.write("boundaryField\n")
+        self.file_handle.write("{\n")
+        
+        for patch_name, bc in self.boundary_conditions.items():
+            self.file_handle.write(f"    {patch_name}\n")
+            self.file_handle.write("    {\n")
+            self.file_handle.write(f"        type            {bc['type']};\n")
+            
+            if 'value' in bc:
+                self.file_handle.write(f"        value           uniform {bc['value']};\n")
+            
+            self.file_handle.write("    }\n")
+        
+        self.file_handle.write("}\n\n")
+
+    def _write_properties(self):
+        """Write the main content of the pressure field file."""
+        self._write_dimensions()
+        self._write_internal_field()
+        self._write_boundary_field()
+
+    def write(self):
+        """
+        Writes the complete pressure field file.
+        """
+        print(f"Writing pressure field (p) 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/zero/u_field_writer.py

@@ -0,0 +1,96 @@
+# u_field_writer.py
+
+"""
+Velocity Field Writer for OpenFOAM cases.
+
+This writer handles the creation of velocity field (U) files in the 0 directory
+with support for various boundary conditions and flow configurations.
+"""
+
+from ..foam_writer import FoamWriter
+
+
+class UFieldWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM velocity field (U) file.
+    
+    This writer supports various boundary conditions including fixedValue,
+    noSlip, slip, inletOutlet, and other velocity-specific conditions.
+    """
+
+    def __init__(self, file_path, internal_velocity, boundary_conditions,
+                 velocity_dimensions=[0, 1, -1, 0, 0, 0, 0]):
+        """
+        Initialize the UFieldWriter.
+
+        Args:
+            file_path (str): The full path to the output file '0/U'.
+            internal_velocity (tuple): Internal field velocity vector (Ux, Uy, Uz).
+            boundary_conditions (dict): Boundary conditions for each patch.
+            velocity_dimensions (list): Velocity field dimensions.
+        """
+        super().__init__(file_path, foam_class="volVectorField", foam_object="U")
+        self.internal_velocity = internal_velocity
+        self.boundary_conditions = boundary_conditions
+        self.velocity_dimensions = velocity_dimensions
+
+    def _write_dimensions(self):
+        """Write the dimensions section."""
+        dims_str = ' '.join(map(str, self.velocity_dimensions))
+        self.file_handle.write(f"dimensions      [{dims_str}];\n\n")
+
+    def _write_internal_field(self):
+        """Write the internal field section."""
+        vel_str = ' '.join(map(str, self.internal_velocity))
+        self.file_handle.write(f"internalField   uniform ({vel_str});\n\n")
+
+    def _write_boundary_field(self):
+        """Write the boundary field section."""
+        self.file_handle.write("boundaryField\n")
+        self.file_handle.write("{\n")
+        
+        for patch_name, bc in self.boundary_conditions.items():
+            self.file_handle.write(f"    {patch_name}\n")
+            self.file_handle.write("    {\n")
+            self.file_handle.write(f"        type            {bc['type']};\n")
+            
+            if 'value' in bc:
+                if isinstance(bc['value'], (list, tuple)):
+                    val_str = ' '.join(map(str, bc['value']))
+                    self.file_handle.write(f"        value           uniform ({val_str});\n")
+                else:
+                    self.file_handle.write(f"        value           uniform {bc['value']};\n")
+            
+            if 'inletValue' in bc:
+                if isinstance(bc['inletValue'], (list, tuple)):
+                    val_str = ' '.join(map(str, bc['inletValue']))
+                    self.file_handle.write(f"        inletValue      uniform ({val_str});\n")
+                else:
+                    self.file_handle.write(f"        inletValue      uniform {bc['inletValue']};\n")
+            
+            self.file_handle.write("    }\n")
+        
+        self.file_handle.write("}\n\n")
+
+    def _write_properties(self):
+        """Write the main content of the velocity field file."""
+        self._write_dimensions()
+        self._write_internal_field()
+        self._write_boundary_field()
+
+    def write(self):
+        """
+        Writes the complete velocity field file.
+        """
+        print(f"Writing velocity field (U) 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")