pybFoam 0.1.2__tar.gz → 0.1.3__tar.gz

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

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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "pybFoam"
-version = "0.1.2"
+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.2 → pybfoam-0.1.3}/src/pybFoam/aggregation/bind_aggregation.cpp

@@ -32,7 +32,8 @@ 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;
@@ -54,8 +55,9 @@ aggregationResult<T> aggSum(
     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;
     }
 
     Foam::reduce(result.values, Foam::sumOp<Foam::Field<T>>());
@@ -63,6 +65,66 @@ aggregationResult<T> aggSum(
     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 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;
+}
+
 template <typename T>
 aggregationResult<T> aggMax(
     const Foam::Field<T> &values,
@@ -104,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>>());
@@ -172,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.2 → pybfoam-0.1.3}/tests/pybind/test_aggregation.py

@@ -41,6 +41,58 @@ def test_sum():
     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])
@@ -60,15 +112,13 @@ def test_min():
 
     # # with groupby
     field = scalarField([1, 2, 3])
-    agg_res = aggregation.min(field, None, labelList([0, 1, 1]))
-    assert agg_res.values[0] == 1
-    assert agg_res.values[1] == 2
-    assert agg_res.group[0] == 0
-    assert agg_res.group[1] == 1
+    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
 
-    agg_res = aggregation.min(field, boolList([True, False, True]), labelList([0, 1, 1]))
-    assert agg_res.values[0] == 1
-    assert agg_res.values[1] == 3
+    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():
 

pybfoam-0.1.2/src/pybFoam/_version.py

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