pybFoam 0.1.7__tar.gz → 0.1.9__tar.gz

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

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

{pybfoam-0.1.7 → pybfoam-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybFoam
-Version: 0.1.7
+Version: 0.1.9
 Summary: python bindings for OpenFOAM
 Keywords: OpenFOAM,simulation,CFD
 Author-Email: Henning Scheufler <henning.scheufler@web.de>

pybfoam-0.1.9/docs/api.rst

@@ -0,0 +1,6 @@
+API Reference
+=============
+
+.. automodule:: pybFoam
+   :members:
+   :undoc-members:

{pybfoam-0.1.7 → pybfoam-0.1.9}/docs/conf.py

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

{pybfoam-0.1.7 → pybfoam-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pybFoam"
-version = "0.1.7"
+version = "0.1.9"
 authors = [
     {name = "Henning Scheufler", email = "henning.scheufler@web.de"},
 ]

pybfoam-0.1.9/src/pybFoam/_version.py

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

{pybfoam-0.1.7 → pybfoam-0.1.9}/src/pybFoam/fvc/bind_fvc.cpp

@@ -140,4 +140,15 @@ void Foam::bindFVC(pybind11::module& fvc)
 
     // ddtCorr
     fvc.def("ddtCorr", [](const volVectorField& vf, const surfaceScalarField& ssf){return fvc::ddtCorr(vf,ssf);});
+
+    fvc.def("snGrad", [](const volScalarField& vf){return fvc::snGrad(vf);});
+    fvc.def("snGrad", [](const tmp<volScalarField>& vf){return fvc::snGrad(vf);});
+    fvc.def("snGrad", [](const volVectorField& vf){return fvc::snGrad(vf);});
+    fvc.def("snGrad", [](const tmp<volVectorField>& vf){return fvc::snGrad(vf);});
+
+
+    fvc.def("reconstruct", [](const surfaceScalarField& sf){return fvc::reconstruct(sf);});
+    fvc.def("reconstruct", [](const tmp<surfaceScalarField>& sf){return fvc::reconstruct(sf);});
+    fvc.def("reconstruct", [](const surfaceVectorField& sf){return fvc::reconstruct(sf);});
+    fvc.def("reconstruct", [](const tmp<surfaceVectorField>& sf){return fvc::reconstruct(sf);});
 }

{pybfoam-0.1.7 → pybfoam-0.1.9}/src/pybFoam/fvc.pyi

@@ -4,7 +4,40 @@ finite volume calculus
 from __future__ import annotations
 import pybFoam.pybFoam_core
 import typing
-__all__ = ['div', 'flux', 'grad', 'interpolate', 'laplacian']
+__all__ = ['ddtCorr', 'div', 'flux', 'grad', 'interpolate', 'laplacian', 'reconstruct', 'snGrad']
+
+# ==== snGrad - surface normal gradient ====
+@typing.overload
+def snGrad(arg0: pybFoam.pybFoam_core.volScalarField) -> pybFoam.pybFoam_core.tmp_surfaceScalarField:
+    ...
+@typing.overload
+def snGrad(arg0: pybFoam.pybFoam_core.tmp_volScalarField) -> pybFoam.pybFoam_core.tmp_surfaceScalarField:
+    ...
+@typing.overload
+def snGrad(arg0: pybFoam.pybFoam_core.volVectorField) -> pybFoam.pybFoam_core.tmp_surfaceVectorField:
+    ...
+@typing.overload
+def snGrad(arg0: pybFoam.pybFoam_core.tmp_volVectorField) -> pybFoam.pybFoam_core.tmp_surfaceVectorField:
+    ...
+
+# ==== reconstruct - reconstruct vector from surface flux ====
+@typing.overload
+def reconstruct(arg0: pybFoam.pybFoam_core.surfaceScalarField) -> pybFoam.pybFoam_core.tmp_volVectorField:
+    ...
+@typing.overload
+def reconstruct(arg0: pybFoam.pybFoam_core.tmp_surfaceScalarField) -> pybFoam.pybFoam_core.tmp_volVectorField:
+    ...
+@typing.overload
+def reconstruct(arg0: pybFoam.pybFoam_core.surfaceVectorField) -> pybFoam.pybFoam_core.tmp_volTensorField:
+    ...
+@typing.overload
+def reconstruct(arg0: pybFoam.pybFoam_core.tmp_surfaceVectorField) -> pybFoam.pybFoam_core.tmp_volTensorField:
+    ...
+
+# ==== ddtCorr ====
+def ddtCorr(arg0: pybFoam.pybFoam_core.volVectorField, arg1: pybFoam.pybFoam_core.surfaceScalarField) -> pybFoam.pybFoam_core.tmp_surfaceScalarField:
+    ...
+
 @typing.overload
 def div(arg0: pybFoam.pybFoam_core.volVectorField) -> pybFoam.pybFoam_core.tmp_volScalarField:
     ...

{pybfoam-0.1.7 → pybfoam-0.1.9}/src/pybFoam/fvm/bind_fvm.cpp

@@ -97,6 +97,7 @@ void Foam::bindFVM(pybind11::module& fvm)
     bindFvmDdt<vector>(fvm);
     bindFvmDdt<tensor>(fvm);
 
+    bindFvmDiv<scalar>(fvm);
     bindFvmDiv<vector>(fvm);
     bindFvmDiv<tensor>(fvm);
     bindFvmDiv<symmTensor>(fvm);

{pybfoam-0.1.7 → pybfoam-0.1.9}/src/pybFoam/pybFoam_core/bind_cfdTools.cpp

@@ -53,6 +53,29 @@ namespace Foam
 
         return std::make_tuple(CoNum, meanCoNum);
     }
+
+    std::tuple <scalar, scalar> computeContinuityErrors
+    (
+        const surfaceScalarField& phi
+    )
+    {
+        // Get mesh and time
+        const fvMesh& mesh = phi.mesh();
+        const Time& runTime = mesh.time();
+        
+        // Compute divergence of flux
+        volScalarField contErr(fvc::div(phi));
+
+        // Calculate local continuity error (absolute sum)
+        scalar sumLocalContErr = runTime.deltaTValue()*
+            mag(contErr)().weightedAverage(mesh.V()).value();
+
+        // Calculate global continuity error (signed)
+        scalar globalContErr = runTime.deltaTValue()*
+            contErr.weightedAverage(mesh.V()).value();
+
+        return std::make_tuple(sumLocalContErr, globalContErr);
+    }
     
 
     template <typename RAUType>
@@ -70,6 +93,7 @@ namespace Foam
 
         m.def("adjustPhi", &adjustPhi);
         declare_constrainPressure<volScalarField>(m);
+        declare_constrainPressure<surfaceScalarField>(m);
         m.def("constrainHbyA", &constrainHbyA);
         m.def("createPhi", [](const volVectorField &U)
         {
@@ -97,6 +121,7 @@ namespace Foam
             return std::make_tuple(pRefCell, pRefValue);
         }, py::arg("p"), py::arg("dict"), py::arg("forceReference") = false);
         m.def("computeCFLNumber", &computeCFLNumber);
+        m.def("computeContinuityErrors", &computeContinuityErrors, py::arg("phi"));
     }
 
 } // namespace Foam

{pybfoam-0.1.7 → pybfoam-0.1.9}/src/pybFoam/pybFoam_core/bind_dict.cpp

@@ -145,10 +145,12 @@ public:
         auto it = reg.find(type_name);
         if (it == reg.end())
             throw std::runtime_error("Unsupported type for dictionary.get: " + type_name);
+
         struct TypeCaller {
             Foam::dictionary& dict;
             GetterFunc func;
             TypeCaller(Foam::dictionary& d, GetterFunc f) : dict(d), func(f) {}
+
             pybind11::object operator()(const std::string& key) {
                 if (!dict.found(key)) {
                     throw pybind11::key_error("Key '" + key + "' not found in dictionary");
@@ -156,6 +158,7 @@ public:
                 return func(dict, key);
             }
         };
+
         return pybind11::cpp_function(TypeCaller(dict, it->second));
     }
 
@@ -167,6 +170,36 @@ public:
     }
 };
 
+class DictionaryGetOrDefaultProxy {
+public:
+    using GetterFunc = std::function<pybind11::object(Foam::dictionary&, const std::string&)>;
+    
+    Foam::dictionary& dict;
+    DictionaryGetOrDefaultProxy(Foam::dictionary& d) : dict(d) {}
+
+    pybind11::object operator[](pybind11::object py_type) {
+        std::string type_name = pybind11::str(py_type.attr("__name__"));
+        auto& reg = DictionaryGetProxy::type_registry();
+        auto it = reg.find(type_name);
+        if (it == reg.end())
+            throw std::runtime_error("Unsupported type for dictionary.getOrDefault: " + type_name);
+        
+        struct TypeCaller {
+            Foam::dictionary& dict;
+            GetterFunc func;
+            TypeCaller(Foam::dictionary& d, GetterFunc f) : dict(d), func(f) {}
+
+            pybind11::object operator()(const std::string& key, pybind11::object default_value) {
+                if (!dict.found(key)) {
+                    return default_value;
+                }
+                return func(dict, key);
+            }
+        };
+        return pybind11::cpp_function(TypeCaller(dict, it->second));
+    }
+};
+
 void bindDict(pybind11::module& m)
 {
     namespace py = pybind11;
@@ -197,6 +230,10 @@ void bindDict(pybind11::module& m)
         .def("toc", &Foam::dictionary::toc)
         .def("clear", &Foam::dictionary::clear)
         .def("clear", &Foam::dictionary::clear)
+        .def("found", [](const Foam::dictionary& self, const std::string key)
+        {
+            return self.found(Foam::word(key));
+        })
         .def("isDict", [](const Foam::dictionary& self, const std::string key)
         {
             return self.isDict(Foam::word(key));
@@ -265,11 +302,21 @@ void bindDict(pybind11::module& m)
             },
             py::return_value_policy::reference_internal
         )
+        .def_property_readonly(
+            "getOrDefault",
+            [](Foam::dictionary& self) {
+                return DictionaryGetOrDefaultProxy(self);
+            },
+            py::return_value_policy::reference_internal
+        )
         ;
 
     py::class_<DictionaryGetProxy>(m, "DictionaryGetProxy")
         .def("__getitem__", &DictionaryGetProxy::operator[]);
 
+    py::class_<DictionaryGetOrDefaultProxy>(m, "DictionaryGetOrDefaultProxy")
+        .def("__getitem__", &DictionaryGetOrDefaultProxy::operator[]);
+
     // Register types for get directly
     DictionaryGetProxy::type_registry()["str"] = [](Foam::dictionary& d, const std::string& key) {
         auto* entry = d.findEntry(Foam::word(key)); 

pybfoam-0.1.9/src/pybFoam/pybFoam_core/bind_dimensioned.cpp

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------*\
+            Copyright (c) 20212, Henning Scheufler
+-------------------------------------------------------------------------------
+License
+    This file is part of the pybFoam source code library, which is an
+	unofficial extension to OpenFOAM.
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "bind_dimensioned.hpp"
+#include "dimensionedType.H"
+#include "dimensionSet.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "tmp.H"
+
+namespace Foam
+{
+
+    template<class Type>
+    auto declare_dimensioned(py::module &m, std::string className)
+    {
+        return py::class_<dimensioned<Type>>(m, className.c_str())
+            .def(py::init<const word&,  const dimensionSet, const Type&>())
+            .def(py::init<const word&, const dimensionSet, const dictionary&>())
+            .def(py::init([](const std::string& name, const dimensionSet& dims, const Type& value) {
+                return dimensioned<Type>(word(name), dims, value);
+            }))
+            .def("name", [](const dimensioned<Type>& self) { return std::string(self.name()); })
+            .def("dimensions", [](const dimensioned<Type>& self) { return self.dimensions(); })
+            .def("value", [](const dimensioned<Type>& self) { return self.value(); })
+            
+            .def("__mul__", [](const dimensioned<Type>& self, const GeometricField<scalar, fvPatchField, volMesh>& field) {
+                return self * field;
+            }, "dimensioned × volScalarField")
+            .def("__mul__", [](const dimensioned<Type>& self, const tmp<GeometricField<scalar, fvPatchField, volMesh>>& field) {
+                return self * field;
+            }, "dimensioned × tmp<volScalarField>")
+            
+            .def("__mul__", [](const dimensioned<Type>& self, const GeometricField<scalar, fvsPatchField, surfaceMesh>& field) {
+                return self * field;
+            }, "dimensioned × surfaceScalarField")
+            .def("__mul__", [](const dimensioned<Type>& self, const tmp<GeometricField<scalar, fvsPatchField, surfaceMesh>>& field) {
+                return self * field;
+            }, "dimensioned × tmp<surfaceScalarField>")
+            
+            .def("__add__", [](const dimensioned<Type>& self, const GeometricField<Type, fvPatchField, volMesh>& field) {
+                return self + field;
+            }, "dimensioned + volField")
+            .def("__add__", [](const dimensioned<Type>& self, const tmp<GeometricField<Type, fvPatchField, volMesh>>& field) {
+                return self + field;
+            }, "dimensioned + tmp<volField>")
+    
+            .def("__sub__", [](const dimensioned<Type>& self, const GeometricField<Type, fvPatchField, volMesh>& field) {
+                return self - field;
+            }, "dimensioned - volField")
+            .def("__sub__", [](const dimensioned<Type>& self, const tmp<GeometricField<Type, fvPatchField, volMesh>>& field) {
+                return self - field;
+            }, "dimensioned - tmp<volField>")
+            ;
+    }
+
+}
+
+
+void bindDimensioned(pybind11::module& m)
+{
+    namespace py = pybind11;
+
+    // Bind dimensionSet class
+    py::class_<Foam::dimensionSet>(m, "dimensionSet")
+        .def(py::init<Foam::scalar, Foam::scalar, Foam::scalar, Foam::scalar, Foam::scalar, Foam::scalar, Foam::scalar>())
+        .def("__pow__", [](const Foam::dimensionSet& self, Foam::scalar p) {
+            return Foam::pow(self, p);
+        })
+        .def("__mul__", [](const Foam::dimensionSet& self, const Foam::dimensionSet& other) {
+            return self * other;
+        })
+        .def("__truediv__", [](const Foam::dimensionSet& self, const Foam::dimensionSet& other) {
+            return self / other;
+        })
+        .def("__and__", [](const Foam::dimensionSet& self, const Foam::dimensionSet& other) {
+            return self & other;
+        })
+        ;
+
+    // Bind common dimension constants
+    m.attr("dimless") = Foam::dimless;
+    m.attr("dimMass") = Foam::dimMass;
+    m.attr("dimLength") = Foam::dimLength;
+    m.attr("dimArea") = Foam::dimArea;
+    m.attr("dimTime") = Foam::dimTime;
+    m.attr("dimTemperature") = Foam::dimTemperature;
+    m.attr("dimMoles") = Foam::dimMoles;
+    m.attr("dimCurrent") = Foam::dimCurrent;
+    m.attr("dimLuminousIntensity") = Foam::dimLuminousIntensity;
+    m.attr("dimVelocity") = Foam::dimVelocity;
+    m.attr("dimAcceleration") = Foam::dimAcceleration;
+    m.attr("dimForce") = Foam::dimForce;
+    m.attr("dimPressure") = Foam::dimPressure;
+    m.attr("dimDensity") = Foam::dimDensity;
+    m.attr("dimEnergy") = Foam::dimEnergy;
+    m.attr("dimPower") = Foam::dimPower;
+    m.attr("dimViscosity") = Foam::dimViscosity;
+
+    auto dsf = Foam::declare_dimensioned<Foam::scalar>(m, "dimensionedScalar");
+    auto dvf = Foam::declare_dimensioned<Foam::vector>(m, "dimensionedVector");
+    auto dtf = Foam::declare_dimensioned<Foam::tensor>(m, "dimensionedTensor");
+
+    // Add scalar-specific cross-type multiplication operators for dimensioned<scalar>
+    // (scalar × vector/tensor fields, etc.)
+    // dimensioned<scalar> × volVectorField
+    dsf.def("__mul__", [](const Foam::dimensioned<Foam::scalar>& self, const Foam::volVectorField& field) {
+        return self * field;
+    }, "dimensioned × volVectorField")
+    .def("__mul__", [](const Foam::dimensioned<Foam::scalar>& self, const Foam::tmp<Foam::volVectorField>& field) {
+        return self * field;
+    }, "dimensioned × tmp<volVectorField>")
+    ;
+
+
+}

{pybfoam-0.1.7 → pybfoam-0.1.9}/src/pybFoam/pybFoam_core/bind_dimensioned.hpp

@@ -40,7 +40,7 @@ namespace Foam
     namespace py = pybind11;
 
 template<class Type>
-void declare_dimensioned(py::module &m, std::string className);
+auto declare_dimensioned(py::module &m, std::string className);
 
 
 }

{pybfoam-0.1.7 → pybfoam-0.1.9}/src/pybFoam/pybFoam_core/bind_fields.cpp

@@ -21,6 +21,10 @@ License
 #include "bind_primitives.hpp"
 #include "bind_primitives.hpp"
 #include "instantList.H"
+#include "uniformDimensionedFields.H"
+#include "fvMesh.H"
+#include "volFields.H"
+#include "surfaceFields.H"
 
 
 namespace py = pybind11;
@@ -98,10 +102,14 @@ py::class_< Field<Type>> declare_fields(py::module &m, std::string className) {
     .def("__setitem__", [](Field<Type>& self, const label idx,const Type& s) {
         self[idx] = s;
     })
-    .def("__add__", &Foam::add<Field<Type> >)
+    .def("__add__", [](const Field<Type>& self, const Field<Type>& f) {
+        return Field<Type>(self + f);
+    })
     .def("__add__", [](Field<Type>& self, const Type& s) {return Field<Type>(self + s);})
-    .def("__sub__", &Foam::subtract<Field<Type> >)
-    .def("__sub__", [](Field<Type>& self, const Type& s) {return Field<Type>(self + s);})
+    .def("__sub__", [](const Field<Type>& self, const Field<Type>& f) {
+        return Field<Type>(self - f);
+    })
+    .def("__sub__", [](Field<Type>& self, const Type& s) {return Field<Type>(self - s);})
     .def("__mul__", [](Field<Type>& self, const scalar& s) {return Field<Type>(self * s);})
     .def("__mul__", [](Foam::Field<Type>& self, const Field<scalar>& sf)
     {
@@ -110,7 +118,7 @@ py::class_< Field<Type>> declare_fields(py::module &m, std::string className) {
     .def("__truediv__", [](Field<Type>& self, const scalar& s) {return Field<Type>(self / s);})
     .def("__truediv__", [](Field<Type>& self, const Field<scalar>& sf)
     {
-        return Field<Type>(self * sf);
+        return Field<Type>(self / sf);
     })
     .def_buffer([](Field<Type>& self) -> py::buffer_info {
         constexpr bool isScalar = std::is_same<Type, Foam::scalar>::value;
@@ -308,4 +316,69 @@ void Foam::bindFields(py::module& m)
     m.def("sum",declare_sum<vector>);
     m.def("sum",declare_sum<tensor>);
     m.def("sum",declare_sum<symmTensor>);
+
+    // ==== uniformDimensionedVectorField bindings ====
+    // Used for reading constant fields like gravity
+    py::class_<Foam::uniformDimensionedVectorField>(m, "uniformDimensionedVectorField")
+        .def(py::init([](const Foam::fvMesh& mesh, const std::string& fieldName) {
+            return Foam::uniformDimensionedVectorField(
+                Foam::IOobject(
+                    fieldName,
+                    mesh.time().constant(),
+                    mesh,
+                    Foam::IOobject::MUST_READ,
+                    Foam::IOobject::NO_WRITE
+                )
+            );
+        }), py::arg("mesh"),
+            py::arg("fieldName"),
+            "Read a uniformDimensionedVectorField from constant/ directory")
+        .def("value", [](const Foam::uniformDimensionedVectorField& self) {
+            return self.value();
+        }, "Get the uniform vector value")
+        .def("name", [](const Foam::uniformDimensionedVectorField& self) {
+            return self.name();
+        }, "Get the field name")
+        .def("dimensions", [](const Foam::uniformDimensionedVectorField& self) {
+            return self.dimensions();
+        }, "Get the field dimensions")
+        .def("__and__", [](const Foam::uniformDimensionedVectorField& self, 
+                           const Foam::volVectorField& vf) {
+            // Use the base class dimensioned<vector> which has operator& defined
+            const Foam::dimensioned<Foam::vector>& dv = self;
+            return dv & vf;
+        }, py::arg("vf"), "Dot product with volVectorField, returns tmp<volScalarField>")
+        .def("__and__", [](const Foam::uniformDimensionedVectorField& self, 
+                           const Foam::surfaceVectorField& vf) {
+            // Use the base class dimensioned<vector> which has operator& defined
+            const Foam::dimensioned<Foam::vector>& dv = self;
+            return dv & vf;
+        }, py::arg("vf"), "Dot product with surfaceVectorField, returns tmp<surfaceScalarField>")
+        ;
+
+    // ==== uniformDimensionedScalarField bindings ====
+    py::class_<Foam::uniformDimensionedScalarField>(m, "uniformDimensionedScalarField")
+        .def(py::init([](const Foam::fvMesh& mesh, const std::string& fieldName) {
+            return Foam::uniformDimensionedScalarField(
+                Foam::IOobject(
+                    fieldName,
+                    mesh.time().constant(),
+                    mesh,
+                    Foam::IOobject::MUST_READ,
+                    Foam::IOobject::NO_WRITE
+                )
+            );
+        }), py::arg("mesh"),
+            py::arg("fieldName"),
+            "Read a uniformDimensionedScalarField from constant/ directory")
+        .def("value", [](const Foam::uniformDimensionedScalarField& self) {
+            return self.value();
+        }, "Get the uniform scalar value")
+        .def("name", [](const Foam::uniformDimensionedScalarField& self) {
+            return self.name();
+        }, "Get the field name")
+        .def("dimensions", [](const Foam::uniformDimensionedScalarField& self) {
+            return self.dimensions();
+        }, "Get the field dimensions")
+        ;
 }