Increase lbmpy Version

CMakeLists.txt

@@ -619,7 +619,7 @@ endif ()
 ##
 #############################################################################################################################
 if ( WALBERLA_BUILD_WITH_CODEGEN )
-   set(LBMPY_MIN_VERSION 1.3.3)
+   set(LBMPY_MIN_VERSION 1.3.6)
    execute_process(COMMAND ${Python_EXECUTABLE} -c "import lbmpy; print(lbmpy.__version__)"
          RESULT_VARIABLE LBMPY_FOUND OUTPUT_VARIABLE LBMPY_VERSION)
     if(NOT LBMPY_FOUND EQUAL 0)

apps/benchmarks/TurbulentChannel/TurbulentChannel.cpp

@@ -526,8 +526,8 @@ namespace walberla {
             const auto * const tkeSGS = block->template getData<ScalarField_T>(meanTkeSGSFieldId_);
             WALBERLA_CHECK_NOT_NULLPTR(tkeSGS)
 
-            const auto * const sop = block->template getData<TensorField_T>(velocityWelford_->sum_of_productsID);
-            WALBERLA_CHECK_NOT_NULLPTR(sop)
+            const auto * const sos = block->template getData<TensorField_T>(velocityWelford_->sum_of_squares_fieldID);
+            WALBERLA_CHECK_NOT_NULLPTR(sos)
 
             for(uint_t idx = 0; idx < parameters_->channelHalfWidth; ++idx) {
 
@@ -541,7 +541,7 @@ namespace walberla {
                   meanVelocityVector[idx] = meanVelocity->get(localCell, flowAxis);
                   tkeSGSVector[idx] = tkeSGS->get(localCell);
                   for(uint_t i = 0; i < TensorField_T::F_SIZE; ++i) {
-                     reynoldsStressVector[idx*TensorField_T::F_SIZE+i] = sop->get(localCell,i) / velocityWelford_->counter_;
+                     reynoldsStressVector[idx*TensorField_T::F_SIZE+i] = sos->get(localCell,i) / velocityWelford_->counter_;
                   }
                   tkeResolvedVector[idx] = real_c(0.5) * (
                      reynoldsStressVector[idx*TensorField_T::F_SIZE+0] +
@@ -706,7 +706,7 @@ namespace walberla {
       // Common Fields
       const BlockDataID velocityFieldId = field::addToStorage< VectorField_T >(blocks, "velocity", real_c(0.0), codegen::layout);
       const BlockDataID meanVelocityFieldId = field::addToStorage< VectorField_T >(blocks, "mean velocity", real_c(0.0), codegen::layout);
-      const BlockDataID sopFieldId = field::addToStorage< TensorField_T >(blocks, "sum of products", real_c(0.0), codegen::layout);
+      const BlockDataID sosFieldId = field::addToStorage< TensorField_T >(blocks, "sum of squares", real_c(0.0), codegen::layout);
 
       const BlockDataID tkeSgsFieldId = field::addToStorage< ScalarField_T >(blocks, "tke_SGS", real_c(0.0), codegen::layout);
       const BlockDataID meanTkeSgsFieldId = field::addToStorage< ScalarField_T >(blocks, "mean_tke_SGS", real_c(0.0), codegen::layout);
@@ -755,7 +755,7 @@ namespace walberla {
       const auto omega = lbm::collision_model::omegaFromViscosity(simulationParameters.viscosity);
       StreamCollideSweep_T streamCollideSweep(omegaFieldId, pdfFieldId, velocityFieldId, initialForce, omega);
 
-      WelfordSweep_T welfordSweep(meanVelocityFieldId, sopFieldId, velocityFieldId, 0_r);
+      WelfordSweep_T welfordSweep(meanVelocityFieldId, sosFieldId, velocityFieldId, 0_r);
       TKEWelfordSweep_T welfordTKESweep(meanTkeSgsFieldId, tkeSgsFieldId, 0_r);
 
       TkeSgsWriter_T tkeSgsWriter(omegaFieldId, pdfFieldId, tkeSgsFieldId, initialForce, omega);
@@ -876,7 +876,7 @@ namespace walberla {
                               welfordSweep.counter_ = real_t(0);
                               welfordTKESweep.counter_ = real_t(0);
                                for(auto & block : *blocks) {
-                                  auto * sopField = block.template getData<TensorField_T >(sopFieldId);
+                                  auto * sopField = block.template getData<TensorField_T >(sosFieldId);
                                   sopField->setWithGhostLayer(0.0);
 
                                   auto * tkeField = block.template getData<ScalarField_T>(tkeSgsFieldId);

apps/benchmarks/TurbulentChannel/TurbulentChannel.py

@@ -97,7 +97,7 @@ with CodeGeneration() as ctx:
     mean_sgs_tke = ps.fields(f"mean_sgs_tke: {data_type}[{stencil.D}D]", layout=layout)
     velocity = ps.fields(f"velocity({stencil.D}): {data_type}[{stencil.D}D]", layout=layout)
     mean_velocity = ps.fields(f"mean_velocity({stencil.D}): {data_type}[{stencil.D}D]", layout=layout)
-    sum_of_products = ps.fields(f"sum_of_products({stencil.D**2}): {data_type}[{stencil.D}D]", layout=layout)
+    sum_of_squares_field = ps.fields(f"sum_of_squares_field({stencil.D**2}): {data_type}[{stencil.D}D]", layout=layout)
 
     # LBM Optimisation
     lbm_opt = LBMOptimisation(cse_global=True,
@@ -146,7 +146,7 @@ with CodeGeneration() as ctx:
     #   Welford update
     # welford_update = welford_assignments(vector_field=velocity, mean_vector_field=mean_velocity)
     welford_update = welford_assignments(field=velocity, mean_field=mean_velocity,
-                                         sum_of_products_field=sum_of_products)
+                                         sum_of_squares_field=sum_of_squares_field)
     generate_sweep(ctx, "TurbulentChannel_Welford", welford_update, target=target)
 
     tke_welford_update = welford_assignments(field=sgs_tke, mean_field=mean_sgs_tke)

pybind11 @ f7b49961

-Subproject commit 7c33cdc2d39c7b99a122579f53bc94c8eb3332ff
+Subproject commit f7b499615e14d70ab098a20deb0cdb3889998a1a