Merge branch 'python_bindings' into 'amd'

# Conflicts:
#   src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.h

CMakeLists.txt

@@ -199,3 +199,8 @@ if(BUILD_VF_GPU OR BUILD_VF_GKS)
     add_subdirectory(src/cuda)
     include (gpu.cmake)
 endif()
+
+if (BUILD_VF_PYTHON_BINDINGS)
+    add_subdirectory(${VF_THIRD_DIR}/pybind11/pybind11-2.6.0)
+    add_subdirectory(pythonbindings)
+endif()

Python/SlurmTests/poiseuille/settings.py

 import os
 from acousticscaling import OneDirectionalAcousticScaling
-from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import RuntimeParameters, GridParameters, PhysicalParameters
+from pyfluids.cpu.kernel import LBMKernel, KernelType
+from pyfluids.cpu.parameters import RuntimeParameters, GridParameters, PhysicalParameters
 
 
 grid_params = GridParameters()

Python/SlurmTests/poiseuille/simulation_runner.py

@@ -2,7 +2,7 @@ import os
 
 from SlurmTests.poiseuille.settings import Scaling
 from poiseuille.simulation import run_simulation
-from pyfluids.writer import Writer, OutputFormat
+from pyfluids.cpu.writer import Writer, OutputFormat
 
 
 scale_level = int(os.environ["PYFLUIDS_SCALE_LEVEL"])

Python/acousticscaling.py

-from pyfluids.kernel import LBMKernel
-from pyfluids.parameters import GridParameters, PhysicalParameters, RuntimeParameters
+from pyfluids.cpu.kernel import LBMKernel
+from pyfluids.cpu.parameters import GridParameters, PhysicalParameters, RuntimeParameters
 
 
 class OneDirectionalAcousticScaling:
@@ -13,10 +13,10 @@ class OneDirectionalAcousticScaling:
         self._runtime_params = runtime_parameters
         self._kernel = kernel
 
-    def configuration_for_scale_level(self, level: int = 1) -> (GridParameters,
+    def configuration_for_scale_level(self, level: int = 1) -> tuple[GridParameters,
                                                                 PhysicalParameters,
                                                                 RuntimeParameters,
-                                                                LBMKernel):
+                                                                LBMKernel]:
         if level < 0:
             raise ValueError("level must be >= 0")
 

Python/actuator_line/actuator_line.py

+#%%
+import numpy as np
+from pathlib import Path
+from mpi4py import MPI
+from pyfluids import basics, gpu, logger
+#%%
+reference_diameter = 126
+
+length = np.array([30,8,8])*reference_diameter
+viscosity = 1.56e-5
+velocity = 9
+mach = 0.1
+nodes_per_diameter = 32
+
+sim_name = "ActuatorLine"
+config_file = Path(__file__).parent/Path("config.txt")
+output_path = Path(__file__).parent/Path("output")
+output_path.mkdir(exist_ok=True)
+timeStepOut = 500
+t_end = 50
+
+#%%
+logger.Logger.initialize_logger()
+basics.logger.Logger.add_stdout()
+basics.logger.Logger.set_debug_level(basics.logger.Level.INFO_LOW)
+basics.logger.Logger.time_stamp(basics.logger.TimeStamp.ENABLE)
+basics.logger.Logger.enable_printed_rank_numbers(True)
+#%%
+grid_builder = gpu.MultipleGridBuilder.make_shared()
+dx = reference_diameter/nodes_per_diameter
+
+grid_builder.add_coarse_grid(0.0, 0.0, 0.0, *length, dx)
+grid_builder.set_periodic_boundary_condition(False, False, False)
+grid_builder.build_grids(basics.LbmOrGks.LBM, False)
+# %%
+comm = gpu.Communicator.get_instance()
+#%%
+config = basics.ConfigurationFile()
+config.load(str(config_file))
+#%%
+para = gpu.Parameter(config, comm.get_number_of_process(), comm.get_pid())
+
+dt = dx * mach / (np.sqrt(3) * velocity)
+velocity_lb = velocity * dt / dx # LB units
+viscosity_lb = viscosity * dt / (dx * dx) # LB units
+
+#%%
+para.set_devices([0])
+para.set_output_prefix(sim_name)
+para.set_output_path(str(output_path))
+para.set_f_name(para.get_output_path() + "/" + para.get_output_prefix())
+para.set_print_files(True)
+para.set_max_level(1)
+#%%
+para.set_velocity(velocity_lb)
+para.set_viscosity(viscosity_lb)    
+para.set_velocity_ratio(dx/dt)
+para.set_main_kernel("CumulantK17CompChim")
+
+def init_func(coord_x, coord_y, coord_z):
+    return [0.0, velocity_lb, 0.0, 0.0]
+
+para.set_initial_condition(init_func)
+para.set_t_out(timeStepOut)
+para.set_t_end(int(t_end/dt))
+para.set_is_body_force(True)
+
+#%%
+grid_builder.set_velocity_boundary_condition(gpu.SideType.MX, velocity_lb, 0.0, 0.0)
+grid_builder.set_velocity_boundary_condition(gpu.SideType.PX, velocity_lb, 0.0, 0.0)
+
+grid_builder.set_velocity_boundary_condition(gpu.SideType.MY, velocity_lb, 0.0, 0.0)
+grid_builder.set_velocity_boundary_condition(gpu.SideType.PY, velocity_lb, 0.0, 0.0)
+
+grid_builder.set_velocity_boundary_condition(gpu.SideType.MZ, velocity_lb, 0.0, 0.0)
+grid_builder.set_velocity_boundary_condition(gpu.SideType.PZ, velocity_lb, 0.0, 0.0)
+
+#%%
+cuda_memory_manager = gpu.CudaMemoryManager.make(para)
+grid_generator = gpu.GridProvider.make_grid_generator(grid_builder, para, cuda_memory_manager)
+#%%
+turb_pos = np.array([3,3,3])*reference_diameter
+epsilon = 5
+density = 1.225
+level = 0
+n_blades = 3
+n_blade_nodes = 32
+alm = gpu.ActuatorLine(n_blades, density, n_blade_nodes, epsilon, *turb_pos, reference_diameter, level, dt, dx)
+para.add_actuator(alm)
+#%%
+point_probe = gpu.probes.PointProbe("pointProbe", str(output_path), 100, 500, 100)
+point_probe.add_probe_points_from_list(np.array([1,2,5])*reference_diameter, np.array([3,3,3])*reference_diameter, np.array([3,3,3])*reference_diameter)
+point_probe.add_post_processing_variable(gpu.probes.PostProcessingVariable.Means)
+
+para.add_probe(point_probe)
+
+plane_probe = gpu.probes.PlaneProbe("planeProbe", str(output_path), 100, 500, 100)
+plane_probe.set_probe_plane(5*reference_diameter, 0, 0, dx, length[1], length[2])
+para.add_probe(plane_probe)
+#%%
+sim = gpu.Simulation(comm)
+kernel_factory = gpu.KernelFactory.get_instance()
+sim.set_factories(kernel_factory, gpu.PreProcessorFactory.get_instance())
+sim.init(para, grid_generator, gpu.FileWriter(), cuda_memory_manager)
+#%%
+sim.run()
+sim.free()
+MPI.Finalize()
\ No newline at end of file

Python/actuator_line/config.txt

+Path = .
+GridPath = .

Python/cubeflow/simulation.py

-from pyfluids import Simulation
-from pyfluids.boundaryconditions import NoSlipBoundaryCondition, VelocityBoundaryCondition, DensityBoundaryCondition
-from pyfluids.geometry import GbCuboid3D
-from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import PhysicalParameters, RuntimeParameters, GridParameters
-from pyfluids.writer import Writer, OutputFormat
+from pyfluids.cpu import Simulation
+from pyfluids.cpu.boundaryconditions import NoSlipBoundaryCondition, VelocityBoundaryCondition, DensityBoundaryCondition
+from pyfluids.cpu.geometry import GbCuboid3D
+from pyfluids.cpu.kernel import LBMKernel, KernelType
+from pyfluids.cpu.parameters import PhysicalParameters, RuntimeParameters, GridParameters
+from pyfluids.cpu.writer import Writer, OutputFormat
 from pymuparser import Parser
 
 import os

Python/liddrivencavity/simulation.py

-from pyfluids import Simulation
-from pyfluids.boundaryconditions import NoSlipBoundaryCondition, VelocityBoundaryCondition
-from pyfluids.geometry import GbCuboid3D
-from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import GridParameters, PhysicalParameters, RuntimeParameters
-from pyfluids.writer import Writer, OutputFormat
+from pyfluids.cpu import Simulation
+from pyfluids.cpu.boundaryconditions import NoSlipBoundaryCondition, VelocityBoundaryCondition
+from pyfluids.cpu.geometry import GbCuboid3D
+from pyfluids.cpu.kernel import LBMKernel, KernelType
+from pyfluids.cpu.parameters import GridParameters, PhysicalParameters, RuntimeParameters
+from pyfluids.cpu.writer import Writer, OutputFormat
 from pymuparser import Parser
 
 runtime_params = RuntimeParameters()

Python/poiseuille/poiseuille_hpc.py

 from poiseuille.simulation import run_simulation
-from pyfluids.parameters import *
+from pyfluids.cpu.parameters import *
 
 grid_parameters = GridParameters()
 grid_parameters.number_of_nodes_per_direction = [64, 64, 512]

Python/poiseuille/simulation.py

-from pyfluids import Simulation
-from pyfluids.boundaryconditions import NoSlipBoundaryCondition
-from pyfluids.geometry import GbCuboid3D, State
-from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import RuntimeParameters, GridParameters, PhysicalParameters
-from pyfluids.writer import Writer, OutputFormat
+from pyfluids.cpu import Simulation
+from pyfluids.cpu.boundaryconditions import NoSlipBoundaryCondition
+from pyfluids.cpu.geometry import GbCuboid3D, State
+from pyfluids.cpu.kernel import LBMKernel, KernelType
+from pyfluids.cpu.parameters import RuntimeParameters, GridParameters, PhysicalParameters
+from pyfluids.cpu.writer import Writer, OutputFormat
 
 default_grid_params = GridParameters()
 default_grid_params.node_distance = 10 / 32

Python/poiseuille/test_poiseuille_l2.py

@@ -5,8 +5,8 @@ import unittest
 import matplotlib.pyplot as plt
 import numpy as np
 import pyvista as pv
-from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import GridParameters, PhysicalParameters, RuntimeParameters
+from pyfluids.cpu.kernel import LBMKernel, KernelType
+from pyfluids.cpu.parameters import GridParameters, PhysicalParameters, RuntimeParameters
 from scipy import stats
 
 from errors import normalized_l2_error

Python/tests/test_acousticscaling.py

 import unittest
 from typing import List
 
-from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import GridParameters, PhysicalParameters, RuntimeParameters
+from pyfluids.cpu.kernel import LBMKernel, KernelType
+from pyfluids.cpu.parameters import GridParameters, PhysicalParameters, RuntimeParameters
 
 from acousticscaling import OneDirectionalAcousticScaling
 

Python/tests/test_boundaryconditions.py

 import unittest
-from pyfluids.boundaryconditions import *
+from pyfluids.cpu.boundaryconditions import *
 
 
 class BoundaryConditionsTest(unittest.TestCase):

Python/tests/test_geometry.py

 import unittest
 
-from pyfluids.geometry import *
+from pyfluids.cpu.geometry import *
 
 
 class TestGeometry(unittest.TestCase):

Python/tests/test_kernel.py

 import unittest
 
-from pyfluids.kernel import LBMKernel, KernelType
+from pyfluids.cpu.kernel import LBMKernel, KernelType
 
 
 class TestLBMKernel(unittest.TestCase):

apps/gpu/LBM/ActuatorLine/ActuatorLine.cpp

@@ -144,11 +144,11 @@ void multipleLevel(const std::string& configPath)
 
     para->setMaxLevel(1);
 
+
     para->setVelocity(velocityLB);
     para->setViscosity(viscosityLB);
-
     para->setVelocityRatio( dx / dt );
-
+    para->setViscosityRatio( dx*dx/dt );
     para->setMainKernel("CumulantK17CompChim");
 
     para->setInitialCondition([&](real coordX, real coordY, real coordZ, real &rho, real &vx, real &vy, real &vz) {
@@ -185,11 +185,10 @@ void multipleLevel(const std::string& configPath)
     uint nBlades = 3;
     uint nBladeNodes = 32;
 
-
     SPtr<ActuatorLine> actuator_line =SPtr<ActuatorLine>( new ActuatorLine(nBlades, density, nBladeNodes, epsilon, turbPos[0], turbPos[1], turbPos[2], reference_diameter, level, dt, dx) );
     para->addActuator( actuator_line );
 
-    SPtr<PointProbe> pointProbe = SPtr<PointProbe>( new PointProbe("pointProbe", 100, 500, 100) );
+    SPtr<PointProbe> pointProbe = SPtr<PointProbe>( new PointProbe("pointProbe", para->getOutputPath(), 100, 500, 100) );
     std::vector<real> probeCoordsX = {reference_diameter,2*reference_diameter,5*reference_diameter};
     std::vector<real> probeCoordsY = {3*reference_diameter,3*reference_diameter,3*reference_diameter};
     std::vector<real> probeCoordsZ = {3*reference_diameter,3*reference_diameter,3*reference_diameter};
@@ -199,7 +198,7 @@ void multipleLevel(const std::string& configPath)
     pointProbe->addPostProcessingVariable(PostProcessingVariable::Variances);
     para->addProbe( pointProbe );
 
-    SPtr<PlaneProbe> planeProbe = SPtr<PlaneProbe>( new PlaneProbe("planeProbe", 100, 500, 100) );
+    SPtr<PlaneProbe> planeProbe = SPtr<PlaneProbe>( new PlaneProbe("planeProbe", para->getOutputPath(), 100, 500, 100) );
     planeProbe->setProbePlane(5*reference_diameter, 0, 0, dx, L_y, L_z);
     planeProbe->addPostProcessingVariable(PostProcessingVariable::Means);
     para->addProbe( planeProbe );

cpu.cmake

@@ -80,9 +80,7 @@ add_subdirectory(${VF_THIRD_DIR}/MuParser)
 add_subdirectory(src/cpu/VirtualFluidsCore)
 
 if(BUILD_VF_PYTHON_BINDINGS)
-    add_subdirectory(${VF_THIRD_DIR}/pybind11/pybind11-2.6.0)
     add_subdirectory(src/cpu/simulationconfig)
-    add_subdirectory(src/cpu/pythonbindings)
 endif()
 
 set (APPS_ROOT_CPU "${VF_ROOT_DIR}/apps/cpu/")

gpu.cmake

@@ -37,8 +37,8 @@ IF (BUILD_VF_GPU)
     #add_subdirectory(targets/apps/LBM/BaselNU)
     #add_subdirectory(targets/apps/LBM/BaselMultiGPU)
 
-    add_subdirectory(apps/gpu/LBM/DrivenCavity)
-    add_subdirectory(apps/gpu/LBM/WTG_RUB)
+    #add_subdirectory(apps/gpu/LBM/DrivenCavity)
+    #add_subdirectory(apps/gpu/LBM/WTG_RUB)
     #add_subdirectory(apps/gpu/LBM/gridGeneratorTest)
     #add_subdirectory(apps/gpu/LBM/TGV_3D)
     #add_subdirectory(apps/gpu/LBM/TGV_3D_MultiGPU)
@@ -136,4 +136,4 @@ endif()
 if(BUILD_VF_TRAFFIC)
     add_subdirectory(src/gpu/Traffic)
     add_subdirectory(apps/gpu/LBM/TrafficTest)
-endif()
+endif()
\ No newline at end of file

pythonbindings/CMakeLists.txt

+project(VirtualFluidsPython LANGUAGES CUDA CXX)
+IF(BUILD_VF_GPU)
+    pybind11_add_module(pyfluids src/VirtualFluidsModulesGPU.cpp)
+    set_source_files_properties(src/VirtualFluidsModulesGPU.cpp PROPERTIES LANGUAGE CUDA)
+
+    target_link_libraries(pyfluids PRIVATE GridGenerator VirtualFluids_GPU basics lbmCuda logger)
+    target_include_directories(pyfluids PRIVATE ${VF_THIRD_DIR}/cuda_samples/)
+
+ENDIF()
+IF(BUILD_VF_CPU)
+    pybind11_add_module(pyfluids src/VirtualFluidsModulesCPU.cpp)
+    pybind11_add_module(pymuparser src/muParser.cpp)
+
+    # TODO: Move this to MuParser CMakeLists.txt
+    set_target_properties(muparser PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+    target_compile_definitions(pyfluids PRIVATE VF_METIS VF_MPI)
+    target_compile_definitions(pymuparser PRIVATE VF_METIS VF_MPI)
+
+    target_link_libraries(pyfluids PRIVATE simulationconfig VirtualFluidsCore muparser basics)
+    target_link_libraries(pymuparser PRIVATE muparser)
+ENDIF()
+target_include_directories(pyfluids PRIVATE ${CMAKE_SOURCE_DIR}/src/)
+target_include_directories(pyfluids PRIVATE ${CMAKE_BINARY_DIR})
\ No newline at end of file