pybFoam 0.1.1__tar.gz → 0.1.3__tar.gz

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

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

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

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

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

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

pybfoam-0.1.3/src/pybFoam/_version.py

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

{pybfoam-0.1.1 → pybfoam-0.1.3}/src/pybFoam/aggregation/bind_aggregation.cpp

@@ -32,22 +32,95 @@ 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)
+    std::optional<Foam::labelList> group = std::nullopt,
+    std::optional<Foam::scalarField> scalingFactor = std::nullopt)
+{
+    aggregationResult<T> result;
+    auto nGroups = group ? max(*group) + 1 : 1;
+    result.values = Foam::Field<T>(nGroups, Foam::Zero);
+    // store the group information in the result
+    // ranging from 0 to nGroups-1
+    // if no grouping is done, this remains nullopt
+    if (group)
+    {
+        result.group = Foam::labelList(nGroups);
+        for (Foam::label i = 0; i < nGroups; ++i)
+        {
+            (*result.group)[i] = i;
+        }
+    }
+
+    const Foam::label nElements = values.size();
+
+    for (Foam::label i = 0; i < nElements; ++i)
+    {
+        Foam::label groupIndex = group ? (*group)[i] : 0;
+        Foam::scalar masking = mask ? (*mask)[i] : 1.0;
+        Foam::scalar scaleFactor = scalingFactor ? (*scalingFactor)[i] : 1.0;
+        result.values[groupIndex] += values[i] * masking * scaleFactor;
+    }
+
+    Foam::reduce(result.values, Foam::sumOp<Foam::Field<T>>());
+
+    return result;
+}
+
+
+template <typename T>
+aggregationResult<T> aggMean(
+    const Foam::Field<T> &values,
+    std::optional<Foam::boolList> mask = std::nullopt,
+    std::optional<Foam::labelList> group = std::nullopt,
+    std::optional<Foam::scalarField> scalingFactor = std::nullopt)
 {
     aggregationResult<T> result;
     auto nGroups = group ? max(*group) + 1 : 1;
     result.values = Foam::Field<T>(nGroups, Foam::Zero);
+    Foam::Field<Foam::scalar> weights(nGroups, 0.0);
+    // store the group information in the result
+    // ranging from 0 to nGroups-1
+    // if no grouping is done, this remains nullopt
+    if (group)
+    {
+        result.group = Foam::labelList(nGroups);
+        for (Foam::label i = 0; i < nGroups; ++i)
+        {
+            (*result.group)[i] = i;
+        }
+    }
 
     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::scalar masking = mask ? (*mask)[i] : 1.0;
+        Foam::scalar scaleFactor = scalingFactor ? (*scalingFactor)[i] : 1.0;
+        result.values[groupIndex] += values[i] * masking * scaleFactor;
+        weights[groupIndex] += masking * scaleFactor;
     }
 
     Foam::reduce(result.values, Foam::sumOp<Foam::Field<T>>());
+    Foam::reduce(weights, Foam::sumOp<Foam::Field<Foam::scalar>>());
+    
+    for (Foam::label i = 0; i < nGroups; ++i)
+    {
+        if (weights[i] > Foam::SMALL)
+        {
+            result.values[i] /= weights[i];
+        }
+        else
+        {
+            if constexpr (std::is_same<T, Foam::scalar>::value)
+            {
+                result.values[i] = Foam::GREAT; // if no valid entries, set to large value
+            }
+            else
+            {
+                result.values[i] = T::one * Foam::GREAT;
+            }
+        }
+    }
 
     return result;
 }
@@ -60,6 +133,17 @@ aggregationResult<T> aggMax(
 {
     aggregationResult<T> result;
     auto nGroups = group ? max(*group) + 1 : 1;
+    // store the group information in the result
+    // ranging from 0 to nGroups-1
+    // if no grouping is done, this remains nullopt
+    if (group)
+    {
+        result.group = Foam::labelList(nGroups);
+        for (Foam::label i = 0; i < nGroups; ++i)
+        {
+            (*result.group)[i] = i;
+        }
+    }
     if constexpr (std::is_same<T, Foam::scalar>::value)
     {
         result.values = Foam::Field<T>(nGroups, -Foam::GREAT);
@@ -82,7 +166,6 @@ aggregationResult<T> aggMax(
             }
         }
         result.values[groupIndex] = Foam::max(result.values[groupIndex], values[i]);
-        
     }
 
     Foam::reduce(result.values, Foam::maxOp<Foam::Field<T>>());
@@ -98,6 +181,17 @@ aggregationResult<T> aggMin(
 {
     aggregationResult<T> result;
     auto nGroups = group ? max(*group) + 1 : 1;
+    // store the group information in the result
+    // ranging from 0 to nGroups-1
+    // if no grouping is done, this remains nullopt
+    if (group)
+    {
+        result.group = Foam::labelList(nGroups);
+        for (Foam::label i = 0; i < nGroups; ++i)
+        {
+            (*result.group)[i] = i;
+        }
+    }
 
     if constexpr (std::is_same<T, Foam::scalar>::value)
     {
@@ -139,8 +233,12 @@ void Foam::bindAggregation(py::module &m)
         .def_readonly("values", &aggregationResult<vector>::values)
         .def_readonly("group", &aggregationResult<vector>::group);
 
-    m.def("sum", &aggSum<scalar>);
-    m.def("sum", &aggSum<vector>);
+    m.def("sum", &aggSum<scalar>, py::arg("values"), py::arg("mask") = std::nullopt, py::arg("group") = std::nullopt, py::kw_only(),py::arg("scalingFactor") = std::nullopt);
+    m.def("sum", &aggSum<vector>, py::arg("values"), py::arg("mask") = std::nullopt, py::arg("group") = std::nullopt, py::kw_only(),py::arg("scalingFactor") = std::nullopt);
+
+
+    m.def("mean", &aggMean<scalar>, py::arg("values"), py::arg("mask") = std::nullopt, py::arg("group") = std::nullopt, py::kw_only(),py::arg("scalingFactor") = std::nullopt);
+    m.def("mean", &aggMean<vector>, py::arg("values"), py::arg("mask") = std::nullopt, py::arg("group") = std::nullopt, py::kw_only(),py::arg("scalingFactor") = std::nullopt);
 
     m.def("max", &aggMax<scalar>);
     m.def("max", &aggMax<vector>);

pybfoam-0.1.3/tests/pybind/test_aggregation.py

@@ -0,0 +1,148 @@
+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, boolList([True, True, True]), None).group == None
+    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])
+    
+    agg_res = aggregation.sum(field, None, labelList([0, 1, 1]))
+    assert agg_res.values[0] == 1
+    assert agg_res.values[1] == 5
+    assert agg_res.group[0] == 0
+    assert agg_res.group[1] == 1
+
+    agg_res = aggregation.sum(field, boolList([True, False, True]), labelList([0, 1, 1]))
+    assert agg_res.values[0] == 1
+    assert agg_res.values[1] == 3
+    assert agg_res.group[0] == 0
+    assert agg_res.group[1] == 1
+
+
+    # with scaling factor
+    field = scalarField([1, 2, 3])
+    scalingFactor = scalarField([2, 4, 4])
+    agg_res = aggregation.sum(field, None, labelList([0, 1, 1]), scalingFactor=scalingFactor)
+    assert agg_res.values[0] == 2
+    assert agg_res.values[1] == 20
+    assert agg_res.group[0] == 0
+    assert agg_res.group[1] == 1
+
+
+def test_mean():
+    field = scalarField([1, 2, 3])
+    assert aggregation.mean(field, None, None).values[0] == 2
+    assert aggregation.mean(field, None, None).group == None
+    assert aggregation.mean(field, boolList([True, True, True]), None).values[0] == 2
+    assert aggregation.mean(field, boolList([True, False, True]), None).values[0] == 2
+
+    field = vectorField([vector(1, 2, 3), vector(4, 5, 6)])
+    assert aggregation.mean(field, None, None).values[0] == vector(2.5, 3.5, 4.5)
+    assert aggregation.mean(field, boolList([True, True]), None).values[0] == vector(2.5, 3.5, 4.5)
+    assert aggregation.mean(field, boolList([True, False]), None).values[0] == vector(1, 2, 3)
+
+    # # with groupby
+    field = scalarField([1, 2, 3])
+    assert aggregation.mean(field, None, labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.mean(field, None, labelList([0, 1, 1])).values[1] == 2.5
+    assert aggregation.mean(field, None, labelList([0, 1, 1])).group[0] == 0
+    assert aggregation.mean(field, None, labelList([0, 1, 1])).group[1] == 1
+
+    assert aggregation.mean(field, boolList([True, False, True]), labelList([0, 1, 1])).values[0] == 1
+    assert aggregation.mean(field, boolList([True, False, True]), labelList([0, 1, 1])).values[1] == 3
+
+    # with scaling factor
+    field = scalarField([1, 28, 3])
+    scalingFactor = scalarField([2, 6, 4])
+    agg_res = aggregation.mean(field, None, labelList([0, 1, 1]), scalingFactor=scalingFactor)
+    assert agg_res.values[0] == 1
+    assert agg_res.values[1] == 18.0
+    assert agg_res.group[0] == 0
+    assert agg_res.group[1] == 1
+
+    # with scaling factor empty groups
+    field = scalarField([1, 28, 3])
+    scalingFactor = scalarField([2, 6, 4])
+    agg_res = aggregation.mean(field, None, labelList([1, 2, 2]), scalingFactor=scalingFactor)
+    assert agg_res.values[0] == 1000000000000000.0 # empty group
+    assert agg_res.values[1] == 1.0
+    assert agg_res.values[2] == 18.0
+    assert agg_res.group[0] == 0
+    assert agg_res.group[1] == 1
+    assert agg_res.group[2] == 2
+
+def test_min():
+
+    field = scalarField([1, 2, 3])
+    assert aggregation.min(field, None, None).values[0] == 1
+    assert aggregation.min(field, None, None).group == None
+    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, None, labelList([0, 1, 1])).group[0] == 0
+    assert aggregation.min(field, None, labelList([0, 1, 1])).group[1] == 1
+
+    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, None, None).group == None
+    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, None, labelList([0, 1, 1])).group[0] == 0
+    assert aggregation.max(field, None, labelList([0, 1, 1])).group[1] == 1
+
+    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.1/src/pybFoam/_version.py

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

pybfoam-0.1.1/tests/pybind/test_aggregation.py

@@ -1,82 +0,0 @@
-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