pycphy 0.1.0__py3-none-any.whl

pycphy/foamCaseDeveloper/writers/block_mesh_writer.py

@@ -0,0 +1,113 @@
+# block_mesh_writer.py
+
+from .foam_writer import FoamWriter
+
+class BlockMeshWriter(FoamWriter):
+    """
+    A class to write OpenFOAM blockMeshDict files.
+
+    It takes Python data structures (lists, dicts) and formats them
+    into a valid blockMeshDict file.
+    """
+
+    def __init__(self, file_path, scale, vertices, blocks, edges, boundary, merge_patch_pairs=None):
+        """
+        Initializes the BlockMeshWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'blockMeshDict'.
+            scale (float): The scaling factor.
+            vertices (list): A list of tuples, where each tuple is a vertex (x, y, z).
+            blocks (list): A list of block definitions. Each definition is a tuple/list,
+                           e.g., ('hex', [0,1,2,3,4,5,6,7], [10,10,1], 'simpleGrading', [1,1,1]).
+            edges (list): A list of edge definitions (e.g., arc definitions).
+            boundary (list): A list of dictionaries, where each dict defines a boundary patch.
+                             e.g., {'name': 'inlet', 'type': 'patch', 'faces': [[...], [...]]}
+            merge_patch_pairs (list, optional): List of pairs to merge. Defaults to an empty list.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="blockMeshDict")
+        self.scale = scale
+        self.vertices = vertices
+        self.blocks = blocks
+        self.edges = edges
+        self.boundary = boundary
+        self.merge_patch_pairs = merge_patch_pairs if merge_patch_pairs is not None else []
+
+    def _format_list_of_tuples(self, tuples):
+        """Helper to format a list of tuples like vertices or faces."""
+        return "\n".join([f"    ({ ' '.join(map(str, v)) })" for v in tuples])
+    
+    def _write_scale(self):
+        """Writes the scale entry."""
+        self.file_handle.write(f"scale   {self.scale};\n\n")
+        
+    def _write_vertices(self):
+        """Writes the vertices section."""
+        self.file_handle.write("vertices\n(\n")
+        self.file_handle.write(self._format_list_of_tuples(self.vertices))
+        self.file_handle.write("\n);\n\n")
+
+    def _write_blocks(self):
+        """Writes the blocks section."""
+        self.file_handle.write("blocks\n(\n")
+        for block in self.blocks:
+            shape = block[0]
+            verts = ' '.join(map(str, block[1]))
+            cells = f"({ ' '.join(map(str, block[2])) })"
+            grading_type = block[3]
+            grading_vals = f"({ ' '.join(map(str, block[4])) })"
+            self.file_handle.write(f"    {shape} ({verts}) {cells} {grading_type} {grading_vals}\n")
+        self.file_handle.write(");\n\n")
+
+    def _write_edges(self):
+        """Writes the edges section."""
+        self.file_handle.write("edges\n(\n")
+        # Logic for formatting different edge types (e.g., arc) would go here
+        # For now, we assume it's simple or empty.
+        for edge in self.edges:
+            self.file_handle.write(f"    {edge}\n")
+        self.file_handle.write(");\n\n")
+
+    def _write_boundary(self):
+        """Writes the boundary section."""
+        self.file_handle.write("boundary\n(\n")
+        for patch in self.boundary:
+            self.file_handle.write(f"    {patch['name']}\n")
+            self.file_handle.write("    {\n")
+            self.file_handle.write(f"        type {patch['type']};\n")
+            self.file_handle.write("        faces\n")
+            self.file_handle.write("        (\n")
+            self.file_handle.write(self._format_list_of_tuples(patch['faces']).replace("    ", "            "))
+            self.file_handle.write("\n        );\n")
+            self.file_handle.write("    }\n")
+        self.file_handle.write(");\n\n")
+
+    def _write_merge_patch_pairs(self):
+        """Writes the mergePatchPairs section."""
+        self.file_handle.write("mergePatchPairs\n(\n")
+        for pair in self.merge_patch_pairs:
+             self.file_handle.write(f"    ({pair[0]} {pair[1]})\n")
+        self.file_handle.write(");\n")
+
+    def write(self):
+        """
+        Writes the complete blockMeshDict file by calling the section-specific methods.
+        """
+        print(f"Writing blockMeshDict 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()
+            
+            # Write blockMeshDict specific content
+            self._write_scale()
+            self._write_vertices()
+            self._write_blocks()
+            self._write_edges()
+            self._write_boundary()
+            self._write_merge_patch_pairs()
+
+            self._write_footer()
+        self.file_handle = None
+        print("...Done")

pycphy/foamCaseDeveloper/writers/control_dict_writer.py

@@ -0,0 +1,54 @@
+# control_dict_writer.py
+
+from .foam_writer import FoamWriter
+
+class ControlDictWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM controlDict file.
+
+    It takes a dictionary of control parameters and formats them
+    into a valid controlDict file.
+    """
+
+    def __init__(self, file_path, params):
+        """
+        Initializes the ControlDictWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'controlDict'.
+            params (dict): A dictionary containing the key-value pairs for the controlDict.
+                           e.g., {'application': 'icoFoam', 'deltaT': 0.001}
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="controlDict")
+        self.params = params
+
+    def _write_parameters(self):
+        """Writes the control parameters from the dictionary."""
+        # Find the longest key for alignment purposes to make the file pretty
+        max_key_len = max(len(key) for key in self.params.keys()) if self.params else 0
+        padding = max_key_len + 4 # Add some extra space
+
+        for key, value in self.params.items():
+            # The format string left-aligns the key in a padded field
+            line = f"{key:<{padding}} {value};\n"
+            self.file_handle.write(line)
+        self.file_handle.write("\n")
+
+
+    def write(self):
+        """
+        Writes the complete controlDict file.
+        """
+        print(f"Writing controlDict 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()
+            
+            # Write controlDict specific content
+            self._write_parameters()
+
+            self._write_footer()
+        self.file_handle = None
+        print("...Done")

pycphy/foamCaseDeveloper/writers/foam_writer.py

@@ -0,0 +1,73 @@
+# foam_writer.py
+
+import os
+from datetime import datetime
+
+class FoamWriter:
+    """
+    A base class for writing OpenFOAM dictionary files.
+    
+    This class handles the creation of the standard OpenFOAM header,
+    FoamFile dictionary, and footer comments. It is intended to be
+    inherited by more specific writer classes.
+    """
+
+    def __init__(self, file_path, foam_class, foam_object):
+        """
+        Initializes the FoamWriter.
+        
+        Args:
+            file_path (str): The full path to the output file.
+            foam_class (str): The 'class' entry for the FoamFile dictionary (e.g., 'dictionary').
+            foam_object (str): The 'object' entry for the FoamFile dictionary (e.g., 'blockMeshDict').
+        """
+        self.file_path = file_path
+        self.foam_class = foam_class
+        self.foam_object = foam_object
+        self.file_handle = None
+        
+        # Ensure the directory exists
+        dir_name = os.path.dirname(self.file_path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+
+    def _write_header(self):
+        """Writes the standard C++ style OpenFOAM header."""
+        header = """/*--------------------------------*- C++ -*----------------------------------*\\
+| =========                 |                                                 |
+| \\\\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\\\    /   O peration     | Version:  v{version}                                 |
+|   \\\\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\\\/     M anipulation  |                                                 |
+\\*---------------------------------------------------------------------------*/
+""".format(version=datetime.now().strftime("%y%m")) # e.g., v2312
+        self.file_handle.write(header)
+
+    def _write_foamfile_dict(self):
+        """Writes the FoamFile dictionary section."""
+        foam_dict = f"""FoamFile
+{{
+    version     2.0;
+    format      ascii;
+    class       {self.foam_class};
+    object      {self.foam_object};
+}}
+"""
+        self.file_handle.write(foam_dict)
+
+    def _write_separator(self):
+        """Writes a standard separator line."""
+        self.file_handle.write("//" + "*" * 79 + "//\n\n")
+
+    def _write_footer(self):
+        """Writes the standard footer line."""
+        self.file_handle.write("\n//" + "*" * 79 + "//\n")
+
+    def write(self):
+        """
+        Main writing method. This should be overridden by child classes.
+        
+        This method sets up the file and writes the common header and footer,
+        but the main content writing is left to the inheriting class.
+        """
+        raise NotImplementedError("The 'write' method must be implemented by a subclass.")

pycphy/foamCaseDeveloper/writers/turbulence_properties_writer.py

@@ -0,0 +1,78 @@
+# turbulence_properties_writer.py
+
+from .foam_writer import FoamWriter
+
+class TurbulencePropertiesWriter(FoamWriter):
+    """
+    A class to write an OpenFOAM turbulenceProperties file.
+
+    This writer can handle the nested dictionary structures required for
+    RAS and LES turbulence models.
+    """
+
+    def __init__(self, file_path, simulation_type, model_properties):
+        """
+        Initializes the TurbulencePropertiesWriter.
+
+        Args:
+            file_path (str): The full path to the output file 'turbulenceProperties'.
+            simulation_type (str): The top-level simulation type (e.g., 'RAS', 'LES', 'laminar').
+            model_properties (dict): A dictionary containing the properties for the chosen model.
+                                     This dictionary can be nested.
+        """
+        super().__init__(file_path, foam_class="dictionary", foam_object="turbulenceProperties")
+        self.simulation_type = simulation_type
+        self.model_properties = model_properties
+
+    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")
+            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_properties(self):
+        """Writes the main content of the turbulenceProperties file."""
+        self.file_handle.write(f"simulationType      {self.simulation_type};\n\n")
+
+        # Start the main model block (e.g., RAS, LES)
+        # For laminar, this block is often omitted, but writing an empty one is also valid.
+        if self.model_properties or self.simulation_type != "laminar":
+            self.file_handle.write(f"{self.simulation_type}\n")
+            self.file_handle.write("{\n")
+            self._write_dict_recursively(self.model_properties, indent_level=1)
+            self.file_handle.write("}\n")
+        
+    def write(self):
+        """
+        Writes the complete turbulenceProperties file.
+        """
+        print(f"Writing turbulenceProperties 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-0.1.0.dist-info/METADATA

@@ -0,0 +1,335 @@
+Metadata-Version: 2.4
+Name: pycphy
+Version: 0.1.0
+Summary: Python: Computational Physics - Tools for physics dynamics simulation
+Home-page: https://github.com/SanjeevBashyal/pycphy
+Author: Sanjeev Bashyal
+Author-email: Sanjeev Bashyal <sanjeev.bashyal@example.com>
+Maintainer-email: Sanjeev Bashyal <sanjeev.bashyal@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/SanjeevBashyal/pycphy
+Project-URL: Repository, https://github.com/SanjeevBashyal/pycphy
+Project-URL: Documentation, https://github.com/SanjeevBashyal/pycphy#readme
+Project-URL: Bug Tracker, https://github.com/SanjeevBashyal/pycphy/issues
+Keywords: computational physics,simulation,openfoam,cfd,physics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: scipy>=1.6.0
+Requires-Dist: matplotlib>=3.3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# pycphy
+
+**Python: Computational Physics**
+
+A comprehensive Python package for computational physics simulations and tools, with a focus on OpenFOAM case development and management.
+
+**Author:** Sanjeev Bashyal  
+**Repository:** [https://github.com/SanjeevBashyal/pycphy](https://github.com/SanjeevBashyal/pycphy)
+
+## Overview
+
+`pycphy` is a Python package designed to provide tools and utilities for computational physics simulations. The package currently includes the `foamCaseDeveloper` module, which offers comprehensive tools for creating and managing OpenFOAM CFD simulation cases.
+
+## Features
+
+### foamCaseDeveloper Module
+
+The `foamCaseDeveloper` module provides:
+
+- **BlockMesh Generation**: Create OpenFOAM blockMeshDict files with custom geometries
+- **Control Dictionary Setup**: Configure solver settings, time control, and output parameters
+- **Turbulence Model Configuration**: Set up RAS, LES, and laminar turbulence models
+- **Complete Case Management**: Automatically create complete OpenFOAM case directories
+- **Validation and Error Checking**: Built-in validation for all configuration parameters
+
+## Installation
+
+### From Source
+
+```bash
+git clone https://github.com/SanjeevBashyal/pycphy.git
+cd pycphy
+pip install -e .
+```
+
+### Development Installation
+
+```bash
+git clone https://github.com/SanjeevBashyal/pycphy.git
+cd pycphy
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+### Using the Command Line Interface
+
+```bash
+# Create an example case
+pycphy-foam --example
+
+# Create a custom case from configuration files
+pycphy-foam --case myCase --geometry configBlockMesh.py --control configControl.py --turbulence configTurbulence.py
+```
+
+### Using Python API
+
+```python
+from pycphy.foamCaseDeveloper import FoamCaseManager, BlockMeshConfig, ControlConfig, TurbulenceConfig
+
+# Create a case manager
+case_manager = FoamCaseManager("myCase")
+
+# Set up geometry
+geometry_config = BlockMeshConfig(
+    p0=(0.0, 0.0, 0.0),
+    p1=(1.0, 1.0, 1.0),
+    cells=(50, 50, 50),
+    patch_names={
+        'minX': 'inlet',
+        'maxX': 'outlet',
+        'minY': 'frontWall',
+        'maxY': 'backWall',
+        'minZ': 'floor',
+        'maxZ': 'ceiling'
+    }
+)
+
+case_manager.setup_geometry(
+    p0=geometry_config.p0,
+    p1=geometry_config.p1,
+    cells=geometry_config.cells,
+    patch_names=geometry_config.patch_names
+)
+
+# Set up control
+control_config = ControlConfig()
+control_config.set_solver("interFoam")
+control_config.set_time_control(start_time=0, end_time=1.0, delta_t=0.001)
+
+case_manager.setup_control(control_config.get_parameters())
+
+# Set up turbulence
+turbulence_config = TurbulenceConfig("RAS")
+turbulence_config.set_ras_model("kOmegaSST")
+
+case_manager.setup_turbulence(
+    simulation_type=turbulence_config.get_simulation_type(),
+    model_properties=turbulence_config.get_model_properties()
+)
+
+# Create the complete case
+case_manager.create_full_case()
+```
+
+## Package Structure
+
+```
+pycphy/
+├── __init__.py
+└── foamCaseDeveloper/
+    ├── __init__.py
+    ├── main.py                    # Command-line interface
+    ├── core/                      # Core functionality
+    │   ├── __init__.py
+    │   ├── foam_case_manager.py   # Main case management class
+    │   ├── block_mesh_developer.py # BlockMesh generation
+    │   ├── control_dict_writer.py  # Control dictionary writer
+    │   └── turbulence_properties_writer.py # Turbulence properties writer
+    ├── writers/                   # OpenFOAM dictionary writers
+    │   ├── __init__.py
+    │   ├── foam_writer.py         # Base writer class
+    │   ├── block_mesh_writer.py   # BlockMesh dictionary writer
+    │   ├── control_dict_writer.py # Control dictionary writer
+    │   └── turbulence_properties_writer.py # Turbulence properties writer
+    └── config/                    # Configuration classes
+        ├── __init__.py
+        ├── block_mesh_config.py   # Geometry configuration
+        ├── control_config.py      # Control configuration
+        └── turbulence_config.py   # Turbulence configuration
+```
+
+## Configuration
+
+### Geometry Configuration (BlockMesh)
+
+```python
+from pycphy.foamCaseDeveloper import BlockMeshConfig
+
+config = BlockMeshConfig(
+    p0=(0.0, 0.0, 0.0),      # Minimum corner
+    p1=(1.0, 1.0, 1.0),      # Maximum corner
+    cells=(50, 50, 50),      # Number of cells
+    patch_names={            # Boundary patch names
+        'minX': 'inlet',
+        'maxX': 'outlet',
+        'minY': 'frontWall',
+        'maxY': 'backWall',
+        'minZ': 'floor',
+        'maxZ': 'ceiling'
+    }
+)
+```
+
+### Control Configuration
+
+```python
+from pycphy.foamCaseDeveloper import ControlConfig
+
+config = ControlConfig()
+config.set_solver("interFoam")
+config.set_time_control(start_time=0, end_time=1.0, delta_t=0.001)
+config.set_write_control(write_interval=0.05)
+config.set_courant_control(max_co=1)
+```
+
+### Turbulence Configuration
+
+```python
+from pycphy.foamCaseDeveloper import TurbulenceConfig
+
+# RAS configuration
+ras_config = TurbulenceConfig("RAS")
+ras_config.set_ras_model("kOmegaSST")
+
+# LES configuration
+les_config = TurbulenceConfig("LES")
+les_config.set_les_model("kEqn")
+les_config.set_delta_model("smooth")
+
+# Laminar configuration
+laminar_config = TurbulenceConfig("laminar")
+```
+
+## Examples
+
+### Channel Flow Case
+
+```python
+from pycphy.foamCaseDeveloper import FoamCaseManager, BlockMeshConfig, ControlConfig, TurbulenceConfig
+
+# Create channel flow case
+case_manager = FoamCaseManager("channelFlow")
+
+# Channel geometry: 0.5m x 0.2m x 0.1m
+geometry = BlockMeshConfig(
+    p0=(0.0, 0.0, 0.0),
+    p1=(0.5, 0.2, 0.1),
+    cells=(50, 20, 50),
+    patch_names={
+        'minX': 'inlet',
+        'maxX': 'outlet',
+        'minY': 'frontWall',
+        'maxY': 'backWall',
+        'minZ': 'floor',
+        'maxZ': 'ceiling'
+    }
+)
+
+case_manager.setup_geometry(
+    p0=geometry.p0, p1=geometry.p1, cells=geometry.cells,
+    patch_names=geometry.patch_names
+)
+
+# Set up solver
+control = ControlConfig()
+control.set_solver("interFoam")
+control.set_time_control(start_time=0, end_time=1.0, delta_t=0.001)
+
+case_manager.setup_control(control.get_parameters())
+
+# Set up turbulence
+turbulence = TurbulenceConfig("RAS")
+turbulence.set_ras_model("kOmegaSST")
+
+case_manager.setup_turbulence(
+    simulation_type=turbulence.get_simulation_type(),
+    model_properties=turbulence.get_model_properties()
+)
+
+# Create the case
+case_manager.create_full_case()
+```
+
+## Requirements
+
+- Python >= 3.7
+- NumPy >= 1.19.0
+- SciPy >= 1.6.0
+- Matplotlib >= 3.3.0
+
+## Development
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Code Formatting
+
+```bash
+black pycphy/
+flake8 pycphy/
+```
+
+### Building Documentation
+
+```bash
+sphinx-build docs/ docs/_build/
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/new-feature`)
+3. Commit your changes (`git commit -am 'Add new feature'`)
+4. Push to the branch (`git push origin feature/new-feature`)
+5. Create a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Citation
+
+If you use pycphy in your research, please cite:
+
+```bibtex
+@software{bashyal2025pycphy,
+  title={pycphy: Python Computational Physics},
+  author={Bashyal, Sanjeev},
+  year={2025},
+  url={https://github.com/SanjeevBashyal/pycphy}
+}
+```
+
+## Support
+
+For questions, issues, or contributions, please visit the [GitHub repository](https://github.com/SanjeevBashyal/pycphy).

pycphy-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+pycphy/__init__.py,sha256=Mm71OUIMs3Eex9oxoNeLft7189a-eHollog8-JomGlc,544
+pycphy/foamCaseDeveloper/__init__.py,sha256=gzvozQIRG8Zktkd9snAPfJhV28Qg8yazh0rZOX6et40,874
+pycphy/foamCaseDeveloper/main.py,sha256=CsAkeZzNREGRcsSDqPgP9tlTAtz7QnPkkB59T1QfkT8,8932
+pycphy/foamCaseDeveloper/config/__init__.py,sha256=6_sGyfn-lC9QYXHSdmRS2F6ObfU5okh_uioaiK6jf6w,816
+pycphy/foamCaseDeveloper/config/block_mesh_config.py,sha256=9QfcdXxPMtazwjgv4Twjp0fp-hder-fSXV0KQXi4kM8,3694
+pycphy/foamCaseDeveloper/config/control_config.py,sha256=LMsB9KG7yniOfKiMnF7ZVtMYZ9v9lXnObxWnuumIkns,7799
+pycphy/foamCaseDeveloper/config/global_config.py,sha256=RgUUYCidlzuTRMgiswDQ69OSQgler9Rz3QZzSP1vw2g,2988
+pycphy/foamCaseDeveloper/config/turbulence_config.py,sha256=oOmVYHX6A30CSZbb3ichQVnnWRs0krkRRP1UhX_5f1Q,8845
+pycphy/foamCaseDeveloper/core/__init__.py,sha256=rxxMmWuPtfLfGdQvjNK7lDVzNoYZ-E57zucwv-NSiPg,552
+pycphy/foamCaseDeveloper/core/block_mesh_developer.py,sha256=17u-OLrVzFMM9LshdMusLCfyIh3ICgFpvYBolLuJliw,3602
+pycphy/foamCaseDeveloper/core/control_dict_writer.py,sha256=ae91vhJ5dIzgozMjADHxWWmJoqXTgRgfGQEDsOAfML0,2067
+pycphy/foamCaseDeveloper/core/foam_case_manager.py,sha256=tvSStP7F27e8su8FM_MyjvL1iBWiwUS71yeVkArZIJw,7315
+pycphy/foamCaseDeveloper/core/turbulence_properties_writer.py,sha256=7XnDUqhNu5XTdXN1thvVjGV-yuTlStCpegc73FM4t-c,2938
+pycphy/foamCaseDeveloper/writers/__init__.py,sha256=GNcGirRv_HBosXMmatN78i5pI5_kaMt1ewwXiJMq2fA,508
+pycphy/foamCaseDeveloper/writers/block_mesh_writer.py,sha256=lirGHOBlCjX_aaSCsCkWDPAjkki7QJBemPz6yVA7Q-g,4877
+pycphy/foamCaseDeveloper/writers/control_dict_writer.py,sha256=gaDls-kvqfv_KzG6Ac_2IbIByQ45-6Sn1ylcfIVHiig,1908
+pycphy/foamCaseDeveloper/writers/foam_writer.py,sha256=KMfQ-338UUg6mEIyW_-55DbcK5UHVihqOXYT0BSsA1M,2854
+pycphy/foamCaseDeveloper/writers/turbulence_properties_writer.py,sha256=gdUqC_snJLEt8PSwC6TNEUYXCFIneVwm9W4fH8LEqLY,3331
+pycphy-0.1.0.dist-info/licenses/LICENSE,sha256=SO-nbkWPNmUErH6Zw-SxD-3bGgO9j9euAnYU8K6Gjeo,1093
+pycphy-0.1.0.dist-info/METADATA,sha256=iOkI2_8BNtIteOj1iKUR16kZ2j3VrAJxEOOKYjdef1o,9698
+pycphy-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pycphy-0.1.0.dist-info/entry_points.txt,sha256=i_F-4TnLFt1X-jvnQgRbStMs-pZY5oXlfnc6Nr3wI_k,67
+pycphy-0.1.0.dist-info/top_level.txt,sha256=w2z-jwGibnt6eh8y4z7LvsPL6I2196b8m_Jxl0XB3PM,7
+pycphy-0.1.0.dist-info/RECORD,,

pycphy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pycphy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pycphy-foam = pycphy.foamCaseDeveloper.main:main