apps/benchmarks/FieldCommunication/CMakeLists.txt

@@ -4,4 +4,4 @@ waLBerla_link_files_to_builddir( "*.py" )
 
 
 waLBerla_add_executable ( NAME FieldCommunication
-                          DEPENDS blockforest core domain_decomposition field postprocessing sqlite python_coupling )
+      DEPENDS walberla::blockforest walberla::core walberla::domain_decomposition walberla::field walberla::postprocessing walberla::sqlite walberla::python_coupling )

apps/benchmarks/FieldCommunication/FieldCommunication.cpp

@@ -34,7 +34,7 @@ template<typename Stencil_T>
 class SingleMessageBufferedScheme
 {
 public:
-    typedef Stencil_T Stencil;
+    using Stencil = Stencil_T;
 
     SingleMessageBufferedScheme( const weak_ptr< StructuredBlockForest > & bf, const int tag = 17953 )
             : blockForest_( bf ), tag_( tag ) {}
@@ -354,8 +354,8 @@ int main( int argc, char **argv )
             auto databaseBlock = config->getBlock( "Database" );
             if ( databaseBlock )
             {
-                for ( auto it = databaseBlock.begin(); it != databaseBlock.end(); ++it )
-                    stringProperties[it->first] = it->second;
+                for (const auto & it : databaseBlock)
+                    stringProperties[it.first] = it.second;
             }
 
             realProperties["total_min"] = real_c( timingPool["totalTime"].min()) / real_c( iterations );

apps/benchmarks/FlowAroundSphereCodeGen/CMakeLists.txt

-waLBerla_link_files_to_builddir( "*.py" )
-
-waLBerla_generate_target_from_python(NAME FlowAroundSphereGenerated
-        FILE FlowAroundSphereCodeGen.py
-        OUT_FILES FlowAroundSphereCodeGen_LbSweep.${CODEGEN_FILE_SUFFIX} FlowAroundSphereCodeGen_LbSweep.h
-        FlowAroundSphereCodeGen_MacroSetter.${CODEGEN_FILE_SUFFIX} FlowAroundSphereCodeGen_MacroSetter.h
-        FlowAroundSphereCodeGen_UBB.${CODEGEN_FILE_SUFFIX} FlowAroundSphereCodeGen_UBB.h
-        FlowAroundSphereCodeGen_NoSlip.${CODEGEN_FILE_SUFFIX} FlowAroundSphereCodeGen_NoSlip.h
-        FlowAroundSphereCodeGen_Outflow.${CODEGEN_FILE_SUFFIX} FlowAroundSphereCodeGen_Outflow.h
-        FlowAroundSphereCodeGen_PackInfoEven.${CODEGEN_FILE_SUFFIX} FlowAroundSphereCodeGen_PackInfoEven.h
-        FlowAroundSphereCodeGen_PackInfoOdd.${CODEGEN_FILE_SUFFIX} FlowAroundSphereCodeGen_PackInfoOdd.h
-        FlowAroundSphereCodeGen_InfoHeader.h)
-
-if (WALBERLA_BUILD_WITH_CUDA)
-    waLBerla_add_executable( NAME FlowAroundSphereCodeGen FILE FlowAroundSphereCodeGen.cpp
-            DEPENDS blockforest boundary core cuda domain_decomposition field geometry python_coupling timeloop vtk FlowAroundSphereGenerated)
-else ()
-    waLBerla_add_executable( NAME FlowAroundSphereCodeGen FILE FlowAroundSphereCodeGen.cpp
-            DEPENDS blockforest boundary core domain_decomposition field geometry python_coupling timeloop vtk FlowAroundSphereGenerated)
-endif (WALBERLA_BUILD_WITH_CUDA)
\ No newline at end of file

apps/benchmarks/FlowAroundSphereCodeGen/FlowAroundSphereCodeGen.py

-from pystencils import Target
-from pystencils.field import fields
-from lbmpy import LBMConfig, LBMOptimisation, LBStencil, Method, Stencil
-
-from lbmpy.advanced_streaming.utility import get_timesteps
-from lbmpy.macroscopic_value_kernels import macroscopic_values_setter
-from lbmpy.creationfunctions import create_lb_collision_rule
-from lbmpy.boundaries import NoSlip, UBB, ExtrapolationOutflow
-
-from pystencils_walberla import CodeGeneration, generate_sweep, generate_info_header
-
-from lbmpy_walberla.additional_data_handler import UBBAdditionalDataHandler, OutflowAdditionalDataHandler
-from lbmpy_walberla import generate_lb_pack_info
-from lbmpy_walberla import generate_alternating_lbm_sweep, generate_alternating_lbm_boundary
-
-import sympy as sp
-
-with CodeGeneration() as ctx:
-    data_type = "float64" if ctx.double_accuracy else "float32"
-    stencil = LBStencil(Stencil.D3Q27)
-    q = stencil.Q
-    dim = stencil.D
-    streaming_pattern = 'esotwist'
-    timesteps = get_timesteps(streaming_pattern)
-
-    pdfs, velocity_field, density_field = fields(f"pdfs({q}), velocity({dim}), density(1) : {data_type}[{dim}D]",
-                                                 layout='fzyx')
-    omega = sp.Symbol("omega")
-    u_max = sp.Symbol("u_max")
-
-    output = {
-        'density': density_field,
-        'velocity': velocity_field
-    }
-
-    lbm_config = LBMConfig(stencil=stencil, method=Method.CUMULANT, compressible=True,
-                           relaxation_rate=omega, galilean_correction=True,
-                           field_name='pdfs', streaming_pattern=streaming_pattern, output=output)
-
-    lbm_optimisation = LBMOptimisation(symbolic_field=pdfs, cse_global=False, cse_pdfs=False)
-
-    collision_rule = create_lb_collision_rule(lbm_config=lbm_config, lbm_optimisation=lbm_optimisation)
-    lb_method = collision_rule.method
-
-    # getter & setter
-    setter_assignments = macroscopic_values_setter(lb_method, velocity=velocity_field.center_vector,
-                                                   pdfs=pdfs, density=1.0,
-                                                   streaming_pattern=streaming_pattern,
-                                                   previous_timestep=timesteps[0])
-
-    # opt = {'instruction_set': 'sse', 'assume_aligned': True, 'nontemporal': False, 'assume_inner_stride_one': True}
-
-    stencil_typedefs = {'Stencil_T': stencil}
-    field_typedefs = {'PdfField_T': pdfs,
-                      'VelocityField_T': velocity_field,
-                      'ScalarField_T': density_field}
-
-    if ctx.cuda:
-        target = Target.GPU
-    else:
-        target = Target.CPU
-
-    # sweeps
-    generate_alternating_lbm_sweep(ctx, 'FlowAroundSphereCodeGen_LbSweep',
-                                   collision_rule, lbm_config=lbm_config, lbm_optimisation=lbm_optimisation,
-                                   target=target)
-    generate_sweep(ctx, 'FlowAroundSphereCodeGen_MacroSetter', setter_assignments, target=target)
-
-    # boundaries
-    ubb = UBB(lambda *args: None, dim=dim, data_type=data_type)
-    ubb_data_handler = UBBAdditionalDataHandler(stencil, ubb)
-    outflow = ExtrapolationOutflow(stencil[4], lb_method, streaming_pattern=streaming_pattern, data_type=data_type)
-    outflow_data_handler = OutflowAdditionalDataHandler(stencil, outflow, target=target)
-
-    generate_alternating_lbm_boundary(ctx, 'FlowAroundSphereCodeGen_UBB', ubb, lb_method,
-                                      target=target, streaming_pattern=streaming_pattern,
-                                      additional_data_handler=ubb_data_handler,
-                                      layout='fzyx')
-
-    generate_alternating_lbm_boundary(ctx, 'FlowAroundSphereCodeGen_NoSlip', NoSlip(), lb_method,
-                                      target=target, streaming_pattern=streaming_pattern,
-                                      layout='fzyx')
-
-    generate_alternating_lbm_boundary(ctx, 'FlowAroundSphereCodeGen_Outflow', outflow, lb_method,
-                                      target=target, streaming_pattern=streaming_pattern,
-                                      additional_data_handler=outflow_data_handler,
-                                      layout='fzyx')
-
-    # communication
-    generate_lb_pack_info(ctx, 'FlowAroundSphereCodeGen_PackInfo', stencil, pdfs,
-                          streaming_pattern=streaming_pattern, always_generate_separate_classes=True, target=target)
-
-    # Info header containing correct template definitions for stencil and field
-    generate_info_header(ctx, 'FlowAroundSphereCodeGen_InfoHeader',
-                         stencil_typedefs=stencil_typedefs, field_typedefs=field_typedefs)

apps/benchmarks/FlowAroundSphereCodeGen/FlowAroundSphereCodeGenParameters.py

-import waLBerla as wlb
-from lbmpy.relaxationrates import relaxation_rate_from_lattice_viscosity
-
-
-class Scenario:
-    def __init__(self):
-        self.timesteps = 1001
-        self.vtkWriteFrequency = 100
-
-        self.cells = (384, 128, 128)
-        self.blocks = (1, 1, 1)
-        self.periodic = (0, 0, 0)
-
-        self.constant_inflow = True
-
-        self.diameter_sphere = min(self.cells) // 2
-        self.u_max = 0.1
-        self.reynolds_number = 1000000
-
-        kinematic_viscosity = (self.diameter_sphere * self.u_max) / self.reynolds_number
-
-        self.omega = relaxation_rate_from_lattice_viscosity(kinematic_viscosity)
-
-        self.total_cells = (self.cells[0] * self.blocks[0],
-                            self.cells[1] * self.blocks[1],
-                            self.cells[2] * self.blocks[2])
-
-    @wlb.member_callback
-    def config(self):
-        return {
-            'DomainSetup': {
-                'blocks': self.blocks,
-                'cellsPerBlock': self.cells,
-                'periodic': self.periodic,
-                'oneBlockPerProcess': True
-            },
-            'Parameters': {
-                'timesteps': self.timesteps,
-                'vtkWriteFrequency': self.vtkWriteFrequency,
-                'omega': self.omega,
-                'u_max': self.u_max,
-                'reynolds_number': self.reynolds_number,
-                'diameter_sphere': self.diameter_sphere,
-                'constant_inflow': self.constant_inflow
-            },
-            'Boundaries': {
-                'Border': [
-                    {'direction': 'N', 'walldistance': -1, 'flag': 'NoSlip'},
-                    {'direction': 'S', 'walldistance': -1, 'flag': 'NoSlip'},
-                    {'direction': 'W', 'walldistance': -1, 'flag': 'UBB'},
-                    {'direction': 'E', 'walldistance': -1, 'flag': 'Outflow'},
-                    {'direction': 'T', 'walldistance': -1, 'flag': 'NoSlip'},
-                    {'direction': 'B', 'walldistance': -1, 'flag': 'NoSlip'},
-                ],
-                'Body': [
-                    {'shape': "sphere",
-                     'midpoint': (int(0.40 * self.total_cells[0]), self.total_cells[1] // 2, self.total_cells[2] // 2),
-                     'radius': self.diameter_sphere // 2,
-                     'flag': 'NoSlip'}
-                ],
-            },
-        }
-
-
-scenarios = wlb.ScenarioManager()
-scenarios.add(Scenario())

apps/benchmarks/FluidParticleCoupling/CMakeLists.txt

@@ -11,63 +11,61 @@ if( WALBERLA_BUILD_WITH_CODEGEN )
             )
 
    waLBerla_add_executable(NAME SphereWallCollision FILES SphereWallCollision.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling
-         mesa_pd postprocessing timeloop vtk FluidParticleCouplingGeneratedLBM)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling
+         walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBM )
 
    waLBerla_add_executable(NAME SettlingSphereInBox FILES SettlingSphereInBox.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling
-         mesa_pd postprocessing timeloop vtk FluidParticleCouplingGeneratedLBM)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling
+         walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBM )
 
    waLBerla_add_executable(NAME SphereMovingWithPrescribedVelocity FILES SphereMovingWithPrescribedVelocity.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm mesa_pd lbm_mesapd_coupling
-         postprocessing timeloop vtk FluidParticleCouplingGeneratedLBM)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::mesa_pd walberla::lbm_mesapd_coupling
+         walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBM )
 
    waLBerla_add_executable(NAME LubricationForceEvaluation FILES LubricationForceEvaluation.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd
-         postprocessing timeloop vtk FluidParticleCouplingGeneratedLBM)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd
+         walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBM )
 
    waLBerla_add_executable(NAME DragForceSphere FILES DragForceSphere.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd
-         postprocessing timeloop vtk FluidParticleCouplingGeneratedLBMWithForce)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd
+         walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBMWithForce )
 
    waLBerla_add_executable(NAME ForcesOnSphereNearPlane FILES ForcesOnSphereNearPlane.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd
-         postprocessing timeloop vtk FluidParticleCouplingGeneratedLBM)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd
+         walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBM )
 
    waLBerla_add_executable(NAME ObliqueWetCollision FILES ObliqueWetCollision.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd
-         postprocessing timeloop vtk FluidParticleCouplingGeneratedLBM)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd
+         walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBM )
 
    waLBerla_add_executable(NAME MotionSettlingSphere FILES MotionSettlingSphere.cpp
-         DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd
-         postprocessing timeloop vtk FluidParticleCouplingGeneratedLBM)
+         DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd
+         walberla::postprocessing walberla::timeloop walberla::vtk FluidParticleCouplingGeneratedLBM )
 
 else()
 
 waLBerla_add_executable ( NAME SphereWallCollision FILES SphereWallCollision.cpp
-                          DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )
 
 waLBerla_add_executable ( NAME SettlingSphereInBox FILES SettlingSphereInBox.cpp
-                          DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )
 
 waLBerla_add_executable ( NAME SphereMovingWithPrescribedVelocity FILES SphereMovingWithPrescribedVelocity.cpp
-                          DEPENDS blockforest boundary core domain_decomposition field lbm mesa_pd lbm_mesapd_coupling postprocessing timeloop vtk )
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::mesa_pd walberla::lbm_mesapd_coupling walberla::postprocessing walberla::timeloop walberla::vtk )
 
 waLBerla_add_executable ( NAME LubricationForceEvaluation FILES LubricationForceEvaluation.cpp
-                          DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )
 
 waLBerla_add_executable ( NAME DragForceSphere FILES DragForceSphere.cpp
-                          DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )
 
 waLBerla_add_executable ( NAME ForcesOnSphereNearPlane FILES ForcesOnSphereNearPlane.cpp
-                          DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )
 
 waLBerla_add_executable ( NAME ObliqueWetCollision FILES ObliqueWetCollision.cpp
-                          DEPENDS blockforest boundary core domain_decomposition field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )
 
 endif()
 
-
-
 waLBerla_add_executable ( NAME ObliqueDryCollision FILES ObliqueDryCollision.cpp
-      DEPENDS blockforest core mesa_pd postprocessing )
\ No newline at end of file
+      DEPENDS walberla::blockforest walberla::core walberla::mesa_pd walberla::postprocessing )

apps/benchmarks/FluidParticleCouplingWithLoadBalancing/CMakeLists.txt

-waLBerla_add_executable( NAME FluidParticleWorkloadEvaluation FILES FluidParticleWorkloadEvaluation.cpp DEPENDS blockforest boundary core field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+waLBerla_add_executable( NAME FluidParticleWorkloadEvaluation FILES FluidParticleWorkloadEvaluation.cpp DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )
 
-waLBerla_add_executable( NAME FluidParticleWorkloadDistribution FILES FluidParticleWorkloadDistribution.cpp DEPENDS blockforest boundary core field lbm lbm_mesapd_coupling mesa_pd postprocessing timeloop vtk )
+waLBerla_add_executable( NAME FluidParticleWorkloadDistribution FILES FluidParticleWorkloadDistribution.cpp DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::postprocessing walberla::timeloop walberla::vtk )

apps/benchmarks/FluidParticleCouplingWithLoadBalancing/Utility.h

@@ -10,21 +10,21 @@ namespace amr {
  * Result from the workload evaluation as described in
  *  Rettinger, Ruede - "Dynamic Load Balancing Techniques for Particulate Flow Simulations", 2019, Computation
  */
-real_t fittedLBMWeightEvaluationFunction(const BlockInfo& blockInfo)
+inline real_t fittedLBMWeightEvaluationFunction(const BlockInfo& blockInfo)
 {
    uint_t Ce = blockInfo.numberOfCells;
    uint_t F  = blockInfo.numberOfFluidCells;
    real_t weight = real_t(7.597476065046571e-06) * real_c(Ce) + real_t(8.95723566283202e-05) * real_c(F) + real_t(-0.1526111388616016);
    return std::max(weight,real_t(0));
 }
-real_t fittedBHWeightEvaluationFunction(const BlockInfo& blockInfo)
+inline real_t fittedBHWeightEvaluationFunction(const BlockInfo& blockInfo)
 {
    uint_t Ce = blockInfo.numberOfCells;
    uint_t NB = blockInfo.numberOfNearBoundaryCells;
    real_t weight = real_t(1.3067711379655123e-07) * real_c(Ce) + real_t(0.0007289549127205142) * real_c(NB) + real_t(-0.1575698071795788);
    return std::max(weight,real_t(0));
 }
-real_t fittedRPDWeightEvaluationFunction(const BlockInfo& blockInfo)
+inline real_t fittedRPDWeightEvaluationFunction(const BlockInfo& blockInfo)
 {
    uint_t Pl = blockInfo.numberOfLocalParticles;
    uint_t Pg = blockInfo.numberOfGhostParticles;
@@ -36,7 +36,7 @@ real_t fittedRPDWeightEvaluationFunction(const BlockInfo& blockInfo)
    real_t weight = real_c(Sc) * ( cPlPg2 * real_c(Pl+Pg) * real_c(Pl+Pg) + cPl * real_c(Pl) + cPg * real_c(Pg) + c );
    return std::max(weight,real_t(0));
 }
-real_t fittedCoup1WeightEvaluationFunction(const BlockInfo& blockInfo)
+inline real_t fittedCoup1WeightEvaluationFunction(const BlockInfo& blockInfo)
 {
    uint_t Ce = blockInfo.numberOfCells;
    uint_t F  = blockInfo.numberOfFluidCells;
@@ -45,7 +45,7 @@ real_t fittedCoup1WeightEvaluationFunction(const BlockInfo& blockInfo)
    real_t weight = real_t(5.610203409278647e-06) * real_c(Ce) + real_t(-7.257635845636656e-07) * real_c(F) + real_t(0.02049703546054693) * real_c(Pl) + real_t(0.04248208493809902) * real_c(Pg) + real_t(-0.26609470510074784);
    return std::max(weight,real_t(0));
 }
-real_t fittedCoup2WeightEvaluationFunction(const BlockInfo& blockInfo)
+inline real_t fittedCoup2WeightEvaluationFunction(const BlockInfo& blockInfo)
 {
    uint_t Ce = blockInfo.numberOfCells;
    uint_t F  = blockInfo.numberOfFluidCells;
@@ -54,7 +54,7 @@ real_t fittedCoup2WeightEvaluationFunction(const BlockInfo& blockInfo)
    real_t weight = real_t(7.198479654682179e-06) * real_c(Ce) + real_t(1.178247475854302e-06) * real_c(F) + real_t(-0.0026401549115124628) * real_c(Pl) + real_t(0.008459646786179298) * real_c(Pg) + real_t(-0.001077320113275954);
    return std::max(weight,real_t(0));
 }
-real_t fittedTotalWeightEvaluationFunction(const BlockInfo& blockInfo)
+inline real_t fittedTotalWeightEvaluationFunction(const BlockInfo& blockInfo)
 {
    return fittedLBMWeightEvaluationFunction(blockInfo) + fittedBHWeightEvaluationFunction(blockInfo) +
           fittedRPDWeightEvaluationFunction(blockInfo) + fittedCoup1WeightEvaluationFunction(blockInfo) +

apps/benchmarks/FluidizedBed/CMakeLists.txt

+waLBerla_link_files_to_builddir("*.prm")
+
+if (WALBERLA_BUILD_WITH_GPU_SUPPORT AND WALBERLA_BUILD_WITH_CODEGEN AND (CMAKE_CUDA_ARCHITECTURES GREATER_EQUAL 60 OR WALBERLA_BUILD_WITH_HIP))
+    waLBerla_add_executable(NAME FluidizedBed_PSM_GPU FILES FluidizedBedGPU.cpp
+          DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::gpu walberla::domain_decomposition walberla::field walberla::lbm walberla::lbm_mesapd_coupling walberla::mesa_pd walberla::timeloop walberla::vtk PSMCodegenPython_srt_sc1 )
+endif ()

apps/benchmarks/ForcesOnSphereNearPlaneInShearFlow/CMakeLists.txt

 waLBerla_add_executable ( NAME ForcesOnSphereNearPlaneInShearFlow
-                          DEPENDS blockforest boundary core domain_decomposition field lbm pe pe_coupling postprocessing timeloop vtk )
\ No newline at end of file
+      DEPENDS walberla::blockforest walberla::boundary walberla::core walberla::domain_decomposition walberla::field walberla::lbm walberla::pe walberla::pe_coupling walberla::postprocessing walberla::timeloop walberla::vtk )
\ No newline at end of file