pybFoam 0.1.6__tar.gz → 0.1.8__tar.gz

{pybfoam-0.1.6 → pybfoam-0.1.8}/CMakeLists.txt

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

{pybfoam-0.1.6 → pybfoam-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybFoam
-Version: 0.1.6
+Version: 0.1.8
 Summary: python bindings for OpenFOAM
 Keywords: OpenFOAM,simulation,CFD
 Author-Email: Henning Scheufler <henning.scheufler@web.de>
@@ -41,8 +41,13 @@ 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[dev,docs]; extra == "all"
+Requires-Dist: pybFoam[benchmark,dev,docs]; extra == "all"
 Description-Content-Type: text/markdown
 
 # pybFoam

pybfoam-0.1.8/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()
+
+
+
+# %%

pybfoam-0.1.8/benchmark/benchmark_expression_vec_add.py

@@ -0,0 +1,118 @@
+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_vector_addition(n_elements):
+    a = scalarField([1.0] * n_elements)
+    b = scalarField([2.0] * n_elements)
+
+    def run():
+        return a + b
+
+    return run
+
+def numpy_vector_addition(n_elements):
+    a = np.ones(n_elements)
+    b = np.full(n_elements, 2.0)
+
+    def run():
+        return a + b
+
+    return run
+
+def jax_vector_addition(n_elements):
+
+    a = jnp.ones(n_elements)
+    b = jnp.full(n_elements, 2.0)
+
+    @jax.jit
+    def run():
+        return a + b
+
+    return run
+
+vector_add_data = {
+    "n_elements": [],
+    "duration": [],
+    "method": [],
+}
+
+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_vector_addition(n_elements)
+    # duration2 = 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_vector_addition(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_vector_addition(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: c = a + b")
+plt.savefig("bench_vec_add.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")
+
+plt.show()
+
+
+
+# %%

pybfoam-0.1.8/benchmark/benchmark_expression_vec_add_4.py

@@ -0,0 +1,120 @@
+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_vector_addition_4(n_elements):
+    a = scalarField([1.0] * n_elements)
+    b = scalarField([2.0] * n_elements)
+    c = scalarField([3.0] * n_elements)
+
+    def run():
+        return a + b + c + a
+
+    return run
+
+def numpy_vector_addition_4(n_elements):
+    a = np.ones(n_elements)
+    b = np.full(n_elements, 2.0)
+    c = np.full(n_elements, 3.0)
+    def run():
+        return a + b + c + a
+
+    return run
+
+def jax_vector_addition_4(n_elements):
+
+    a = jnp.ones(n_elements)
+    b = jnp.full(n_elements, 2.0)
+    c = jnp.full(n_elements, 3.0)
+
+
+    @jax.jit
+    def run():
+        return a + b + c + a
+
+    return run
+
+vector_add_data_4 = {
+    "n_elements": [],
+    "duration": [],
+    "method": [],
+    # "jax": []
+}
+
+def add_data(n_elements, duration, method):
+    vector_add_data_4["n_elements"].append(n_elements)
+    vector_add_data_4["duration"].append(duration)
+    vector_add_data_4["method"].append(method)
+
+for n_elements in [10, 100, 1000, 10_000, 100_000, 1_000_000, 10_000_000]:
+
+    bench = pybfoam_vector_addition_4(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_vector_addition_4(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_vector_addition_4(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_4)
+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: c = a + b + c + a")
+plt.savefig("bench_vec_add_4.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")
+
+plt.show()
+
+
+# %%

{pybfoam-0.1.6 → pybfoam-0.1.8}/docs/conf.py

@@ -9,7 +9,7 @@
 project = "pybFoam"
 copyright = "2025, Henning Scheufler"
 author = "Henning Scheufler"
-release = "0.1.6"
+release = "0.1.8"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{pybfoam-0.1.6 → pybfoam-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pybFoam"
-version = "0.1.6"
+version = "0.1.8"
 authors = [
     {name = "Henning Scheufler", email = "henning.scheufler@web.de"},
 ]
@@ -28,7 +28,7 @@ dependencies = [
     "numpy>=1.20",
     "pybind11>=2.6.0",
     "pydantic",
-    "pyyaml"
+    "pyyaml",
 ]
 
 [project.optional-dependencies]
@@ -49,8 +49,14 @@ docs = [
     "furo",
     "sphinxcontrib-mermaid"
 ]
+benchmark = [
+    "jax",
+    "seaborn",
+    "matplotlib",
+    "PyQt6"
+]
 all = [
-    "pybFoam[dev,docs]",
+    "pybFoam[dev,docs,benchmark]",
 ]
 
 [project.urls]

{pybfoam-0.1.6 → pybfoam-0.1.8}/src/pybFoam/CMakeLists.txt

@@ -7,7 +7,6 @@ add_subdirectory(fvc)
 add_subdirectory(fvm)
 add_subdirectory(thermo)
 add_subdirectory(turbulence)
-add_subdirectory(aggregation)
 add_subdirectory(sampling)
 
 # Create a Python module that includes all components

{pybfoam-0.1.6 → pybfoam-0.1.8}/src/pybFoam/__init__.py

@@ -24,4 +24,3 @@ from . import fvm
 from . import runTimeTables
 from . import thermo
 from . import turbulence
-from . import aggregation

pybfoam-0.1.8/src/pybFoam/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.8"

{pybfoam-0.1.6 → pybfoam-0.1.8}/src/pybFoam/io/model_base.py

@@ -7,17 +7,17 @@ from pybFoam import dictionary
 from pydantic import BaseModel, Field
 
 type_dispatch = {
-    str: lambda v: v,  # Keep as string
-    int: lambda v: int(v),
-    float: lambda v: float(v),
-    bool: lambda v: bool(v),
-    pybFoam.Word: lambda v: pybFoam.Word(v),
+    str: lambda s: s,  # Keep as string
+    int: lambda i: int(i),
+    float: lambda f: float(f),
+    bool: lambda b: bool(b),
+    pybFoam.Word: lambda w: pybFoam.Word(w),
     pybFoam.vector: lambda v: pybFoam.vector(*v),
-    pybFoam.tensor: lambda v: pybFoam.tensor(*v),
-    pybFoam.wordList: lambda v: pybFoam.wordList(v),
-    pybFoam.scalarField: lambda v: pybFoam.scalarField(v),
+    pybFoam.tensor: lambda t: pybFoam.tensor(*t),
+    pybFoam.wordList: lambda w: pybFoam.wordList(w),
+    pybFoam.scalarField: lambda s: pybFoam.scalarField(s),
     pybFoam.vectorField: lambda v: pybFoam.vectorField(v),
-    pybFoam.tensorField: lambda v: pybFoam.tensorField(v),
+    pybFoam.tensorField: lambda t: pybFoam.tensorField(t),
 }
 
 

{pybfoam-0.1.6 → pybfoam-0.1.8}/src/pybFoam/pybFoam_core/bind_dict.cpp

@@ -23,6 +23,8 @@ License
 #include "IOobject.H"
 #include "dictionaryEntry.H"
 #include "entry.H"
+#include "SolverPerformance.H"
+#include "List.H"
 #include <unordered_map>
 #include <functional>
 
@@ -61,6 +63,68 @@ namespace Foam
         dict.add<Type>(word(key),T);
     }
 
+    // Helper function to lookup List<SolverPerformance<Type>> and return as std::vector
+    // OpenFOAM stores solver performance as List<SolverPerformance<Type>>
+    template<class Type>
+    std::vector<SolverPerformance<Type>> lookupSolverPerformanceList(const dictionary& dict, const std::string& fieldName)
+    {
+        // Check if entry exists first
+        const entry* e = dict.findEntry(word(fieldName), keyType::LITERAL);
+        if (!e)
+        {
+            throw std::runtime_error(
+                "Entry " + fieldName + " not found in dictionary"
+            );
+        }
+        
+        // Enable exception throwing for FatalIOError to catch type mismatches
+        bool previousThrowState = FatalIOError.throwExceptions();
+        
+        try
+        {
+            // The dictionary stores List<SolverPerformance<Type>>
+            List<SolverPerformance<Type>> sp;
+            bool success = dict.readIfPresent(word(fieldName), sp);
+            
+            // Restore previous exception state
+            FatalIOError.throwExceptions(previousThrowState);
+            
+            if (!success || sp.empty())
+            {
+                throw std::runtime_error(
+                    "Entry " + fieldName + " could not be read as List<SolverPerformance<" 
+                    + pTraits<Type>::typeName + ">> type or is empty"
+                );
+            }
+            
+            // Convert to std::vector for Python compatibility
+            std::vector<SolverPerformance<Type>> result;
+            result.reserve(sp.size());
+            for (const auto& item : sp)
+            {
+                result.push_back(item);
+            }
+            
+            return result;
+        }
+        catch (const Foam::error& e)
+        {
+            // Restore previous exception state before rethrowing
+            FatalIOError.throwExceptions(previousThrowState);
+            
+            throw std::runtime_error(
+                "Entry " + fieldName + " could not be read as List<SolverPerformance<" 
+                + pTraits<Type>::typeName + ">> type: " + std::string(e.what())
+            );
+        }
+        catch (...)
+        {
+            // Restore previous exception state before rethrowing
+            FatalIOError.throwExceptions(previousThrowState);
+            throw;
+        }
+    }
+
 }
 
 
@@ -191,6 +255,9 @@ void bindDict(pybind11::module& m)
         .def("add", &Foam::add<Foam::Field<Foam::scalar>>)
         .def("add", &Foam::add<Foam::Field<Foam::vector>>)
         .def("add", &Foam::add<Foam::Field<Foam::tensor>>)
+        .def("lookupSolverPerformanceScalarList", &Foam::lookupSolverPerformanceList<Foam::scalar>)
+        .def("lookupSolverPerformanceVectorList", &Foam::lookupSolverPerformanceList<Foam::vector>)
+        .def("lookupSolverPerformanceTensorList", &Foam::lookupSolverPerformanceList<Foam::tensor>)
         .def_property_readonly(
             "get",
             [](Foam::dictionary& self) {

{pybfoam-0.1.6 → pybfoam-0.1.8}/src/pybFoam/pybFoam_core/bind_fvMatrix.cpp

@@ -173,6 +173,21 @@ void declare_solve(py::module &m)
     });
 }
 
+template<class Type>
+py::class_<Foam::SolverPerformance<Type>>
+declare_SolverPerformance(py::module &m, std::string className)
+{
+    return py::class_<Foam::SolverPerformance<Type>>(m, className.c_str())
+        .def(py::init<>())
+        .def("solverName", [](const Foam::SolverPerformance<Type>& self) { return self.solverName(); })
+        .def("fieldName", [](const Foam::SolverPerformance<Type>& self) { return self.fieldName(); })
+        .def("initialResidual", [](const Foam::SolverPerformance<Type>& self) { return self.initialResidual(); })
+        .def("finalResidual", [](const Foam::SolverPerformance<Type>& self) { return self.finalResidual(); })
+        .def("nIterations", [](const Foam::SolverPerformance<Type>& self) { return self.nIterations(); })
+        .def("converged", &Foam::SolverPerformance<Type>::converged)
+        .def("singular", &Foam::SolverPerformance<Type>::singular);
+}
+
 }
 
 void Foam::bindFvMatrix(py::module& m)
@@ -183,9 +198,9 @@ void Foam::bindFvMatrix(py::module& m)
     auto fvVectorMatrix = declare_fvMatrix<Foam::vector>(m, std::string("fvVectorMatrix"));
     auto fvTensorMatrix = declare_fvMatrix<Foam::tensor>(m, std::string("fvTensorMatrix"));
 
-    py::class_<Foam::SolverPerformance<Foam::scalar>>(m, "SolverScalarPerformance");
-    py::class_<Foam::SolverPerformance<Foam::vector>>(m, "SolverVectorPerformance");
-    py::class_<Foam::SolverPerformance<Foam::tensor>>(m, "SolverTensorPerformance");
+    declare_SolverPerformance<Foam::scalar>(m, "SolverScalarPerformance");
+    declare_SolverPerformance<Foam::vector>(m, "SolverVectorPerformance");
+    declare_SolverPerformance<Foam::tensor>(m, "SolverTensorPerformance");
 
     declare_solve<Foam::scalar>(m);
     declare_solve<Foam::vector>(m);

{pybfoam-0.1.6 → pybfoam-0.1.8}/src/pybFoam/pybFoam_core/bind_io.cpp

@@ -20,6 +20,7 @@ License
 #include "bind_io.hpp"
 
 #include "messageStream.H"
+#include "dictionary.H"
 
 
 namespace Foam
@@ -31,6 +32,11 @@ namespace Foam
             Info << word(message) << endl;
         });
 
+        m.def("Info", [](const dictionary& dict)
+        {
+            Info << dict << endl;
+        });
+
     }
     
 

{pybfoam-0.1.6 → pybfoam-0.1.8}/src/pybFoam/pybFoam_core/bind_mesh.cpp

@@ -114,6 +114,7 @@ void bindMesh(pybind11::module &m)
         .def("value", &Foam::Time::timeOutputValue)
         .def("deltaTValue", [](Foam::Time &self) { return self.deltaTValue(); })
         .def("loop", &Foam::Time::loop)
+        .def("run", &Foam::Time::run)
         .def("write", &Foam::Time::write)
         .def("increment", [](Foam::Time &self)
              { self++; }
@@ -155,6 +156,9 @@ void bindMesh(pybind11::module &m)
         .def("Sf", &Foam::fvMesh::Sf, py::return_value_policy::reference)
         .def("magSf", &Foam::fvMesh::magSf, py::return_value_policy::reference)
         .def("setFluxRequired", &Foam::fvMesh::setFluxRequired)
+        .def("solverPerformanceDict", [](const Foam::fvMesh &self)
+             { return &self.data().solverPerformanceDict(); },
+             py::return_value_policy::reference)
         // dynamic mesh support
         .def("changing", [](Foam::fvMesh &self)
              { return self.changing(); })