pybFoam 0.1.0__tar.gz → 0.1.1__tar.gz

{pybfoam-0.1.0 → pybfoam-0.1.1}/.github/workflows/ci.yaml

@@ -28,11 +28,9 @@ jobs:
       - name: Install build dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install scikit-build-core[pyproject] pybind11 cmake numpy pydantic pyyaml
-          pip install .[dev]
       - name: Build package
         run: |
-          pip install .
+          pip install .[dev]
       - name: Run tests
         run: |
           pytest

pybfoam-0.1.1/.github/workflows/release.yaml

@@ -0,0 +1,29 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install build and twine
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+      - name: Build sdist
+        run: |
+          python -m build --sdist
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_PYBFOAM_API_TOKEN }}
+        run: |
+          twine upload dist/*

{pybfoam-0.1.0 → pybfoam-0.1.1}/CMakeLists.txt

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

{pybfoam-0.1.0 → pybfoam-0.1.1}/PKG-INFO

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

{pybfoam-0.1.0 → pybfoam-0.1.1}/pyproject.toml

@@ -1,14 +1,6 @@
-[build-system]
-requires = [
-    "scikit-build-core[pyproject]>=0.4.3",
-    "pybind11>=2.6.0",
-    "cmake>=3.18",
-]
-build-backend = "scikit_build_core.build"
-
 [project]
 name = "pybFoam"
-version = "0.1.0"
+version = "0.1.1"
 authors = [
     {name = "Henning Scheufler", email = "henning.scheufler@dlr.de"},
 ]
@@ -68,6 +60,15 @@ Issues = "https://github.com/DLR-RY/pybFoam/issues"
 include-package-data = true
 zip-safe = false
 
+[build-system]
+requires = [
+    "scikit-build-core[pyproject]>=0.4.3",
+    "pybind11>=2.6.0",
+    "cmake>=3.18",
+]
+build-backend = "scikit_build_core.build"
+
+
 [tool.scikit-build]
 cmake.version = ">=3.18"
 cmake.build-type = "Release"

{pybfoam-0.1.0 → pybfoam-0.1.1}/src/pybFoam/CMakeLists.txt

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

{pybfoam-0.1.0 → pybfoam-0.1.1}/src/pybFoam/__init__.py

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

pybfoam-0.1.1/src/pybFoam/_version.py

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

pybfoam-0.1.1/src/pybFoam/aggregation/CMakeLists.txt

@@ -0,0 +1,43 @@
+# thermo module CMakeLists.txt
+
+set(THERMO_SOURCES
+    bind_aggregation.cpp
+    aggregation.cpp
+)
+
+set(THERMO_HEADERS
+    bind_aggregation.hpp
+)
+
+# Create the pybind11 module
+pybind11_add_module(aggregation ${THERMO_SOURCES})
+
+# Set target properties
+set_target_properties(aggregation PROPERTIES
+    CXX_VISIBILITY_PRESET "hidden"
+    VISIBILITY_INLINES_HIDDEN ON
+)
+
+# Link OpenFOAM libraries
+target_link_libraries(aggregation PRIVATE
+    OpenFOAM::finiteVolume
+)
+
+# Add include directories specific to this module
+target_include_directories(aggregation PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# Install the module
+if(DEFINED SKBUILD)
+    # scikit-build-core manages the installation
+    install(TARGETS aggregation
+        LIBRARY DESTINATION pybFoam
+        COMPONENT python
+    )
+else()
+    # Standalone build - install to Python site-packages
+    install(TARGETS aggregation
+        LIBRARY DESTINATION "${Python_SITELIB}/pybFoam"
+    )
+endif()

pybfoam-0.1.1/src/pybFoam/aggregation/aggregation.cpp

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------*\
+            Copyright (c) 2021, German Aerospace Center (DLR)
+-------------------------------------------------------------------------------
+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 <pybind11/pybind11.h>
+
+#include "bind_aggregation.hpp"
+
+namespace py = pybind11;
+
+
+PYBIND11_MODULE(aggregation, aggregation) {
+    aggregation.doc() = "openfoam aggregation package"; // optional module docstring
+
+    Foam::bindAggregation(aggregation);
+}

pybfoam-0.1.1/src/pybFoam/aggregation/bind_aggregation.cpp

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+            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_aggregation.hpp"
+
+namespace py = pybind11;
+
+template <class Type>
+struct aggregationResult
+{
+    Foam::Field<Type> values;
+    std::optional<Foam::labelList> group = std::nullopt;
+};
+
+template <typename T>
+aggregationResult<T> aggSum(
+    const Foam::Field<T> &values,
+    std::optional<Foam::boolList> mask = std::nullopt,
+    std::optional<Foam::labelList> group = std::nullopt)
+{
+    aggregationResult<T> result;
+    auto nGroups = group ? max(*group) + 1 : 1;
+    result.values = Foam::Field<T>(nGroups, Foam::Zero);
+
+    const Foam::label nElements = values.size();
+
+    for (Foam::label i = 0; i < nElements; ++i)
+    {
+        Foam::label groupIndex = group ? (*group)[i] : 0;
+        Foam::scalar scale = mask ? (*mask)[i] : 1.0;
+        result.values[groupIndex] += values[i] * scale;
+    }
+
+    Foam::reduce(result.values, Foam::sumOp<Foam::Field<T>>());
+
+    return result;
+}
+
+template <typename T>
+aggregationResult<T> aggMax(
+    const Foam::Field<T> &values,
+    std::optional<Foam::boolList> mask = std::nullopt,
+    std::optional<Foam::labelList> group = std::nullopt)
+{
+    aggregationResult<T> result;
+    auto nGroups = group ? max(*group) + 1 : 1;
+    if constexpr (std::is_same<T, Foam::scalar>::value)
+    {
+        result.values = Foam::Field<T>(nGroups, -Foam::GREAT);
+    }
+    else
+    {
+        result.values = Foam::Field<T>(nGroups, T::one * -Foam::GREAT);
+    }
+
+    const Foam::label nElements = values.size();
+
+    for (Foam::label i = 0; i < nElements; ++i)
+    {
+        Foam::label groupIndex = group ? (*group)[i] : 0;
+        if (mask)
+        {
+            if (!(*mask)[i]) // if mask is false, skip
+            {
+                continue;
+            }
+        }
+        result.values[groupIndex] = Foam::max(result.values[groupIndex], values[i]);
+        
+    }
+
+    Foam::reduce(result.values, Foam::maxOp<Foam::Field<T>>());
+
+    return result;
+}
+
+template <typename T>
+aggregationResult<T> aggMin(
+    const Foam::Field<T> &values,
+    std::optional<Foam::boolList> mask = std::nullopt,
+    std::optional<Foam::labelList> group = std::nullopt)
+{
+    aggregationResult<T> result;
+    auto nGroups = group ? max(*group) + 1 : 1;
+
+    if constexpr (std::is_same<T, Foam::scalar>::value)
+    {
+        result.values = Foam::Field<T>(nGroups, Foam::GREAT);
+    }
+    else
+    {
+        result.values = Foam::Field<T>(nGroups, T::one * Foam::GREAT);
+    }
+
+    const Foam::label nElements = values.size();
+
+    for (Foam::label i = 0; i < nElements; ++i)
+    {
+        Foam::label groupIndex = group ? (*group)[i] : 0;
+        if (mask)
+        {
+            if (!(*mask)[i]) // if mask is false, skip
+            {
+                continue;
+            }
+        }
+        result.values[groupIndex] = Foam::min(result.values[groupIndex], values[i]);
+    }
+
+    Foam::reduce(result.values, Foam::minOp<Foam::Field<T>>());
+
+    return result;
+}
+
+void Foam::bindAggregation(py::module &m)
+{
+
+    py::class_<aggregationResult<scalar>>(m, "scalarAggregationResult")
+        .def_readonly("values", &aggregationResult<scalar>::values)
+        .def_readonly("group", &aggregationResult<scalar>::group);
+
+    py::class_<aggregationResult<vector>>(m, "vectorAggregationResult")
+        .def_readonly("values", &aggregationResult<vector>::values)
+        .def_readonly("group", &aggregationResult<vector>::group);
+
+    m.def("sum", &aggSum<scalar>);
+    m.def("sum", &aggSum<vector>);
+
+    m.def("max", &aggMax<scalar>);
+    m.def("max", &aggMax<vector>);
+
+    m.def("min", &aggMin<scalar>);
+    m.def("min", &aggMin<vector>);
+}

pybfoam-0.1.1/src/pybFoam/aggregation/bind_aggregation.hpp

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------*\
+            Copyright (c) 2022, 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/>.
+
+Class
+    Foam::pyInterp
+
+Description
+
+Author
+    Henning Scheufler, all rights reserved.
+
+SourceFiles
+
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef bind_thermo
+#define bind_thermo
+
+// System includes
+#include <pybind11/pybind11.h>
+#include "Field.H"
+#include "scalar.H"
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+
+
+namespace py = pybind11;
+
+namespace Foam
+{
+
+void  bindAggregation(py::module& m);
+
+}
+
+#endif 

{pybfoam-0.1.0 → pybfoam-0.1.1}/src/pybFoam/pybFoam_core/bind_fields.cpp

@@ -161,6 +161,72 @@ void Foam::bindFields(py::module& m)
         })
     ;
 
+    py::class_<List<bool>>(m, "boolList")
+        .def(py::init<List<bool> > ())
+        .def(py::init([](std::vector<bool> vec) {
+            List<bool> f(vec.size());
+            forAll(f,i)
+            {
+                f[i] = vec[i];
+            }
+            return f;
+        }))
+        .def("__len__", [](const List<bool>& self) {
+            return self.size();
+        })
+        .def("__getitem__", [](const List<bool>& self, const label idx) {
+            if (idx >= self.size())
+            {
+                throw py::index_error();
+            }
+            return self[idx];
+        })
+        .def("__setitem__", [](List<bool>& self, const label idx,const bool& s) {
+            self[idx] = s;
+        })
+        .def("list",[](List<bool>& self){
+            std::vector<bool> l_out(self.size());
+            forAll(self,i)
+            {
+                l_out[i] = self[i];
+            }
+            return l_out;
+        })
+        ;
+
+    py::class_<List<label>>(m, "labelList")
+        .def(py::init<List<label> > ())
+        .def(py::init([](std::vector<label> vec) {
+            List<label> f(vec.size());
+            forAll(f,i)
+            {
+                f[i] = vec[i];
+            }
+            return f;
+        }))
+        .def("__len__", [](const List<label>& self) {
+            return self.size();
+        })
+        .def("__getitem__", [](const List<label>& self, const label idx) {
+            if (idx >= self.size())
+            {
+                throw py::index_error();
+            }
+            return self[idx];
+        })
+        .def("__setitem__", [](List<label>& self, const label idx,const label& s) {
+            self[idx] = s;
+        })
+        .def("list",[](List<label>& self){
+            std::vector<label> l_out(self.size());
+            forAll(self,i)
+            {
+                l_out[i] = self[i];
+            }
+            return l_out;
+        })
+        ;
+
     py::class_<List<word>>(m, "wordList")
         .def(py::init<List<word> > ())
         .def(py::init([](std::vector<std::string> vec) {
@@ -235,6 +301,8 @@ void Foam::bindFields(py::module& m)
 
 
 
+
+
     m.def("sum",declare_sum<scalar>);
     m.def("sum",declare_sum<vector>);
     m.def("sum",declare_sum<tensor>);

pybfoam-0.1.1/tests/pybind/test_aggregation.py

@@ -0,0 +1,82 @@
+import pytest
+from pybFoam import vector, boolList, labelList, mag, scalarField, vectorField, tensorField
+from pybFoam import aggregation
+import numpy as np
+
+
+def test_mag():
+    s = -10
+    assert mag(s) == 10
+
+
+def test_sum():
+    field = scalarField([1, 2, 3])
+    assert aggregation.sum(field, boolList([True, True, True]), None).values[0] == 6
+    assert aggregation.sum(field, None, None).values[0] == 6
+    assert aggregation.sum(field, boolList([True, False, True]), None).values[0] == 4
+
+    field = vectorField([vector(1, 2, 3), vector(4, 5, 6)])
+    assert aggregation.sum(field, None, None).values[0] == vector(5, 7, 9)
+    assert aggregation.sum(field, boolList([True, True]), None).values[0] == vector(
+        5, 7, 9
+    )
+    assert aggregation.sum(field, boolList([True, False]), None).values[0] == vector(
+        1, 2, 3
+    )
+
+    # # with groupby
+    field = scalarField([1, 2, 3])
+    assert aggregation.sum(field, None, labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.sum(field, None, labelList([0, 1, 1])).values[1] == 5
+
+    assert aggregation.sum(field, boolList([True, False, True]), labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.sum(field, boolList([True, False, True]), labelList([0, 1, 1])).values[1] == 3
+
+
+def test_min():
+
+    field = scalarField([1, 2, 3])
+    assert aggregation.min(field, None, None).values[0] == 1
+    assert aggregation.min(field, boolList([True, True, True]), None).values[0] == 1
+    assert aggregation.min(field, boolList([True, False, True]), None).values[0] == 1
+
+    field = vectorField([vector(1, 2, 3), vector(4, 5, 6)])
+    assert aggregation.min(field, None, None).values[0] == vector(1, 2, 3)
+    assert aggregation.min(field, boolList([True, True]), None).values[0] == vector(
+        1, 2, 3
+    )
+    assert aggregation.min(field, boolList([True, False]), None).values[0] == vector(
+        1, 2, 3
+    )
+
+    # # with groupby
+    field = scalarField([1, 2, 3])
+    assert aggregation.min(field, None, labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.min(field, None, labelList([0, 1, 1])).values[1] == 2
+
+    assert aggregation.min(field, boolList([True, False, True]), labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.min(field, boolList([True, False, True]), labelList([0, 1, 1])).values[1] == 3
+
+def test_max():
+
+    field = scalarField([1, 2, 3])
+    assert aggregation.max(field, None, None).values[0] == 3
+    assert aggregation.max(field, boolList([True, True, True]), None).values[0] == 3
+    assert aggregation.max(field, boolList([True, False, True]), None).values[0] == 3
+
+    field = vectorField([vector(1, 2, 3), vector(4, 5, 6)])
+    assert aggregation.max(field, None, None).values[0] == vector(4, 5, 6)
+    assert aggregation.max(field, boolList([True, True]), None).values[0] == vector(
+        4, 5, 6
+    )
+    assert aggregation.max(field, boolList([True, False]), None).values[0] == vector(
+        1, 2, 3
+    )
+
+    # # with groupby
+    field = scalarField([1, 2, 3])
+    assert aggregation.max(field, None, labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.max(field, None, labelList([0, 1, 1])).values[1] == 3
+
+    assert aggregation.max(field, boolList([True, False, True]), labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.max(field, boolList([True, False, True]), labelList([0, 1, 1])).values[1] == 3

pybfoam-0.1.0/src/pybFoam/_version.py

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