Renamed virtualfluids python package to pyfluids

Python/poiseuille_flow.py

-from virtualfluids.boundaryconditions import NoSlipBCAdapter, NoSlipBCAlgorithm
-from virtualfluids.builder import VirtualFluidsBuilder
-from virtualfluids.geometry import GbCuboid3D
-from virtualfluids.kernel import LBMKernel, KernelType
-from virtualfluids.writer import Writer, WriterType
+from pyfluids import Simulation
+from pyfluids.boundaryconditions import NoSlipBCAdapter, NoSlipBCAlgorithm
+from pyfluids.geometry import GbCuboid3D
+from pyfluids.kernel import LBMKernel, KernelType
+from pyfluids.writer import Writer, WriterType
 
 
 def simulate_poiseuille_flow(physical_params, grid_params, sim_params):
-    builder = VirtualFluidsBuilder()
+    simulation = Simulation()
 
     kernel = LBMKernel(KernelType.CompressibleCumulantFourthOrderViscosity)
     kernel.use_forcing = True
@@ -21,18 +21,18 @@ def simulate_poiseuille_flow(physical_params, grid_params, sim_params):
     writer.output_path = "./output"
     writer.type = WriterType.BINARY
 
-    builder.set_kernel_config(kernel)
-    builder.set_physical_parameters(physical_params)
-    builder.set_grid_parameters(grid_params)
-    builder.set_simulation_parameters(sim_params)
-    builder.set_writer(writer)
+    simulation.set_kernel_config(kernel)
+    simulation.set_physical_parameters(physical_params)
+    simulation.set_grid_parameters(grid_params)
+    simulation.set_simulation_parameters(sim_params)
+    simulation.set_writer(writer)
 
     no_slip_adapter = NoSlipBCAdapter()
     no_slip_adapter.algorithm = NoSlipBCAlgorithm()
-    builder.add_bc_adapter(no_slip_adapter)
+    simulation.add_bc_adapter(no_slip_adapter)
 
     block_length = 3 * grid_params.delta_x
-    builder.add_object(
+    simulation.add_object(
         GbCuboid3D(g_min_x1 - block_length,
                    g_min_x2 - block_length,
                    g_min_x3 - block_length,
@@ -42,7 +42,7 @@ def simulate_poiseuille_flow(physical_params, grid_params, sim_params):
         no_slip_adapter,
         1, "/geo/addWallZMin")
 
-    builder.add_object(
+    simulation.add_object(
         GbCuboid3D(g_min_x1 - block_length,
                    g_min_x2 - block_length,
                    g_max_x3,
@@ -52,4 +52,4 @@ def simulate_poiseuille_flow(physical_params, grid_params, sim_params):
         no_slip_adapter,
         1, "/geo/addWallZMax")
 
-    builder.run_simulation()
+    simulation.run_simulation()

Python/test_boundaryconditions.py

-from virtualfluids.boundaryconditions import *
+from pyfluids.boundaryconditions import *
 
 no_slip_algo = NoSlipBCAlgorithm()
 no_slip_bc_adapter = NoSlipBCAdapter()

Python/test_cubeflow.py

@@ -2,8 +2,8 @@ from virtualfluids.geometry import GbCuboid3D
 from virtualfluids.boundaryconditions import NoSlipBCAlgorithm, NoSlipBCAdapter, VelocityBCAdapter, DensityBCAdapter, \
     VelocityBCAlgorithm, NonReflectingOutflowBCAlgorithm
 from virtualfluids.parameters import PhysicalParameters, SimulationParameters, GridParameters
-from virtualfluids.kernel import CompressibleCumulantFourthOrderViscosityKernel
-from virtualfluids.builder import VirtualFluidsBuilder
+from virtualfluids.kernel import LBMKernel, KernelType
+from virtualfluids.simulation import Simulation
 from virtualfluids.writer import Writer, WriterType
 from pymuparser import Parser
 
@@ -27,7 +27,7 @@ grid_parameters.periodic_boundary_in_x3 = True
 
 sim_parameters = SimulationParameters()
 sim_parameters.timestep_log_interval = 1000
-sim_parameters.number_of_timesteps = 1000000
+sim_parameters.number_of_timesteps = 1000
 sim_parameters.number_of_threads = 4
 
 wall_thickness = 3 * grid_parameters.delta_x
@@ -67,7 +67,7 @@ velocity_function.expression = "u"
 velocity_bc = VelocityBCAdapter(True, False, False, velocity_function, 0, -10)
 velocity_bc.algorithm = VelocityBCAlgorithm()
 
-kernel = CompressibleCumulantFourthOrderViscosityKernel()
+kernel = LBMKernel(KernelType.CompressibleCumulantFourthOrderViscosity)
 # kernel.use_forcing = True
 # kernel.forcing_in_x1 = 3e-6
 
@@ -75,7 +75,7 @@ writer = Writer()
 writer.output_path = "./output"
 writer.type = WriterType.BINARY
 
-builder = VirtualFluidsBuilder(communicator_type="mpi")
+builder = Simulation()
 builder.set_writer(writer)
 
 builder.set_physical_parameters(physical_parameters)

Python/test_geometry.py

-from virtualfluids.geometry import *
+from pyfluids.geometry import *
 
 point1 = GbPoint3D(1, 2, 3)
 point2 = GbPoint3D(4, 5, 6)

Python/test_kernel.py

-from virtualfluids.kernel import LBMKernel, KernelType
+from pyfluids.kernel import LBMKernel, KernelType
 
 kernel = LBMKernel(KernelType.BGK)
 kernel.use_forcing = True

Python/test_lid_driven_cavity.py

+from pyfluids import Simulation
+from pyfluids.boundaryconditions import NoSlipBCAdapter, NoSlipBCAlgorithm, VelocityBCAdapter, VelocityBCAlgorithm
+from pyfluids.geometry import GbCuboid3D
+from pyfluids.kernel import LBMKernel, KernelType
+from pyfluids.parameters import GridParameters, PhysicalParameters, SimulationParameters
 from pymuparser import Parser
-from virtualfluids.boundaryconditions import NoSlipBCAdapter, NoSlipBCAlgorithm, VelocityBCAdapter, VelocityBCAlgorithm
-from virtualfluids.builder import VirtualFluidsBuilder
-from virtualfluids.geometry import GbCuboid3D
-from virtualfluids.kernel import CumulantK17LBMKernelConfig
-from virtualfluids.parameters import GridParameters, PhysicalParameters, SimulationParameters
-
-builder = VirtualFluidsBuilder(communicator_type="mpi")
-kernel = CumulantK17LBMKernelConfig()
+
+builder = Simulation()
+kernel = LBMKernel(KernelType.CompressibleCumulantFourthOrderViscosity)
 
 sim_parameters = SimulationParameters()
 sim_parameters.number_of_threads = 4

Python/test_poiseuille_l2.py

@@ -4,7 +4,7 @@ import pyvista as pv
 from norms import l2_norm
 from poiseuille_analytical import poiseuille_at_heights, PoiseuilleSettings
 from poiseuille_flow import simulate_poiseuille_flow
-from virtualfluids.parameters import PhysicalParameters, GridParameters, SimulationParameters
+from pyfluids.parameters import PhysicalParameters, GridParameters, SimulationParameters
 from vtk_utilities import vertical_column_from_mesh, get_values_from_indices
 
 

Python/test_virtualfluids_help.py

-import virtualfluids
-import virtualfluids.geometry
-help(virtualfluids)
\ No newline at end of file
+import pyfluids
+help(pyfluids)
\ No newline at end of file

src/cpu/pythonbindings/CMakeLists.txt

@@ -2,18 +2,18 @@ project(VirtualFluidsPython)
 
 file(GLOB SUBMODULE_SOURCES src/submodules/*.cpp)
 
-pybind11_add_module(virtualfluids src/VirtualfluidsModule.cpp)
+pybind11_add_module(pyfluids src/VirtualfluidsModule.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(virtualfluids PRIVATE VF_METIS VF_MPI)
+target_compile_definitions(pyfluids PRIVATE VF_METIS VF_MPI)
 target_compile_definitions(pymuparser PRIVATE VF_METIS VF_MPI)
 
-target_link_libraries(virtualfluids PRIVATE VirtualFluidsBuilder VirtualFluidsCore muparser basics)
+target_link_libraries(pyfluids PRIVATE simulationconfig VirtualFluidsCore muparser basics)
 target_link_libraries(pymuparser PRIVATE muparser)
 
-install(TARGETS virtualfluids DESTINATION .)
+install(TARGETS pyfluids DESTINATION .)
 install(TARGETS pymuparser DESTINATION .)
 

src/cpu/pythonbindings/src/VirtualfluidsModule.cpp

 #include <pybind11/pybind11.h>
 #include "submodules/boundaryconditions.cpp"
-#include "submodules/builder.cpp"
+#include "submodules/simulationconfig.cpp"
 #include "submodules/geometry.cpp"
 #include "submodules/kernel.cpp"
 #include "submodules/simulationparameters.cpp"
@@ -8,10 +8,10 @@
 
 namespace py = pybind11;
 
-PYBIND11_MODULE(virtualfluids, m)
+PYBIND11_MODULE(pyfluids, m)
 {
     makeBoundaryConditionsModule(m);
-    makeBuilderModule(m);
+    makeSimulationModule(m);
     makeGeometryModule(m);
     makeKernelModule(m);
     makeParametersModule(m);

src/cpu/pythonbindings/src/submodules/builder.cpp

-#include <pybind11/pybind11.h>
-#include <VirtualFluidsBuilder/VirtualFluidsBuilder.h>
-
-namespace py = pybind11;
-
-void makeBuilderModule(py::module &parentModule)
-{
-    using namespace pybind11::literals;
-
-    py::module builderModule = parentModule.def_submodule("builder");
-
-    py::class_<VirtualFluidsBuilder, std::shared_ptr<VirtualFluidsBuilder>>(builderModule, "VirtualFluidsBuilder")
-            .def(py::init())
-            .def("set_writer", &VirtualFluidsBuilder::setWriterConfig)
-            .def("set_grid_parameters", &VirtualFluidsBuilder::setGridParameters)
-            .def("set_physical_parameters", &VirtualFluidsBuilder::setPhysicalParameters)
-            .def("set_simulation_parameters", &VirtualFluidsBuilder::setSimulationParameters)
-            .def("set_kernel_config", &VirtualFluidsBuilder::setKernelConfig)
-            .def("add_object", &VirtualFluidsBuilder::addObject)
-            .def("add_bc_adapter", &VirtualFluidsBuilder::addBCAdapter)
-            .def("run_simulation", &VirtualFluidsBuilder::run);
-
-
-}
\ No newline at end of file

src/cpu/pythonbindings/src/submodules/kernel.cpp

 #include <memory>
 #include <pybind11/pybind11.h>
-#include <VirtualFluidsBuilder/KernelFactory.h>
-#include <VirtualFluidsBuilder/KernelConfigStructs.h>
+#include <simulationconfig/KernelFactory.h>
+#include <simulationconfig/KernelConfigStructs.h>
 
 
 namespace py = pybind11;

src/cpu/pythonbindings/src/submodules/simulationconfig.cpp

+#include <pybind11/pybind11.h>
+#include <simulationconfig/Simulation.h>
+
+namespace py = pybind11;
+
+void makeSimulationModule(py::module &parentModule)
+{
+    using namespace pybind11::literals;
+
+    py::class_<Simulation, std::shared_ptr<Simulation>>(parentModule, "Simulation")
+            .def(py::init())
+            .def("set_writer", &Simulation::setWriterConfig)
+            .def("set_grid_parameters", &Simulation::setGridParameters)
+            .def("set_physical_parameters", &Simulation::setPhysicalParameters)
+            .def("set_simulation_parameters", &Simulation::setSimulationParameters)
+            .def("set_kernel_config", &Simulation::setKernelConfig)
+            .def("add_object", &Simulation::addObject)
+            .def("add_bc_adapter", &Simulation::addBCAdapter)
+            .def("run_simulation", &Simulation::run);
+
+
+}
\ No newline at end of file

src/cpu/pythonbindings/src/submodules/simulationparameters.cpp

 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
-#include <VirtualFluidsBuilder/SimulationParameters.h>
+#include <simulationconfig/SimulationParameters.h>
 
 namespace py = pybind11;
 

src/cpu/pythonbindings/src/submodules/writer.cpp

 #include <pybind11/pybind11.h>
-#include <VirtualFluidsBuilder/WriterConfig.h>
+#include <simulationconfig/WriterConfig.h>
 
 namespace py = pybind11;
 

src/cpu/simulationconfig/CMakeLists.txt

 cmake_minimum_required(VERSION 3.1)
-project(VirtualFluidsBuilder)
+project(simulationconfig)
 
 set(VFBUILDER_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
-file(GLOB HEADERS ${VFBUILDER_INCLUDE_DIR}/VirtualFluidsBuilder/*.h)
+file(GLOB HEADERS ${VFBUILDER_INCLUDE_DIR}/simulationconfig/*.h)
 file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
 
-add_library(VirtualFluidsBuilder STATIC ${SRC} ${HEADERS})
+add_library(simulationconfig STATIC ${SRC} ${HEADERS})
 
-set_target_properties(VirtualFluidsBuilder PROPERTIES CXX_STANDARD 11 POSITION_INDEPENDENT_CODE ON)
+set_target_properties(simulationconfig PROPERTIES CXX_STANDARD 11 POSITION_INDEPENDENT_CODE ON)
 
-target_include_directories(VirtualFluidsBuilder PUBLIC ${VFBUILDER_INCLUDE_DIR})
-target_link_libraries(VirtualFluidsBuilder PRIVATE VirtualFluidsCore basics muparser)
-target_compile_definitions(VirtualFluidsBuilder PRIVATE VF_METIS VF_MPI)
+target_include_directories(simulationconfig PUBLIC ${VFBUILDER_INCLUDE_DIR})
+target_link_libraries(simulationconfig PRIVATE VirtualFluidsCore basics muparser)
+target_compile_definitions(simulationconfig PRIVATE VF_METIS VF_MPI)
 
 

src/cpu/simulationconfig/include/VirtualFluidsBuilder/AbstractLBMSystem.h → src/cpu/simulationconfig/include/simulationconfig/AbstractLBMSystem.h

-//
-// Created by Sven Marcus on 20.08.20.
-//
-
 #ifndef VIRTUALFLUIDSPYTHONBINDINGS_ABSTRACTLBMSYSTEM_H
 #define VIRTUALFLUIDSPYTHONBINDINGS_ABSTRACTLBMSYSTEM_H
 

src/cpu/simulationconfig/include/VirtualFluidsBuilder/D3Q27LBMSystem.h → src/cpu/simulationconfig/include/simulationconfig/D3Q27LBMSystem.h

-//
-// Created by Sven Marcus on 20.08.20.
-//
-
 #ifndef VIRTUALFLUIDSPYTHONBINDINGS_D3Q27LBMSYSTEM_H
 #define VIRTUALFLUIDSPYTHONBINDINGS_D3Q27LBMSYSTEM_H
 

src/cpu/simulationconfig/include/VirtualFluidsBuilder/KernelConfigStructs.h → src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h

-//
-// Created by Sven Marcus on 10.09.20.
-//
-
 #ifndef VIRTUALFLUIDSPYTHONBINDINGS_KERNELCONFIGSTRUCTS_H
 #define VIRTUALFLUIDSPYTHONBINDINGS_KERNELCONFIGSTRUCTS_H
 

src/cpu/simulationconfig/include/VirtualFluidsBuilder/KernelFactory.h → src/cpu/simulationconfig/include/simulationconfig/KernelFactory.h

-//
-// Created by Sven Marcus on 20.08.20.
-//
-
 #ifndef VIRTUALFLUIDSPYTHONBINDINGS_KERNELFACTORY_H
 #define VIRTUALFLUIDSPYTHONBINDINGS_KERNELFACTORY_H