diff --git a/Python/cubeflow/simulation.py b/Python/cubeflow/simulation.py
index 6db6f34a1d0a4642fe9903d3ea23122cd7a87147..628e8321975dbb3d3f7c552b1a16397327171d21 100644
--- a/Python/cubeflow/simulation.py
+++ b/Python/cubeflow/simulation.py
@@ -1,10 +1,9 @@
from pyfluids import Simulation
-from pyfluids.boundaryconditions import NoSlipBCAlgorithm, NoSlipBCAdapter, VelocityBCAdapter, DensityBCAdapter, \
- VelocityBCAlgorithm, NonReflectingOutflowBCAlgorithm
+from pyfluids.boundaryconditions import NoSlipBoundaryCondition, VelocityBoundaryCondition, DensityBoundaryCondition
from pyfluids.geometry import GbCuboid3D
from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import PhysicalParameters, SimulationParameters, GridParameters
-from pyfluids.writer import Writer, WriterType
+from pyfluids.parameters import PhysicalParameters, RuntimeParameters, GridParameters
+from pyfluids.writer import Writer, OutputFormat
from pymuparser import Parser
import os
@@ -22,23 +21,23 @@ physical_params.lattice_viscosity = 0.005
grid_params = GridParameters()
grid_params.number_of_nodes_per_direction = [200, 120, 120]
grid_params.blocks_per_direction = [2, 2, 2]
-grid_params.delta_x = 0.125
+grid_params.node_distance = 0.125
grid_params.periodic_boundary_in_x1 = False
grid_params.periodic_boundary_in_x2 = True
grid_params.periodic_boundary_in_x3 = True
-sim_params = SimulationParameters()
-sim_params.timestep_log_interval = 1000
-sim_params.number_of_timesteps = 50000
-sim_params.number_of_threads = int(os.environ.get("OMP_NUM_THREADS", 4))
+runtime_params = RuntimeParameters()
+runtime_params.timestep_log_interval = 1000
+runtime_params.number_of_timesteps = 50000
+runtime_params.number_of_threads = int(os.environ.get("OMP_NUM_THREADS", 4))
def run_simulation(physical_parameters=physical_params, grid_parameters=grid_params,
- sim_parameters=sim_params):
- wall_thickness = 3 * grid_parameters.delta_x
+ runtime_parameters=runtime_params):
+ wall_thickness = 3 * grid_parameters.node_distance
min_x, min_y, min_z = 0, 0, 0
- max_x, max_y, max_z = get_max_length(grid_parameters.number_of_nodes_per_direction, grid_parameters.delta_x)
+ max_x, max_y, max_z = get_max_length(grid_parameters.number_of_nodes_per_direction, grid_parameters.node_distance)
bottom_wall = GbCuboid3D(min_x - wall_thickness, min_y - wall_thickness, min_z, max_x + wall_thickness,
max_y + wall_thickness, min_z - wall_thickness)
@@ -62,17 +61,14 @@ def run_simulation(physical_parameters=physical_params, grid_parameters=grid_par
outflow_boundary = GbCuboid3D(max_x, min_y - wall_thickness, min_z - wall_thickness, max_x + wall_thickness,
max_y + wall_thickness, max_z + wall_thickness)
- no_slip_bc = NoSlipBCAdapter()
- no_slip_bc.algorithm = NoSlipBCAlgorithm()
+ no_slip_bc = NoSlipBoundaryCondition()
- outflow_bc = DensityBCAdapter()
- outflow_bc.algorithm = NonReflectingOutflowBCAlgorithm()
+ outflow_bc = DensityBoundaryCondition()
velocity_function = Parser()
velocity_function.define_constant("u", 0.07)
velocity_function.expression = "u"
- velocity_bc = VelocityBCAdapter(True, False, False, velocity_function, 0, -10)
- velocity_bc.algorithm = VelocityBCAlgorithm()
+ velocity_bc = VelocityBoundaryCondition(True, False, False, velocity_function, 0, -10)
kernel = LBMKernel(KernelType.CompressibleCumulantFourthOrderViscosity)
# kernel.use_forcing = True
@@ -80,14 +76,14 @@ def run_simulation(physical_parameters=physical_params, grid_parameters=grid_par
writer = Writer()
writer.output_path = "./output"
- writer.type = WriterType.BINARY
+ writer.output_format = OutputFormat.BINARY
builder = Simulation()
builder.set_writer(writer)
builder.set_physical_parameters(physical_parameters)
builder.set_grid_parameters(grid_parameters)
- builder.set_simulation_parameters(sim_parameters)
+ builder.set_simulation_parameters(runtime_parameters)
builder.set_kernel_config(kernel)
# builder.add_object(bottom_wall, no_slip_bc, 1, "/geo/bottomWall")
diff --git a/Python/liddrivencavity/simulation.py b/Python/liddrivencavity/simulation.py
index 132949c46a3f4fd8a46a8af605e87afdad963f95..fc40f418f1ecac9bc6f240d1eb8f01fa2bd673ca 100644
--- a/Python/liddrivencavity/simulation.py
+++ b/Python/liddrivencavity/simulation.py
@@ -1,15 +1,15 @@
from pyfluids import Simulation
-from pyfluids.boundaryconditions import NoSlipBCAdapter, NoSlipBCAlgorithm, VelocityBCAdapter, VelocityBCAlgorithm
+from pyfluids.boundaryconditions import NoSlipBoundaryCondition, VelocityBoundaryCondition
from pyfluids.geometry import GbCuboid3D
from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import GridParameters, PhysicalParameters, SimulationParameters
-from pyfluids.writer import Writer, WriterType
+from pyfluids.parameters import GridParameters, PhysicalParameters, RuntimeParameters
+from pyfluids.writer import Writer, OutputFormat
from pymuparser import Parser
-sim_params = SimulationParameters()
-sim_params.number_of_threads = 4
-sim_params.number_of_timesteps = 10000
-sim_params.timestep_log_interval = 1000
+runtime_params = RuntimeParameters()
+runtime_params.number_of_threads = 4
+runtime_params.number_of_timesteps = 10000
+runtime_params.timestep_log_interval = 1000
physical_params = PhysicalParameters()
physical_params.lattice_viscosity = 0.005
@@ -17,38 +17,36 @@ physical_params.lattice_viscosity = 0.005
grid_params = GridParameters()
grid_params.number_of_nodes_per_direction = [64, 64, 64]
grid_params.blocks_per_direction = [2, 2, 2]
-grid_params.delta_x = 1 / 10
+grid_params.node_distance = 1 / 10
-def run_simulation(physical_params=physical_params, grid_params=grid_params, sim_params=sim_params):
+def run_simulation(physical_params=physical_params, grid_params=grid_params, runtime_params=runtime_params):
simulation = Simulation()
kernel = LBMKernel(KernelType.CompressibleCumulantFourthOrderViscosity)
writer = Writer()
- writer.type = WriterType.BINARY
writer.output_path = "./output"
+ writer.output_format = OutputFormat.BINARY
simulation.set_grid_parameters(grid_params)
simulation.set_physical_parameters(physical_params)
- simulation.set_simulation_parameters(sim_params)
+ simulation.set_simulation_parameters(runtime_params)
simulation.set_kernel_config(kernel)
simulation.set_writer(writer)
- no_slip_bc_adapter = NoSlipBCAdapter()
- no_slip_bc_adapter.algorithm = NoSlipBCAlgorithm()
+ no_slip_bc_adapter = NoSlipBoundaryCondition()
fct = Parser()
fct.expression = "u"
fct.define_constant("u", 0.005)
- velocity_bc_adapter = VelocityBCAdapter(True, True, False, fct, 0, -10.0)
- velocity_bc_adapter.algorithm = VelocityBCAlgorithm()
+ velocity_bc_adapter = VelocityBoundaryCondition(True, True, False, fct, 0, -10.0)
g_min_x1, g_min_x2, g_min_x3 = 0, 0, 0
- g_max_x1 = grid_params.number_of_nodes_per_direction[0] * grid_params.delta_x
- g_max_x2 = grid_params.number_of_nodes_per_direction[1] * grid_params.delta_x
- g_max_x3 = grid_params.number_of_nodes_per_direction[2] * grid_params.delta_x
+ g_max_x1 = grid_params.number_of_nodes_per_direction[0] * grid_params.node_distance
+ g_max_x2 = grid_params.number_of_nodes_per_direction[1] * grid_params.node_distance
+ g_max_x3 = grid_params.number_of_nodes_per_direction[2] * grid_params.node_distance
- dx = grid_params.delta_x
+ dx = grid_params.node_distance
wall_x_min = GbCuboid3D(g_min_x1 - dx, g_min_x2 - dx, g_min_x3 - dx, g_min_x1, g_max_x2 + dx, g_max_x3)
wall_x_max = GbCuboid3D(g_max_x1, g_min_x2 - dx, g_min_x3 - dx, g_max_x1 + dx, g_max_x2 + dx, g_max_x3)
diff --git a/Python/poiseuille/simulation.py b/Python/poiseuille/simulation.py
index 035fb43031c44779fb7a94fa2e8e229f5d888608..6906cef8f2fd7e2c8e18352693061c64c5134455 100644
--- a/Python/poiseuille/simulation.py
+++ b/Python/poiseuille/simulation.py
@@ -1,12 +1,12 @@
from pyfluids import Simulation
-from pyfluids.boundaryconditions import NoSlipBCAdapter, NoSlipBCAlgorithm
+from pyfluids.boundaryconditions import NoSlipBoundaryCondition
from pyfluids.geometry import GbCuboid3D, State
from pyfluids.kernel import LBMKernel, KernelType
-from pyfluids.parameters import SimulationParameters, GridParameters, PhysicalParameters
-from pyfluids.writer import Writer, WriterType
+from pyfluids.parameters import RuntimeParameters, GridParameters, PhysicalParameters
+from pyfluids.writer import Writer, OutputFormat
grid_params = GridParameters()
-grid_params.delta_x = 1
+grid_params.node_distance = 1
grid_params.number_of_nodes_per_direction = [2, 2, 10]
grid_params.blocks_per_direction = [1, 1, 1]
grid_params.periodic_boundary_in_x1 = True
@@ -15,13 +15,13 @@ grid_params.periodic_boundary_in_x2 = True
physical_params = PhysicalParameters()
physical_params.lattice_viscosity = 0.005
-sim_params = SimulationParameters()
-sim_params.number_of_threads = 4
-sim_params.number_of_timesteps = 10000
-sim_params.timestep_log_interval = 1000
+runtime_params = RuntimeParameters()
+runtime_params.number_of_threads = 4
+runtime_params.number_of_timesteps = 10000
+runtime_params.timestep_log_interval = 1000
-def run_simulation(physical_params=physical_params, grid_params=grid_params, sim_params=sim_params):
+def run_simulation(physical_params=physical_params, grid_params=grid_params, runtime_params=runtime_params):
simulation = Simulation()
kernel = LBMKernel(KernelType.CompressibleCumulantFourthOrderViscosity)
@@ -29,25 +29,23 @@ def run_simulation(physical_params=physical_params, grid_params=grid_params, sim
kernel.forcing_in_x1 = 1e-6
g_min_x1, g_min_x2, g_min_x3 = 0, 0, 0
- g_max_x1 = (grid_params.number_of_nodes_per_direction[0]) * grid_params.delta_x
- g_max_x2 = (grid_params.number_of_nodes_per_direction[1]) * grid_params.delta_x
- g_max_x3 = (grid_params.number_of_nodes_per_direction[2]) * grid_params.delta_x
+ g_max_x1 = (grid_params.number_of_nodes_per_direction[0]) * grid_params.node_distance
+ g_max_x2 = (grid_params.number_of_nodes_per_direction[1]) * grid_params.node_distance
+ g_max_x3 = (grid_params.number_of_nodes_per_direction[2]) * grid_params.node_distance
writer = Writer()
writer.output_path = "./output"
- writer.type = WriterType.BINARY
+ writer.output_format = OutputFormat.BINARY
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_simulation_parameters(runtime_params)
simulation.set_writer(writer)
- no_slip_adapter = NoSlipBCAdapter()
- no_slip_adapter.algorithm = NoSlipBCAlgorithm()
- simulation.add_bc_adapter(no_slip_adapter)
+ no_slip_adapter = NoSlipBoundaryCondition()
- block_length = 3 * grid_params.delta_x
+ block_length = 3 * grid_params.node_distance
simulation.add_object(
GbCuboid3D(g_min_x1 - block_length,
g_min_x2 - block_length,
diff --git a/Python/poiseuille/test_poiseuille_l2.py b/Python/poiseuille/test_poiseuille_l2.py
index 83b8cbc9fc05af8899b68b6994e122542841fa64..e9391f0c3f0b8671389ab18bf72763d9e1d04ed9 100644
--- a/Python/poiseuille/test_poiseuille_l2.py
+++ b/Python/poiseuille/test_poiseuille_l2.py
@@ -3,29 +3,35 @@ import unittest
import pyvista as pv
from norms import l2_norm
from poiseuille.analytical import poiseuille_at_heights, PoiseuilleSettings
-from poiseuille.simulation import run_simulation, grid_params, physical_params, sim_params
+from poiseuille.simulation import run_simulation, grid_params, physical_params, runtime_params
from vtk_utilities import vertical_column_from_mesh, get_values_from_indices
class TestPoiseuilleFlow(unittest.TestCase):
def test_poiseuille_flow(self):
+ """
+ WHEN comparing the simulation results to the analytical solution THEN the L2-Norm should be less than 1e-4
+ """
+
run_simulation()
- file_name = _get_output_file_name(sim_params)
- mesh = pv.read(file_name)
- indices = vertical_column_from_mesh(mesh)
- numerical_results = get_values_from_indices(mesh.get_array("Vx"), indices)
- heights = _get_heights_from_indices(mesh, indices)
+ file_name_of_last_timestep = get_output_file_name(runtime_params)
+ mesh_of_last_timestep = pv.read(file_name_of_last_timestep)
+ column_indices = vertical_column_from_mesh(mesh_of_last_timestep)
+ numerical_results_from_single_column = get_values_from_indices(mesh_of_last_timestep.get_array("Vx"), column_indices)
- settings = _get_analytical_poiseuille_settings(grid_params, physical_params)
+ heights = get_heights_from_indices(mesh_of_last_timestep, column_indices)
+ settings = get_analytical_poiseuille_settings(grid_params, physical_params)
analytical_results = poiseuille_at_heights(settings, heights)
- norm = l2_norm(analytical_results, numerical_results)
- print(f"L2 norm value: {norm}")
- self.assertLessEqual(norm, 1e-4)
+ l2_norm_result = l2_norm(analytical_results, numerical_results_from_single_column)
+
+ max_acceptable_error = 1e-4
+ self.assertLessEqual(l2_norm_result, max_acceptable_error)
+ print(f"The L2-Norm is: {l2_norm_result}")
-def _get_analytical_poiseuille_settings(grid_params, physical_params):
+def get_analytical_poiseuille_settings(grid_params, physical_params):
settings = PoiseuilleSettings()
settings.length = grid_params.number_of_nodes_per_direction[0]
settings.height = grid_params.number_of_nodes_per_direction[2]
@@ -35,11 +41,12 @@ def _get_analytical_poiseuille_settings(grid_params, physical_params):
return settings
-def _get_output_file_name(sim_params):
- file_name = f"output/mq/mq{sim_params.number_of_timesteps}/mq0_{sim_params.number_of_timesteps}.bin.vtu"
+def get_output_file_name(rumtime_params):
+ timesteps = rumtime_params.number_of_timesteps
+ file_name = f"output/mq/mq{timesteps}/mq0_{timesteps}.bin.vtu"
return file_name
-def _get_heights_from_indices(mesh, indices):
+def get_heights_from_indices(mesh, indices):
return [mesh.points[index][2] for index in indices]
diff --git a/Python/test_boundaryconditions.py b/Python/test_boundaryconditions.py
deleted file mode 100644
index 437a26953ec1063d64e57a8a5bf76773729c7d12..0000000000000000000000000000000000000000
--- a/Python/test_boundaryconditions.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from pyfluids.boundaryconditions import *
-
-no_slip_algo = NoSlipBCAlgorithm()
-no_slip_bc_adapter = NoSlipBCAdapter()
-no_slip_bc_adapter.algorithm = no_slip_algo
diff --git a/Python/test_muparser.py b/Python/test_muparser.py
deleted file mode 100644
index 177e70e81b18b38e49b28149ee380c8d1f8f1b46..0000000000000000000000000000000000000000
--- a/Python/test_muparser.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from pymuparser import Parser
-
-p = Parser()
-p.expression = "u"
-p.define_constant("u", 5)
diff --git a/src/cpu/pythonbindings/src/submodules/boundaryconditions.cpp b/src/cpu/pythonbindings/src/submodules/boundaryconditions.cpp
index 37fc1fdb8ec790f6b9136634207e9259cc2435b7..ef8b923fd9aa2feea9c81da686df38cb891a4f84 100644
--- a/src/cpu/pythonbindings/src/submodules/boundaryconditions.cpp
+++ b/src/cpu/pythonbindings/src/submodules/boundaryconditions.cpp
@@ -9,42 +9,54 @@
#include <BoundaryConditions/VelocityBCAlgorithm.h>
namespace py = pybind11;
+using namespace py::literals;
-void makeBoundaryConditionsModule(py::module_ &parentModule)
-{
- py::module bcModule = parentModule.def_submodule("boundaryconditions");
-
- py::class_<BCAdapter, std::shared_ptr<BCAdapter>>(bcModule, "BCAdapter")
- .def_property("algorithm", &BCAdapter::getAlgorithm, &BCAdapter::setBcAlgorithm);
+template<class Adapter>
+using py_bc_class = py::class_<Adapter, BCAdapter, std::shared_ptr<Adapter>>;
- py::class_<NoSlipBCAdapter, BCAdapter, std::shared_ptr<NoSlipBCAdapter>>(bcModule, "NoSlipBCAdapter")
- .def(py::init());
-
- py::class_<VelocityBCAdapter, BCAdapter, std::shared_ptr<VelocityBCAdapter>>(bcModule, "VelocityBCAdapter")
- .def(py::init())
- .def(py::init<bool &, bool &, bool &, mu::Parser &, double &, double &>())
- .def(py::init<bool &, bool &, bool &, mu::Parser &, mu::Parser &, mu::Parser &, double &, double &>())
- .def(py::init<bool &, bool &, bool &, std::string &, double &, double &>())
- .def(py::init<BCFunction &, bool, bool, bool>())
- .def(py::init<BCFunction &, BCFunction &, BCFunction &>())
- .def(py::init<std::vector<BCFunction> &, std::vector<BCFunction> &, std::vector<BCFunction> &>())
- .def(py::init<double &, double &, double &, double &, double &, double &, double &, double &, double &>())
- .def(py::init<std::string &, double &, double &, std::string &, double &, double &, std::string &, double &, double &>());
+template<class Adapter, class Algorithm, typename ...Args>
+std::shared_ptr<Adapter> create(Args... args)
+{
+ auto adapter = std::make_shared<Adapter>(args...);
+ adapter->setBcAlgorithm(std::make_shared<Algorithm>());
+ return adapter;
+}
- py::class_<DensityBCAdapter, BCAdapter, std::shared_ptr<DensityBCAdapter>>(bcModule, "DensityBCAdapter")
- .def(py::init());
+template<class Algorithm>
+void add_constructors_to_velocity_bc(py_bc_class<VelocityBCAdapter> &cls)
+{
+ auto firstConstructor = &create<VelocityBCAdapter, Algorithm, bool &, bool &, bool &, mu::Parser &, double &, double &>;
+ auto secondConstructor = &create<VelocityBCAdapter, Algorithm,
+ bool &, bool &, bool &, mu::Parser &, mu::Parser &, mu::Parser &, double &, double &>;
+ auto thirdConstructor = &create<VelocityBCAdapter, Algorithm,
+ double &, double &, double &, double &, double &, double &, double &, double &, double &>;
+
+ cls.def(py::init(&create<VelocityBCAdapter, Algorithm>))
+ .def(py::init(firstConstructor),
+ "vx1"_a, "vx2"_a, "vx3"_a, "function"_a, "start_time"_a, "end_time"_a)
+ .def(py::init(secondConstructor),
+ "vx1"_a, "vx2"_a, "vx3"_a,
+ "function_vx1"_a, "function_vx2"_a, "function_vx2"_a,
+ "start_time"_a, "end_time"_a)
+ .def(py::init(thirdConstructor),
+ "vx1"_a, "vx1_start_time"_a, "vx1_end_time"_a,
+ "vx2"_a, "vx2_start_time"_a, "vx2_end_time"_a,
+ "vx3"_a, "vx3_start_time"_a, "vx3_end_time"_a);
+}
+void makeBoundaryConditionsModule(py::module_ &parentModule)
+{
+ py::module_ bcModule = parentModule.def_submodule("boundaryconditions");
- py::class_<BCAlgorithm, std::shared_ptr<BCAlgorithm>>(bcModule, "BCAlgorithm");
+ py::class_<BCAdapter, std::shared_ptr<BCAdapter>>(bcModule, "BCAdapter");
- py::class_<NoSlipBCAlgorithm, BCAlgorithm, std::shared_ptr<NoSlipBCAlgorithm>>(bcModule, "NoSlipBCAlgorithm")
- .def(py::init());
+ py_bc_class<NoSlipBCAdapter>(bcModule, "NoSlipBoundaryCondition")
+ .def(py::init(&create<NoSlipBCAdapter, NoSlipBCAlgorithm>));
- py::class_<VelocityBCAlgorithm, BCAlgorithm, std::shared_ptr<VelocityBCAlgorithm>>(bcModule, "VelocityBCAlgorithm")
- .def(py::init());
+ auto velocityBoundaryCondition = py_bc_class<VelocityBCAdapter>(bcModule, "VelocityBoundaryCondition");
+ add_constructors_to_velocity_bc<VelocityBCAlgorithm>(velocityBoundaryCondition);
- py::class_<NonReflectingOutflowBCAlgorithm, BCAlgorithm, std::shared_ptr<NonReflectingOutflowBCAlgorithm>>(bcModule,
- "NonReflectingOutflowBCAlgorithm")
- .def(py::init());
+ py_bc_class<DensityBCAdapter>(bcModule, "DensityBoundaryCondition")
+ .def(py::init(&create<DensityBCAdapter, NonReflectingOutflowBCAlgorithm>));
}
diff --git a/src/cpu/pythonbindings/src/submodules/geometry.cpp b/src/cpu/pythonbindings/src/submodules/geometry.cpp
index e4c3a9ca1aa6e19c3037bfd129431d3102cbc989..884ced7b92ddae8a30a8f482e4b22dcbfa37beec 100644
--- a/src/cpu/pythonbindings/src/submodules/geometry.cpp
+++ b/src/cpu/pythonbindings/src/submodules/geometry.cpp
@@ -5,9 +5,11 @@
#include <geometry3d/GbLine3D.h>
#include <Interactors/Interactor3D.h>
-
namespace py = pybind11;
+template<class GeoObject>
+using py_geometry = py::class_<GeoObject, GbObject3D, std::shared_ptr<GeoObject>>;
+
std::string GbPoint3D_repr_(const GbPoint3D &instance)
{
std::ostringstream stream;
@@ -21,12 +23,11 @@ std::string GbPoint3D_repr_(const GbPoint3D &instance)
void makeGeometryModule(py::module_ &parentModule)
{
-
py::module geometry = parentModule.def_submodule("geometry");
py::class_<GbObject3D, std::shared_ptr<GbObject3D>>(geometry, "GbObject3D");
- py::class_<GbPoint3D, GbObject3D, std::shared_ptr<GbPoint3D>>(geometry, "GbPoint3D")
+ py_geometry<GbPoint3D>(geometry, "GbPoint3D")
.def(py::init())
.def(py::init<double &, double &, double &>())
.def(py::init<GbPoint3D *>())
@@ -34,16 +35,18 @@ void makeGeometryModule(py::module_ &parentModule)
.def_property("x2", &GbPoint3D::getX2Coordinate, &GbPoint3D::setX2)
.def_property("x3", &GbPoint3D::getX3Coordinate, &GbPoint3D::setX3)
.def("get_distance", &GbPoint3D::getDistance)
- .def("__repr__", [&](const GbPoint3D &instance) { return GbPoint3D_repr_(instance); });
+ .def("__repr__", [&](const GbPoint3D &instance)
+ { return GbPoint3D_repr_(instance); });
- py::class_<GbCuboid3D, GbObject3D, std::shared_ptr<GbCuboid3D>>(geometry, "GbCuboid3D")
+ py_geometry<GbCuboid3D>(geometry, "GbCuboid3D")
.def(py::init())
.def(py::init<double &, double &, double &, double &, double &, double &>())
.def(py::init<GbPoint3D *, GbPoint3D *>())
.def(py::init<GbCuboid3D *>())
.def_property("point1", &GbCuboid3D::getPoint1, &GbCuboid3D::setPoint1)
.def_property("point2", &GbCuboid3D::getPoint2, &GbCuboid3D::setPoint2)
- .def("__repr__", [&](GbCuboid3D instance) {
+ .def("__repr__", [&](GbCuboid3D instance)
+ {
std::ostringstream stream;
stream << "<GbCuboid3D" << std::endl
<< "point1: " << GbPoint3D_repr_(instance.getPoint1()) << std::endl
@@ -51,13 +54,14 @@ void makeGeometryModule(py::module_ &parentModule)
return stream.str();
});
- py::class_<GbLine3D, GbObject3D, std::shared_ptr<GbLine3D>>(geometry, "GbLine3D")
+ py_geometry<GbLine3D>(geometry, "GbLine3D")
.def(py::init())
.def(py::init<GbPoint3D *, GbPoint3D *>())
.def(py::init<GbLine3D>())
.def_property("point1", &GbLine3D::getPoint1, &GbLine3D::setPoint1)
.def_property("point2", &GbLine3D::getPoint2, &GbLine3D::setPoint2)
- .def("__repr__", [&](GbLine3D instance) {
+ .def("__repr__", [&](GbLine3D instance)
+ {
std::ostringstream stream;
stream << "<GbLine3D" << std::endl
<< "point1: " << GbPoint3D_repr_(instance.getPoint1()) << std::endl
diff --git a/src/cpu/pythonbindings/src/submodules/kernel.cpp b/src/cpu/pythonbindings/src/submodules/kernel.cpp
index d9ff9d529d622b1ce31fcf2b61905d67892d9c83..0e2e23c8c6a8ff56ea01c277e9825e7eb78c5c02 100644
--- a/src/cpu/pythonbindings/src/submodules/kernel.cpp
+++ b/src/cpu/pythonbindings/src/submodules/kernel.cpp
@@ -9,8 +9,6 @@ namespace py = pybind11;
void makeKernelModule(py::module_ &parentModule)
{
- using namespace pybind11::literals;
-
py::module kernelModule = parentModule.def_submodule("kernel");
py::enum_<KernelFactory::KernelType>(kernelModule, "KernelType")
@@ -19,18 +17,18 @@ void makeKernelModule(py::module_ &parentModule)
KernelFactory::COMPRESSIBLE_CUMULANT_4TH_ORDER_VISCOSITY);
- py::class_<LBMKernelConfig, std::shared_ptr<LBMKernelConfig>>(kernelModule, "LBMKernel")
+ py::class_<LBMKernelConfiguration, std::shared_ptr<LBMKernelConfiguration>>(kernelModule, "LBMKernel")
.def(py::init<KernelFactory::KernelType>())
- .def_readwrite("use_forcing", &LBMKernelConfig::useForcing)
- .def_readwrite("forcing_in_x1", &LBMKernelConfig::forcingX1)
- .def_readwrite("forcing_in_x2", &LBMKernelConfig::forcingX2)
- .def_readwrite("forcing_in_x3", &LBMKernelConfig::forcingX3)
- .def("set_forcing", [](LBMKernelConfig &kernelConfig, double x1, double x2, double x3) {
+ .def_readwrite("use_forcing", &LBMKernelConfiguration::useForcing)
+ .def_readwrite("forcing_in_x1", &LBMKernelConfiguration::forcingX1)
+ .def_readwrite("forcing_in_x2", &LBMKernelConfiguration::forcingX2)
+ .def_readwrite("forcing_in_x3", &LBMKernelConfiguration::forcingX3)
+ .def("set_forcing", [](LBMKernelConfiguration &kernelConfig, double x1, double x2, double x3) {
kernelConfig.forcingX1 = x1;
kernelConfig.forcingX2 = x2;
kernelConfig.forcingX3 = x3;
})
- .def("__repr__", [](LBMKernelConfig &kernelConfig) {
+ .def("__repr__", [](LBMKernelConfiguration &kernelConfig) {
std::ostringstream stream;
stream << "<" << kernelConfig.kernelType << std::endl
<< "Use forcing: " << kernelConfig.useForcing << std::endl
diff --git a/src/cpu/pythonbindings/src/submodules/simulationparameters.cpp b/src/cpu/pythonbindings/src/submodules/simulationparameters.cpp
index 13875126df9ff3403defb8ccc3e17b7b1b1d1402..61b3c9b4460fb2b6a8d628aa4d5a10d05d0854f6 100644
--- a/src/cpu/pythonbindings/src/submodules/simulationparameters.cpp
+++ b/src/cpu/pythonbindings/src/submodules/simulationparameters.cpp
@@ -12,12 +12,11 @@ void makeParametersModule(py::module_ &parentModule)
.def(py::init())
.def_readwrite("bulk_viscosity_factor", &PhysicalParameters::bulkViscosityFactor,
"The viscosity of the fluid will be multiplied with this factor to calculate its bulk viscosity. Default is 1.0")
- .def_readwrite("lattice_viscosity", &PhysicalParameters::latticeViscosity, "Lattice viscosity")
- .def_readwrite("lattice_density", &PhysicalParameters::latticeDensity, "Lattice Density");
+ .def_readwrite("lattice_viscosity", &PhysicalParameters::latticeViscosity, "Lattice viscosity");
py::class_<GridParameters, std::shared_ptr<GridParameters>>(parametersModule, "GridParameters")
.def(py::init())
- .def_readwrite("delta_x", &GridParameters::deltaX)
+ .def_readwrite("node_distance", &GridParameters::nodeDistance)
.def_readwrite("reference_direction_index", &GridParameters::referenceDirectionIndex)
.def_readwrite("number_of_nodes_per_direction", &GridParameters::numberOfNodesPerDirection)
.def_readwrite("blocks_per_direction", &GridParameters::blocksPerDirection)
@@ -25,10 +24,10 @@ void makeParametersModule(py::module_ &parentModule)
.def_readwrite("periodic_boundary_in_x2", &GridParameters::periodicBoundaryInX2)
.def_readwrite("periodic_boundary_in_x3", &GridParameters::periodicBoundaryInX3);
- py::class_<SimulationParameters, std::shared_ptr<SimulationParameters>>(parametersModule, "SimulationParameters")
+ py::class_<RuntimeParameters, std::shared_ptr<RuntimeParameters>>(parametersModule, "RuntimeParameters")
.def(py::init())
- .def_readwrite("number_of_timesteps", &SimulationParameters::numberOfTimeSteps)
- .def_readwrite("timestep_log_interval", &SimulationParameters::timeStepLogInterval)
- .def_readwrite("number_of_threads", &SimulationParameters::numberOfThreads);
+ .def_readwrite("number_of_timesteps", &RuntimeParameters::numberOfTimeSteps)
+ .def_readwrite("timestep_log_interval", &RuntimeParameters::timeStepLogInterval)
+ .def_readwrite("number_of_threads", &RuntimeParameters::numberOfThreads);
}
\ No newline at end of file
diff --git a/src/cpu/pythonbindings/src/submodules/writer.cpp b/src/cpu/pythonbindings/src/submodules/writer.cpp
index ef9c99ba3fdb3a07ef672f334dc844fcddcb054d..40819e4766eb30a442967067f954fef5508a4707 100644
--- a/src/cpu/pythonbindings/src/submodules/writer.cpp
+++ b/src/cpu/pythonbindings/src/submodules/writer.cpp
@@ -1,5 +1,5 @@
#include <pybind11/pybind11.h>
-#include <simulationconfig/WriterConfig.h>
+#include <simulationconfig/WriterConfiguration.h>
namespace py = pybind11;
@@ -7,12 +7,12 @@ void makeWriterModule(py::module_ &parentModule)
{
py::module writerModule = parentModule.def_submodule("writer");
- py::enum_<WriterType>(writerModule, "WriterType")
- .value("ASCII", WriterType::ASCII)
- .value("BINARY", WriterType::BINARY);
+ py::enum_<OutputFormat>(writerModule, "OutputFormat")
+ .value("ASCII", OutputFormat::ASCII)
+ .value("BINARY", OutputFormat::BINARY);
- py::class_<WriterConfig>(writerModule, "Writer")
+ py::class_<WriterConfiguration>(writerModule, "Writer")
.def(py::init())
- .def_readwrite("output_path", &WriterConfig::outputPath)
- .def_readwrite("type", &WriterConfig::writerType);
+ .def_readwrite("output_path", &WriterConfiguration::outputPath)
+ .def_readwrite("output_format", &WriterConfiguration::outputFormat);
}
\ No newline at end of file
diff --git a/src/cpu/simulationconfig/CMakeLists.txt b/src/cpu/simulationconfig/CMakeLists.txt
index 4d55e1ae490bfa71ebe775879f3c9fbaba66d89b..4c231302312752cbef3d18fc92bea92be5d25d94 100644
--- a/src/cpu/simulationconfig/CMakeLists.txt
+++ b/src/cpu/simulationconfig/CMakeLists.txt
@@ -3,7 +3,10 @@ project(simulationconfig)
set(VFBUILDER_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
-file(GLOB HEADERS ${VFBUILDER_INCLUDE_DIR}/simulationconfig/*.h)
+file(GLOB HEADERS
+ ${VFBUILDER_INCLUDE_DIR}/simulationconfig/*.h
+ ${VFBUILDER_INCLUDE_DIR}/simulationconfig/boundaryconditions/*.h)
+
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
add_library(simulationconfig STATIC ${SRC} ${HEADERS})
diff --git a/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h b/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h
index b70de7f9bdbddb80bcae4e297a1ac2304e32211d..88e621a3fe00a522b23fda4101e84d39305e80a2 100644
--- a/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h
+++ b/src/cpu/simulationconfig/include/simulationconfig/KernelConfigStructs.h
@@ -4,14 +4,14 @@
#include <string>
#include <LBM/LBMSystem.h>
-struct LBMKernelConfig {
+struct LBMKernelConfiguration {
KernelFactory::KernelType kernelType;
bool useForcing = false;
LBMReal forcingX1{};
LBMReal forcingX2{};
LBMReal forcingX3{};
- explicit LBMKernelConfig(KernelFactory::KernelType kernelType) : kernelType(kernelType)
+ explicit LBMKernelConfiguration(KernelFactory::KernelType kernelType) : kernelType(kernelType)
{
}
};
diff --git a/src/cpu/simulationconfig/include/simulationconfig/Simulation.h b/src/cpu/simulationconfig/include/simulationconfig/Simulation.h
index f003999c444d7b8e6423b25e94e2e0cbe5e993c8..df2b436e812fbebd9882517921b47167e35318b5 100644
--- a/src/cpu/simulationconfig/include/simulationconfig/Simulation.h
+++ b/src/cpu/simulationconfig/include/simulationconfig/Simulation.h
@@ -15,7 +15,7 @@
#include "AbstractLBMSystem.h"
#include "KernelConfigStructs.h"
#include "SimulationParameters.h"
-#include "WriterConfig.h"
+#include "WriterConfiguration.h"
class Simulation {
@@ -26,64 +26,64 @@ private:
std::shared_ptr<AbstractLBMSystem> lbmSystem;
std::shared_ptr<Communicator> communicator;
- SPtr<Grid3D> grid;
- std::vector<SPtr<Interactor3D>> interactors;
+ std::shared_ptr<Grid3D> grid;
+ std::vector<std::shared_ptr<Interactor3D>> interactors;
BoundaryConditionsBlockVisitor bcVisitor;
- std::set<SPtr<BCAdapter>> registeredAdapters;
+ std::set<std::shared_ptr<BCAdapter>> registeredAdapters;
- SPtr<LBMKernelConfig> kernelConfig;
- SPtr<SimulationParameters> simulationParameters;
- SPtr<GridParameters> gridParameters;
- SPtr<PhysicalParameters> physicalParameters;
+ std::shared_ptr<LBMKernelConfiguration> kernelConfig;
+ std::shared_ptr<RuntimeParameters> simulationParameters;
+ std::shared_ptr<GridParameters> gridParameters;
+ std::shared_ptr<PhysicalParameters> physicalParameters;
- WriterConfig &writerConfig = *(new WriterConfig());
+ WriterConfiguration &writerConfig = *(new WriterConfiguration());
public:
explicit Simulation();
~Simulation();
- WriterConfig &getWriterConfig();
+ WriterConfiguration &getWriterConfig();
- void setWriterConfig(const WriterConfig &config);
+ void setWriterConfig(const WriterConfiguration &config);
- void setGridParameters(SPtr<GridParameters> parameters);
+ void setGridParameters(std::shared_ptr<GridParameters> parameters);
- void setPhysicalParameters(SPtr<PhysicalParameters> parameters);
+ void setPhysicalParameters(std::shared_ptr<PhysicalParameters> parameters);
- void setSimulationParameters(SPtr<SimulationParameters> parameters);
+ void setSimulationParameters(std::shared_ptr<RuntimeParameters> parameters);
- void setKernelConfig(const SPtr<LBMKernelConfig> &kernel);
+ void setKernelConfig(const std::shared_ptr<LBMKernelConfiguration> &kernel);
- void addObject(const SPtr<GbObject3D> &object, const SPtr<BCAdapter> &bcAdapter, int state,
+ void addObject(const std::shared_ptr<GbObject3D> &object, const std::shared_ptr<BCAdapter> &bcAdapter, int state,
const std::string &folderPath);
- void addBCAdapter(const SPtr<BCAdapter> &bcAdapter);
+ void addBCAdapter(const std::shared_ptr<BCAdapter> &bcAdapter);
void run();
private:
- SPtr<GbObject3D> makeSimulationBoundingBox(const int &nodesInX1, const int &nodesInX2, const int &nodesInX3) const;
+ std::shared_ptr<GbObject3D> makeSimulationBoundingBox(const int &nodesInX1, const int &nodesInX2, const int &nodesInX3) const;
void writeBlocks() const;
void writeBoundaryConditions() const;
- SPtr<CoProcessor> makeMacroscopicQuantitiesCoProcessor(const std::shared_ptr<LBMUnitConverter> &converter,
- const SPtr<UbScheduler> &visSch) const;
+ std::shared_ptr<CoProcessor> makeMacroscopicQuantitiesCoProcessor(const std::shared_ptr<LBMUnitConverter> &converter,
+ const std::shared_ptr<UbScheduler> &visSch) const;
static std::shared_ptr<LBMUnitConverter> makeLBMUnitConverter();
void setBlockSize(const int &nodesInX1, const int &nodesInX2, const int &nodesInX3) const;
- static void setBoundaryConditionProcessor(const SPtr<LBMKernel> &kernel);
+ static void setBoundaryConditionProcessor(const std::shared_ptr<LBMKernel> &kernel);
- void generateBlockGrid(const SPtr<GbObject3D> &gridCube) const;
+ void generateBlockGrid(const std::shared_ptr<GbObject3D> &gridCube) const;
void logSimulationData(const int &nodesInX1, const int &nodesInX2, const int &nodesInX3) const;
- void setKernelForcing(const SPtr<LBMKernel> &kernel, std::shared_ptr<LBMUnitConverter> &converter) const;
+ void setKernelForcing(const std::shared_ptr<LBMKernel> &kernel, std::shared_ptr<LBMUnitConverter> &converter) const;
};
#endif
\ No newline at end of file
diff --git a/src/cpu/simulationconfig/include/simulationconfig/SimulationParameters.h b/src/cpu/simulationconfig/include/simulationconfig/SimulationParameters.h
index 41cf95fb80037fe1275d4505cc91ffe0531d1465..5b076c30328458c3fc47cfab18551c9c83fa7556 100644
--- a/src/cpu/simulationconfig/include/simulationconfig/SimulationParameters.h
+++ b/src/cpu/simulationconfig/include/simulationconfig/SimulationParameters.h
@@ -7,20 +7,19 @@
struct PhysicalParameters {
double latticeViscosity{};
double bulkViscosityFactor{1};
- double latticeDensity{};
};
struct GridParameters {
std::array<int, 3> numberOfNodesPerDirection{1, 1, 1};
std::array<int, 3> blocksPerDirection{1, 1, 1};
int referenceDirectionIndex{};
- double deltaX{1};
+ double nodeDistance{1};
bool periodicBoundaryInX1{};
bool periodicBoundaryInX2{};
bool periodicBoundaryInX3{};
};
-struct SimulationParameters {
+struct RuntimeParameters {
int numberOfTimeSteps{};
int timeStepLogInterval{};
int numberOfThreads{};
diff --git a/src/cpu/simulationconfig/include/simulationconfig/WriterConfig.h b/src/cpu/simulationconfig/include/simulationconfig/WriterConfiguration.h
similarity index 66%
rename from src/cpu/simulationconfig/include/simulationconfig/WriterConfig.h
rename to src/cpu/simulationconfig/include/simulationconfig/WriterConfiguration.h
index 0caf25d94f264dd488ac7130274e351c0597fc89..a487917ff3c8a9a7b7f3847e5b04de1801a0fce0 100644
--- a/src/cpu/simulationconfig/include/simulationconfig/WriterConfig.h
+++ b/src/cpu/simulationconfig/include/simulationconfig/WriterConfiguration.h
@@ -6,18 +6,18 @@
#include <basics/writer/WbWriterVtkXmlASCII.h>
#include <basics/writer/WbWriterVtkXmlBinary.h>
-enum WriterType {
+enum OutputFormat {
ASCII, BINARY
};
-struct WriterConfig {
- WriterType writerType{};
+struct WriterConfiguration {
+ OutputFormat outputFormat{};
std::string outputPath{"./output"};
WbWriter *getWriter()
{
- if (writerType == ASCII) return WbWriterVtkXmlASCII::getInstance();
- if (writerType == BINARY) return WbWriterVtkXmlBinary::getInstance();
+ if (outputFormat == ASCII) return WbWriterVtkXmlASCII::getInstance();
+ if (outputFormat == BINARY) return WbWriterVtkXmlBinary::getInstance();
return nullptr;
}
};
diff --git a/src/cpu/simulationconfig/src/Simulation.cpp b/src/cpu/simulationconfig/src/Simulation.cpp
index 32c63087dc153ca510badd51734141423ebeb91e..a92b0050de0b546a577f16265600fac7d13dfcae 100644
--- a/src/cpu/simulationconfig/src/Simulation.cpp
+++ b/src/cpu/simulationconfig/src/Simulation.cpp
@@ -1,3 +1,4 @@
+#include <memory>
#include <string>
#include <set>
#include <utility>
@@ -35,29 +36,29 @@
Simulation::Simulation()
{
this->communicator = MPICommunicator::getInstance();
- this->grid = SPtr<Grid3D>(new Grid3D(communicator));
- this->interactors = std::vector<SPtr<Interactor3D>>();
+ this->grid = std::shared_ptr<Grid3D>(new Grid3D(communicator));
+ this->interactors = std::vector<std::shared_ptr<Interactor3D>>();
this->bcVisitor = BoundaryConditionsBlockVisitor();
- this->registeredAdapters = std::set<SPtr<BCAdapter>>();
+ this->registeredAdapters = std::set<std::shared_ptr<BCAdapter>>();
}
-void Simulation::setGridParameters(SPtr<GridParameters> parameters)
+void Simulation::setGridParameters(std::shared_ptr<GridParameters> parameters)
{
this->gridParameters = std::move(parameters);
}
-void Simulation::setPhysicalParameters(SPtr<PhysicalParameters> parameters)
+void Simulation::setPhysicalParameters(std::shared_ptr<PhysicalParameters> parameters)
{
this->physicalParameters = std::move(parameters);
}
-void Simulation::setSimulationParameters(SPtr<SimulationParameters> parameters)
+void Simulation::setSimulationParameters(std::shared_ptr<RuntimeParameters> parameters)
{
this->simulationParameters = std::move(parameters);
}
void
-Simulation::addObject(const SPtr<GbObject3D> &object, const SPtr<BCAdapter> &bcAdapter, int state,
+Simulation::addObject(const std::shared_ptr<GbObject3D> &object, const std::shared_ptr<BCAdapter> &bcAdapter, int state,
const std::string &folderPath)
{
const bool is_in = registeredAdapters.find(bcAdapter) != registeredAdapters.end();
@@ -66,25 +67,25 @@ Simulation::addObject(const SPtr<GbObject3D> &object, const SPtr<BCAdapter> &bcA
GbSystem3D::writeGeoObject(object, writerConfig.outputPath + folderPath, writerConfig.getWriter());
}
-void Simulation::addBCAdapter(const SPtr<BCAdapter> &bcAdapter)
+void Simulation::addBCAdapter(const std::shared_ptr<BCAdapter> &bcAdapter)
{
registeredAdapters.insert(bcAdapter);
this->bcVisitor.addBC(bcAdapter);
}
-void Simulation::setKernelConfig(const SPtr<LBMKernelConfig> &kernel)
+void Simulation::setKernelConfig(const std::shared_ptr<LBMKernelConfiguration> &kernel)
{
this->kernelConfig = kernel;
this->lbmKernel = kernelFactory.makeKernel(kernel->kernelType);
this->lbmSystem = kernelFactory.makeLBMSystem(kernel->kernelType);
}
-void Simulation::setWriterConfig(const WriterConfig &config)
+void Simulation::setWriterConfig(const WriterConfiguration &config)
{
this->writerConfig = config;
}
-WriterConfig &Simulation::getWriterConfig()
+WriterConfiguration &Simulation::getWriterConfig()
{
return writerConfig;
}
@@ -92,7 +93,7 @@ WriterConfig &Simulation::getWriterConfig()
void Simulation::run()
{
UBLOG(logINFO, "Beginning simulation setup")
- grid->setDeltaX(gridParameters->deltaX);
+ grid->setDeltaX(gridParameters->nodeDistance);
grid->setPeriodicX1(gridParameters->periodicBoundaryInX1);
grid->setPeriodicX2(gridParameters->periodicBoundaryInX2);
grid->setPeriodicX3(gridParameters->periodicBoundaryInX3);
@@ -106,14 +107,14 @@ void Simulation::run()
logSimulationData(nodesInX1, nodesInX2, nodesInX3);
setBlockSize(nodesInX1, nodesInX2, nodesInX3);
- SPtr<GbObject3D> gridCube = makeSimulationBoundingBox(nodesInX1, nodesInX2, nodesInX3);
+ std::shared_ptr<GbObject3D> gridCube = makeSimulationBoundingBox(nodesInX1, nodesInX2, nodesInX3);
generateBlockGrid(gridCube);
setKernelForcing(lbmKernel, converter);
setBoundaryConditionProcessor(lbmKernel);
- SPtr<Grid3DVisitor> metisVisitor(
+ std::shared_ptr<Grid3DVisitor> metisVisitor(
new MetisPartitioningGridVisitor(communicator,
MetisPartitioningGridVisitor::LevelBased,
D3Q27System::B));
@@ -130,7 +131,7 @@ void Simulation::run()
grid->accept(kernelVisitor);
intHelper.setBC();
- SPtr<InterpolationProcessor> iProcessor(new CompressibleOffsetMomentsInterpolationProcessor());
+ std::shared_ptr<InterpolationProcessor> iProcessor(new CompressibleOffsetMomentsInterpolationProcessor());
dynamicPointerCast<CompressibleOffsetMomentsInterpolationProcessor>(iProcessor)->setBulkViscosity(
physicalParameters->latticeViscosity,
physicalParameters->latticeViscosity * physicalParameters->bulkViscosityFactor);
@@ -146,11 +147,12 @@ void Simulation::run()
writeBoundaryConditions();
- SPtr<UbScheduler> visualizationScheduler(new UbScheduler(simulationParameters->timeStepLogInterval));
- SPtr<CoProcessor> mqCoProcessor = makeMacroscopicQuantitiesCoProcessor(converter, visualizationScheduler);
+ std::shared_ptr<UbScheduler> visualizationScheduler(new UbScheduler(simulationParameters->timeStepLogInterval));
+ std::shared_ptr<CoProcessor> mqCoProcessor = makeMacroscopicQuantitiesCoProcessor(converter,
+ visualizationScheduler);
- SPtr<UbScheduler> nupsScheduler(new UbScheduler(100, 100));
- SPtr<CoProcessor> nupsCoProcessor(
+ std::shared_ptr<UbScheduler> nupsScheduler(new UbScheduler(100, 100));
+ std::shared_ptr<CoProcessor> nupsCoProcessor(
new NUPSCounterCoProcessor(grid, nupsScheduler, simulationParameters->numberOfThreads, communicator));
@@ -158,7 +160,7 @@ void Simulation::run()
omp_set_num_threads(simulationParameters->numberOfThreads);
#endif
- SPtr<Calculator> calculator(
+ std::shared_ptr<Calculator> calculator(
new BasicCalculator(grid, visualizationScheduler, simulationParameters->numberOfTimeSteps));
calculator->addCoProcessor(nupsCoProcessor);
calculator->addCoProcessor(mqCoProcessor);
@@ -169,7 +171,7 @@ void Simulation::run()
}
void
-Simulation::setKernelForcing(const SPtr<LBMKernel> &kernel,
+Simulation::setKernelForcing(const std::shared_ptr<LBMKernel> &kernel,
std::shared_ptr<LBMUnitConverter> &converter) const
{
kernel->setWithForcing(kernelConfig->useForcing);
@@ -181,11 +183,11 @@ Simulation::setKernelForcing(const SPtr<LBMKernel> &kernel,
void Simulation::logSimulationData(const int &nodesInX1, const int &nodesInX2, const int &nodesInX3) const
{
UBLOG(logINFO, "Domain size = " << nodesInX1 << " x " << nodesInX2 << " x " << nodesInX3)
- UBLOG(logINFO, "dx = " << gridParameters->deltaX << " m")
+ UBLOG(logINFO, "dx = " << gridParameters->nodeDistance << " m")
UBLOG(logINFO, "latticeViscosity = " << physicalParameters->latticeViscosity)
}
-void Simulation::generateBlockGrid(const SPtr<GbObject3D> &gridCube) const
+void Simulation::generateBlockGrid(const std::shared_ptr<GbObject3D> &gridCube) const
{
UBLOG(logINFO, "Generate block grid")
GenBlocksGridVisitor genBlocks(gridCube);
@@ -193,11 +195,11 @@ void Simulation::generateBlockGrid(const SPtr<GbObject3D> &gridCube) const
writeBlocks();
}
-void Simulation::setBoundaryConditionProcessor(const SPtr<LBMKernel> &kernel)
+void Simulation::setBoundaryConditionProcessor(const std::shared_ptr<LBMKernel> &kernel)
{
UBLOG(logINFO, "Create boundary conditions processor")
- SPtr<BCProcessor> bcProc;
- bcProc = SPtr<BCProcessor>(new BCProcessor());
+ std::shared_ptr<BCProcessor> bcProc;
+ bcProc = std::shared_ptr<BCProcessor>(new BCProcessor());
kernel->setBCProcessor(bcProc);
}
@@ -215,14 +217,14 @@ void Simulation::setBlockSize(const int &nodesInX1, const int &nodesInX2, const
std::shared_ptr<LBMUnitConverter>
Simulation::makeLBMUnitConverter()
{
- return SPtr<LBMUnitConverter>(new LBMUnitConverter());
+ return std::shared_ptr<LBMUnitConverter>(new LBMUnitConverter());
}
-SPtr<CoProcessor>
+std::shared_ptr<CoProcessor>
Simulation::makeMacroscopicQuantitiesCoProcessor(const std::shared_ptr<LBMUnitConverter> &converter,
- const SPtr<UbScheduler> &visSch) const
+ const std::shared_ptr<UbScheduler> &visSch) const
{
- SPtr<CoProcessor> mqCoProcessor(
+ std::shared_ptr<CoProcessor> mqCoProcessor(
new WriteMacroscopicQuantitiesCoProcessor(grid, visSch, writerConfig.outputPath, writerConfig.getWriter(),
converter,
communicator));
@@ -232,7 +234,7 @@ Simulation::makeMacroscopicQuantitiesCoProcessor(const std::shared_ptr<LBMUnitCo
void Simulation::writeBoundaryConditions() const
{
- SPtr<UbScheduler> geoSch(new UbScheduler(1));
+ std::shared_ptr<UbScheduler> geoSch(new UbScheduler(1));
WriteBoundaryConditionsCoProcessor ppgeo(grid, geoSch, writerConfig.outputPath, writerConfig.getWriter(),
communicator);
ppgeo.process(0);
@@ -241,9 +243,9 @@ void Simulation::writeBoundaryConditions() const
void Simulation::writeBlocks() const
{
UBLOG(logINFO, "Write block grid to VTK-file")
- SPtr<CoProcessor> ppblocks(
+ std::shared_ptr<CoProcessor> ppblocks(
new WriteBlocksCoProcessor(grid,
- SPtr<UbScheduler>(new UbScheduler(1)),
+ std::shared_ptr<UbScheduler>(new UbScheduler(1)),
writerConfig.outputPath,
writerConfig.getWriter(),
communicator));
@@ -252,20 +254,20 @@ void Simulation::writeBlocks() const
ppblocks.reset();
}
-SPtr<GbObject3D>
+std::shared_ptr<GbObject3D>
Simulation::makeSimulationBoundingBox(const int &nodesInX1, const int &nodesInX2,
const int &nodesInX3) const
{
double minX1 = 0, minX2 = 0, minX3 = 0;
- const double maxX1 = minX1 + gridParameters->deltaX * nodesInX1;
- const double maxX2 = minX2 + gridParameters->deltaX * nodesInX2;
- const double maxX3 = minX3 + gridParameters->deltaX * nodesInX3;
+ const double maxX1 = minX1 + gridParameters->nodeDistance * nodesInX1;
+ const double maxX2 = minX2 + gridParameters->nodeDistance * nodesInX2;
+ const double maxX3 = minX3 + gridParameters->nodeDistance * nodesInX3;
UBLOG(logINFO, "Bounding box dimensions = [("
<< minX1 << ", " << minX2 << ", " << minX3 << "); ("
<< maxX1 << ", " << maxX2 << ", " << maxX3 << ")]")
- SPtr<GbObject3D> gridCube(new GbCuboid3D(minX1, minX2, minX3, maxX1, maxX2, maxX3));
+ std::shared_ptr<GbObject3D> gridCube(new GbCuboid3D(minX1, minX2, minX3, maxX1, maxX2, maxX3));
GbSystem3D::writeGeoObject(gridCube.get(), writerConfig.outputPath + "/geo/gridCube", writerConfig.getWriter());
return gridCube;
}