pybFoam 0.1.5__tar.gz → 0.1.7__tar.gz

pybfoam-0.1.7/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+
+## [0.1.6] 
+
+### Added
+- Initial implementation of sampling module with pybind11 bindings
+- Support for sampledSurface types (plane, patch, cutting plane, iso-surface)
+- Interpolation schemes (cell, cellPoint, cellPointFace)
+- Line sampling functionality (uniform, cloud, polyLine, circle)
+- Integration tests for surface and set sampling
+
+### Changed
+- Updated build system to use scikit-build-core
+- Improved CMake configuration for OpenFOAM library detection
+
+---
+
+## [-0.1.5]
+
+### Added
+- Python bindings for OpenFOAM core functionality
+- Field access and manipulation (volScalarField, volVectorField, volTensorField)
+- Finite volume operators (fvc, fvm)
+- Mesh access (fvMesh, polyMesh)
+- Time management
+- Dictionary I/O
+- Basic turbulence model support
+- NumPy buffer protocol integration for zero-copy field access
+
+### Known Issues
+- Memory leaks in `selectTimes` function (requires RAII fix)
+- Incorrect return value policies in some bindings
+- Missing negative index checks in field accessors
+
+---

{pybfoam-0.1.5 → pybfoam-0.1.7}/CMakeLists.txt

@@ -5,7 +5,7 @@ if(POLICY CMP0169)
     cmake_policy(SET CMP0169 OLD)
 endif()
 
-project(pybFoam VERSION 0.1.5 LANGUAGES CXX)
+project(pybFoam VERSION 0.1.7 LANGUAGES CXX)
 
 # Set C++ standard
 set(CMAKE_CXX_STANDARD 17)

pybfoam-0.1.7/PKG-INFO

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: pybFoam
+Version: 0.1.7
+Summary: python bindings for OpenFOAM
+Keywords: OpenFOAM,simulation,CFD
+Author-Email: Henning Scheufler <henning.scheufler@web.de>
+License-Expression: GPL-3.0-or-later
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Project-URL: Homepage, https://github.com/HenningScheufler/pybFoam
+Project-URL: Repository, https://github.com/HenningScheufler/pybFoam.git
+Project-URL: Issues, https://github.com/HenningScheufler/pybFoam/issues
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20
+Requires-Dist: pybind11>=2.6.0
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: cmake>=3.18; extra == "dev"
+Requires-Dist: pybind11-stubgen>=2.5; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=4.0; extra == "docs"
+Requires-Dist: sphinx-sitemap; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: sphinxcontrib-mermaid; extra == "docs"
+Provides-Extra: benchmark
+Requires-Dist: jax; extra == "benchmark"
+Requires-Dist: seaborn; extra == "benchmark"
+Requires-Dist: matplotlib; extra == "benchmark"
+Requires-Dist: PyQt6; extra == "benchmark"
+Provides-Extra: all
+Requires-Dist: pybFoam[benchmark,dev,docs]; extra == "all"
+Description-Content-Type: text/markdown
+
+# pybFoam
+
+Python bindings for OpenFOAM - enabling direct manipulation of OpenFOAM cases, fields, and meshes from Python.
+
+Currently in the pre-alpha release state.
+
+---
+
+## Features
+
+- **Direct Python access to OpenFOAM data structures**: Time, fvMesh, fields
+- **Finite volume operators**: fvc (calculus), fvm (matrix operations)
+- **Turbulence and thermodynamic models**: Access to OpenFOAM turbulence and thermo libraries
+- **Sampling and post-processing**: Surface sampling, line sampling, interpolation
+- **Pydantic configuration models**: Type-safe dictionary construction for sampling surfaces
+- **NumPy integration**: Zero-copy access to OpenFOAM field data via buffer protocol
+
+---
+
+## Requirements
+
+- **OpenFOAM**: v2012 or higher (sourced and installed)
+- **Python**: 3.8 or higher
+- **CMake**: 3.18 or higher
+- **C++ Compiler**: C++17 compatible (GCC 7+, Clang 5+)
+- **Build tools**: pybind11, scikit-build-core
+- **Python packages**: numpy, pydantic
+
+---
+
+## Installation
+
+### Prerequisites
+
+1. Source your OpenFOAM environment:
+   ```bash
+   source /path/to/OpenFOAM/etc/bashrc
+   ```
+
+2. (Recommended) Create a virtual environment:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   ```
+
+### Install from source
+
+```bash
+pip install .
+```
+
+For development:
+```bash
+pip install -e . --no-build-isolation
+```
+
+---
+
+## Quick Start
+
+### Basic Usage
+
+```python
+import pybFoam as pf
+
+# Create OpenFOAM time and mesh
+time = pf.createTime()
+mesh = pf.fvMesh(time)
+
+# Access fields
+p = pf.volScalarField.read_field(mesh, "p")
+U = pf.volVectorField.read_field(mesh, "U")
+
+# Compute gradients using finite volume calculus
+grad_p = pf.fvc.grad(p)
+div_U = pf.fvc.div(U)
+
+# Convert to NumPy arrays for analysis
+import numpy as np
+p_array = np.asarray(p["internalField"])
+print(f"Pressure range: {p_array.min():.3f} to {p_array.max():.3f}")
+```
+
+### Sampling Surfaces
+
+```python
+from pybFoam.sampling import SampledPlaneConfig, sampledSurface, interpolationScalar
+from pybFoam import Word
+
+# Create a sampling plane using Pydantic config
+plane_config = SampledPlaneConfig(
+    point=[0.5, 0.5, 0.0],
+    normal=[1.0, 0.0, 0.0]
+)
+
+# Create the surface
+plane = sampledSurface.New(Word("myPlane"), mesh, plane_config.to_foam_dict())
+plane.update()
+
+# Interpolate field onto surface
+interp = interpolationScalar.New(Word("cellPoint"), p)
+sampled_values = interp.sampleOnFaces(plane)
+```
+
+### Dictionary I/O with Pydantic
+
+```python
+from pybFoam.io import IOModelBase
+from pydantic import Field
+
+class TransportProperties(IOModelBase):
+    nu: float = Field(..., description="Kinematic viscosity")
+    
+    class Config:
+        foam_file_name = "transportProperties"
+
+# Read from OpenFOAM dictionary
+props = TransportProperties.from_file("constant/transportProperties")
+print(f"Viscosity: {props.nu}")
+
+# Modify and write back
+props.nu = 1e-5
+props.to_file("constant/transportProperties")
+```
+
+---
+
+## Examples
+
+See the `tests/` directory for more examples:
+- **Basic field operations**: `tests/pybind/test_primitives.py`
+- **Finite volume operators**: `tests/pybind/test_fvc.py`, `tests/pybind/test_fvm.py`
+- **Surface sampling**: `tests/pybind/test_surface_sampling.py`
+- **Line sampling**: `tests/pybind/test_set_sampling.py`
+- **Solver example**: `tests/cavity/icoFoam.py`
+
+---
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest tests/
+```
+
+Run specific test categories:
+```bash
+pytest tests/pybind/          # C++ binding tests
+pytest tests/test_sampling_models.py  # Pydantic config tests
+```
+
+---
+
+## Documentation
+
+Full documentation is available at: [https://henningscheufler.github.io/pybFoam/](https://henningscheufler.github.io/pybFoam/index.html)
+
+---
+
+### Development Setup
+
+1. Clone the repository
+2. Install development dependencies:
+   ```bash
+   pip install -e ".[dev]"
+   ```
+3. Run tests before committing:
+   ```bash
+   pytest tests/
+   ```
+
+---
+
+## License
+
+See [LICENSE](LICENSE) file for details.
+
+---
+
+

pybfoam-0.1.7/README.md

@@ -0,0 +1,181 @@
+# pybFoam
+
+Python bindings for OpenFOAM - enabling direct manipulation of OpenFOAM cases, fields, and meshes from Python.
+
+Currently in the pre-alpha release state.
+
+---
+
+## Features
+
+- **Direct Python access to OpenFOAM data structures**: Time, fvMesh, fields
+- **Finite volume operators**: fvc (calculus), fvm (matrix operations)
+- **Turbulence and thermodynamic models**: Access to OpenFOAM turbulence and thermo libraries
+- **Sampling and post-processing**: Surface sampling, line sampling, interpolation
+- **Pydantic configuration models**: Type-safe dictionary construction for sampling surfaces
+- **NumPy integration**: Zero-copy access to OpenFOAM field data via buffer protocol
+
+---
+
+## Requirements
+
+- **OpenFOAM**: v2012 or higher (sourced and installed)
+- **Python**: 3.8 or higher
+- **CMake**: 3.18 or higher
+- **C++ Compiler**: C++17 compatible (GCC 7+, Clang 5+)
+- **Build tools**: pybind11, scikit-build-core
+- **Python packages**: numpy, pydantic
+
+---
+
+## Installation
+
+### Prerequisites
+
+1. Source your OpenFOAM environment:
+   ```bash
+   source /path/to/OpenFOAM/etc/bashrc
+   ```
+
+2. (Recommended) Create a virtual environment:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   ```
+
+### Install from source
+
+```bash
+pip install .
+```
+
+For development:
+```bash
+pip install -e . --no-build-isolation
+```
+
+---
+
+## Quick Start
+
+### Basic Usage
+
+```python
+import pybFoam as pf
+
+# Create OpenFOAM time and mesh
+time = pf.createTime()
+mesh = pf.fvMesh(time)
+
+# Access fields
+p = pf.volScalarField.read_field(mesh, "p")
+U = pf.volVectorField.read_field(mesh, "U")
+
+# Compute gradients using finite volume calculus
+grad_p = pf.fvc.grad(p)
+div_U = pf.fvc.div(U)
+
+# Convert to NumPy arrays for analysis
+import numpy as np
+p_array = np.asarray(p["internalField"])
+print(f"Pressure range: {p_array.min():.3f} to {p_array.max():.3f}")
+```
+
+### Sampling Surfaces
+
+```python
+from pybFoam.sampling import SampledPlaneConfig, sampledSurface, interpolationScalar
+from pybFoam import Word
+
+# Create a sampling plane using Pydantic config
+plane_config = SampledPlaneConfig(
+    point=[0.5, 0.5, 0.0],
+    normal=[1.0, 0.0, 0.0]
+)
+
+# Create the surface
+plane = sampledSurface.New(Word("myPlane"), mesh, plane_config.to_foam_dict())
+plane.update()
+
+# Interpolate field onto surface
+interp = interpolationScalar.New(Word("cellPoint"), p)
+sampled_values = interp.sampleOnFaces(plane)
+```
+
+### Dictionary I/O with Pydantic
+
+```python
+from pybFoam.io import IOModelBase
+from pydantic import Field
+
+class TransportProperties(IOModelBase):
+    nu: float = Field(..., description="Kinematic viscosity")
+    
+    class Config:
+        foam_file_name = "transportProperties"
+
+# Read from OpenFOAM dictionary
+props = TransportProperties.from_file("constant/transportProperties")
+print(f"Viscosity: {props.nu}")
+
+# Modify and write back
+props.nu = 1e-5
+props.to_file("constant/transportProperties")
+```
+
+---
+
+## Examples
+
+See the `tests/` directory for more examples:
+- **Basic field operations**: `tests/pybind/test_primitives.py`
+- **Finite volume operators**: `tests/pybind/test_fvc.py`, `tests/pybind/test_fvm.py`
+- **Surface sampling**: `tests/pybind/test_surface_sampling.py`
+- **Line sampling**: `tests/pybind/test_set_sampling.py`
+- **Solver example**: `tests/cavity/icoFoam.py`
+
+---
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest tests/
+```
+
+Run specific test categories:
+```bash
+pytest tests/pybind/          # C++ binding tests
+pytest tests/test_sampling_models.py  # Pydantic config tests
+```
+
+---
+
+## Documentation
+
+Full documentation is available at: [https://henningscheufler.github.io/pybFoam/](https://henningscheufler.github.io/pybFoam/index.html)
+
+---
+
+### Development Setup
+
+1. Clone the repository
+2. Install development dependencies:
+   ```bash
+   pip install -e ".[dev]"
+   ```
+3. Run tests before committing:
+   ```bash
+   pytest tests/
+   ```
+
+---
+
+## License
+
+See [LICENSE](LICENSE) file for details.
+
+---
+
+

pybfoam-0.1.7/benchmark/benchmark_expression_complex.py

@@ -0,0 +1,142 @@
+# import os
+
+# N = 8
+
+# os.environ["XLA_FLAGS"] = (
+#     f"--xla_cpu_multi_thread_eigen=true "
+#     f"intra_op_parallelism_threads={N}"
+# )
+import os
+
+def configure_threads(n=1):
+    multi_thread = True if n > 1 else False
+    os.environ["XLA_FLAGS"] = (
+        f"--xla_cpu_multi_thread_eigen={multi_thread} "
+        f"intra_op_parallelism_threads={n}"
+    )
+    os.environ["NPROC"] = f"{n}"
+    os.environ["OMP_NUM_THREADS"] = str(n)
+    os.environ["MKL_NUM_THREADS"] = str(n)
+    os.environ["OPENBLAS_NUM_THREADS"] = str(n)
+
+configure_threads(1)
+
+from pybFoam import scalarField
+import numpy as np
+import timeit
+import time
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import jax
+import jax.numpy as jnp
+
+
+def pybfoam_expression(n_elements):
+    a = scalarField([1.1] * n_elements)
+    b = scalarField([2.2] * n_elements)
+    c = scalarField([3.3] * n_elements)
+    d = scalarField([4.4] * n_elements)
+
+    def run():
+        x = a * b + c
+        y = d - a * c
+        return (x * y + b) / (a + 1.0)
+    return run
+
+def numpy_expression(n_elements):
+    a = np.full(n_elements, 1.1)
+    b = np.full(n_elements, 2.2)
+    c = np.full(n_elements, 3.3)
+    d = np.full(n_elements, 4.4)
+
+    def run():
+        x = a * b + c
+        y = d - a * c
+        return (x * y + b) / (a + 1.0)
+
+    return run
+
+def jax_expression(n_elements):
+    a = jnp.full(n_elements, 1.1)
+    b = jnp.full(n_elements, 2.2)
+    c = jnp.full(n_elements, 3.3)
+    d = jnp.full(n_elements, 4.4)
+
+    @jax.jit
+    def run():
+        x = a * b + c
+        y = d - a * c
+        return (x * y + b) / (a + 1.0)
+
+    return run
+
+vector_add_data = {
+    "n_elements": [],
+    "duration": [],
+    "method": [],
+    # "jax": []
+}
+
+def add_data(n_elements, duration, method):
+    vector_add_data["n_elements"].append(n_elements)
+    vector_add_data["duration"].append(duration)
+    vector_add_data["method"].append(method)
+
+for n_elements in [10, 100, 1000, 10_000, 100_000, 1_000_000, 10_000_000]:
+
+    bench = pybfoam_expression(n_elements)
+    # duration = timeit.timeit(bench, number=1)
+    t0 = time.perf_counter() # lower overhead than timeit
+    bench()
+    t1 = time.perf_counter()
+    duration = t1 - t0
+    add_data(n_elements, duration, "pybFoam")
+
+    bench = numpy_expression(n_elements)
+    # duration = timeit.timeit(bench, number=1)
+    t0 = time.perf_counter() # lower overhead than timeit
+    bench()
+    t1 = time.perf_counter()
+    duration = t1 - t0
+    add_data(n_elements, duration, "NumPy")
+
+    bench = jax_expression(n_elements)
+    # First call to compile
+    bench()
+    # duration = timeit.timeit(bench, number=1)
+    t0 = time.perf_counter() # lower overhead than timeit
+    bench()
+    t1 = time.perf_counter()
+    duration = t1 - t0
+    add_data(n_elements, duration, "JAX")
+
+
+df_vector_add = pd.DataFrame(vector_add_data)
+df_vector_add["time_per_element [ns]"] = df_vector_add["duration"] / df_vector_add["n_elements"] * 1e9  # time per element in nanoseconds
+print("Vector Addition Benchmark:",df_vector_add)
+
+sns.lineplot(data=df_vector_add, x="n_elements", y="time_per_element [ns]", hue="method", marker="o")
+plt.xscale("log")
+plt.yscale("log")
+plt.xlabel("Number of Elements")
+plt.ylabel("Time per Element (nanoseconds)")
+plt.title("Expression: (x * y + b) / (a + 1.0)")
+plt.savefig("bench_complex.png")
+n_elements = 10_000_000
+timings = df_vector_add[df_vector_add["n_elements"] == n_elements]
+print(f"Timings for {n_elements} elements:")
+for _, row in timings.iterrows():
+    print(f"{row['method']}: {row['time_per_element [ns]']:.2f} ns per element")
+n_elements = 1_000_000
+print("")
+timings = df_vector_add[df_vector_add["n_elements"] == n_elements]
+print(f"Timings for {n_elements} elements:")
+for _, row in timings.iterrows():
+    print(f"{row['method']}: {row['time_per_element [ns]']:.2f} ns per element")
+
+plt.show()
+
+
+
+# %%