diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 0903a6e50d3501f32141582df55736dd0a39ed2d..36970b16f74ac0005322ecee25646cefda1c16f2 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -47,11 +47,10 @@ stages:
- mkdir -p $CI_PROJECT_DIR/$BUILD_FOLDER
- cd $CI_PROJECT_DIR/$BUILD_FOLDER
- rm -r -f ./*
- - cmake ..
+ - cmake .. -LAH
--preset=all_make_ccache
-DBUILD_WARNINGS_AS_ERRORS=ON
-DCMAKE_CUDA_ARCHITECTURES=60
- - cmake . -LAH
- make -j4
- ccache --show-stats
diff --git a/CMake/VirtualFluidsMacros.cmake b/CMake/VirtualFluidsMacros.cmake
index 23d5029d2dff46076c27158e4f15d0375bf8565f..2c2bc1d650e5e2c402f34a1a2547b9fa6f5e063b 100644
--- a/CMake/VirtualFluidsMacros.cmake
+++ b/CMake/VirtualFluidsMacros.cmake
@@ -131,18 +131,18 @@ function(vf_add_library)
#################################################################
### ADD TARGET ###
#################################################################
- IF(${ARG_BUILDTYPE} MATCHES binary)
- ADD_EXECUTABLE(${library_name} ${MY_SRCS} )
+ if(${ARG_BUILDTYPE} MATCHES binary)
+ add_executable(${library_name} ${MY_SRCS} )
groupTarget(${library_name} ${appFolder})
- ELSEIF(${ARG_BUILDTYPE} MATCHES shared)
- ADD_LIBRARY(${library_name} SHARED ${MY_SRCS} )
+ elseif(${ARG_BUILDTYPE} MATCHES shared)
+ add_library(${library_name} SHARED ${MY_SRCS} )
groupTarget(${library_name} ${libraryFolder})
- ELSEIF(${ARG_BUILDTYPE} MATCHES static)
- ADD_LIBRARY(${library_name} STATIC ${MY_SRCS} )
+ elseif(${ARG_BUILDTYPE} MATCHES static)
+ add_library(${library_name} STATIC ${MY_SRCS} )
groupTarget(${library_name} ${libraryFolder})
- ELSE()
- MESSAGE(FATAL_ERROR "build_type=${ARG_BUILDTYPE} doesn't match BINARY, SHARED or STATIC")
- ENDIF()
+ else()
+ message(FATAL_ERROR "build_type=${ARG_BUILDTYPE} doesn't match BINARY, SHARED or STATIC")
+ endif()
# Set the output directory for build artifacts
set_target_properties(${library_name}
@@ -152,6 +152,21 @@ function(vf_add_library)
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+ # link time optimization
+ if(BUILD_VF_LTO)
+ if(NOT ${ARG_BUILDTYPE} MATCHES binary)
+ include(CheckIPOSupported)
+ check_ipo_supported(RESULT ipo_supported OUTPUT ipo_error LANGUAGES CXX)
+
+ if( ipo_supported )
+ status_lib("IPO / LTO enabled")
+ set_target_properties(${library_name} PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
+ else()
+ status_lib("IPO / LTO not supported: <${ipo_error}>")
+ endif()
+ endif()
+ endif()
+
# clang-tidy
if(BUILD_VF_CLANG_TIDY)
find_program(CLANG_TIDY_PROGRAM NAMES clang-tidy)
@@ -286,6 +301,7 @@ function(vf_add_tests)
# link googlemock
linkGMOCK()
+ # add the target to ctest
gtest_add_tests(TARGET ${library_test_name})
endfunction()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9685f4de572b180fa32766f6a15b87f4a8d3a922..d74febdac96544fa6f50b65602392d3c44a5ca10 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -51,6 +51,8 @@ option(BUILD_VF_INCLUDE_WHAT_YOU_USE "Add IWYU to the targets" OFF)
option(BUILD_VF_CPPCHECK "Add cppcheck to the targets" OFF)
option(BUILD_VF_COVERAGE "Add the -coverage compiler flag." OFF)
+option(BUILD_CUDA_LTO "Enables the cuda link optimization." OFF)
+
option(BUILD_SHARED_LIBS "" OFF)
option(BUILD_WARNINGS_AS_ERRORS "" OFF)
@@ -94,14 +96,36 @@ if(BUILD_VF_GPU)
set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
+ enable_language(CUDA)
+
+
if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
message(WARNING "CMAKE_CUDA_ARCHITECTURES was not defined and is set to 30 (CUDA support until 10.1 only).")
set(CMAKE_CUDA_ARCHITECTURES 30)
endif()
+
+ if(BUILD_CUDA_LTO)
+
+ if(CMAKE_CUDA_ARCHITECTURES LESS 50)
+ message(FATAL_ERROR "CUDA Link time optimization requires CUDA 11.2 and CC 5.0.")
+ else()
+
+ set(CMAKE_CUDA_FLAGS "-dlto -arch=sm_${CMAKE_CUDA_ARCHITECTURES}")
+ set(CMAKE_CUDA_ARCHITECTURES OFF)
+
+ list(APPEND VF_COMPILER_DEFINITION BUILD_CUDA_LTO)
+
+ endif()
+ endif()
+
+ set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
+
+ message("CMAKE_CUDA_FLAGS: ${CMAKE_CUDA_FLAGS}")
message("CUDA Architecture: ${CMAKE_CUDA_ARCHITECTURES}")
endif()
+
#################################################################################
# COMMON LIBRARIES
#################################################################################
@@ -119,6 +143,7 @@ find_package(MPI REQUIRED)
add_subdirectory(src/basics)
+add_subdirectory(src/lbm)
#################################################################################
diff --git a/CMakePresets.json b/CMakePresets.json
index 6863446af85b177bb4dc99eed475aa52f4d50269..6527d5c1f4feba60064b1473fa12dbb2331279aa 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -1,133 +1,179 @@
{
- "version": 1,
- "cmakeMinimumRequired": {
- "major": 3,
- "minor": 19,
- "patch": 0
- },
- "configurePresets": [
- {
- "name": "default",
- "hidden": true,
- "binaryDir": "${sourceDir}/build/",
- "cacheVariables": {
- "BUILD_VF_UNIT_TESTS": "ON"
- }
- },
- {
- "name": "default_make",
- "inherits": "default",
- "hidden": true,
- "generator": "Unix Makefiles"
- },
- {
- "name": "default_ccache_make",
- "inherits": "default_make",
- "hidden": true,
- "cacheVariables": {
- "CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
- "CMAKE_CUDA_COMPILER_LAUNCHER": "ccache",
- "CMAKE_C_COMPILER_LAUNCHER": "ccache"
- }
- },
- {
- "name": "default_msvc",
- "inherits": "default",
- "hidden": true,
- "generator": "Visual Studio 16 2019",
- "architecture": "x64"
- },
- {
- "name": "default_cpu",
- "hidden": true,
- "description": "CPU build of VirtualFluids",
- "cacheVariables": {
- "BUILD_VF_CPU": "ON"
- }
- },
- {
- "name": "default_gpu",
- "hidden": true,
- "description": "GPU build of VirtualFluids",
- "cacheVariables": {
- "BUILD_VF_GPU": "ON"
- }
- },
- {
- "name": "default_gpu_numerical_tests",
- "inherits": ["default_gpu"],
- "hidden": true,
- "description": "GPU numerical tests of VirtualFluids",
- "cacheVariables": {
- "BUILD_VF_DOUBLE_ACCURACY": "ON",
- "BUILD_NUMERIC_TESTS": "ON"
- }
- },
- {
- "name": "default_all",
- "hidden": true,
- "description": "All build of VirtualFluids",
- "inherits": ["default_cpu", "default_gpu"]
- },
- {
- "name": "cpu_make",
- "inherits": ["default_make", "default_cpu"],
- "displayName": "cpu make configuration"
- },
- {
- "name": "cpu_make_ccache",
- "inherits": ["default_ccache_make", "default_cpu"],
- "displayName": "cpu ccache make configuration"
- },
- {
- "name": "cpu_msvc",
- "inherits": ["default_msvc", "default_cpu"],
- "displayName": "cpu msvc configuration"
- },
- {
- "name": "gpu_make",
- "inherits": ["default_make", "default_gpu"],
- "displayName": "gpu make configuration"
- },
- {
- "name": "gpu_make_ccache",
- "inherits": ["default_ccache_make", "default_gpu"],
- "displayName": "gpu ccache make configuration"
- },
- {
- "name": "gpu_msvc",
- "inherits": ["default_msvc", "default_gpu"],
- "displayName": "gpu msvc configuration"
- },
- {
- "name": "all_make",
- "inherits": ["default_make", "default_all"],
- "displayName": "all make configuration"
- },
- {
- "name": "all_make_ccache",
- "inherits": ["default_ccache_make", "default_all"],
- "displayName": "all ccache make configuration"
- },
- {
- "name": "all_msvc",
- "inherits": ["default_msvc", "default_all"],
- "displayName": "all msvc configuration"
- },
- {
- "name": "gpu_numerical_tests_make",
- "inherits": ["default_make", "default_gpu_numerical_tests"],
- "displayName": "gpu numerical tests make configuration"
- },
- {
- "name": "gpu_numerical_tests_ccache_make",
- "inherits": ["default_ccache_make", "default_gpu_numerical_tests"],
- "displayName": "gpu numerical tests ccache make configuration"
- },
- {
- "name": "gpu_numerical_tests_msvc",
- "inherits": ["default_msvc", "default_gpu_numerical_tests"],
- "displayName": "gpu numerical tests msvc configuration"
- }
- ]
+ "version": 1,
+ "cmakeMinimumRequired": {
+ "major": 3,
+ "minor": 19,
+ "patch": 0
+ },
+ "configurePresets": [
+ {
+ "name": "default",
+ "hidden": true,
+ "binaryDir": "${sourceDir}/build/",
+ "cacheVariables": {
+ "BUILD_VF_UNIT_TESTS": "ON"
+ }
+ },
+ {
+ "name": "default_make",
+ "inherits": "default",
+ "hidden": true,
+ "generator": "Unix Makefiles"
+ },
+ {
+ "name": "default_ccache_make",
+ "inherits": "default_make",
+ "hidden": true,
+ "cacheVariables": {
+ "CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
+ "CMAKE_CUDA_COMPILER_LAUNCHER": "ccache",
+ "CMAKE_C_COMPILER_LAUNCHER": "ccache"
+ }
+ },
+ {
+ "name": "default_msvc",
+ "inherits": "default",
+ "hidden": true,
+ "generator": "Visual Studio 16 2019",
+ "architecture": "x64"
+ },
+ {
+ "name": "default_cpu",
+ "hidden": true,
+ "description": "CPU build of VirtualFluids",
+ "cacheVariables": {
+ "BUILD_VF_CPU": "ON",
+ "BUILD_VF_DOUBLE_ACCURACY": "ON"
+ }
+ },
+ {
+ "name": "default_gpu",
+ "hidden": true,
+ "description": "GPU build of VirtualFluids",
+ "cacheVariables": {
+ "BUILD_VF_GPU": "ON",
+ "BUILD_VF_DOUBLE_ACCURACY": "OFF"
+ }
+ },
+ {
+ "name": "default_gpu_numerical_tests",
+ "inherits": [
+ "default_gpu"
+ ],
+ "hidden": true,
+ "description": "GPU numerical tests of VirtualFluids",
+ "cacheVariables": {
+ "BUILD_VF_DOUBLE_ACCURACY": "ON",
+ "BUILD_NUMERIC_TESTS": "ON"
+ }
+ },
+ {
+ "name": "default_all",
+ "hidden": true,
+ "description": "All build of VirtualFluids",
+ "inherits": [
+ "default_cpu",
+ "default_gpu"
+ ],
+ "cacheVariables": {
+ "BUILD_VF_DOUBLE_ACCURACY": "ON"
+ }
+ },
+ {
+ "name": "cpu_make",
+ "inherits": [
+ "default_make",
+ "default_cpu"
+ ],
+ "displayName": "cpu make configuration"
+ },
+ {
+ "name": "cpu_make_ccache",
+ "inherits": [
+ "default_ccache_make",
+ "default_cpu"
+ ],
+ "displayName": "cpu ccache make configuration"
+ },
+ {
+ "name": "cpu_msvc",
+ "inherits": [
+ "default_msvc",
+ "default_cpu"
+ ],
+ "displayName": "cpu msvc configuration"
+ },
+ {
+ "name": "gpu_make",
+ "inherits": [
+ "default_make",
+ "default_gpu"
+ ],
+ "displayName": "gpu make configuration"
+ },
+ {
+ "name": "gpu_make_ccache",
+ "inherits": [
+ "default_ccache_make",
+ "default_gpu"
+ ],
+ "displayName": "gpu ccache make configuration"
+ },
+ {
+ "name": "gpu_msvc",
+ "inherits": [
+ "default_msvc",
+ "default_gpu"
+ ],
+ "displayName": "gpu msvc configuration"
+ },
+ {
+ "name": "all_make",
+ "inherits": [
+ "default_make",
+ "default_all"
+ ],
+ "displayName": "all make configuration"
+ },
+ {
+ "name": "all_make_ccache",
+ "inherits": [
+ "default_ccache_make",
+ "default_all"
+ ],
+ "displayName": "all ccache make configuration"
+ },
+ {
+ "name": "all_msvc",
+ "inherits": [
+ "default_msvc",
+ "default_all"
+ ],
+ "displayName": "all msvc configuration"
+ },
+ {
+ "name": "gpu_numerical_tests_make",
+ "inherits": [
+ "default_make",
+ "default_gpu_numerical_tests"
+ ],
+ "displayName": "gpu numerical tests make configuration"
+ },
+ {
+ "name": "gpu_numerical_tests_ccache_make",
+ "inherits": [
+ "default_ccache_make",
+ "default_gpu_numerical_tests"
+ ],
+ "displayName": "gpu numerical tests ccache make configuration"
+ },
+ {
+ "name": "gpu_numerical_tests_msvc",
+ "inherits": [
+ "default_msvc",
+ "default_gpu_numerical_tests"
+ ],
+ "displayName": "gpu numerical tests msvc configuration"
+ }
+ ]
}
diff --git a/apps/cpu/sphere/CMakeLists.txt b/apps/cpu/sphere/CMakeLists.txt
index d80737cdd94aa0b912a62acd69dcd30372f6fd82..8346e80d26800582c37090b208e846737e087d5d 100644
--- a/apps/cpu/sphere/CMakeLists.txt
+++ b/apps/cpu/sphere/CMakeLists.txt
@@ -1,6 +1,6 @@
########################################################
## C++ PROJECT ###
########################################################
-PROJECT(sphere)
+PROJECT(sphere LANGUAGES CXX)
vf_add_library(BUILDTYPE binary PRIVATE_LINK VirtualFluidsCore basics ${MPI_CXX_LIBRARIES} FILES sphere.cpp )
\ No newline at end of file
diff --git a/apps/gpu/LBM/DrivenCavity/CMakeLists.txt b/apps/gpu/LBM/DrivenCavity/CMakeLists.txt
index e4f62c0150c29f147dee0b99480d1fe28161511a..8384e1bc6fcfa3fd2514434b620b266e96b3626a 100644
--- a/apps/gpu/LBM/DrivenCavity/CMakeLists.txt
+++ b/apps/gpu/LBM/DrivenCavity/CMakeLists.txt
@@ -5,3 +5,5 @@ PROJECT(DrivenCavity LANGUAGES CUDA CXX)
vf_add_library(BUILDTYPE binary PRIVATE_LINK basics VirtualFluids_GPU GridGenerator MPI::MPI_CXX FILES DrivenCavity.cpp)
set_source_files_properties(DrivenCavity.cpp PROPERTIES LANGUAGE CUDA)
+
+set_target_properties(DrivenCavity PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/apps/gpu/LBM/DrivenCavity/DrivenCavity.cpp b/apps/gpu/LBM/DrivenCavity/DrivenCavity.cpp
index 070d94f6a6921ce395ebc32bb5fc9ef0d17a7ab3..fc12e73a18c3e63b93724fc10bb0828391a1a096 100644
--- a/apps/gpu/LBM/DrivenCavity/DrivenCavity.cpp
+++ b/apps/gpu/LBM/DrivenCavity/DrivenCavity.cpp
@@ -97,7 +97,8 @@ const real dt = (real)1.0e-3; //0.5e-3;
const uint nx = 64;
//std::string path("F:/Work/Computations/out/DrivenCavity/"); //LEGOLAS
-std::string path("D:/out/DrivenCavity"); //Mollok
+//std::string path("D:/out/DrivenCavity"); //Mollok
+std::string path("/home/sopeters/Computations/out/DrivenCavity64_unified"); // phoenix
std::string simulationName("DrivenCavityChim");
@@ -186,7 +187,7 @@ void multipleLevel(const std::string& configPath)
para->setVelocityRatio(velocity/ velocityLB);
- para->setMainKernel("CumulantK17CompChim");
+ //para->setMainKernel("CumulantK17CompChim");
para->setInitialCondition([&](real coordX, real coordY, real coordZ, real &rho, real &vx, real &vy, real &vz) {
rho = (real)0.0;
diff --git a/setup.py b/setup.py
index c5de9128136df9c769f0450f01e64234784040f0..ffe6663be9561a209945b91bb396254b703ae892 100644
--- a/setup.py
+++ b/setup.py
@@ -10,6 +10,10 @@ from distutils.version import LooseVersion
vf_cmake_args = [
"-DBUILD_VF_PYTHON_BINDINGS=ON",
+ "-DBUILD_VF_DOUBLE_ACCURACY=ON",
+ "-DCMAKE_CXX_COMPILER_LAUNCHER=ccache",
+ "-DCMAKE_CUDA_COMPILER_LAUNCHER=ccache",
+ "-DCMAKE_C_COMPILER_LAUNCHER=ccache",
"-DBUILD_VF_CPU:BOOL=ON",
"-DBUILD_VF_GPU:BOOL=OFF",
"-DUSE_METIS=ON",
diff --git a/src/cpu/VirtualFluidsCore/CMakeLists.txt b/src/cpu/VirtualFluidsCore/CMakeLists.txt
index 09766e266935ed1c7d89223c0713363f4df5edcf..36ac278fb8aee484d38a09a3fd4499965875f712 100644
--- a/src/cpu/VirtualFluidsCore/CMakeLists.txt
+++ b/src/cpu/VirtualFluidsCore/CMakeLists.txt
@@ -25,7 +25,7 @@ if(BUILD_USE_OPENMP)
list(APPEND VF_LIBRARIES OpenMP::OpenMP_CXX)
endif()
-vf_add_library(BUILDTYPE static PUBLIC_LINK basics muparser MPI::MPI_CXX ${VF_LIBRARIES})
+vf_add_library(BUILDTYPE static PUBLIC_LINK basics muparser MPI::MPI_CXX ${VF_LIBRARIES} PRIVATE_LINK lbm)
vf_get_library_name(library_name)
diff --git a/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationBECoProcessor.cpp b/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationBECoProcessor.cpp
index d82c594e6b127f2ade7979f8945b057e7ef6db6c..f51655dee0ff3268e316ea1b2386097568d1f42e 100644
--- a/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationBECoProcessor.cpp
+++ b/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationBECoProcessor.cpp
@@ -1325,7 +1325,7 @@ void MPIIOMigrationBECoProcessor::readArray(int step, Arrays arrType, std::strin
//----------------------------- restore data ---------------------------------
int blockID;
- std::vector<double> vectorsOfValues;
+ std::vector<LBMReal> vectorsOfValues;
size_t index;
size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
diff --git a/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationCoProcessor.cpp b/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationCoProcessor.cpp
index 2c5a547c4cca531fe50e7255b0aba6a6a4b5c6e9..153752ecb3f4e8ee19937d515a1dd0568198edd3 100644
--- a/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationCoProcessor.cpp
+++ b/src/cpu/VirtualFluidsCore/CoProcessors/MPIIOMigrationCoProcessor.cpp
@@ -1973,10 +1973,10 @@ void MPIIOMigrationCoProcessor::readArray(int step, Arrays arrType, std::string
//----------------------------- restore data ---------------------------------
size_t index = 0;
- size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
- std::vector<double> vectorsOfValues;
- for (std::size_t n = 0; n < blocksCount; n++)
- {
+ size_t nextVectorSize =
+ dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
+ std::vector<LBMReal> vectorsOfValues;
+ for (std::size_t n = 0; n < blocksCount; n++) {
SPtr<Block3D> block = grid->getBlock(dataSetSmallArray[n].globalID);
vectorsOfValues.assign(doubleValuesArray.data() + index, doubleValuesArray.data() + index + nextVectorSize);
diff --git a/src/cpu/VirtualFluidsCore/CoProcessors/MPIIORestartCoProcessor.cpp b/src/cpu/VirtualFluidsCore/CoProcessors/MPIIORestartCoProcessor.cpp
index 036fea0c780bf2a74b22789ee6e0cb605ddbd065..98a7a3bf41dc74d746fc2dbdea9749b74cf6c10d 100644
--- a/src/cpu/VirtualFluidsCore/CoProcessors/MPIIORestartCoProcessor.cpp
+++ b/src/cpu/VirtualFluidsCore/CoProcessors/MPIIORestartCoProcessor.cpp
@@ -1949,10 +1949,10 @@ void MPIIORestartCoProcessor::readAverageDensityArray(int step)
}
size_t index = 0;
- size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
- std::vector<double> vectorsOfValues;
- for (int n = 0; n < blocksCount; n++)
- {
+ size_t nextVectorSize =
+ dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
+ std::vector<LBMReal> vectorsOfValues;
+ for (int n = 0; n < blocksCount; n++) {
vectorsOfValues.assign(doubleValuesArray.data() + index, doubleValuesArray.data() + index + nextVectorSize);
index += nextVectorSize;
@@ -2046,10 +2046,10 @@ void MPIIORestartCoProcessor::readAverageVelocityArray(int step)
}
size_t index = 0;
- size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
- std::vector<double> vectorsOfValues;
- for (int n = 0; n < blocksCount; n++)
- {
+ size_t nextVectorSize =
+ dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
+ std::vector<LBMReal> vectorsOfValues;
+ for (int n = 0; n < blocksCount; n++) {
vectorsOfValues.assign(doubleValuesArray.data() + index, doubleValuesArray.data() + index + nextVectorSize);
index += nextVectorSize;
@@ -2144,10 +2144,10 @@ void MPIIORestartCoProcessor::readAverageFluktuationsArray(int step)
}
size_t index = 0;
- size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
- std::vector<double> vectorsOfValues;
- for (int n = 0; n < blocksCount; n++)
- {
+ size_t nextVectorSize =
+ dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
+ std::vector<LBMReal> vectorsOfValues;
+ for (int n = 0; n < blocksCount; n++) {
vectorsOfValues.assign(doubleValuesArray.data() + index, doubleValuesArray.data() + index + nextVectorSize);
index += nextVectorSize;
@@ -2241,10 +2241,10 @@ void MPIIORestartCoProcessor::readAverageTripleArray(int step)
}
size_t index = 0;
- size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
- std::vector<double> vectorsOfValues;
- for (int n = 0; n < blocksCount; n++)
- {
+ size_t nextVectorSize =
+ dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
+ std::vector<LBMReal> vectorsOfValues;
+ for (int n = 0; n < blocksCount; n++) {
vectorsOfValues.assign(doubleValuesArray.data() + index, doubleValuesArray.data() + index + nextVectorSize);
index += nextVectorSize;
@@ -2338,10 +2338,10 @@ void MPIIORestartCoProcessor::readShearStressValArray(int step)
}
size_t index = 0;
- size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
- std::vector<double> vectorsOfValues;
- for (int n = 0; n < blocksCount; n++)
- {
+ size_t nextVectorSize =
+ dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
+ std::vector<LBMReal> vectorsOfValues;
+ for (int n = 0; n < blocksCount; n++) {
vectorsOfValues.assign(doubleValuesArray.data() + index, doubleValuesArray.data() + index + nextVectorSize);
index += nextVectorSize;
@@ -2435,10 +2435,10 @@ void MPIIORestartCoProcessor::readRelaxationFactor(int step)
}
size_t index = 0;
- size_t nextVectorSize = dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
- std::vector<double> vectorsOfValues;
- for (int n = 0; n < blocksCount; n++)
- {
+ size_t nextVectorSize =
+ dataSetParamStr.nx[0] * dataSetParamStr.nx[1] * dataSetParamStr.nx[2] * dataSetParamStr.nx[3];
+ std::vector<LBMReal> vectorsOfValues;
+ for (int n = 0; n < blocksCount; n++) {
vectorsOfValues.assign(doubleValuesArray.data() + index, doubleValuesArray.data() + index + nextVectorSize);
index += nextVectorSize;
diff --git a/src/cpu/VirtualFluidsCore/CoProcessors/PressureCoefficientCoProcessor.cpp b/src/cpu/VirtualFluidsCore/CoProcessors/PressureCoefficientCoProcessor.cpp
index b350f441b3b237032ca24cd4a3743c3cf629a89e..1c7e47f52e721069b20a6b3c27d1e71857ef74ab 100644
--- a/src/cpu/VirtualFluidsCore/CoProcessors/PressureCoefficientCoProcessor.cpp
+++ b/src/cpu/VirtualFluidsCore/CoProcessors/PressureCoefficientCoProcessor.cpp
@@ -42,8 +42,8 @@ void PressureCoefficientCoProcessor::collectData(double step)
//////////////////////////////////////////////////////////////////////////
void PressureCoefficientCoProcessor::calculateRho()
{
- double f[D3Q27System::ENDF + 1];
- double vx1, vx2, vx3, rho;
+ LBMReal f[D3Q27System::ENDF + 1];
+ LBMReal vx1, vx2, vx3, rho;
std::vector<double> values;
std::vector<double> rvalues;
diff --git a/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.cpp b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.cpp
index daed493b9cc1afddbd92acabcd551da0f463ea26..9c52f5e0469ce5b6c6e08136f25d3c027d36bdbd 100644
--- a/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.cpp
+++ b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.cpp
@@ -39,6 +39,7 @@
#include "Block3D.h"
#include "BCArray3D.h"
+
#define PROOF_CORRECTNESS
using namespace UbMath;
diff --git a/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.h b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.h
index 10cfd49264bb829eac1fc6b9bedeee3b6eace265..3052f50e3e48925ed21a3c3af68cc2d247c88a02 100644
--- a/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.h
+++ b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernel.h
@@ -144,4 +144,4 @@ inline void CumulantK17LBMKernel::backwardChimera(LBMReal& mfa, LBMReal& mfb, LB
mfa = ma;
}
-#endif // CumulantK17LBMKernel_h__
\ No newline at end of file
+#endif // CumulantK17LBMKernel_h__
diff --git a/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernelUnified.cpp b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernelUnified.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9b4c17f9fd6fe9f11abc652c65c09df246c98327
--- /dev/null
+++ b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernelUnified.cpp
@@ -0,0 +1,336 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file CumulantK17LBMKernel.cpp
+//! \ingroup LBM
+//! \author Konstantin Kutscher, Martin Geier
+//=======================================================================================
+#include "CumulantK17LBMKernelUnified.h"
+#include "D3Q27System.h"
+#include "D3Q27EsoTwist3DSplittedVector.h"
+#include <cmath>
+#include "DataSet3D.h"
+#include "LBMKernel.h"
+#include "Block3D.h"
+#include "BCArray3D.h"
+
+#include <lbm/KernelParameter.h>
+#include <lbm/CumulantChimera.h>
+#include <lbm/constants/D3Q27.h>
+
+//#define PROOF_CORRECTNESS
+
+using namespace UbMath;
+
+//////////////////////////////////////////////////////////////////////////
+CumulantK17LBMKernelUnified::CumulantK17LBMKernelUnified()
+{
+ this->compressible = true;
+}
+//////////////////////////////////////////////////////////////////////////
+void CumulantK17LBMKernelUnified::initDataSet()
+{
+ SPtr<DistributionArray3D> d(new D3Q27EsoTwist3DSplittedVector(nx[0] + 2, nx[1] + 2, nx[2] + 2, -999.9));
+ dataSet->setFdistributions(d);
+}
+//////////////////////////////////////////////////////////////////////////
+SPtr<LBMKernel> CumulantK17LBMKernelUnified::clone()
+{
+ SPtr<LBMKernel> kernel(new CumulantK17LBMKernelUnified());
+ kernel->setNX(nx);
+ std::dynamic_pointer_cast<CumulantK17LBMKernelUnified>(kernel)->initDataSet();
+ kernel->setCollisionFactor(this->collFactor);
+ kernel->setBCProcessor(bcProcessor->clone(kernel));
+ kernel->setWithForcing(withForcing);
+ kernel->setForcingX1(muForcingX1);
+ kernel->setForcingX2(muForcingX2);
+ kernel->setForcingX3(muForcingX3);
+ kernel->setIndex(ix1, ix2, ix3);
+ kernel->setDeltaT(deltaT);
+ kernel->setBlock(block.lock());
+
+ return kernel;
+}
+//////////////////////////////////////////////////////////////////////////
+void CumulantK17LBMKernelUnified::calculate(int step)
+{
+ //////////////////////////////////////////////////////////////////////////
+ //! Cumulant K17 Kernel is based on
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05.040 ]</b></a>
+ //! and
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.07.004"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.07.004 ]</b></a>
+ //!
+ //! The cumulant kernel is executed in the following steps
+ //!
+ ////////////////////////////////////////////////////////////////////////////////
+ //! - Get node index coordinates from thredIdx, blockIdx, blockDim and gridDim.
+ //!
+
+ using namespace std;
+
+ //initializing of forcing stuff
+ if (withForcing)
+ {
+ muForcingX1.DefineVar("x1", &muX1); muForcingX1.DefineVar("x2", &muX2); muForcingX1.DefineVar("x3", &muX3);
+ muForcingX2.DefineVar("x1", &muX1); muForcingX2.DefineVar("x2", &muX2); muForcingX2.DefineVar("x3", &muX3);
+ muForcingX3.DefineVar("x1", &muX1); muForcingX3.DefineVar("x2", &muX2); muForcingX3.DefineVar("x3", &muX3);
+
+ muDeltaT = deltaT;
+
+ muForcingX1.DefineVar("dt", &muDeltaT);
+ muForcingX2.DefineVar("dt", &muDeltaT);
+ muForcingX3.DefineVar("dt", &muDeltaT);
+
+ muNu = (1.0 / 3.0) * (1.0 / collFactor - 1.0 / 2.0);
+
+ muForcingX1.DefineVar("nu", &muNu);
+ muForcingX2.DefineVar("nu", &muNu);
+ muForcingX3.DefineVar("nu", &muNu);
+ }
+ /////////////////////////////////////
+
+ localDistributions = dynamic_pointer_cast<D3Q27EsoTwist3DSplittedVector>(dataSet->getFdistributions())->getLocalDistributions();
+ nonLocalDistributions = dynamic_pointer_cast<D3Q27EsoTwist3DSplittedVector>(dataSet->getFdistributions())->getNonLocalDistributions();
+ restDistributions = dynamic_pointer_cast<D3Q27EsoTwist3DSplittedVector>(dataSet->getFdistributions())->getZeroDistributions();
+
+ SPtr<BCArray3D> bcArray = this->getBCProcessor()->getBCArray();
+
+ const int bcArrayMaxX1 = (int)bcArray->getNX1();
+ const int bcArrayMaxX2 = (int)bcArray->getNX2();
+ const int bcArrayMaxX3 = (int)bcArray->getNX3();
+
+ int minX1 = ghostLayerWidth;
+ int minX2 = ghostLayerWidth;
+ int minX3 = ghostLayerWidth;
+ int maxX1 = bcArrayMaxX1 - ghostLayerWidth;
+ int maxX2 = bcArrayMaxX2 - ghostLayerWidth;
+ int maxX3 = bcArrayMaxX3 - ghostLayerWidth;
+
+ LBMReal omega = collFactor;
+
+ for (int x3 = minX3; x3 < maxX3; x3++)
+ {
+ for (int x2 = minX2; x2 < maxX2; x2++)
+ {
+ for (int x1 = minX1; x1 < maxX1; x1++)
+ {
+ if (!bcArray->isSolid(x1, x2, x3) && !bcArray->isUndefined(x1, x2, x3))
+ {
+ int x1p = x1 + 1;
+ int x2p = x2 + 1;
+ int x3p = x3 + 1;
+ //////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////
+ //! - Read distributions: style of reading and writing the distributions from/to stored arrays dependent on timestep is based on the esoteric twist algorithm
+ //! <a href="https://doi.org/10.3390/computation5020019"><b>[ M. Geier et al. (2017), DOI:10.3390/computation5020019 ]</b></a>
+ //!
+ ////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////
+
+ //E N T
+ //c c c
+ //////////
+ //W S B
+ //a a a
+
+ //Rest is b
+
+ //mfxyz
+ //a - negative
+ //b - null
+ //c - positive
+
+ // a b c
+ //-1 0 1
+
+ LBMReal mfcbb = (*this->localDistributions)(D3Q27System::ET_E, x1, x2, x3);
+ LBMReal mfbcb = (*this->localDistributions)(D3Q27System::ET_N, x1, x2, x3);
+ LBMReal mfbbc = (*this->localDistributions)(D3Q27System::ET_T, x1, x2, x3);
+ LBMReal mfccb = (*this->localDistributions)(D3Q27System::ET_NE, x1, x2, x3);
+ LBMReal mfacb = (*this->localDistributions)(D3Q27System::ET_NW, x1p, x2, x3);
+ LBMReal mfcbc = (*this->localDistributions)(D3Q27System::ET_TE, x1, x2, x3);
+ LBMReal mfabc = (*this->localDistributions)(D3Q27System::ET_TW, x1p, x2, x3);
+ LBMReal mfbcc = (*this->localDistributions)(D3Q27System::ET_TN, x1, x2, x3);
+ LBMReal mfbac = (*this->localDistributions)(D3Q27System::ET_TS, x1, x2p, x3);
+ LBMReal mfccc = (*this->localDistributions)(D3Q27System::ET_TNE, x1, x2, x3);
+ LBMReal mfacc = (*this->localDistributions)(D3Q27System::ET_TNW, x1p, x2, x3);
+ LBMReal mfcac = (*this->localDistributions)(D3Q27System::ET_TSE, x1, x2p, x3);
+ LBMReal mfaac = (*this->localDistributions)(D3Q27System::ET_TSW, x1p, x2p, x3);
+
+ LBMReal mfabb = (*this->nonLocalDistributions)(D3Q27System::ET_W, x1p, x2, x3);
+ LBMReal mfbab = (*this->nonLocalDistributions)(D3Q27System::ET_S, x1, x2p, x3);
+ LBMReal mfbba = (*this->nonLocalDistributions)(D3Q27System::ET_B, x1, x2, x3p);
+ LBMReal mfaab = (*this->nonLocalDistributions)(D3Q27System::ET_SW, x1p, x2p, x3);
+ LBMReal mfcab = (*this->nonLocalDistributions)(D3Q27System::ET_SE, x1, x2p, x3);
+ LBMReal mfaba = (*this->nonLocalDistributions)(D3Q27System::ET_BW, x1p, x2, x3p);
+ LBMReal mfcba = (*this->nonLocalDistributions)(D3Q27System::ET_BE, x1, x2, x3p);
+ LBMReal mfbaa = (*this->nonLocalDistributions)(D3Q27System::ET_BS, x1, x2p, x3p);
+ LBMReal mfbca = (*this->nonLocalDistributions)(D3Q27System::ET_BN, x1, x2, x3p);
+ LBMReal mfaaa = (*this->nonLocalDistributions)(D3Q27System::ET_BSW, x1p, x2p, x3p);
+ LBMReal mfcaa = (*this->nonLocalDistributions)(D3Q27System::ET_BSE, x1, x2p, x3p);
+ LBMReal mfaca = (*this->nonLocalDistributions)(D3Q27System::ET_BNW, x1p, x2, x3p);
+ LBMReal mfcca = (*this->nonLocalDistributions)(D3Q27System::ET_BNE, x1, x2, x3p);
+
+ LBMReal mfbbb = (*this->restDistributions)(x1, x2, x3);
+
+
+ LBMReal forces[3] = {0., 0., 0.};
+ if (withForcing)
+ {
+ muX1 = static_cast<double>(x1 - 1 + ix1 * maxX1);
+ muX2 = static_cast<double>(x2 - 1 + ix2 * maxX2);
+ muX3 = static_cast<double>(x3 - 1 + ix3 * maxX3);
+
+ forcingX1 = muForcingX1.Eval();
+ forcingX2 = muForcingX2.Eval();
+ forcingX3 = muForcingX3.Eval();
+
+ forces[0] = forcingX1 * deltaT;
+ forces[1] = forcingX2 * deltaT;
+ forces[2] = forcingX3 * deltaT;
+ }
+
+ vf::lbm::Distribution27 distribution;
+
+ distribution.f[vf::lbm::dir::PZZ] = mfcbb;
+ distribution.f[vf::lbm::dir::MZZ] = mfabb;
+ distribution.f[vf::lbm::dir::ZPZ] = mfbcb;
+ distribution.f[vf::lbm::dir::ZMZ] = mfbab;
+ distribution.f[vf::lbm::dir::ZZP] = mfbbc;
+ distribution.f[vf::lbm::dir::ZZM] = mfbba;
+ distribution.f[vf::lbm::dir::PPZ] = mfccb;
+ distribution.f[vf::lbm::dir::MMZ] = mfaab;
+ distribution.f[vf::lbm::dir::PMZ] = mfcab;
+ distribution.f[vf::lbm::dir::MPZ] = mfacb;
+ distribution.f[vf::lbm::dir::PZP] = mfcbc;
+ distribution.f[vf::lbm::dir::MZM] = mfaba;
+ distribution.f[vf::lbm::dir::PZM] = mfcba;
+ distribution.f[vf::lbm::dir::MZP] = mfabc;
+ distribution.f[vf::lbm::dir::ZPP] = mfbcc;
+ distribution.f[vf::lbm::dir::ZMM] = mfbaa;
+ distribution.f[vf::lbm::dir::ZPM] = mfbca;
+ distribution.f[vf::lbm::dir::ZMP] = mfbac;
+ distribution.f[vf::lbm::dir::PPP] = mfccc;
+ distribution.f[vf::lbm::dir::MPP] = mfacc;
+ distribution.f[vf::lbm::dir::PMP] = mfcac;
+ distribution.f[vf::lbm::dir::MMP] = mfaac;
+ distribution.f[vf::lbm::dir::PPM] = mfcca;
+ distribution.f[vf::lbm::dir::MPM] = mfaca;
+ distribution.f[vf::lbm::dir::PMM] = mfcaa;
+ distribution.f[vf::lbm::dir::MMM] = mfaaa;
+ distribution.f[vf::lbm::dir::ZZZ] = mfbbb;
+
+ vf::lbm::KernelParameter parameter {distribution, omega, forces};
+ vf::lbm::cumulantChimera(parameter, vf::lbm::setRelaxationRatesK17);
+
+ mfcbb = distribution.f[vf::lbm::dir::PZZ];
+ mfabb = distribution.f[vf::lbm::dir::MZZ];
+ mfbcb = distribution.f[vf::lbm::dir::ZPZ];
+ mfbab = distribution.f[vf::lbm::dir::ZMZ];
+ mfbbc = distribution.f[vf::lbm::dir::ZZP];
+ mfbba = distribution.f[vf::lbm::dir::ZZM];
+ mfccb = distribution.f[vf::lbm::dir::PPZ];
+ mfaab = distribution.f[vf::lbm::dir::MMZ];
+ mfcab = distribution.f[vf::lbm::dir::PMZ];
+ mfacb = distribution.f[vf::lbm::dir::MPZ];
+ mfcbc = distribution.f[vf::lbm::dir::PZP];
+ mfaba = distribution.f[vf::lbm::dir::MZM];
+ mfcba = distribution.f[vf::lbm::dir::PZM];
+ mfabc = distribution.f[vf::lbm::dir::MZP];
+ mfbcc = distribution.f[vf::lbm::dir::ZPP];
+ mfbaa = distribution.f[vf::lbm::dir::ZMM];
+ mfbca = distribution.f[vf::lbm::dir::ZPM];
+ mfbac = distribution.f[vf::lbm::dir::ZMP];
+ mfccc = distribution.f[vf::lbm::dir::PPP];
+ mfacc = distribution.f[vf::lbm::dir::MPP];
+ mfcac = distribution.f[vf::lbm::dir::PMP];
+ mfaac = distribution.f[vf::lbm::dir::MMP];
+ mfcca = distribution.f[vf::lbm::dir::PPM];
+ mfaca = distribution.f[vf::lbm::dir::MPM];
+ mfcaa = distribution.f[vf::lbm::dir::PMM];
+ mfaaa = distribution.f[vf::lbm::dir::MMM];
+ mfbbb = distribution.f[vf::lbm::dir::ZZZ];
+
+ //////////////////////////////////////////////////////////////////////////
+ //proof correctness
+ //////////////////////////////////////////////////////////////////////////
+#ifdef PROOF_CORRECTNESS
+ LBMReal drho_post = (mfaaa + mfaac + mfaca + mfcaa + mfacc + mfcac + mfccc + mfcca)
+ + (mfaab + mfacb + mfcab + mfccb) + (mfaba + mfabc + mfcba + mfcbc) + (mfbaa + mfbac + mfbca + mfbcc)
+ + (mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc) + mfbbb;
+ LBMReal dif = distribution.getDensity_() - drho_post;
+#ifdef SINGLEPRECISION
+ if (dif > 10.0E-7 || dif < -10.0E-7)
+#else
+ if (dif > 10.0E-15 || dif < -10.0E-15)
+#endif
+ {
+ UB_THROW(UbException(UB_EXARGS, "rho=" + UbSystem::toString(distribution.getDensity_()) + ", rho_post=" + UbSystem::toString(drho_post)
+ + " dif=" + UbSystem::toString(dif)
+ + " rho is not correct for node " + UbSystem::toString(x1) + "," + UbSystem::toString(x2) + "," + UbSystem::toString(x3)
+ + " in " + block.lock()->toString() + " step = " + UbSystem::toString(step)));
+ }
+#endif
+
+ (*this->localDistributions)(D3Q27System::ET_E, x1, x2, x3) = mfcbb;
+ (*this->localDistributions)(D3Q27System::ET_N, x1, x2, x3) = mfbcb;
+ (*this->localDistributions)(D3Q27System::ET_T, x1, x2, x3) = mfbbc;
+ (*this->localDistributions)(D3Q27System::ET_NE, x1, x2, x3) = mfccb;
+ (*this->localDistributions)(D3Q27System::ET_NW, x1p, x2, x3) = mfacb;
+ (*this->localDistributions)(D3Q27System::ET_TE, x1, x2, x3) = mfcbc;
+ (*this->localDistributions)(D3Q27System::ET_TW, x1p, x2, x3) = mfabc;
+ (*this->localDistributions)(D3Q27System::ET_TN, x1, x2, x3) = mfbcc;
+ (*this->localDistributions)(D3Q27System::ET_TS, x1, x2p, x3) = mfbac;
+ (*this->localDistributions)(D3Q27System::ET_TNE, x1, x2, x3) = mfccc;
+ (*this->localDistributions)(D3Q27System::ET_TNW, x1p, x2, x3) = mfacc;
+ (*this->localDistributions)(D3Q27System::ET_TSE, x1, x2p, x3) = mfcac;
+ (*this->localDistributions)(D3Q27System::ET_TSW, x1p, x2p, x3) = mfaac;
+
+ (*this->nonLocalDistributions)(D3Q27System::ET_W, x1p, x2, x3) = mfabb;
+ (*this->nonLocalDistributions)(D3Q27System::ET_S, x1, x2p, x3) = mfbab;
+ (*this->nonLocalDistributions)(D3Q27System::ET_B, x1, x2, x3p) = mfbba;
+ (*this->nonLocalDistributions)(D3Q27System::ET_SW, x1p, x2p, x3) = mfaab;
+ (*this->nonLocalDistributions)(D3Q27System::ET_SE, x1, x2p, x3) = mfcab;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BW, x1p, x2, x3p) = mfaba;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BE, x1, x2, x3p) = mfcba;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BS, x1, x2p, x3p) = mfbaa;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BN, x1, x2, x3p) = mfbca;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BSW, x1p, x2p, x3p) = mfaaa;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BSE, x1, x2p, x3p) = mfcaa;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BNW, x1p, x2, x3p) = mfaca;
+ (*this->nonLocalDistributions)(D3Q27System::ET_BNE, x1, x2, x3p) = mfcca;
+ (*this->restDistributions)(x1, x2, x3) = mfbbb;
+ //////////////////////////////////////////////////////////////////////////
+
+ }
+ }
+ }
+ }
+}
+//////////////////////////////////////////////////////////////////////////
+
diff --git a/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernelUnified.h b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernelUnified.h
new file mode 100644
index 0000000000000000000000000000000000000000..175fdd4cba2a0c8ce47248f5de6672f34dda0cc3
--- /dev/null
+++ b/src/cpu/VirtualFluidsCore/LBM/CumulantK17LBMKernelUnified.h
@@ -0,0 +1,77 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file CumulantK17LBMKernel.h
+//! \ingroup LBM
+//! \author Konstantin Kutscher, Martin Geier
+//=======================================================================================
+
+#ifndef CumulantK17LBMKernelUnified_h__
+#define CumulantK17LBMKernelUnified_h__
+
+#include "LBMKernel.h"
+#include "BCProcessor.h"
+#include "D3Q27System.h"
+#include "basics/utilities/UbTiming.h"
+#include "basics/container/CbArray4D.h"
+#include "basics/container/CbArray3D.h"
+
+//! \brief Compressible cumulant LBM kernel.
+//! \details LBM implementation that use Cascaded Cumulant Lattice Boltzmann method for D3Q27 model
+//!
+//! The model is publisched in
+//! <a href="http://dx.doi.org/10.1016/j.jcp.2017.05.040"><b>[ Geier et al., (2017), 10.1016/j.jcp.2017.05.040]</b></a>,
+//! <a href="http://dx.doi.org/10.1016/j.jcp.2017.07.004"><b>[ Geier et al., (2017), 10.1016/j.jcp.2017.07.004]</b></a>
+//!
+class CumulantK17LBMKernelUnified : public LBMKernel
+{
+public:
+ CumulantK17LBMKernelUnified();
+ ~CumulantK17LBMKernelUnified() = default;
+ void calculate(int step) override;
+ SPtr<LBMKernel> clone() override;
+ double getCalculationTime() override { return .0; }
+
+protected:
+ virtual void initDataSet();
+ LBMReal f[D3Q27System::ENDF + 1];
+
+ CbArray4D<LBMReal, IndexerX4X3X2X1>::CbArray4DPtr localDistributions;
+ CbArray4D<LBMReal, IndexerX4X3X2X1>::CbArray4DPtr nonLocalDistributions;
+ CbArray3D<LBMReal, IndexerX3X2X1>::CbArray3DPtr restDistributions;
+
+ mu::value_type muX1, muX2, muX3;
+ mu::value_type muDeltaT;
+ mu::value_type muNu;
+ LBMReal forcingX1;
+ LBMReal forcingX2;
+ LBMReal forcingX3;
+};
+
+
+#endif // CumulantK17LBMKernel_h__
\ No newline at end of file
diff --git a/src/cpu/VirtualFluidsCore/LBM/D3Q27System.cpp b/src/cpu/VirtualFluidsCore/LBM/D3Q27System.cpp
index 5e88242fa23bdf37386f4f4d293ed7c2c33750ee..105603b35d043799672a58fda83ba503af70b703 100644
--- a/src/cpu/VirtualFluidsCore/LBM/D3Q27System.cpp
+++ b/src/cpu/VirtualFluidsCore/LBM/D3Q27System.cpp
@@ -1,5 +1,7 @@
#include "D3Q27System.h"
+#include "lbm/MacroscopicQuantities.h"
+
namespace D3Q27System
{
using namespace UbMath;
@@ -18,4 +20,31 @@ const int INVDIR[] = { INV_E, INV_W, INV_N, INV_S, INV_T, INV_B, INV
INV_NW, INV_TE, INV_BW, INV_BE, INV_TW, INV_TN, INV_BS, INV_BN, INV_TS,
INV_TNE, INV_TNW, INV_TSE, INV_TSW, INV_BNE, INV_BNW, INV_BSE, INV_BSW };
+
+
+
+LBMReal getDensity(const LBMReal *const &f /*[27]*/)
+{
+ return vf::lbm::getDensity(f);
+}
+
+LBMReal getIncompVelocityX1(const LBMReal *const &f /*[27]*/)
+{
+ return vf::lbm::getIncompressibleVelocityX1(f);
+}
+
+LBMReal getIncompVelocityX2(const LBMReal *const &f /*[27]*/)
+{
+ return vf::lbm::getIncompressibleVelocityX2(f);
+}
+
+LBMReal getIncompVelocityX3(const LBMReal *const &f /*[27]*/)
+{
+ return vf::lbm::getIncompressibleVelocityX3(f);
+}
+
+
+
+
+
} // namespace D3Q27System
\ No newline at end of file
diff --git a/src/cpu/VirtualFluidsCore/LBM/D3Q27System.h b/src/cpu/VirtualFluidsCore/LBM/D3Q27System.h
index 8f8c376459ce0b9bd4d0b7691655c173a6d4e149..04fe8a819b143db8cc935fc893faa514805060a6 100644
--- a/src/cpu/VirtualFluidsCore/LBM/D3Q27System.h
+++ b/src/cpu/VirtualFluidsCore/LBM/D3Q27System.h
@@ -42,6 +42,7 @@
#include "UbException.h"
#include "UbMath.h"
+
//! \brief namespace for global system-functions
namespace D3Q27System
{
@@ -147,36 +148,21 @@ static const int ET_BNW = 11;
static const int ET_TSW = 12;
static const int ET_BNE = 12;
+
//////////////////////////////////////////////////////////////////////////
// MACROSCOPIC VALUES
/*=====================================================================*/
-static LBMReal getDensity(const LBMReal *const &f /*[27]*/)
-{
- return ((f[TNE] + f[BSW]) + (f[TSE] + f[BNW])) + ((f[BSE] + f[TNW]) + (f[TSW] + f[BNE])) +
- (((f[NE] + f[SW]) + (f[SE] + f[NW])) + ((f[TE] + f[BW]) + (f[BE] + f[TW])) +
- ((f[BN] + f[TS]) + (f[TN] + f[BS]))) +
- ((f[E] + f[W]) + (f[N] + f[S]) + (f[T] + f[B])) + f[REST];
-}
+LBMReal getDensity(const LBMReal *const &f /*[27]*/);
/*=====================================================================*/
static LBMReal getPressure(const LBMReal *const &f /*[27]*/) { return REAL_CAST(UbMath::c1o3) * getDensity(f); }
/*=====================================================================*/
-static LBMReal getIncompVelocityX1(const LBMReal *const &f /*[27]*/)
-{
- return ((((f[TNE] - f[BSW]) + (f[TSE] - f[BNW])) + ((f[BSE] - f[TNW]) + (f[BNE] - f[TSW]))) +
- (((f[BE] - f[TW]) + (f[TE] - f[BW])) + ((f[SE] - f[NW]) + (f[NE] - f[SW]))) + (f[E] - f[W]));
-}
+LBMReal getIncompVelocityX1(const LBMReal *const &f /*[27]*/);
/*=====================================================================*/
-static LBMReal getIncompVelocityX2(const LBMReal *const &f /*[27]*/)
-{
- return ((((f[TNE] - f[BSW]) + (f[BNW] - f[TSE])) + ((f[TNW] - f[BSE]) + (f[BNE] - f[TSW]))) +
- (((f[BN] - f[TS]) + (f[TN] - f[BS])) + ((f[NW] - f[SE]) + (f[NE] - f[SW]))) + (f[N] - f[S]));
-}
+LBMReal getIncompVelocityX2(const LBMReal *const &f /*[27]*/);
/*=====================================================================*/
-static LBMReal getIncompVelocityX3(const LBMReal *const &f /*[27]*/)
-{
- return ((((f[TNE] - f[BSW]) + (f[TSE] - f[BNW])) + ((f[TNW] - f[BSE]) + (f[TSW] - f[BNE]))) +
- (((f[TS] - f[BN]) + (f[TN] - f[BS])) + ((f[TW] - f[BE]) + (f[TE] - f[BW]))) + (f[T] - f[B]));
-}
+LBMReal getIncompVelocityX3(const LBMReal *const &f /*[27]*/);
+
+
/*=====================================================================*/
static void calcDensity(const LBMReal *const &f /*[27]*/, LBMReal &rho)
{
diff --git a/src/cpu/VirtualFluidsCore/LBM/ILBMKernel.h b/src/cpu/VirtualFluidsCore/LBM/ILBMKernel.h
index 4dbe8eee09a37c0c220f47619b72bade2e6ec527..bde61d9d314b61327ff8f8a2a71d2864d50cc7f5 100644
--- a/src/cpu/VirtualFluidsCore/LBM/ILBMKernel.h
+++ b/src/cpu/VirtualFluidsCore/LBM/ILBMKernel.h
@@ -36,6 +36,8 @@
#include <PointerDefinitions.h>
+#include "LBMSystem.h"
+
class BCProcessor;
class DataSet3D;
@@ -57,7 +59,7 @@ public:
virtual void setCollisionFactor(double collFactor) = 0;
virtual bool isInsideOfDomain(const int &x1, const int &x2, const int &x3) const = 0;
virtual int getGhostLayerWidth() const = 0;
- virtual double getDeltaT() const = 0;
+ virtual LBMReal getDeltaT() const = 0;
virtual bool getWithForcing() const = 0;
};
diff --git a/src/cpu/VirtualFluidsCore/LBM/LBMKernel.h b/src/cpu/VirtualFluidsCore/LBM/LBMKernel.h
index 5c3e067656e2fc5cb06046e28c0442b15c180050..f4d96d946a9f3bab367e7bc935b54352e09063a6 100644
--- a/src/cpu/VirtualFluidsCore/LBM/LBMKernel.h
+++ b/src/cpu/VirtualFluidsCore/LBM/LBMKernel.h
@@ -53,6 +53,7 @@ public:
public:
LBMKernel();
+ virtual ~LBMKernel() = default;
virtual SPtr<LBMKernel> clone() = 0;
diff --git a/src/cpu/VirtualFluidsCore/LBM/LBMSystem.h b/src/cpu/VirtualFluidsCore/LBM/LBMSystem.h
index d24775aef0fbe6822fbdc03d42e2acfeb3021430..14b4d223b2e07e3dbca9947cefd89de045bfb3cf 100644
--- a/src/cpu/VirtualFluidsCore/LBM/LBMSystem.h
+++ b/src/cpu/VirtualFluidsCore/LBM/LBMSystem.h
@@ -37,6 +37,8 @@
#include <iostream>
#include <string>
+#include "basics/Core/DataTypes.h"
+
//! \brief namespace for global system-functions
namespace LBMSystem
@@ -45,10 +47,10 @@ namespace LBMSystem
//#define SINGLEPRECISION
#ifdef SINGLEPRECISION
-typedef float real;
+//using real = float;
#define REAL_CAST(x) ((LBMSystem::real)(x))
#else
-using real = double;
+//using real = double;
#define REAL_CAST(x) (x)
#endif
@@ -82,6 +84,7 @@ static real calcOmega2(real viscosity, real deltaT) { return REAL_CAST(1.0 / (4.
} // namespace LBMSystem
// some typedefs for global namespace
-using LBMReal = LBMSystem::real;
+//using LBMReal = LBMSystem::real;
+using LBMReal = real;
#endif
diff --git a/src/cpu/pythonbindings/CMakeLists.txt b/src/cpu/pythonbindings/CMakeLists.txt
index 4c728febe0e669fa308d45158c7fae4ce3762c05..3b4e7e5a1506899710dc03ea275c0d4ac1cff66d 100644
--- a/src/cpu/pythonbindings/CMakeLists.txt
+++ b/src/cpu/pythonbindings/CMakeLists.txt
@@ -12,4 +12,5 @@ target_compile_definitions(pymuparser PRIVATE VF_METIS VF_MPI)
target_link_libraries(pyfluids PRIVATE simulationconfig VirtualFluidsCore muparser basics)
target_link_libraries(pymuparser PRIVATE muparser)
-
+target_include_directories(pyfluids PRIVATE ${CMAKE_SOURCE_DIR}/src/)
+target_include_directories(pyfluids PRIVATE ${CMAKE_BINARY_DIR})
\ No newline at end of file
diff --git a/src/cpu/simulationconfig/CMakeLists.txt b/src/cpu/simulationconfig/CMakeLists.txt
index 2e5e7f2eb9cba467e1ecbe3ec9cea13b3a3f322d..95ee969a049fd65cfadc6cc95d814e788a02aa8e 100644
--- a/src/cpu/simulationconfig/CMakeLists.txt
+++ b/src/cpu/simulationconfig/CMakeLists.txt
@@ -1,20 +1,8 @@
-cmake_minimum_required(VERSION 3.1)
project(simulationconfig)
-set(VFBUILDER_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
-file(GLOB HEADERS
- ${VFBUILDER_INCLUDE_DIR}/simulationconfig/*.h
- ${VFBUILDER_INCLUDE_DIR}/simulationconfig/boundaryconditions/*.h)
+vf_add_library(NAME simulationconfig PUBLIC_LINK VirtualFluidsCore basics muparser)
-file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-
-add_library(simulationconfig STATIC ${SRC} ${HEADERS})
-
-set_target_properties(simulationconfig PROPERTIES CXX_STANDARD 14 POSITION_INDEPENDENT_CODE ON)
-
-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)
-target_include_directories(simulationconfig PUBLIC ${CMAKE_BINARY_DIR})
+set_target_properties(simulationconfig PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(simulationconfig PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
diff --git a/src/cpu/simulationconfig/include/simulationconfig/AbstractLBMSystem.h b/src/cpu/simulationconfig/include/simulationconfig/AbstractLBMSystem.h
index 0c3ac72db2d3cb3488860227171f2fd27600c028..156649c6fd3c060117e8247efab2765f56f7c77b 100644
--- a/src/cpu/simulationconfig/include/simulationconfig/AbstractLBMSystem.h
+++ b/src/cpu/simulationconfig/include/simulationconfig/AbstractLBMSystem.h
@@ -7,6 +7,8 @@
class AbstractLBMSystem {
public:
+ virtual ~AbstractLBMSystem() = default;
+
virtual int getNumberOfDirections() = 0;
virtual std::shared_ptr<Interactor3D> makeInteractor() = 0;
diff --git a/src/cpu/simulationconfig/include/simulationconfig/KernelFactory.h b/src/cpu/simulationconfig/include/simulationconfig/KernelFactory.h
index 6b151d96f9c538bcfbf3aeb693afd56e36e6cf35..6f984849bea91a832d0d778107feacb3cfdbdca6 100644
--- a/src/cpu/simulationconfig/include/simulationconfig/KernelFactory.h
+++ b/src/cpu/simulationconfig/include/simulationconfig/KernelFactory.h
@@ -20,6 +20,7 @@ public:
};
KernelFactory() = default;
+ virtual ~KernelFactory() = default;
std::shared_ptr<LBMKernel> makeKernel(KernelType kernelType);
diff --git a/src/cpu/simulationconfig/src/Simulation.cpp b/src/cpu/simulationconfig/src/Simulation.cpp
index 2ac83701cbd17d0c790022552ace5c7c804a7acd..f4fbad090fc60e424e777b4f601243eef8eb151e 100644
--- a/src/cpu/simulationconfig/src/Simulation.cpp
+++ b/src/cpu/simulationconfig/src/Simulation.cpp
@@ -101,7 +101,7 @@ void Simulation::run()
grid->setPeriodicX2(gridParameters->periodicBoundaryInX2);
grid->setPeriodicX3(gridParameters->periodicBoundaryInX3);
- int &numberOfNodesInReferenceDirection = gridParameters->numberOfNodesPerDirection[gridParameters->referenceDirectionIndex];
+ //int &numberOfNodesInReferenceDirection = gridParameters->numberOfNodesPerDirection[gridParameters->referenceDirectionIndex];
std::shared_ptr<LBMUnitConverter> converter = makeLBMUnitConverter();
int &nodesInX1 = gridParameters->numberOfNodesPerDirection[0];
diff --git a/src/gpu/GridGenerator/CMakeLists.txt b/src/gpu/GridGenerator/CMakeLists.txt
index 29d77897ac4e6138057ec2b4f13f5f942bdb0e01..844e933d5c053aaeef38085c5c5a9e01721ff6aa 100644
--- a/src/gpu/GridGenerator/CMakeLists.txt
+++ b/src/gpu/GridGenerator/CMakeLists.txt
@@ -6,11 +6,5 @@ vf_add_library(PRIVATE_LINK basics OpenMP::OpenMP_CXX)
vf_get_library_name(library_name)
set_target_properties(${library_name} PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
-# according to linker error when building static libraries.
-# https://stackoverflow.com/questions/50033435/cmake-cuda-separate-compilation-static-lib-link-error-on-windows-but-not-on-ubun
-if (NOT BUILD_SHARED_LIBRARY)
- set_target_properties(${library_name} PROPERTIES CUDA_RESOLVE_DEVICE_SYMBOLS ON)
-endif()
-
# we want to suppress all cuda warnings so far for this library.
target_compile_options(${library_name} PUBLIC $<$<COMPILE_LANGUAGE:CUDA>:-Xcudafe "-w" >)
diff --git a/src/gpu/VirtualFluids_GPU/CMakeLists.txt b/src/gpu/VirtualFluids_GPU/CMakeLists.txt
index ce1bb9d921f114b3d06143901355c56ab24b77fd..5c93599449cb4e5cef1c0112670068aa4e76abb3 100644
--- a/src/gpu/VirtualFluids_GPU/CMakeLists.txt
+++ b/src/gpu/VirtualFluids_GPU/CMakeLists.txt
@@ -5,10 +5,19 @@ if(MSVC)
set(additional_libraries ws2_32 Traffic) # ws_32 throws an error on Phoenix
endif()
-vf_add_library(PRIVATE_LINK ${additional_libraries} GridGenerator basics MPI::MPI_CXX)
+vf_add_library(PUBLIC_LINK basics lbmCuda PRIVATE_LINK ${additional_libraries} GridGenerator MPI::MPI_CXX)
+
#SET(TPN_WIN32 "/EHsc")
#https://stackoverflow.com/questions/6832666/lnk2019-when-including-asio-headers-solution-generated-with-cmake
#https://stackoverflow.com/questions/27442885/syntax-error-with-stdnumeric-limitsmax
+set_target_properties(VirtualFluids_GPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+
vf_add_tests()
+
+if(BUILD_VF_UNIT_TESTS)
+ set_target_properties(VirtualFluids_GPUTests PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+ set_source_files_properties(Kernel/Utilities/DistributionHelperTests.cpp PROPERTIES LANGUAGE CUDA)
+endif()
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp
index 2b2a2e68d0980b4d3aa4b27a04bd8ce703704a05..957935756163795945e9ac1c4762e0eb825239ee 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp
@@ -118,6 +118,12 @@ void GridProvider::allocAndCopyForcing()
{
cudaMemoryManager->cudaAllocForcing();
cudaMemoryManager->cudaCopyForcingToDevice();
+
+ for (int level = para->getCoarse(); level <= para->getFine(); level++)
+ {
+ cudaMemoryManager->cudaAllocLevelForcing(level);
+ cudaMemoryManager->cudaCopyLevelForcingToDevice(level);
+ }
}
void GridProvider::allocAndCopyQuadricLimiters()
diff --git a/src/gpu/VirtualFluids_GPU/GPU/CalcMac27.cu b/src/gpu/VirtualFluids_GPU/GPU/CalcMac27.cu
index ce3082817776d5b8ed6237b027354956df3a8777..562140eb24bad470604b5782a816a4e60d5000f3 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/CalcMac27.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/CalcMac27.cu
@@ -12,6 +12,11 @@
using namespace vf::lbm::constant;
+#include "lbm/MacroscopicQuantities.h"
+
+#include "../Kernel/Utilities/DistributionHelper.cuh"
+
+
////////////////////////////////////////////////////////////////////////////////
extern "C" __global__ void LBCalcMac27( real* vxD,
real* vyD,
@@ -22,196 +27,37 @@ extern "C" __global__ void LBCalcMac27( real* vxD,
unsigned int* neighborY,
unsigned int* neighborZ,
unsigned int size_Mat,
- real* DD,
- bool evenOrOdd)
+ real* distributions,
+ bool isEvenTimestep)
{
- Distributions27 D;
- if (evenOrOdd==true)
- {
- D.f[dirE ] = &DD[dirE *size_Mat];
- D.f[dirW ] = &DD[dirW *size_Mat];
- D.f[dirN ] = &DD[dirN *size_Mat];
- D.f[dirS ] = &DD[dirS *size_Mat];
- D.f[dirT ] = &DD[dirT *size_Mat];
- D.f[dirB ] = &DD[dirB *size_Mat];
- D.f[dirNE ] = &DD[dirNE *size_Mat];
- D.f[dirSW ] = &DD[dirSW *size_Mat];
- D.f[dirSE ] = &DD[dirSE *size_Mat];
- D.f[dirNW ] = &DD[dirNW *size_Mat];
- D.f[dirTE ] = &DD[dirTE *size_Mat];
- D.f[dirBW ] = &DD[dirBW *size_Mat];
- D.f[dirBE ] = &DD[dirBE *size_Mat];
- D.f[dirTW ] = &DD[dirTW *size_Mat];
- D.f[dirTN ] = &DD[dirTN *size_Mat];
- D.f[dirBS ] = &DD[dirBS *size_Mat];
- D.f[dirBN ] = &DD[dirBN *size_Mat];
- D.f[dirTS ] = &DD[dirTS *size_Mat];
- D.f[dirZERO] = &DD[dirZERO*size_Mat];
- D.f[dirTNE ] = &DD[dirTNE *size_Mat];
- D.f[dirTSW ] = &DD[dirTSW *size_Mat];
- D.f[dirTSE ] = &DD[dirTSE *size_Mat];
- D.f[dirTNW ] = &DD[dirTNW *size_Mat];
- D.f[dirBNE ] = &DD[dirBNE *size_Mat];
- D.f[dirBSW ] = &DD[dirBSW *size_Mat];
- D.f[dirBSE ] = &DD[dirBSE *size_Mat];
- D.f[dirBNW ] = &DD[dirBNW *size_Mat];
- }
- else
- {
- D.f[dirW ] = &DD[dirE *size_Mat];
- D.f[dirE ] = &DD[dirW *size_Mat];
- D.f[dirS ] = &DD[dirN *size_Mat];
- D.f[dirN ] = &DD[dirS *size_Mat];
- D.f[dirB ] = &DD[dirT *size_Mat];
- D.f[dirT ] = &DD[dirB *size_Mat];
- D.f[dirSW ] = &DD[dirNE *size_Mat];
- D.f[dirNE ] = &DD[dirSW *size_Mat];
- D.f[dirNW ] = &DD[dirSE *size_Mat];
- D.f[dirSE ] = &DD[dirNW *size_Mat];
- D.f[dirBW ] = &DD[dirTE *size_Mat];
- D.f[dirTE ] = &DD[dirBW *size_Mat];
- D.f[dirTW ] = &DD[dirBE *size_Mat];
- D.f[dirBE ] = &DD[dirTW *size_Mat];
- D.f[dirBS ] = &DD[dirTN *size_Mat];
- D.f[dirTN ] = &DD[dirBS *size_Mat];
- D.f[dirTS ] = &DD[dirBN *size_Mat];
- D.f[dirBN ] = &DD[dirTS *size_Mat];
- D.f[dirZERO] = &DD[dirZERO*size_Mat];
- D.f[dirTNE ] = &DD[dirBSW *size_Mat];
- D.f[dirTSW ] = &DD[dirBNE *size_Mat];
- D.f[dirTSE ] = &DD[dirBNW *size_Mat];
- D.f[dirTNW ] = &DD[dirBSE *size_Mat];
- D.f[dirBNE ] = &DD[dirTSW *size_Mat];
- D.f[dirBSW ] = &DD[dirTNE *size_Mat];
- D.f[dirBSE ] = &DD[dirTNW *size_Mat];
- D.f[dirBNW ] = &DD[dirTSE *size_Mat];
- }
- ////////////////////////////////////////////////////////////////////////////////
- unsigned int k; // Zugriff auf arrays im device
- //
- unsigned int tx = threadIdx.x; // Thread index = lokaler i index
- unsigned int by = blockIdx.x; // Block index x
- unsigned int bz = blockIdx.y; // Block index y
- unsigned int x = tx + STARTOFFX; // Globaler x-Index
- unsigned int y = by + STARTOFFY; // Globaler y-Index
- unsigned int z = bz + STARTOFFZ; // Globaler z-Index
-
- const unsigned sizeX = blockDim.x;
- const unsigned sizeY = gridDim.x;
- const unsigned nx = sizeX + 2 * STARTOFFX;
- const unsigned ny = sizeY + 2 * STARTOFFY;
-
- k = nx*(ny*z + y) + x;
- //////////////////////////////////////////////////////////////////////////
- //index
- unsigned int kzero= k;
- unsigned int ke = k;
- unsigned int kw = neighborX[k];
- unsigned int kn = k;
- unsigned int ks = neighborY[k];
- unsigned int kt = k;
- unsigned int kb = neighborZ[k];
- unsigned int ksw = neighborY[kw];
- unsigned int kne = k;
- unsigned int kse = ks;
- unsigned int knw = kw;
- unsigned int kbw = neighborZ[kw];
- unsigned int kte = k;
- unsigned int kbe = kb;
- unsigned int ktw = kw;
- unsigned int kbs = neighborZ[ks];
- unsigned int ktn = k;
- unsigned int kbn = kb;
- unsigned int kts = ks;
- unsigned int ktse = ks;
- unsigned int kbnw = kbw;
- unsigned int ktnw = kw;
- unsigned int kbse = kbs;
- unsigned int ktsw = ksw;
- unsigned int kbne = kb;
- unsigned int ktne = k;
- unsigned int kbsw = neighborZ[ksw];
- //unsigned int nxny = nx*ny;
- //unsigned int kzero= k;
- //unsigned int ke = k;
- //unsigned int kw = k + 1;
- //unsigned int kn = k;
- //unsigned int ks = k + nx;
- //unsigned int kt = k;
- //unsigned int kb = k + nxny;
- //unsigned int ksw = k + nx + 1;
- //unsigned int kne = k;
- //unsigned int kse = k + nx;
- //unsigned int knw = k + 1;
- //unsigned int kbw = k + nxny + 1;
- //unsigned int kte = k;
- //unsigned int kbe = k + nxny;
- //unsigned int ktw = k + 1;
- //unsigned int kbs = k + nxny + nx;
- //unsigned int ktn = k;
- //unsigned int kbn = k + nxny;
- //unsigned int kts = k + nx;
- //unsigned int ktse = k + nx;
- //unsigned int kbnw = k + nxny + 1;
- //unsigned int ktnw = k + 1;
- //unsigned int kbse = k + nxny + nx;
- //unsigned int ktsw = k + nx + 1;
- //unsigned int kbne = k + nxny;
- //unsigned int ktne = k;
- //unsigned int kbsw = k + nxny + nx + 1;
- //////////////////////////////////////////////////////////////////////////
+ const unsigned int tx = threadIdx.x; // Thread index = lokaler i index
+ const unsigned int by = blockIdx.x; // Block index x
+ const unsigned int bz = blockIdx.y; // Block index y
+ const unsigned int x = tx + STARTOFFX; // Globaler x-Index
+ const unsigned int y = by + STARTOFFY; // Globaler y-Index
+ const unsigned int z = bz + STARTOFFZ; // Globaler z-Index
+
+ const unsigned nx = blockDim.x + 2 * STARTOFFX;
+ const unsigned ny = gridDim.x + 2 * STARTOFFY;
+
+ const unsigned int k = nx*(ny*z + y) + x; // Zugriff auf arrays im device
+
rhoD[k] = c0o1;
vxD[k] = c0o1;
vyD[k] = c0o1;
vzD[k] = c0o1;
- if(geoD[k] == GEO_FLUID)
- {
- rhoD[k] = (D.f[dirE ])[ke ]+ (D.f[dirW ])[kw ]+
- (D.f[dirN ])[kn ]+ (D.f[dirS ])[ks ]+
- (D.f[dirT ])[kt ]+ (D.f[dirB ])[kb ]+
- (D.f[dirNE ])[kne ]+ (D.f[dirSW ])[ksw ]+
- (D.f[dirSE ])[kse ]+ (D.f[dirNW ])[knw ]+
- (D.f[dirTE ])[kte ]+ (D.f[dirBW ])[kbw ]+
- (D.f[dirBE ])[kbe ]+ (D.f[dirTW ])[ktw ]+
- (D.f[dirTN ])[ktn ]+ (D.f[dirBS ])[kbs ]+
- (D.f[dirBN ])[kbn ]+ (D.f[dirTS ])[kts ]+
- (D.f[dirZERO])[kzero]+
- (D.f[dirTNE ])[ktne]+ (D.f[dirTSW ])[ktsw]+
- (D.f[dirTSE ])[ktse]+ (D.f[dirTNW ])[ktnw]+
- (D.f[dirBNE ])[kbne]+ (D.f[dirBSW ])[kbsw]+
- (D.f[dirBSE ])[kbse]+ (D.f[dirBNW ])[kbnw];
-
- vxD[k] = (D.f[dirE ])[ke ]- (D.f[dirW ])[kw ]+
- (D.f[dirNE ])[kne ]- (D.f[dirSW ])[ksw ]+
- (D.f[dirSE ])[kse ]- (D.f[dirNW ])[knw ]+
- (D.f[dirTE ])[kte ]- (D.f[dirBW ])[kbw ]+
- (D.f[dirBE ])[kbe ]- (D.f[dirTW ])[ktw ]+
- (D.f[dirTNE ])[ktne]- (D.f[dirTSW ])[ktsw]+
- (D.f[dirTSE ])[ktse]- (D.f[dirTNW ])[ktnw]+
- (D.f[dirBNE ])[kbne]- (D.f[dirBSW ])[kbsw]+
- (D.f[dirBSE ])[kbse]- (D.f[dirBNW ])[kbnw];
-
- vyD[k] = (D.f[dirN ])[kn ]- (D.f[dirS ])[ks ]+
- (D.f[dirNE ])[kne ]- (D.f[dirSW ])[ksw ]-
- (D.f[dirSE ])[kse ]+ (D.f[dirNW ])[knw ]+
- (D.f[dirTN ])[ktn ]- (D.f[dirBS ])[kbs ]+
- (D.f[dirBN ])[kbn ]- (D.f[dirTS ])[kts ]+
- (D.f[dirTNE ])[ktne]- (D.f[dirTSW ])[ktsw]-
- (D.f[dirTSE ])[ktse]+ (D.f[dirTNW ])[ktnw]+
- (D.f[dirBNE ])[kbne]- (D.f[dirBSW ])[kbsw]-
- (D.f[dirBSE ])[kbse]+ (D.f[dirBNW ])[kbnw];
-
- vzD[k] = (D.f[dirT ])[kt ]- (D.f[dirB ])[kb ]+
- (D.f[dirTE ])[kte ]- (D.f[dirBW ])[kbw ]-
- (D.f[dirBE ])[kbe ]+ (D.f[dirTW ])[ktw ]+
- (D.f[dirTN ])[ktn ]- (D.f[dirBS ])[kbs ]-
- (D.f[dirBN ])[kbn ]+ (D.f[dirTS ])[kts ]+
- (D.f[dirTNE ])[ktne]+ (D.f[dirTSW ])[ktsw]+
- (D.f[dirTSE ])[ktse]+ (D.f[dirTNW ])[ktnw]-
- (D.f[dirBNE ])[kbne]- (D.f[dirBSW ])[kbsw]-
- (D.f[dirBSE ])[kbse]- (D.f[dirBNW ])[kbnw];
- }
+ if(!vf::gpu::isValidFluidNode(k, size_Mat, geoD[k]))
+ return;
+
+ vf::gpu::DistributionWrapper distr_wrapper(distributions, size_Mat, isEvenTimestep, k, neighborX, neighborY, neighborZ);
+ const auto& distribution = distr_wrapper.distribution;
+
+ rhoD[k] = vf::lbm::getDensity(distribution.f);
+ vxD[k] = vf::lbm::getIncompressibleVelocityX1(distribution.f);
+ vyD[k] = vf::lbm::getIncompressibleVelocityX2(distribution.f);
+ vzD[k] = vf::lbm::getIncompressibleVelocityX3(distribution.f);
+
}
@@ -412,251 +258,34 @@ extern "C" __global__ void LBCalcMacSP27( real* vxD,
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
////////////////////////////////////////////////////////////////////////////////
-extern "C" __global__ void LBCalcMacCompSP27( real* vxD,
- real* vyD,
- real* vzD,
- real* rhoD,
- real* pressD,
- unsigned int* geoD,
- unsigned int* neighborX,
- unsigned int* neighborY,
- unsigned int* neighborZ,
- unsigned int size_Mat,
- real* DD,
- bool evenOrOdd)
+extern "C" __global__ void LBCalcMacCompSP27(real *vxD, real *vyD, real *vzD, real *rhoD, real *pressD,
+ unsigned int *geoD, unsigned int *neighborX, unsigned int *neighborY,
+ unsigned int *neighborZ, unsigned int size_Mat, real *distributions,
+ bool isEvenTimestep)
{
- Distributions27 D;
- if (evenOrOdd==true)
- {
- D.f[dirE ] = &DD[dirE *size_Mat];
- D.f[dirW ] = &DD[dirW *size_Mat];
- D.f[dirN ] = &DD[dirN *size_Mat];
- D.f[dirS ] = &DD[dirS *size_Mat];
- D.f[dirT ] = &DD[dirT *size_Mat];
- D.f[dirB ] = &DD[dirB *size_Mat];
- D.f[dirNE ] = &DD[dirNE *size_Mat];
- D.f[dirSW ] = &DD[dirSW *size_Mat];
- D.f[dirSE ] = &DD[dirSE *size_Mat];
- D.f[dirNW ] = &DD[dirNW *size_Mat];
- D.f[dirTE ] = &DD[dirTE *size_Mat];
- D.f[dirBW ] = &DD[dirBW *size_Mat];
- D.f[dirBE ] = &DD[dirBE *size_Mat];
- D.f[dirTW ] = &DD[dirTW *size_Mat];
- D.f[dirTN ] = &DD[dirTN *size_Mat];
- D.f[dirBS ] = &DD[dirBS *size_Mat];
- D.f[dirBN ] = &DD[dirBN *size_Mat];
- D.f[dirTS ] = &DD[dirTS *size_Mat];
- D.f[dirZERO] = &DD[dirZERO*size_Mat];
- D.f[dirTNE ] = &DD[dirTNE *size_Mat];
- D.f[dirTSW ] = &DD[dirTSW *size_Mat];
- D.f[dirTSE ] = &DD[dirTSE *size_Mat];
- D.f[dirTNW ] = &DD[dirTNW *size_Mat];
- D.f[dirBNE ] = &DD[dirBNE *size_Mat];
- D.f[dirBSW ] = &DD[dirBSW *size_Mat];
- D.f[dirBSE ] = &DD[dirBSE *size_Mat];
- D.f[dirBNW ] = &DD[dirBNW *size_Mat];
- }
- else
- {
- D.f[dirW ] = &DD[dirE *size_Mat];
- D.f[dirE ] = &DD[dirW *size_Mat];
- D.f[dirS ] = &DD[dirN *size_Mat];
- D.f[dirN ] = &DD[dirS *size_Mat];
- D.f[dirB ] = &DD[dirT *size_Mat];
- D.f[dirT ] = &DD[dirB *size_Mat];
- D.f[dirSW ] = &DD[dirNE *size_Mat];
- D.f[dirNE ] = &DD[dirSW *size_Mat];
- D.f[dirNW ] = &DD[dirSE *size_Mat];
- D.f[dirSE ] = &DD[dirNW *size_Mat];
- D.f[dirBW ] = &DD[dirTE *size_Mat];
- D.f[dirTE ] = &DD[dirBW *size_Mat];
- D.f[dirTW ] = &DD[dirBE *size_Mat];
- D.f[dirBE ] = &DD[dirTW *size_Mat];
- D.f[dirBS ] = &DD[dirTN *size_Mat];
- D.f[dirTN ] = &DD[dirBS *size_Mat];
- D.f[dirTS ] = &DD[dirBN *size_Mat];
- D.f[dirBN ] = &DD[dirTS *size_Mat];
- D.f[dirZERO] = &DD[dirZERO*size_Mat];
- D.f[dirTNE ] = &DD[dirBSW *size_Mat];
- D.f[dirTSW ] = &DD[dirBNE *size_Mat];
- D.f[dirTSE ] = &DD[dirBNW *size_Mat];
- D.f[dirTNW ] = &DD[dirBSE *size_Mat];
- D.f[dirBNE ] = &DD[dirTSW *size_Mat];
- D.f[dirBSW ] = &DD[dirTNE *size_Mat];
- D.f[dirBSE ] = &DD[dirTNW *size_Mat];
- D.f[dirBNW ] = &DD[dirTSE *size_Mat];
- }
- ////////////////////////////////////////////////////////////////////////////////
- const unsigned x = threadIdx.x; // Globaler x-Index
- const unsigned y = blockIdx.x; // Globaler y-Index
- const unsigned z = blockIdx.y; // Globaler z-Index
-
- const unsigned nx = blockDim.x;
- const unsigned ny = gridDim.x;
-
- const unsigned k = nx*(ny*z + y) + x;
- //////////////////////////////////////////////////////////////////////////
-
- if(k<size_Mat)
- {
- //////////////////////////////////////////////////////////////////////////
- //index
- unsigned int kzero= k;
- unsigned int ke = k;
- unsigned int kw = neighborX[k];
- unsigned int kn = k;
- unsigned int ks = neighborY[k];
- unsigned int kt = k;
- unsigned int kb = neighborZ[k];
- unsigned int ksw = neighborY[kw];
- unsigned int kne = k;
- unsigned int kse = ks;
- unsigned int knw = kw;
- unsigned int kbw = neighborZ[kw];
- unsigned int kte = k;
- unsigned int kbe = kb;
- unsigned int ktw = kw;
- unsigned int kbs = neighborZ[ks];
- unsigned int ktn = k;
- unsigned int kbn = kb;
- unsigned int kts = ks;
- unsigned int ktse = ks;
- unsigned int kbnw = kbw;
- unsigned int ktnw = kw;
- unsigned int kbse = kbs;
- unsigned int ktsw = ksw;
- unsigned int kbne = kb;
- unsigned int ktne = k;
- unsigned int kbsw = neighborZ[ksw];
- //////////////////////////////////////////////////////////////////////////
- pressD[k] = c0o1;
- rhoD[k] = c0o1;
- vxD[k] = c0o1;
- vyD[k] = c0o1;
- vzD[k] = c0o1;
-
- if(geoD[k] == GEO_FLUID || geoD[k] == GEO_PM_0 || geoD[k] == GEO_PM_1 || geoD[k] == GEO_PM_2)
- {
- rhoD[k] = (D.f[dirE ])[ke ]+ (D.f[dirW ])[kw ]+
- (D.f[dirN ])[kn ]+ (D.f[dirS ])[ks ]+
- (D.f[dirT ])[kt ]+ (D.f[dirB ])[kb ]+
- (D.f[dirNE ])[kne ]+ (D.f[dirSW ])[ksw ]+
- (D.f[dirSE ])[kse ]+ (D.f[dirNW ])[knw ]+
- (D.f[dirTE ])[kte ]+ (D.f[dirBW ])[kbw ]+
- (D.f[dirBE ])[kbe ]+ (D.f[dirTW ])[ktw ]+
- (D.f[dirTN ])[ktn ]+ (D.f[dirBS ])[kbs ]+
- (D.f[dirBN ])[kbn ]+ (D.f[dirTS ])[kts ]+
- (D.f[dirZERO])[kzero]+
- (D.f[dirTNE ])[ktne]+ (D.f[dirTSW ])[ktsw]+
- (D.f[dirTSE ])[ktse]+ (D.f[dirTNW ])[ktnw]+
- (D.f[dirBNE ])[kbne]+ (D.f[dirBSW ])[kbsw]+
- (D.f[dirBSE ])[kbse]+ (D.f[dirBNW ])[kbnw];
-
- vxD[k] = ((D.f[dirE ])[ke ]- (D.f[dirW ])[kw ]+
- (D.f[dirNE ])[kne ]- (D.f[dirSW ])[ksw ]+
- (D.f[dirSE ])[kse ]- (D.f[dirNW ])[knw ]+
- (D.f[dirTE ])[kte ]- (D.f[dirBW ])[kbw ]+
- (D.f[dirBE ])[kbe ]- (D.f[dirTW ])[ktw ]+
- (D.f[dirTNE ])[ktne]- (D.f[dirTSW ])[ktsw]+
- (D.f[dirTSE ])[ktse]- (D.f[dirTNW ])[ktnw]+
- (D.f[dirBNE ])[kbne]- (D.f[dirBSW ])[kbsw]+
- (D.f[dirBSE ])[kbse]- (D.f[dirBNW ])[kbnw]) / (c1o1 + rhoD[k]);
-
- vyD[k] = ((D.f[dirN ])[kn ]- (D.f[dirS ])[ks ]+
- (D.f[dirNE ])[kne ]- (D.f[dirSW ])[ksw ]-
- (D.f[dirSE ])[kse ]+ (D.f[dirNW ])[knw ]+
- (D.f[dirTN ])[ktn ]- (D.f[dirBS ])[kbs ]+
- (D.f[dirBN ])[kbn ]- (D.f[dirTS ])[kts ]+
- (D.f[dirTNE ])[ktne]- (D.f[dirTSW ])[ktsw]-
- (D.f[dirTSE ])[ktse]+ (D.f[dirTNW ])[ktnw]+
- (D.f[dirBNE ])[kbne]- (D.f[dirBSW ])[kbsw]-
- (D.f[dirBSE ])[kbse]+ (D.f[dirBNW ])[kbnw]) / (c1o1 + rhoD[k]);
-
- vzD[k] = ((D.f[dirT ])[kt ]- (D.f[dirB ])[kb ]+
- (D.f[dirTE ])[kte ]- (D.f[dirBW ])[kbw ]-
- (D.f[dirBE ])[kbe ]+ (D.f[dirTW ])[ktw ]+
- (D.f[dirTN ])[ktn ]- (D.f[dirBS ])[kbs ]-
- (D.f[dirBN ])[kbn ]+ (D.f[dirTS ])[kts ]+
- (D.f[dirTNE ])[ktne]+ (D.f[dirTSW ])[ktsw]+
- (D.f[dirTSE ])[ktse]+ (D.f[dirTNW ])[ktnw]-
- (D.f[dirBNE ])[kbne]- (D.f[dirBSW ])[kbsw]-
- (D.f[dirBSE ])[kbse]- (D.f[dirBNW ])[kbnw]) / (c1o1 + rhoD[k]);
-
- pressD[k] = ((D.f[dirE ])[ke ]+ (D.f[dirW ])[kw ]+
- (D.f[dirN ])[kn ]+ (D.f[dirS ])[ks ]+
- (D.f[dirT ])[kt ]+ (D.f[dirB ])[kb ]+
- c2o1*(
- (D.f[dirNE ])[kne ]+ (D.f[dirSW ])[ksw ]+
- (D.f[dirSE ])[kse ]+ (D.f[dirNW ])[knw ]+
- (D.f[dirTE ])[kte ]+ (D.f[dirBW ])[kbw ]+
- (D.f[dirBE ])[kbe ]+ (D.f[dirTW ])[ktw ]+
- (D.f[dirTN ])[ktn ]+ (D.f[dirBS ])[kbs ]+
- (D.f[dirBN ])[kbn ]+ (D.f[dirTS ])[kts ])+
- c3o1*(
- (D.f[dirTNE ])[ktne]+ (D.f[dirTSW ])[ktsw]+
- (D.f[dirTSE ])[ktse]+ (D.f[dirTNW ])[ktnw]+
- (D.f[dirBNE ])[kbne]+ (D.f[dirBSW ])[kbsw]+
- (D.f[dirBSE ])[kbse]+ (D.f[dirBNW ])[kbnw])-
- rhoD[k]-(vxD[k] * vxD[k] + vyD[k] * vyD[k] + vzD[k] * vzD[k]) * (c1o1+rhoD[k])) * c1o2+rhoD[k]; // times zero for incompressible case
- //achtung op hart gesetzt Annahme op = 1 ; ^^^^(1.0/op-0.5)=0.5
-
- }
- }
+ const unsigned k = vf::gpu::getNodeIndex();
+
+ pressD[k] = c0o1;
+ rhoD[k] = c0o1;
+ vxD[k] = c0o1;
+ vyD[k] = c0o1;
+ vzD[k] = c0o1;
+
+ if (!vf::gpu::isValidFluidNode(k, size_Mat, geoD[k]))
+ return;
+
+ vf::gpu::DistributionWrapper distr_wrapper(distributions, size_Mat, isEvenTimestep, k, neighborX, neighborY,
+ neighborZ);
+ const auto &distribution = distr_wrapper.distribution;
+
+ rhoD[k] = vf::lbm::getDensity(distribution.f);
+ vxD[k] = vf::lbm::getCompressibleVelocityX1(distribution.f, rhoD[k]);
+ vyD[k] = vf::lbm::getCompressibleVelocityX2(distribution.f, rhoD[k]);
+ vzD[k] = vf::lbm::getCompressibleVelocityX3(distribution.f, rhoD[k]);
+ pressD[k] = vf::lbm::getPressure(distribution.f, rhoD[k], vxD[k], vyD[k], vzD[k]);
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
////////////////////////////////////////////////////////////////////////////////
extern "C" __global__ void LBCalcMacThS7( real* Conc,
unsigned int* geoD,
diff --git a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
index 6c1585bd689a5f2e2da603d5e9fdb81cbc175aab..aeafe342f0680763fbbffe63cf1c6760e61c2102 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
+++ b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
@@ -6,6 +6,8 @@
#include <Parameter/Parameter.h>
+#include <lbm/constants/NumericConstants.h>
+
void CudaMemoryManager::cudaAllocFull(int lev)
{
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->geo ), parameter->getParH(lev)->mem_size_int ));
@@ -404,6 +406,44 @@ void CudaMemoryManager::cudaFreeForcing()
{
checkCudaErrors( cudaFreeHost(parameter->getForcesHost()));
}
+
+void CudaMemoryManager::cudaAllocLevelForcing(int level)
+{
+ real fx_t{ 1. }, fy_t{ 1. }, fz_t{ 1. };
+ for (int i = 0; i < level; i++) {
+ fx_t *= vf::lbm::constant::c2o1;
+ fy_t *= vf::lbm::constant::c2o1;
+ fz_t *= vf::lbm::constant::c2o1;
+ }
+
+ const unsigned int mem_size = sizeof(real) * 3;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(level)->forcing), mem_size));
+ parameter->getParH(level)->forcing[0] = parameter->forcingH[0] / fx_t;
+ parameter->getParH(level)->forcing[1] = parameter->forcingH[1] / fy_t;
+ parameter->getParH(level)->forcing[2] = parameter->forcingH[2] / fz_t;
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(level)->forcing, mem_size));
+ //////////////////////////////////////////////////////////////////////////
+ const double tmp = (double)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+
+void CudaMemoryManager::cudaCopyLevelForcingToDevice(int level)
+{
+ unsigned int mem_size = sizeof(real) * 3;
+ checkCudaErrors( cudaMemcpy(parameter->getParD(level)->forcing, parameter->getParH(level)->forcing, mem_size, cudaMemcpyHostToDevice));
+}
+
+void CudaMemoryManager::cudaFreeLevelForcing(int level)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(level)->forcing));
+ checkCudaErrors( cudaFree(parameter->getParD(level)->forcing));
+}
+
+
//quadric Limiters
void CudaMemoryManager::cudaAllocQuadricLimiters()
{
diff --git a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h
index c26db65afd384ac7a4e6c436c4dea2c46647ae95..4853205f510348a954fbc8dcdaed72385a30d559 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h
+++ b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h
@@ -78,6 +78,10 @@ public:
void cudaCopyForcingToHost();
void cudaFreeForcing();
+ void cudaAllocLevelForcing(int level);
+ void cudaCopyLevelForcingToDevice(int level);
+ void cudaFreeLevelForcing(int level);
+
void cudaAllocQuadricLimiters();
void cudaCopyQuadricLimitersToDevice();
void cudaFreeQuadricLimiters();
diff --git a/src/gpu/VirtualFluids_GPU/GPU/Cumulant27chim.cu b/src/gpu/VirtualFluids_GPU/GPU/Cumulant27chim.cu
index bb34a11a7337a499f8558a48d27c3547932618a6..9dc75cfa6019a29350263f9a554aa9a489566cfa 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/Cumulant27chim.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/Cumulant27chim.cu
@@ -1,10 +1,35 @@
-// _ ___ __ __________ _ __ ______________ __
-// | | / (_)____/ /___ ______ _/ / ____/ /_ __(_)___/ /____ / ___/ __ / / / /
-// | | / / / ___/ __/ / / / __ `/ / /_ / / / / / / __ / ___/ / /___/ /_/ / / / /
-// | |/ / / / / /_/ /_/ / /_/ / / __/ / / /_/ / / /_/ (__ ) / /_) / ____/ /__/ /
-// |___/_/_/ \__/\__,_/\__,_/_/_/ /_/\__,_/_/\__,_/____/ \____/_/ \_____/
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
//
-//////////////////////////////////////////////////////////////////////////
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file Cumulant27chim.cu
+//! \ingroup GPU
+//! \author Martin Schoenherr
+//=======================================================================================
/* Device code */
#include "LBM/LB.h"
#include "LBM/D3Q27.h"
@@ -13,951 +38,882 @@
using namespace vf::lbm::constant;
#include "math.h"
-
-////////////////////////////////////////////////////////////////////////////////
-inline __device__ void forwardInverseChimeraWithK(real &mfa, real &mfb, real &mfc, real vv, real v2, real Kinverse, real K) {
- real m2 = mfa + mfc;
- real m1 = mfc - mfa;
- real m0 = m2 + mfb;
- mfa = m0;
- m0 *= Kinverse;
- m0 += c1o1;
- mfb = (m1*Kinverse - m0 * vv) * K;
- mfc = ((m2 - c2o1* m1 * vv)*Kinverse + v2 * m0) * K;
-}
-
-inline __device__ void backwardInverseChimeraWithK(real &mfa, real &mfb, real &mfc, real vv, real v2, real Kinverse, real K) {
- real m0 = (((mfc - mfb) * c1o2 + mfb * vv)*Kinverse + (mfa*Kinverse + c1o1) * (v2 - vv) * c1o2) * K;
- real m1 = (((mfa - mfc) - c2o1 * mfb * vv)*Kinverse + (mfa*Kinverse + c1o1) * ( -v2)) * K;
- mfc = (((mfc + mfb) * c1o2 + mfb * vv)*Kinverse + (mfa*Kinverse + c1o1) * (v2 + vv) * c1o2) * K;
- mfa = m0;
- mfb = m1;
-}
-////////////////////////////////////////////////////////////////////////////////
-
-
-
-
-
-inline __device__ void forwardChimeraWithK(real &mfa, real &mfb, real &mfc, real vv, real v2, real K) {
-
- real m2 = mfa + mfc;
- real m1 = mfc - mfa;
- real m0 = m2 + mfb;
- mfa = m0;
- //m0 += K;
- mfb = (m1 - K*vv) - m0 * vv;
- mfc = ((m2 - c2o1* m1 * vv) + v2*K) + v2 * m0;
- //m0 += K;
- //mfb = m1 - m0 * vv;
- //mfc = m2 - two* m1 * vv + v2 * m0;
-}
-
-inline __device__ void forwardChimera(real &mfa, real &mfb, real &mfc, real vv, real v2) {
- real m1 = (mfa + mfc) + mfb;
- real m2 = mfc - mfa;
- mfc = (mfc + mfa) + (v2*m1 - c2o1*vv*m2);
- mfb = m2 - vv*m1;
- mfa = m1;
-}
-
-
-inline __device__ void backwardChimera(real &mfa, real &mfb, real &mfc, real vv, real v2) {
- real ma = (mfc + mfa*(v2 - vv))*c1o2 + mfb*(vv - c1o2);
- real mb = ((mfa - mfc) - mfa*v2) - c2o1*mfb*vv;
- mfc = (mfc + mfa*(v2 + vv))*c1o2 + mfb*(vv + c1o2);
- mfb = mb;
- mfa = ma;
-}
-
-
-inline __device__ void backwardChimeraWithK(real &mfa, real &mfb, real &mfc, real vv, real v2, real K) {
- real m0 = (mfc - mfb)* c1o2 + mfb * (vv)+(mfa + K) * (v2 - vv) * c1o2;
- real m1 = (mfa - mfc) - c2o1* mfb * vv + (mfa + K) * (-v2);
- mfc = (mfc + mfb)* c1o2 + mfb * (vv)+(mfa + K) * (v2 + vv) * c1o2;
- mfa = m0;
- mfb = m1;
-
-}
-
-
-
-
+#include <lbm/Chimera.h>
////////////////////////////////////////////////////////////////////////////////
extern "C" __global__ void Cumulant_One_preconditioned_errorDiffusion_chim_Comp_SP_27(
- real omega,
- unsigned int* bcMatD,
- unsigned int* neighborX,
- unsigned int* neighborY,
- unsigned int* neighborZ,
- real* DDStart,
- int size_Mat,
- int level,
- real* forces,
- bool EvenOrOdd)
+ real omega,
+ unsigned int* bcMatD,
+ unsigned int* neighborX,
+ unsigned int* neighborY,
+ unsigned int* neighborZ,
+ real* DDStart,
+ int size_Mat,
+ int level,
+ real* forces,
+ bool EvenOrOdd)
{
- ////////////////////////////////////////////////////////////////////////////////
- const unsigned x = threadIdx.x; // Globaler x-Index
- const unsigned y = blockIdx.x; // Globaler y-Index
- const unsigned z = blockIdx.y; // Globaler z-Index
-
- const unsigned nx = blockDim.x;
- const unsigned ny = gridDim.x;
-
- const unsigned k = nx*(ny*z + y) + x;
- //////////////////////////////////////////////////////////////////////////
-
- if (k<size_Mat)
- {
- ////////////////////////////////////////////////////////////////////////////////
- unsigned int BC;
- BC = bcMatD[k];
-
- if (BC >= GEO_FLUID/*(BC != GEO_SOLID) && (BC != GEO_VOID)*/)
- {
- Distributions27 D;
- if (EvenOrOdd == true)
- {
- D.f[dirE] = &DDStart[dirE *size_Mat];
- D.f[dirW] = &DDStart[dirW *size_Mat];
- D.f[dirN] = &DDStart[dirN *size_Mat];
- D.f[dirS] = &DDStart[dirS *size_Mat];
- D.f[dirT] = &DDStart[dirT *size_Mat];
- D.f[dirB] = &DDStart[dirB *size_Mat];
- D.f[dirNE] = &DDStart[dirNE *size_Mat];
- D.f[dirSW] = &DDStart[dirSW *size_Mat];
- D.f[dirSE] = &DDStart[dirSE *size_Mat];
- D.f[dirNW] = &DDStart[dirNW *size_Mat];
- D.f[dirTE] = &DDStart[dirTE *size_Mat];
- D.f[dirBW] = &DDStart[dirBW *size_Mat];
- D.f[dirBE] = &DDStart[dirBE *size_Mat];
- D.f[dirTW] = &DDStart[dirTW *size_Mat];
- D.f[dirTN] = &DDStart[dirTN *size_Mat];
- D.f[dirBS] = &DDStart[dirBS *size_Mat];
- D.f[dirBN] = &DDStart[dirBN *size_Mat];
- D.f[dirTS] = &DDStart[dirTS *size_Mat];
- D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
- D.f[dirTNE] = &DDStart[dirTNE *size_Mat];
- D.f[dirTSW] = &DDStart[dirTSW *size_Mat];
- D.f[dirTSE] = &DDStart[dirTSE *size_Mat];
- D.f[dirTNW] = &DDStart[dirTNW *size_Mat];
- D.f[dirBNE] = &DDStart[dirBNE *size_Mat];
- D.f[dirBSW] = &DDStart[dirBSW *size_Mat];
- D.f[dirBSE] = &DDStart[dirBSE *size_Mat];
- D.f[dirBNW] = &DDStart[dirBNW *size_Mat];
- }
- else
- {
- D.f[dirW] = &DDStart[dirE *size_Mat];
- D.f[dirE] = &DDStart[dirW *size_Mat];
- D.f[dirS] = &DDStart[dirN *size_Mat];
- D.f[dirN] = &DDStart[dirS *size_Mat];
- D.f[dirB] = &DDStart[dirT *size_Mat];
- D.f[dirT] = &DDStart[dirB *size_Mat];
- D.f[dirSW] = &DDStart[dirNE *size_Mat];
- D.f[dirNE] = &DDStart[dirSW *size_Mat];
- D.f[dirNW] = &DDStart[dirSE *size_Mat];
- D.f[dirSE] = &DDStart[dirNW *size_Mat];
- D.f[dirBW] = &DDStart[dirTE *size_Mat];
- D.f[dirTE] = &DDStart[dirBW *size_Mat];
- D.f[dirTW] = &DDStart[dirBE *size_Mat];
- D.f[dirBE] = &DDStart[dirTW *size_Mat];
- D.f[dirBS] = &DDStart[dirTN *size_Mat];
- D.f[dirTN] = &DDStart[dirBS *size_Mat];
- D.f[dirTS] = &DDStart[dirBN *size_Mat];
- D.f[dirBN] = &DDStart[dirTS *size_Mat];
- D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
- D.f[dirBSW] = &DDStart[dirTNE *size_Mat];
- D.f[dirBNE] = &DDStart[dirTSW *size_Mat];
- D.f[dirBNW] = &DDStart[dirTSE *size_Mat];
- D.f[dirBSE] = &DDStart[dirTNW *size_Mat];
- D.f[dirTSW] = &DDStart[dirBNE *size_Mat];
- D.f[dirTNE] = &DDStart[dirBSW *size_Mat];
- D.f[dirTNW] = &DDStart[dirBSE *size_Mat];
- D.f[dirTSE] = &DDStart[dirBNW *size_Mat];
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- //index
- //unsigned int kzero= k;
- //unsigned int ke = k;
- unsigned int kw = neighborX[k];
- //unsigned int kn = k;
- unsigned int ks = neighborY[k];
- //unsigned int kt = k;
- unsigned int kb = neighborZ[k];
- unsigned int ksw = neighborY[kw];
- //unsigned int kne = k;
- //unsigned int kse = ks;
- //unsigned int knw = kw;
- unsigned int kbw = neighborZ[kw];
- //unsigned int kte = k;
- //unsigned int kbe = kb;
- //unsigned int ktw = kw;
- unsigned int kbs = neighborZ[ks];
- //unsigned int ktn = k;
- //unsigned int kbn = kb;
- //unsigned int kts = ks;
- //unsigned int ktse = ks;
- //unsigned int kbnw = kbw;
- //unsigned int ktnw = kw;
- //unsigned int kbse = kbs;
- //unsigned int ktsw = ksw;
- //unsigned int kbne = kb;
- //unsigned int ktne = k;
- unsigned int kbsw = neighborZ[ksw];
-
-
-
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- real mfcbb = (D.f[dirE])[k];//[ke ];// + c2over27 ;(D.f[dirE ])[k ];//ke
- real mfabb = (D.f[dirW])[kw];//[kw ];// + c2over27 ;(D.f[dirW ])[kw ];
- real mfbcb = (D.f[dirN])[k];//[kn ];// + c2over27 ;(D.f[dirN ])[k ];//kn
- real mfbab = (D.f[dirS])[ks];//[ks ];// + c2over27 ;(D.f[dirS ])[ks ];
- real mfbbc = (D.f[dirT])[k];//[kt ];// + c2over27 ;(D.f[dirT ])[k ];//kt
- real mfbba = (D.f[dirB])[kb];//[kb ];// + c2over27 ;(D.f[dirB ])[kb ];
- real mfccb = (D.f[dirNE])[k];//[kne ];// + c1over54 ;(D.f[dirNE ])[k ];//kne
- real mfaab = (D.f[dirSW])[ksw];//[ksw ];// + c1over54 ;(D.f[dirSW ])[ksw];
- real mfcab = (D.f[dirSE])[ks];//[kse ];// + c1over54 ;(D.f[dirSE ])[ks ];//kse
- real mfacb = (D.f[dirNW])[kw];//[knw ];// + c1over54 ;(D.f[dirNW ])[kw ];//knw
- real mfcbc = (D.f[dirTE])[k];//[kte ];// + c1over54 ;(D.f[dirTE ])[k ];//kte
- real mfaba = (D.f[dirBW])[kbw];//[kbw ];// + c1over54 ;(D.f[dirBW ])[kbw];
- real mfcba = (D.f[dirBE])[kb];//[kbe ];// + c1over54 ;(D.f[dirBE ])[kb ];//kbe
- real mfabc = (D.f[dirTW])[kw];//[ktw ];// + c1over54 ;(D.f[dirTW ])[kw ];//ktw
- real mfbcc = (D.f[dirTN])[k];//[ktn ];// + c1over54 ;(D.f[dirTN ])[k ];//ktn
- real mfbaa = (D.f[dirBS])[kbs];//[kbs ];// + c1over54 ;(D.f[dirBS ])[kbs];
- real mfbca = (D.f[dirBN])[kb];//[kbn ];// + c1over54 ;(D.f[dirBN ])[kb ];//kbn
- real mfbac = (D.f[dirTS])[ks];//[kts ];// + c1over54 ;(D.f[dirTS ])[ks ];//kts
- real mfbbb = (D.f[dirZERO])[k];//[kzero];// + c8over27 ;(D.f[dirZERO])[k ];//kzero
- real mfccc = (D.f[dirTNE])[k];//[ktne ];// + c1over216;(D.f[dirTNE ])[k ];//ktne
- real mfaac = (D.f[dirTSW])[ksw];//[ktsw ];// + c1over216;(D.f[dirTSW ])[ksw];//ktsw
- real mfcac = (D.f[dirTSE])[ks];//[ktse ];// + c1over216;(D.f[dirTSE ])[ks ];//ktse
- real mfacc = (D.f[dirTNW])[kw];//[ktnw ];// + c1over216;(D.f[dirTNW ])[kw ];//ktnw
- real mfcca = (D.f[dirBNE])[kb];//[kbne ];// + c1over216;(D.f[dirBNE ])[kb ];//kbne
- real mfaaa = (D.f[dirBSW])[kbsw];//[kbsw ];// + c1over216;(D.f[dirBSW ])[kbsw];
- real mfcaa = (D.f[dirBSE])[kbs];//[kbse ];// + c1over216;(D.f[dirBSE ])[kbs];//kbse
- real mfaca = (D.f[dirBNW])[kbw];//[kbnw ];// + c1over216;(D.f[dirBNW ])[kbw];//kbnw
- ////////////////////////////////////////////////////////////////////////////////////
- real drho = ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
- (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
- ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
-
- real rho = c1o1 + drho;
- ////////////////////////////////////////////////////////////////////////////////////
- real vvx = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfcaa - mfacc) + (mfcca - mfaac))) +
- (((mfcba - mfabc) + (mfcbc - mfaba)) + ((mfcab - mfacb) + (mfccb - mfaab))) +
- (mfcbb - mfabb)) / rho;
- real vvy = ((((mfccc - mfaaa) + (mfaca - mfcac)) + ((mfacc - mfcaa) + (mfcca - mfaac))) +
- (((mfbca - mfbac) + (mfbcc - mfbaa)) + ((mfacb - mfcab) + (mfccb - mfaab))) +
- (mfbcb - mfbab)) / rho;
- real vvz = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfacc - mfcaa) + (mfaac - mfcca))) +
- (((mfbac - mfbca) + (mfbcc - mfbaa)) + ((mfabc - mfcba) + (mfcbc - mfaba))) +
- (mfbbc - mfbba)) / rho;
- ////////////////////////////////////////////////////////////////////////////////////
- //the force be with you
- real fx = forces[0] / (pow((double)c2o1, (double)level)); //zero;//0.0032653/(pow(two,level)); //0.000000005;//(two/1600000.0) / 120.0; //
- real fy = forces[1] / (pow((double)c2o1, (double)level)); //zero;
- real fz = forces[2] / (pow((double)c2o1, (double)level)); //zero;
- vvx += fx*c1o2;
- vvy += fy*c1o2;
- vvz += fz*c1o2;
- ////////////////////////////////////////////////////////////////////////////////////
- //real omega = omega_in;
- ////////////////////////////////////////////////////////////////////////////////////
- //fast
- //real oMdrho = c1o1; // comp special
- //real m0, m1, m2;
- real vx2;
- real vy2;
- real vz2;
- vx2 = vvx*vvx;
- vy2 = vvy*vvy;
- vz2 = vvz*vvz;
- ////////////////////////////////////////////////////////////////////////////////////
- //real wadjust;
- //real qudricLimitP = c1o100;// * 0.0001f;
- //real qudricLimitM = c1o100;// * 0.0001f;
- //real qudricLimitD = c1o100;// * 0.001f;
- //real s9 = minusomega;
- //test
- //s9 = 0.;
-
-
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- real EQcbb = c0o1;
- real EQabb = c0o1;
- real EQbcb = c0o1;
- real EQbab = c0o1;
- real EQbbc = c0o1;
- real EQbba = c0o1;
- real EQccb = c0o1;
- real EQaab = c0o1;
- real EQcab = c0o1;
- real EQacb = c0o1;
- real EQcbc = c0o1;
- real EQaba = c0o1;
- real EQcba = c0o1;
- real EQabc = c0o1;
- real EQbcc = c0o1;
- real EQbaa = c0o1;
- real EQbca = c0o1;
- real EQbac = c0o1;
- real EQbbb = c0o1;
- real EQccc = drho * c1o27;
- real EQaac = drho * c1o3;
- real EQcac = drho * c1o9;
- real EQacc = drho * c1o9;
- real EQcca = drho * c1o9;
- real EQaaa = drho;
- real EQcaa = drho * c1o3;
- real EQaca = drho * c1o3;
- ////////////////////////////////////////////////////////////////////////////////////
- backwardChimeraWithK(EQaaa, EQaab, EQaac, vvz, vz2, c1o1);
- backwardChimeraWithK(EQaca, EQacb, EQacc, vvz, vz2, c1o3);
- ///////////////////////////////////////////////////////////
- EQcaa = EQaca; EQcab = EQacb; EQcac = EQacc;
- ///////////////////////////////////////////////////////////
- backwardChimeraWithK(EQcca, EQccb, EQccc, vvz, vz2, c1o9);
-
- backwardChimeraWithK(EQaaa, EQaba, EQaca, vvy, vy2, c1o6);
- backwardChimeraWithK(EQaab, EQabb, EQacb, vvy, vy2, c2o3);
- backwardChimeraWithK(EQaac, EQabc, EQacc, vvy, vy2, c1o6);
- backwardChimeraWithK(EQcaa, EQcba, EQcca, vvy, vy2, c1o18);
- backwardChimeraWithK(EQcab, EQcbb, EQccb, vvy, vy2, c2o9);
- backwardChimeraWithK(EQcac, EQcbc, EQccc, vvy, vy2, c1o18);
-
- backwardChimeraWithK(EQaaa, EQbaa, EQcaa, vvx, vx2, c1o36);
- backwardChimeraWithK(EQaab, EQbab, EQcab, vvx, vx2, c1o9);
- backwardChimeraWithK(EQaac, EQbac, EQcac, vvx, vx2, c1o36);
- backwardChimeraWithK(EQaba, EQbba, EQcba, vvx, vx2, c1o9);
- backwardChimeraWithK(EQabb, EQbbb, EQcbb, vvx, vx2, c4o9);
- backwardChimeraWithK(EQabc, EQbbc, EQcbc, vvx, vx2, c1o9);
- backwardChimeraWithK(EQaca, EQbca, EQcca, vvx, vx2, c1o36);
- backwardChimeraWithK(EQacb, EQbcb, EQccb, vvx, vx2, c1o9);
- backwardChimeraWithK(EQacc, EQbcc, EQccc, vvx, vx2, c1o36);
-
- ////////////////////////////////////////////////////////////////////////////////////
- //Pre-condition
- mfcbb -= EQcbb;
- mfabb -= EQabb;
- mfbcb -= EQbcb;
- mfbab -= EQbab;
- mfbbc -= EQbbc;
- mfbba -= EQbba;
- mfccb -= EQccb;
- mfaab -= EQaab;
- mfcab -= EQcab;
- mfacb -= EQacb;
- mfcbc -= EQcbc;
- mfaba -= EQaba;
- mfcba -= EQcba;
- mfabc -= EQabc;
- mfbcc -= EQbcc;
- mfbaa -= EQbaa;
- mfbca -= EQbca;
- mfbac -= EQbac;
- mfbbb -= EQbbb;
- mfccc -= EQccc;
- mfaac -= EQaac;
- mfcac -= EQcac;
- mfacc -= EQacc;
- mfcca -= EQcca;
- mfaaa -= EQaaa;
- mfcaa -= EQcaa;
- mfaca -= EQaca;
-
- ////////////////////////////////////////////////////////////////////////////////////
- //Hin
- ////////////////////////////////////////////////////////////////////////////////////
- forwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
- forwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
- forwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
- forwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
- forwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
- forwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
- forwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
- forwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
- forwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
-
- forwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
- forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
- forwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
- forwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
- forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
- forwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
- forwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
- forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
- forwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
-
- forwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
- forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
- forwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
- forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
- forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
- forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
- forwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
- forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
- forwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
-
- //////////////////////////////////////////////////////////////////////////////////////
- ////Hin
- //////////////////////////////////////////////////////////////////////////////////////
- //// mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Z - Dir
- //forwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, c4o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //// mit 1/6, 0, 1/18, 2/3, 0, 2/9, 1/6, 0, 1/18 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Y - Dir
- //forwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o18);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, c2o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, c2o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //// mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// X - Dir
- //forwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, one);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
-
-
- ////////////////////////////////////////////////////////////////////////////////////
- // Cumulants
- ////////////////////////////////////////////////////////////////////////////////////
- real OxxPyyPzz = c1o1; //omega; // one; //set the bulk viscosity one is high / two is very low and zero is (too) high
-
- ////////////////////////////////////////////////////////////
- //3.
- //////////////////////////////
- real OxyyPxzz = c1o1;
- real OxyyMxzz = c1o1;
- //real Oxyz = c1o1;
- ////////////////////////////////////////////////////////////
- //4.
- //////////////////////////////
- real O4 = c1o1;
- ////////////////////////////////////////////////////////////
- //5.
- //////////////////////////////
- real O5 = c1o1;
- ////////////////////////////////////////////////////////////
- //6.
- //////////////////////////////
- real O6 = c1o1;
- ////////////////////////////////////////////////////////////
-
-
- //central moments to cumulants
- //4.
- real CUMcbb = mfcbb - ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
- real CUMbcb = mfbcb - ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
- real CUMbbc = mfbbc - ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
-
- real CUMcca = mfcca - (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
- real CUMcac = mfcac - (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
- real CUMacc = mfacc - (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
-
- //5.
- real CUMbcc = mfbcc - ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
- real CUMcbc = mfcbc - ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
- real CUMccb = mfccb - ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
-
- //6.
-
- real CUMccc = mfccc + ((-c4o1 * mfbbb * mfbbb
- - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
- - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
- - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
- + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
- + c2o1 * (mfcaa * mfaca * mfaac)
- + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
- - c1o3 * (mfacc + mfcac + mfcca) / rho
- - c1o9 * (mfcaa + mfaca + mfaac) / rho
- + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
- + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
- + c1o27*((drho * drho - drho) / (rho*rho)));
-
-
-
-
- //2.
- // linear combinations
- real mxxPyyPzz = mfcaa + mfaca + mfaac;
- real mxxMyy = mfcaa - mfaca;
- real mxxMzz = mfcaa - mfaac;
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //incl. correction (hat noch nicht so gut funktioniert...Optimierungsbedarf??)
- {
- real dxux = c1o2 * (-omega) *(mxxMyy + mxxMzz) + c1o2 * OxxPyyPzz * (mfaaa - mxxPyyPzz);
- real dyuy = dxux + omega * c3o2 * mxxMyy;
- real dzuz = dxux + omega * c3o2 * mxxMzz;
-
- //relax
- mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz) - c3o1 * (c1o1 - c1o2 * OxxPyyPzz) * (vx2 * dxux + vy2 * dyuy + vz2 * dzuz);//-magicBulk*OxxPyyPzz;
- mxxMyy += omega * (-mxxMyy) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vy2 * dyuy);
- mxxMzz += omega * (-mxxMzz) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vz2 * dzuz);
-
- }
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////no correction
- //mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz);//-magicBulk*OxxPyyPzz;
- //mxxMyy += -(-omega) * (-mxxMyy);
- //mxxMzz += -(-omega) * (-mxxMzz);
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- mfabb += omega * (-mfabb);
- mfbab += omega * (-mfbab);
- mfbba += omega * (-mfbba);
-
- //////////////////////////////////////////////////////////////////////////
-
- // linear combinations back
- mfcaa = c1o3 * (mxxMyy + mxxMzz + mxxPyyPzz);
- mfaca = c1o3 * (-c2o1* mxxMyy + mxxMzz + mxxPyyPzz);
- mfaac = c1o3 * (mxxMyy - c2o1* mxxMzz + mxxPyyPzz);
-
- //3.
- // linear combinations
-
- real mxxyPyzz = mfcba + mfabc;
- real mxxyMyzz = mfcba - mfabc;
-
- real mxxzPyyz = mfcab + mfacb;
- real mxxzMyyz = mfcab - mfacb;
-
- real mxyyPxzz = mfbca + mfbac;
- real mxyyMxzz = mfbca - mfbac;
-
- //relax
- //////////////////////////////////////////////////////////////////////////
- mfbbb += OxyyMxzz * (-mfbbb);
- mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
- mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
- mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
- mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
- mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
- mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
- //////////////////////////////////////////////////////////////////////////
-
- mfcba = (mxxyMyzz + mxxyPyzz) * c1o2;
- mfabc = (-mxxyMyzz + mxxyPyzz) * c1o2;
- mfcab = (mxxzMyyz + mxxzPyyz) * c1o2;
- mfacb = (-mxxzMyyz + mxxzPyyz) * c1o2;
- mfbca = (mxyyMxzz + mxyyPxzz) * c1o2;
- mfbac = (-mxyyMxzz + mxyyPxzz) * c1o2;
-
- //4.
- //////////////////////////////////////////////////////////////////////////
- CUMacc += O4 * (-CUMacc);
- CUMcac += O4 * (-CUMcac);
- CUMcca += O4 * (-CUMcca);
-
- CUMbbc += O4 * (-CUMbbc);
- CUMbcb += O4 * (-CUMbcb);
- CUMcbb += O4 * (-CUMcbb);
- //////////////////////////////////////////////////////////////////////////
-
-
- //5.
- CUMbcc += O5 * (-CUMbcc);
- CUMcbc += O5 * (-CUMcbc);
- CUMccb += O5 * (-CUMccb);
-
- //6.
- CUMccc += O6 * (-CUMccc);
-
-
-
- //back cumulants to central moments
- //4.
- mfcbb = CUMcbb + ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
- mfbcb = CUMbcb + ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
- mfbbc = CUMbbc + ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
-
- mfcca = CUMcca + (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
- mfcac = CUMcac + (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
- mfacc = CUMacc + (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
-
- //5.
- mfbcc = CUMbcc + ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
- mfcbc = CUMcbc + ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
- mfccb = CUMccb + ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
-
- //6.
- mfccc = CUMccc - ((-c4o1 * mfbbb * mfbbb
- - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
- - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
- - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
- + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
- + c2o1 * (mfcaa * mfaca * mfaac)
- + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
- - c1o3 * (mfacc + mfcac + mfcca) / rho
- - c1o9 * (mfcaa + mfaca + mfaac) / rho
- + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
- + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
- + c1o27*((drho * drho - drho) / (rho*rho)));
-
- ////////////////////////////////////////////////////////////////////////////////////
- //the force be with you
- mfbaa = -mfbaa;
- mfaba = -mfaba;
- mfaab = -mfaab;
- ////////////////////////////////////////////////////////////////////////////////////
-
-
- ////////////////////////////////////////////////////////////////////////////////////
- //back
- ////////////////////////////////////////////////////////////////////////////////////
- backwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
- backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
- backwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
- backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
- backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
- backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
- backwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
- backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
- backwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
-
- backwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
- backwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
- backwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
- backwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
- backwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
- backwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
- backwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
- backwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
- backwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
-
- backwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
- backwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
- backwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
- backwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
- backwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
- backwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
- backwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
- backwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
- backwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
-
- ////////////////////////////////////////////////////////////////////////////////////
- //mfcbb += EQcbb;
- //mfabb += EQabb;
- //mfbcb += EQbcb;
- //mfbab += EQbab;
- //mfbbc += EQbbc;
- //mfbba += EQbba;
- //mfccb += EQccb;
- //mfaab += EQaab;
- //mfcab += EQcab;
- //mfacb += EQacb;
- //mfcbc += EQcbc;
- //mfaba += EQaba;
- //mfcba += EQcba;
- //mfabc += EQabc;
- //mfbcc += EQbcc;
- //mfbaa += EQbaa;
- //mfbca += EQbca;
- //mfbac += EQbac;
- //mfbbb += EQbbb;
- //mfccc += EQccc;
- //mfaac += EQaac;
- //mfcac += EQcac;
- //mfacc += EQacc;
- //mfcca += EQcca;
- //mfaaa += EQaaa;
- //mfcaa += EQcaa;
- //mfaca += EQaca;
- ////////////////////////////////////////////////////////////////////////////////////
- ////Error diffusion
- real fTEMP = mfbbb + EQbbb;
- real delta0 = mfbbb - (fTEMP - EQbbb);
- delta0 *= c1o4;
- mfbbb = fTEMP;
-
-
- fTEMP = mfcbb + EQcbb;
- real deltacbb = mfcbb - (fTEMP - EQcbb);
- mfcbb = fTEMP;
- //mfcbb+=EQcbb;
-
- fTEMP = mfabb + EQabb;
- real deltaabb = mfabb - (fTEMP - EQabb);
- mfabb = fTEMP;
- //mfabb+=EQabb;
-
- fTEMP = mfbcb + EQbcb;
- real deltabcb = mfbcb - (fTEMP - EQbcb);
- mfbcb = fTEMP;
- //mfbcb+=EQbcb;
-
- fTEMP = mfbab + EQbab;
- real deltabab = mfbab - (fTEMP - EQbab);
- mfbab = fTEMP;
- //mfbab+=EQbab;
-
- fTEMP = mfbbc + EQbbc;
- real deltabbc = mfbbc - (fTEMP - EQbbc);
- mfbbc = fTEMP;
- //mfbbc+=EQbbc;
-
- fTEMP = mfbba + EQbba;
- real deltabba = mfbba - (fTEMP - EQbba);
- mfbba = fTEMP;
- //mfbba+=EQbba;
-
- EQccb += (delta0 + c1o2*(deltacbb + deltabcb));
- fTEMP = mfccb + EQccb;
- real deltaccb = mfccb - (fTEMP - EQccb);
- mfccb = fTEMP;
- //mfccb+=EQccb+(delta0+c1o2*(deltacbb+deltabcb));
-
- EQaab += (delta0 + c1o2*(deltaabb + deltabab));
- fTEMP = mfaab + EQaab;
- real deltaaab = mfaab - (fTEMP - EQaab);
- mfaab = fTEMP;
- //mfaab+=EQaab+(delta0+c1o2*(deltaabb+deltabab));
-
- EQcab += (delta0 + c1o2*(deltacbb + deltabab));
- fTEMP = mfcab + EQcab;
- real deltacab = mfcab - (fTEMP - EQcab);
- mfcab = fTEMP;
- //mfcab+=EQcab+(delta0+c1o2*(deltacbb+deltabab));
-
- EQacb += (delta0 + c1o2*(deltaabb + deltabcb));
- fTEMP = mfacb + EQacb;
- real deltaacb = mfacb - (fTEMP - EQacb);
- mfacb = fTEMP;
- //mfacb+=EQacb+(delta0+c1o2*(deltaabb+deltabcb));
-
- EQcbc += (delta0 + c1o2*(deltacbb + deltabbc));
- fTEMP = mfcbc + EQcbc;
- real deltacbc = mfcbc - (fTEMP - EQcbc);
- mfcbc = fTEMP;
- //mfcbc+=EQcbc+(delta0+c1o2*(deltacbb+deltabbc));
-
- EQaba += (delta0 + c1o2*(deltaabb + deltabba));
- fTEMP = mfaba + EQaba;
- real deltaaba = mfaba - (fTEMP - EQaba);
- mfaba = fTEMP;
- //mfaba+=EQaba+(delta0+c1o2*(deltaabb+deltabba));
-
- EQcba += (delta0 + c1o2*(deltacbb + deltabba));
- fTEMP = mfcba + EQcba;
- real deltacba = mfcba - (fTEMP - EQcba);
- mfcba = fTEMP;
- //mfcba+=EQcba+(delta0+c1o2*(deltacbb+deltabba));
-
- EQabc += (delta0 + c1o2*(deltaabb + deltabbc));
- fTEMP = mfabc + EQabc;
- real deltaabc = mfabc - (fTEMP - EQabc);
- mfabc = fTEMP;
- //mfabc+=EQabc+(delta0+c1o2*(deltaabb+deltabbc));
-
- EQbcc += (delta0 + c1o2*(deltabcb + deltabbc));
- fTEMP = mfbcc + EQbcc;
- real deltabcc = mfbcc - (fTEMP - EQbcc);
- mfbcc = fTEMP;
- //mfbcc+=EQbcc+(delta0+c1o2*(deltabcb+deltabbc));
-
- EQbaa += (delta0 + c1o2*(deltabab + deltabba));
- fTEMP = mfbaa + EQbaa;
- real deltabaa = mfbaa - (fTEMP - EQbaa);
- mfbaa = fTEMP;
- //mfbaa+=EQbaa+(delta0+c1o2*(deltabab+deltabba));
-
- EQbca += (delta0 + c1o2*(deltabcb + deltabba));
- fTEMP = mfbca + EQbca;
- real deltabca = mfbca - (fTEMP - EQbca);
- mfbca = fTEMP;
- //mfbca+=EQbca+(delta0+c1o2*(deltabcb+deltabba));
-
- EQbac += (delta0 + c1o2*(deltabab + deltabbc));
- fTEMP = mfbac + EQbac;
- real deltabac = mfbac - (fTEMP - EQbac);
- mfbac = fTEMP;
- //mfbac+=EQbac+(delta0+c1o2*(deltabab+deltabbc));
-
- mfccc += EQccc - (delta0 + c1o4*(deltacbb + deltabcb + deltabbc) - c1o2*(deltabcc + deltacbc + deltaccb));
- mfaac += EQaac - (delta0 + c1o4*(deltaabb + deltabab + deltabbc) - c1o2*(deltabac + deltaabc + deltaaab));
- mfcac += EQcac - (delta0 + c1o4*(deltacbb + deltabab + deltabbc) - c1o2*(deltabac + deltacbc + deltacab));
- mfacc += EQacc - (delta0 + c1o4*(deltaabb + deltabcb + deltabbc) - c1o2*(deltabcc + deltaabc + deltaacb));
- mfcca += EQcca - (delta0 + c1o4*(deltacbb + deltabcb + deltabba) - c1o2*(deltabca + deltacba + deltaccb));
- mfaaa += EQaaa - (delta0 + c1o4*(deltaabb + deltabab + deltabba) - c1o2*(deltabaa + deltaaba + deltaaab));
- mfcaa += EQcaa - (delta0 + c1o4*(deltacbb + deltabab + deltabba) - c1o2*(deltabaa + deltacba + deltacab));
- mfaca += EQaca - (delta0 + c1o4*(deltaabb + deltabcb + deltabba) - c1o2*(deltabca + deltaaba + deltaacb));
-
-
-
- //////////////////////////////////////////////////////////////////////////////////////
- ////back
- //////////////////////////////////////////////////////////////////////////////////////
- ////mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Z - Dir
- //backwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, one);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o3);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- ////mit 1/6, 2/3, 1/6, 0, 0, 0, 1/18, 2/9, 1/18 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Y - Dir
- //backwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaab, mfabb, mfacb, vvy, vy2, c2o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbaa, mfbba, mfbca, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbab, mfbbb, mfbcb, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbac, mfbbc, mfbcc, vvz, vz2);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o18);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcab, mfcbb, mfccb, vvy, vy2, c2o9);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- ////mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// X - Dir
- //backwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaba, mfbba, mfcba, vvx, vx2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaab, mfbab, mfcab, vvx, vx2, c1o9);
- /////////////b////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfabb, mfbbb, mfcbb, vvx, vx2, c4o9);
- /////////////b////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfacb, mfbcb, mfccb, vvx, vx2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o36);
- /////////////c////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfabc, mfbbc, mfcbc, vvx, vx2, c1o9);
- /////////////c////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
-
- ////////////////////////////////////////////////////////////////////////////////////////
- //real drhoPost =
- // ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
- // (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
- // ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
- //mfbbb += drho - drhoPost;
- ////////////////////////////////////////////////////////////////////////////////////
- (D.f[dirE])[k] = mfabb;//(D.f[ dirE ])[ke ] = mfabb;// - c2over27 ; (D.f[ dirE ])[k ]
- (D.f[dirW])[kw] = mfcbb;//(D.f[ dirW ])[kw ] = mfcbb;// - c2over27 ; (D.f[ dirW ])[kw ]
- (D.f[dirN])[k] = mfbab;//(D.f[ dirN ])[kn ] = mfbab;// - c2over27 ; (D.f[ dirN ])[k ]
- (D.f[dirS])[ks] = mfbcb;//(D.f[ dirS ])[ks ] = mfbcb;// - c2over27 ; (D.f[ dirS ])[ks ]
- (D.f[dirT])[k] = mfbba;//(D.f[ dirT ])[kt ] = mfbba;// - c2over27 ; (D.f[ dirT ])[k ]
- (D.f[dirB])[kb] = mfbbc;//(D.f[ dirB ])[kb ] = mfbbc;// - c2over27 ; (D.f[ dirB ])[kb ]
- (D.f[dirNE])[k] = mfaab;//(D.f[ dirNE ])[kne ] = mfaab;// - c1over54 ; (D.f[ dirNE ])[k ]
- (D.f[dirSW])[ksw] = mfccb;//(D.f[ dirSW ])[ksw ] = mfccb;// - c1over54 ; (D.f[ dirSW ])[ksw ]
- (D.f[dirSE])[ks] = mfacb;//(D.f[ dirSE ])[kse ] = mfacb;// - c1over54 ; (D.f[ dirSE ])[ks ]
- (D.f[dirNW])[kw] = mfcab;//(D.f[ dirNW ])[knw ] = mfcab;// - c1over54 ; (D.f[ dirNW ])[kw ]
- (D.f[dirTE])[k] = mfaba;//(D.f[ dirTE ])[kte ] = mfaba;// - c1over54 ; (D.f[ dirTE ])[k ]
- (D.f[dirBW])[kbw] = mfcbc;//(D.f[ dirBW ])[kbw ] = mfcbc;// - c1over54 ; (D.f[ dirBW ])[kbw ]
- (D.f[dirBE])[kb] = mfabc;//(D.f[ dirBE ])[kbe ] = mfabc;// - c1over54 ; (D.f[ dirBE ])[kb ]
- (D.f[dirTW])[kw] = mfcba;//(D.f[ dirTW ])[ktw ] = mfcba;// - c1over54 ; (D.f[ dirTW ])[kw ]
- (D.f[dirTN])[k] = mfbaa;//(D.f[ dirTN ])[ktn ] = mfbaa;// - c1over54 ; (D.f[ dirTN ])[k ]
- (D.f[dirBS])[kbs] = mfbcc;//(D.f[ dirBS ])[kbs ] = mfbcc;// - c1over54 ; (D.f[ dirBS ])[kbs ]
- (D.f[dirBN])[kb] = mfbac;//(D.f[ dirBN ])[kbn ] = mfbac;// - c1over54 ; (D.f[ dirBN ])[kb ]
- (D.f[dirTS])[ks] = mfbca;//(D.f[ dirTS ])[kts ] = mfbca;// - c1over54 ; (D.f[ dirTS ])[ks ]
- (D.f[dirZERO])[k] = mfbbb;//(D.f[ dirZERO])[kzero] = mfbbb;// - c8over27 ; (D.f[ dirZERO])[k ]
- (D.f[dirTNE])[k] = mfaaa;//(D.f[ dirTNE ])[ktne ] = mfaaa;// - c1over216; (D.f[ dirTNE ])[k ]
- (D.f[dirTSE])[ks] = mfaca;//(D.f[ dirTSE ])[ktse ] = mfaca;// - c1over216; (D.f[ dirTSE ])[ks ]
- (D.f[dirBNE])[kb] = mfaac;//(D.f[ dirBNE ])[kbne ] = mfaac;// - c1over216; (D.f[ dirBNE ])[kb ]
- (D.f[dirBSE])[kbs] = mfacc;//(D.f[ dirBSE ])[kbse ] = mfacc;// - c1over216; (D.f[ dirBSE ])[kbs ]
- (D.f[dirTNW])[kw] = mfcaa;//(D.f[ dirTNW ])[ktnw ] = mfcaa;// - c1over216; (D.f[ dirTNW ])[kw ]
- (D.f[dirTSW])[ksw] = mfcca;//(D.f[ dirTSW ])[ktsw ] = mfcca;// - c1over216; (D.f[ dirTSW ])[ksw ]
- (D.f[dirBNW])[kbw] = mfcac;//(D.f[ dirBNW ])[kbnw ] = mfcac;// - c1over216; (D.f[ dirBNW ])[kbw ]
- (D.f[dirBSW])[kbsw] = mfccc;//(D.f[ dirBSW ])[kbsw ] = mfccc;// - c1over216; (D.f[ dirBSW ])[kbsw]
- ////////////////////////////////////////////////////////////////////////////////////
- }
- }
+ ////////////////////////////////////////////////////////////////////////////////
+ const unsigned x = threadIdx.x; // Globaler x-Index
+ const unsigned y = blockIdx.x; // Globaler y-Index
+ const unsigned z = blockIdx.y; // Globaler z-Index
+
+ const unsigned nx = blockDim.x;
+ const unsigned ny = gridDim.x;
+
+ const unsigned k = nx*(ny*z + y) + x;
+ //////////////////////////////////////////////////////////////////////////
+
+ if (k<size_Mat)
+ {
+ ////////////////////////////////////////////////////////////////////////////////
+ unsigned int BC;
+ BC = bcMatD[k];
+
+ if (BC >= GEO_FLUID/*(BC != GEO_SOLID) && (BC != GEO_VOID)*/)
+ {
+ Distributions27 D;
+ if (EvenOrOdd == true)
+ {
+ D.f[dirE] = &DDStart[dirE *size_Mat];
+ D.f[dirW] = &DDStart[dirW *size_Mat];
+ D.f[dirN] = &DDStart[dirN *size_Mat];
+ D.f[dirS] = &DDStart[dirS *size_Mat];
+ D.f[dirT] = &DDStart[dirT *size_Mat];
+ D.f[dirB] = &DDStart[dirB *size_Mat];
+ D.f[dirNE] = &DDStart[dirNE *size_Mat];
+ D.f[dirSW] = &DDStart[dirSW *size_Mat];
+ D.f[dirSE] = &DDStart[dirSE *size_Mat];
+ D.f[dirNW] = &DDStart[dirNW *size_Mat];
+ D.f[dirTE] = &DDStart[dirTE *size_Mat];
+ D.f[dirBW] = &DDStart[dirBW *size_Mat];
+ D.f[dirBE] = &DDStart[dirBE *size_Mat];
+ D.f[dirTW] = &DDStart[dirTW *size_Mat];
+ D.f[dirTN] = &DDStart[dirTN *size_Mat];
+ D.f[dirBS] = &DDStart[dirBS *size_Mat];
+ D.f[dirBN] = &DDStart[dirBN *size_Mat];
+ D.f[dirTS] = &DDStart[dirTS *size_Mat];
+ D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
+ D.f[dirTNE] = &DDStart[dirTNE *size_Mat];
+ D.f[dirTSW] = &DDStart[dirTSW *size_Mat];
+ D.f[dirTSE] = &DDStart[dirTSE *size_Mat];
+ D.f[dirTNW] = &DDStart[dirTNW *size_Mat];
+ D.f[dirBNE] = &DDStart[dirBNE *size_Mat];
+ D.f[dirBSW] = &DDStart[dirBSW *size_Mat];
+ D.f[dirBSE] = &DDStart[dirBSE *size_Mat];
+ D.f[dirBNW] = &DDStart[dirBNW *size_Mat];
+ }
+ else
+ {
+ D.f[dirW] = &DDStart[dirE *size_Mat];
+ D.f[dirE] = &DDStart[dirW *size_Mat];
+ D.f[dirS] = &DDStart[dirN *size_Mat];
+ D.f[dirN] = &DDStart[dirS *size_Mat];
+ D.f[dirB] = &DDStart[dirT *size_Mat];
+ D.f[dirT] = &DDStart[dirB *size_Mat];
+ D.f[dirSW] = &DDStart[dirNE *size_Mat];
+ D.f[dirNE] = &DDStart[dirSW *size_Mat];
+ D.f[dirNW] = &DDStart[dirSE *size_Mat];
+ D.f[dirSE] = &DDStart[dirNW *size_Mat];
+ D.f[dirBW] = &DDStart[dirTE *size_Mat];
+ D.f[dirTE] = &DDStart[dirBW *size_Mat];
+ D.f[dirTW] = &DDStart[dirBE *size_Mat];
+ D.f[dirBE] = &DDStart[dirTW *size_Mat];
+ D.f[dirBS] = &DDStart[dirTN *size_Mat];
+ D.f[dirTN] = &DDStart[dirBS *size_Mat];
+ D.f[dirTS] = &DDStart[dirBN *size_Mat];
+ D.f[dirBN] = &DDStart[dirTS *size_Mat];
+ D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
+ D.f[dirBSW] = &DDStart[dirTNE *size_Mat];
+ D.f[dirBNE] = &DDStart[dirTSW *size_Mat];
+ D.f[dirBNW] = &DDStart[dirTSE *size_Mat];
+ D.f[dirBSE] = &DDStart[dirTNW *size_Mat];
+ D.f[dirTSW] = &DDStart[dirBNE *size_Mat];
+ D.f[dirTNE] = &DDStart[dirBSW *size_Mat];
+ D.f[dirTNW] = &DDStart[dirBSE *size_Mat];
+ D.f[dirTSE] = &DDStart[dirBNW *size_Mat];
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ //index
+ //unsigned int kzero= k;
+ //unsigned int ke = k;
+ unsigned int kw = neighborX[k];
+ //unsigned int kn = k;
+ unsigned int ks = neighborY[k];
+ //unsigned int kt = k;
+ unsigned int kb = neighborZ[k];
+ unsigned int ksw = neighborY[kw];
+ //unsigned int kne = k;
+ //unsigned int kse = ks;
+ //unsigned int knw = kw;
+ unsigned int kbw = neighborZ[kw];
+ //unsigned int kte = k;
+ //unsigned int kbe = kb;
+ //unsigned int ktw = kw;
+ unsigned int kbs = neighborZ[ks];
+ //unsigned int ktn = k;
+ //unsigned int kbn = kb;
+ //unsigned int kts = ks;
+ //unsigned int ktse = ks;
+ //unsigned int kbnw = kbw;
+ //unsigned int ktnw = kw;
+ //unsigned int kbse = kbs;
+ //unsigned int ktsw = ksw;
+ //unsigned int kbne = kb;
+ //unsigned int ktne = k;
+ unsigned int kbsw = neighborZ[ksw];
+
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ real mfcbb = (D.f[dirE])[k];//[ke ];// + c2over27 ;(D.f[dirE ])[k ];//ke
+ real mfabb = (D.f[dirW])[kw];//[kw ];// + c2over27 ;(D.f[dirW ])[kw ];
+ real mfbcb = (D.f[dirN])[k];//[kn ];// + c2over27 ;(D.f[dirN ])[k ];//kn
+ real mfbab = (D.f[dirS])[ks];//[ks ];// + c2over27 ;(D.f[dirS ])[ks ];
+ real mfbbc = (D.f[dirT])[k];//[kt ];// + c2over27 ;(D.f[dirT ])[k ];//kt
+ real mfbba = (D.f[dirB])[kb];//[kb ];// + c2over27 ;(D.f[dirB ])[kb ];
+ real mfccb = (D.f[dirNE])[k];//[kne ];// + c1over54 ;(D.f[dirNE ])[k ];//kne
+ real mfaab = (D.f[dirSW])[ksw];//[ksw ];// + c1over54 ;(D.f[dirSW ])[ksw];
+ real mfcab = (D.f[dirSE])[ks];//[kse ];// + c1over54 ;(D.f[dirSE ])[ks ];//kse
+ real mfacb = (D.f[dirNW])[kw];//[knw ];// + c1over54 ;(D.f[dirNW ])[kw ];//knw
+ real mfcbc = (D.f[dirTE])[k];//[kte ];// + c1over54 ;(D.f[dirTE ])[k ];//kte
+ real mfaba = (D.f[dirBW])[kbw];//[kbw ];// + c1over54 ;(D.f[dirBW ])[kbw];
+ real mfcba = (D.f[dirBE])[kb];//[kbe ];// + c1over54 ;(D.f[dirBE ])[kb ];//kbe
+ real mfabc = (D.f[dirTW])[kw];//[ktw ];// + c1over54 ;(D.f[dirTW ])[kw ];//ktw
+ real mfbcc = (D.f[dirTN])[k];//[ktn ];// + c1over54 ;(D.f[dirTN ])[k ];//ktn
+ real mfbaa = (D.f[dirBS])[kbs];//[kbs ];// + c1over54 ;(D.f[dirBS ])[kbs];
+ real mfbca = (D.f[dirBN])[kb];//[kbn ];// + c1over54 ;(D.f[dirBN ])[kb ];//kbn
+ real mfbac = (D.f[dirTS])[ks];//[kts ];// + c1over54 ;(D.f[dirTS ])[ks ];//kts
+ real mfbbb = (D.f[dirZERO])[k];//[kzero];// + c8over27 ;(D.f[dirZERO])[k ];//kzero
+ real mfccc = (D.f[dirTNE])[k];//[ktne ];// + c1over216;(D.f[dirTNE ])[k ];//ktne
+ real mfaac = (D.f[dirTSW])[ksw];//[ktsw ];// + c1over216;(D.f[dirTSW ])[ksw];//ktsw
+ real mfcac = (D.f[dirTSE])[ks];//[ktse ];// + c1over216;(D.f[dirTSE ])[ks ];//ktse
+ real mfacc = (D.f[dirTNW])[kw];//[ktnw ];// + c1over216;(D.f[dirTNW ])[kw ];//ktnw
+ real mfcca = (D.f[dirBNE])[kb];//[kbne ];// + c1over216;(D.f[dirBNE ])[kb ];//kbne
+ real mfaaa = (D.f[dirBSW])[kbsw];//[kbsw ];// + c1over216;(D.f[dirBSW ])[kbsw];
+ real mfcaa = (D.f[dirBSE])[kbs];//[kbse ];// + c1over216;(D.f[dirBSE ])[kbs];//kbse
+ real mfaca = (D.f[dirBNW])[kbw];//[kbnw ];// + c1over216;(D.f[dirBNW ])[kbw];//kbnw
+ ////////////////////////////////////////////////////////////////////////////////////
+ real drho = ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
+ (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
+ ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
+
+ real rho = c1o1 + drho;
+ ////////////////////////////////////////////////////////////////////////////////////
+ real vvx = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfcaa - mfacc) + (mfcca - mfaac))) +
+ (((mfcba - mfabc) + (mfcbc - mfaba)) + ((mfcab - mfacb) + (mfccb - mfaab))) +
+ (mfcbb - mfabb)) / rho;
+ real vvy = ((((mfccc - mfaaa) + (mfaca - mfcac)) + ((mfacc - mfcaa) + (mfcca - mfaac))) +
+ (((mfbca - mfbac) + (mfbcc - mfbaa)) + ((mfacb - mfcab) + (mfccb - mfaab))) +
+ (mfbcb - mfbab)) / rho;
+ real vvz = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfacc - mfcaa) + (mfaac - mfcca))) +
+ (((mfbac - mfbca) + (mfbcc - mfbaa)) + ((mfabc - mfcba) + (mfcbc - mfaba))) +
+ (mfbbc - mfbba)) / rho;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //the force be with you
+ real fx = forces[0] / (pow((double)c2o1, (double)level)); //zero;//0.0032653/(pow(two,level)); //0.000000005;//(two/1600000.0) / 120.0; //
+ real fy = forces[1] / (pow((double)c2o1, (double)level)); //zero;
+ real fz = forces[2] / (pow((double)c2o1, (double)level)); //zero;
+ vvx += fx*c1o2;
+ vvy += fy*c1o2;
+ vvz += fz*c1o2;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //real omega = omega_in;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //fast
+ //real oMdrho = c1o1; // comp special
+ //real m0, m1, m2;
+ real vx2;
+ real vy2;
+ real vz2;
+ vx2 = vvx*vvx;
+ vy2 = vvy*vvy;
+ vz2 = vvz*vvz;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //real wadjust;
+ //real qudricLimitP = c1o100;// * 0.0001f;
+ //real qudricLimitM = c1o100;// * 0.0001f;
+ //real qudricLimitD = c1o100;// * 0.001f;
+ //real s9 = minusomega;
+ //test
+ //s9 = 0.;
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ real EQcbb = c0o1;
+ real EQabb = c0o1;
+ real EQbcb = c0o1;
+ real EQbab = c0o1;
+ real EQbbc = c0o1;
+ real EQbba = c0o1;
+ real EQccb = c0o1;
+ real EQaab = c0o1;
+ real EQcab = c0o1;
+ real EQacb = c0o1;
+ real EQcbc = c0o1;
+ real EQaba = c0o1;
+ real EQcba = c0o1;
+ real EQabc = c0o1;
+ real EQbcc = c0o1;
+ real EQbaa = c0o1;
+ real EQbca = c0o1;
+ real EQbac = c0o1;
+ real EQbbb = c0o1;
+ real EQccc = drho * c1o27;
+ real EQaac = drho * c1o3;
+ real EQcac = drho * c1o9;
+ real EQacc = drho * c1o9;
+ real EQcca = drho * c1o9;
+ real EQaaa = drho;
+ real EQcaa = drho * c1o3;
+ real EQaca = drho * c1o3;
+ ////////////////////////////////////////////////////////////////////////////////////
+ vf::lbm::backwardChimeraWithK(EQaaa, EQaab, EQaac, vvz, vz2, c1o1);
+ vf::lbm::backwardChimeraWithK(EQaca, EQacb, EQacc, vvz, vz2, c1o3);
+ ///////////////////////////////////////////////////////////
+ EQcaa = EQaca; EQcab = EQacb; EQcac = EQacc;
+ ///////////////////////////////////////////////////////////
+ vf::lbm::backwardChimeraWithK(EQcca, EQccb, EQccc, vvz, vz2, c1o9);
+
+ vf::lbm::backwardChimeraWithK(EQaaa, EQaba, EQaca, vvy, vy2, c1o6);
+ vf::lbm::backwardChimeraWithK(EQaab, EQabb, EQacb, vvy, vy2, c2o3);
+ vf::lbm::backwardChimeraWithK(EQaac, EQabc, EQacc, vvy, vy2, c1o6);
+ vf::lbm::backwardChimeraWithK(EQcaa, EQcba, EQcca, vvy, vy2, c1o18);
+ vf::lbm::backwardChimeraWithK(EQcab, EQcbb, EQccb, vvy, vy2, c2o9);
+ vf::lbm::backwardChimeraWithK(EQcac, EQcbc, EQccc, vvy, vy2, c1o18);
+
+ vf::lbm::backwardChimeraWithK(EQaaa, EQbaa, EQcaa, vvx, vx2, c1o36);
+ vf::lbm::backwardChimeraWithK(EQaab, EQbab, EQcab, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQaac, EQbac, EQcac, vvx, vx2, c1o36);
+ vf::lbm::backwardChimeraWithK(EQaba, EQbba, EQcba, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQabb, EQbbb, EQcbb, vvx, vx2, c4o9);
+ vf::lbm::backwardChimeraWithK(EQabc, EQbbc, EQcbc, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQaca, EQbca, EQcca, vvx, vx2, c1o36);
+ vf::lbm::backwardChimeraWithK(EQacb, EQbcb, EQccb, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQacc, EQbcc, EQccc, vvx, vx2, c1o36);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //Pre-condition
+ mfcbb -= EQcbb;
+ mfabb -= EQabb;
+ mfbcb -= EQbcb;
+ mfbab -= EQbab;
+ mfbbc -= EQbbc;
+ mfbba -= EQbba;
+ mfccb -= EQccb;
+ mfaab -= EQaab;
+ mfcab -= EQcab;
+ mfacb -= EQacb;
+ mfcbc -= EQcbc;
+ mfaba -= EQaba;
+ mfcba -= EQcba;
+ mfabc -= EQabc;
+ mfbcc -= EQbcc;
+ mfbaa -= EQbaa;
+ mfbca -= EQbca;
+ mfbac -= EQbac;
+ mfbbb -= EQbbb;
+ mfccc -= EQccc;
+ mfaac -= EQaac;
+ mfcac -= EQcac;
+ mfacc -= EQacc;
+ mfcca -= EQcca;
+ mfaaa -= EQaaa;
+ mfcaa -= EQcaa;
+ mfaca -= EQaca;
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //Hin
+ ////////////////////////////////////////////////////////////////////////////////////
+ vf::lbm::forwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
+ vf::lbm::forwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
+ vf::lbm::forwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
+ vf::lbm::forwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
+ vf::lbm::forwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
+ vf::lbm::forwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
+ vf::lbm::forwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
+ vf::lbm::forwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
+ vf::lbm::forwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
+
+ vf::lbm::forwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
+ vf::lbm::forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::forwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
+ vf::lbm::forwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
+ vf::lbm::forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::forwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
+ vf::lbm::forwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
+ vf::lbm::forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::forwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
+
+ vf::lbm::forwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
+ vf::lbm::forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::forwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
+ vf::lbm::forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::forwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
+ vf::lbm::forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::forwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
+
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////Hin
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Z - Dir
+ //forwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, c4o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// mit 1/6, 0, 1/18, 2/3, 0, 2/9, 1/6, 0, 1/18 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Y - Dir
+ //forwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o18);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, c2o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, c2o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// X - Dir
+ //forwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, one);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Cumulants
+ ////////////////////////////////////////////////////////////////////////////////////
+ real OxxPyyPzz = c1o1; //omega; // one; //set the bulk viscosity one is high / two is very low and zero is (too) high
+
+ ////////////////////////////////////////////////////////////
+ //3.
+ //////////////////////////////
+ real OxyyPxzz = c1o1;
+ real OxyyMxzz = c1o1;
+ //real Oxyz = c1o1;
+ ////////////////////////////////////////////////////////////
+ //4.
+ //////////////////////////////
+ real O4 = c1o1;
+ ////////////////////////////////////////////////////////////
+ //5.
+ //////////////////////////////
+ real O5 = c1o1;
+ ////////////////////////////////////////////////////////////
+ //6.
+ //////////////////////////////
+ real O6 = c1o1;
+ ////////////////////////////////////////////////////////////
+
+
+ //central moments to cumulants
+ //4.
+ real CUMcbb = mfcbb - ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
+ real CUMbcb = mfbcb - ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
+ real CUMbbc = mfbbc - ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
+
+ real CUMcca = mfcca - (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
+ real CUMcac = mfcac - (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
+ real CUMacc = mfacc - (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
+
+ //5.
+ real CUMbcc = mfbcc - ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
+ real CUMcbc = mfcbc - ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
+ real CUMccb = mfccb - ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
+
+ //6.
+
+ real CUMccc = mfccc + ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
+ - c1o3 * (mfacc + mfcac + mfcca) / rho
+ - c1o9 * (mfcaa + mfaca + mfaac) / rho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
+ + c1o27*((drho * drho - drho) / (rho*rho)));
+
+
+
+
+ //2.
+ // linear combinations
+ real mxxPyyPzz = mfcaa + mfaca + mfaac;
+ real mxxMyy = mfcaa - mfaca;
+ real mxxMzz = mfcaa - mfaac;
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //incl. correction (hat noch nicht so gut funktioniert...Optimierungsbedarf??)
+ {
+ real dxux = c1o2 * (-omega) *(mxxMyy + mxxMzz) + c1o2 * OxxPyyPzz * (mfaaa - mxxPyyPzz);
+ real dyuy = dxux + omega * c3o2 * mxxMyy;
+ real dzuz = dxux + omega * c3o2 * mxxMzz;
+
+ //relax
+ mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz) - c3o1 * (c1o1 - c1o2 * OxxPyyPzz) * (vx2 * dxux + vy2 * dyuy + vz2 * dzuz);//-magicBulk*OxxPyyPzz;
+ mxxMyy += omega * (-mxxMyy) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vy2 * dyuy);
+ mxxMzz += omega * (-mxxMzz) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vz2 * dzuz);
+
+ }
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////no correction
+ //mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz);//-magicBulk*OxxPyyPzz;
+ //mxxMyy += -(-omega) * (-mxxMyy);
+ //mxxMzz += -(-omega) * (-mxxMzz);
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ mfabb += omega * (-mfabb);
+ mfbab += omega * (-mfbab);
+ mfbba += omega * (-mfbba);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ // linear combinations back
+ mfcaa = c1o3 * (mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaca = c1o3 * (-c2o1* mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaac = c1o3 * (mxxMyy - c2o1* mxxMzz + mxxPyyPzz);
+
+ //3.
+ // linear combinations
+
+ real mxxyPyzz = mfcba + mfabc;
+ real mxxyMyzz = mfcba - mfabc;
+
+ real mxxzPyyz = mfcab + mfacb;
+ real mxxzMyyz = mfcab - mfacb;
+
+ real mxyyPxzz = mfbca + mfbac;
+ real mxyyMxzz = mfbca - mfbac;
+
+ //relax
+ //////////////////////////////////////////////////////////////////////////
+ mfbbb += OxyyMxzz * (-mfbbb);
+ mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
+ mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
+ mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
+ mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
+ mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
+ mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
+ //////////////////////////////////////////////////////////////////////////
+
+ mfcba = (mxxyMyzz + mxxyPyzz) * c1o2;
+ mfabc = (-mxxyMyzz + mxxyPyzz) * c1o2;
+ mfcab = (mxxzMyyz + mxxzPyyz) * c1o2;
+ mfacb = (-mxxzMyyz + mxxzPyyz) * c1o2;
+ mfbca = (mxyyMxzz + mxyyPxzz) * c1o2;
+ mfbac = (-mxyyMxzz + mxyyPxzz) * c1o2;
+
+ //4.
+ //////////////////////////////////////////////////////////////////////////
+ CUMacc += O4 * (-CUMacc);
+ CUMcac += O4 * (-CUMcac);
+ CUMcca += O4 * (-CUMcca);
+
+ CUMbbc += O4 * (-CUMbbc);
+ CUMbcb += O4 * (-CUMbcb);
+ CUMcbb += O4 * (-CUMcbb);
+ //////////////////////////////////////////////////////////////////////////
+
+
+ //5.
+ CUMbcc += O5 * (-CUMbcc);
+ CUMcbc += O5 * (-CUMcbc);
+ CUMccb += O5 * (-CUMccb);
+
+ //6.
+ CUMccc += O6 * (-CUMccc);
+
+
+
+ //back cumulants to central moments
+ //4.
+ mfcbb = CUMcbb + ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
+ mfbcb = CUMbcb + ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
+ mfbbc = CUMbbc + ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
+
+ mfcca = CUMcca + (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
+ mfcac = CUMcac + (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
+ mfacc = CUMacc + (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
+
+ //5.
+ mfbcc = CUMbcc + ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
+ mfcbc = CUMcbc + ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
+ mfccb = CUMccb + ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
+
+ //6.
+ mfccc = CUMccc - ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
+ - c1o3 * (mfacc + mfcac + mfcca) / rho
+ - c1o9 * (mfcaa + mfaca + mfaac) / rho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
+ + c1o27*((drho * drho - drho) / (rho*rho)));
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //the force be with you
+ mfbaa = -mfbaa;
+ mfaba = -mfaba;
+ mfaab = -mfaab;
+ ////////////////////////////////////////////////////////////////////////////////////
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //back
+ ////////////////////////////////////////////////////////////////////////////////////
+ vf::lbm::backwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
+ vf::lbm::backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
+ vf::lbm::backwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
+ vf::lbm::backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
+ vf::lbm::backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
+ vf::lbm::backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
+ vf::lbm::backwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
+ vf::lbm::backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
+ vf::lbm::backwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
+
+ vf::lbm::backwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
+ vf::lbm::backwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::backwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
+ vf::lbm::backwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
+ vf::lbm::backwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::backwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
+ vf::lbm::backwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
+ vf::lbm::backwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::backwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
+
+ vf::lbm::backwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
+ vf::lbm::backwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::backwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
+ vf::lbm::backwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::backwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::backwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::backwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
+ vf::lbm::backwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::backwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //mfcbb += EQcbb;
+ //mfabb += EQabb;
+ //mfbcb += EQbcb;
+ //mfbab += EQbab;
+ //mfbbc += EQbbc;
+ //mfbba += EQbba;
+ //mfccb += EQccb;
+ //mfaab += EQaab;
+ //mfcab += EQcab;
+ //mfacb += EQacb;
+ //mfcbc += EQcbc;
+ //mfaba += EQaba;
+ //mfcba += EQcba;
+ //mfabc += EQabc;
+ //mfbcc += EQbcc;
+ //mfbaa += EQbaa;
+ //mfbca += EQbca;
+ //mfbac += EQbac;
+ //mfbbb += EQbbb;
+ //mfccc += EQccc;
+ //mfaac += EQaac;
+ //mfcac += EQcac;
+ //mfacc += EQacc;
+ //mfcca += EQcca;
+ //mfaaa += EQaaa;
+ //mfcaa += EQcaa;
+ //mfaca += EQaca;
+ ////////////////////////////////////////////////////////////////////////////////////
+ ////Error diffusion
+ real fTEMP = mfbbb + EQbbb;
+ real delta0 = mfbbb - (fTEMP - EQbbb);
+ delta0 *= c1o4;
+ mfbbb = fTEMP;
+
+
+ fTEMP = mfcbb + EQcbb;
+ real deltacbb = mfcbb - (fTEMP - EQcbb);
+ mfcbb = fTEMP;
+ //mfcbb+=EQcbb;
+
+ fTEMP = mfabb + EQabb;
+ real deltaabb = mfabb - (fTEMP - EQabb);
+ mfabb = fTEMP;
+ //mfabb+=EQabb;
+
+ fTEMP = mfbcb + EQbcb;
+ real deltabcb = mfbcb - (fTEMP - EQbcb);
+ mfbcb = fTEMP;
+ //mfbcb+=EQbcb;
+
+ fTEMP = mfbab + EQbab;
+ real deltabab = mfbab - (fTEMP - EQbab);
+ mfbab = fTEMP;
+ //mfbab+=EQbab;
+
+ fTEMP = mfbbc + EQbbc;
+ real deltabbc = mfbbc - (fTEMP - EQbbc);
+ mfbbc = fTEMP;
+ //mfbbc+=EQbbc;
+
+ fTEMP = mfbba + EQbba;
+ real deltabba = mfbba - (fTEMP - EQbba);
+ mfbba = fTEMP;
+ //mfbba+=EQbba;
+
+ EQccb += (delta0 + c1o2*(deltacbb + deltabcb));
+ fTEMP = mfccb + EQccb;
+ real deltaccb = mfccb - (fTEMP - EQccb);
+ mfccb = fTEMP;
+ //mfccb+=EQccb+(delta0+c1o2*(deltacbb+deltabcb));
+
+ EQaab += (delta0 + c1o2*(deltaabb + deltabab));
+ fTEMP = mfaab + EQaab;
+ real deltaaab = mfaab - (fTEMP - EQaab);
+ mfaab = fTEMP;
+ //mfaab+=EQaab+(delta0+c1o2*(deltaabb+deltabab));
+
+ EQcab += (delta0 + c1o2*(deltacbb + deltabab));
+ fTEMP = mfcab + EQcab;
+ real deltacab = mfcab - (fTEMP - EQcab);
+ mfcab = fTEMP;
+ //mfcab+=EQcab+(delta0+c1o2*(deltacbb+deltabab));
+
+ EQacb += (delta0 + c1o2*(deltaabb + deltabcb));
+ fTEMP = mfacb + EQacb;
+ real deltaacb = mfacb - (fTEMP - EQacb);
+ mfacb = fTEMP;
+ //mfacb+=EQacb+(delta0+c1o2*(deltaabb+deltabcb));
+
+ EQcbc += (delta0 + c1o2*(deltacbb + deltabbc));
+ fTEMP = mfcbc + EQcbc;
+ real deltacbc = mfcbc - (fTEMP - EQcbc);
+ mfcbc = fTEMP;
+ //mfcbc+=EQcbc+(delta0+c1o2*(deltacbb+deltabbc));
+
+ EQaba += (delta0 + c1o2*(deltaabb + deltabba));
+ fTEMP = mfaba + EQaba;
+ real deltaaba = mfaba - (fTEMP - EQaba);
+ mfaba = fTEMP;
+ //mfaba+=EQaba+(delta0+c1o2*(deltaabb+deltabba));
+
+ EQcba += (delta0 + c1o2*(deltacbb + deltabba));
+ fTEMP = mfcba + EQcba;
+ real deltacba = mfcba - (fTEMP - EQcba);
+ mfcba = fTEMP;
+ //mfcba+=EQcba+(delta0+c1o2*(deltacbb+deltabba));
+
+ EQabc += (delta0 + c1o2*(deltaabb + deltabbc));
+ fTEMP = mfabc + EQabc;
+ real deltaabc = mfabc - (fTEMP - EQabc);
+ mfabc = fTEMP;
+ //mfabc+=EQabc+(delta0+c1o2*(deltaabb+deltabbc));
+
+ EQbcc += (delta0 + c1o2*(deltabcb + deltabbc));
+ fTEMP = mfbcc + EQbcc;
+ real deltabcc = mfbcc - (fTEMP - EQbcc);
+ mfbcc = fTEMP;
+ //mfbcc+=EQbcc+(delta0+c1o2*(deltabcb+deltabbc));
+
+ EQbaa += (delta0 + c1o2*(deltabab + deltabba));
+ fTEMP = mfbaa + EQbaa;
+ real deltabaa = mfbaa - (fTEMP - EQbaa);
+ mfbaa = fTEMP;
+ //mfbaa+=EQbaa+(delta0+c1o2*(deltabab+deltabba));
+
+ EQbca += (delta0 + c1o2*(deltabcb + deltabba));
+ fTEMP = mfbca + EQbca;
+ real deltabca = mfbca - (fTEMP - EQbca);
+ mfbca = fTEMP;
+ //mfbca+=EQbca+(delta0+c1o2*(deltabcb+deltabba));
+
+ EQbac += (delta0 + c1o2*(deltabab + deltabbc));
+ fTEMP = mfbac + EQbac;
+ real deltabac = mfbac - (fTEMP - EQbac);
+ mfbac = fTEMP;
+ //mfbac+=EQbac+(delta0+c1o2*(deltabab+deltabbc));
+
+ mfccc += EQccc - (delta0 + c1o4*(deltacbb + deltabcb + deltabbc) - c1o2*(deltabcc + deltacbc + deltaccb));
+ mfaac += EQaac - (delta0 + c1o4*(deltaabb + deltabab + deltabbc) - c1o2*(deltabac + deltaabc + deltaaab));
+ mfcac += EQcac - (delta0 + c1o4*(deltacbb + deltabab + deltabbc) - c1o2*(deltabac + deltacbc + deltacab));
+ mfacc += EQacc - (delta0 + c1o4*(deltaabb + deltabcb + deltabbc) - c1o2*(deltabcc + deltaabc + deltaacb));
+ mfcca += EQcca - (delta0 + c1o4*(deltacbb + deltabcb + deltabba) - c1o2*(deltabca + deltacba + deltaccb));
+ mfaaa += EQaaa - (delta0 + c1o4*(deltaabb + deltabab + deltabba) - c1o2*(deltabaa + deltaaba + deltaaab));
+ mfcaa += EQcaa - (delta0 + c1o4*(deltacbb + deltabab + deltabba) - c1o2*(deltabaa + deltacba + deltacab));
+ mfaca += EQaca - (delta0 + c1o4*(deltaabb + deltabcb + deltabba) - c1o2*(deltabca + deltaaba + deltaacb));
+
+
+
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////back
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Z - Dir
+ //backwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, one);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o3);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////mit 1/6, 2/3, 1/6, 0, 0, 0, 1/18, 2/9, 1/18 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Y - Dir
+ //backwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaab, mfabb, mfacb, vvy, vy2, c2o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbaa, mfbba, mfbca, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbab, mfbbb, mfbcb, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbac, mfbbc, mfbcc, vvz, vz2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o18);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcab, mfcbb, mfccb, vvy, vy2, c2o9);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// X - Dir
+ //backwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaba, mfbba, mfcba, vvx, vx2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaab, mfbab, mfcab, vvx, vx2, c1o9);
+ /////////////b////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfabb, mfbbb, mfcbb, vvx, vx2, c4o9);
+ /////////////b////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfacb, mfbcb, mfccb, vvx, vx2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o36);
+ /////////////c////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfabc, mfbbc, mfcbc, vvx, vx2, c1o9);
+ /////////////c////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+
+ ////////////////////////////////////////////////////////////////////////////////////////
+ //real drhoPost =
+ // ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
+ // (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
+ // ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
+ //mfbbb += drho - drhoPost;
+ ////////////////////////////////////////////////////////////////////////////////////
+ (D.f[dirE])[k] = mfabb;//(D.f[ dirE ])[ke ] = mfabb;// - c2over27 ; (D.f[ dirE ])[k ]
+ (D.f[dirW])[kw] = mfcbb;//(D.f[ dirW ])[kw ] = mfcbb;// - c2over27 ; (D.f[ dirW ])[kw ]
+ (D.f[dirN])[k] = mfbab;//(D.f[ dirN ])[kn ] = mfbab;// - c2over27 ; (D.f[ dirN ])[k ]
+ (D.f[dirS])[ks] = mfbcb;//(D.f[ dirS ])[ks ] = mfbcb;// - c2over27 ; (D.f[ dirS ])[ks ]
+ (D.f[dirT])[k] = mfbba;//(D.f[ dirT ])[kt ] = mfbba;// - c2over27 ; (D.f[ dirT ])[k ]
+ (D.f[dirB])[kb] = mfbbc;//(D.f[ dirB ])[kb ] = mfbbc;// - c2over27 ; (D.f[ dirB ])[kb ]
+ (D.f[dirNE])[k] = mfaab;//(D.f[ dirNE ])[kne ] = mfaab;// - c1over54 ; (D.f[ dirNE ])[k ]
+ (D.f[dirSW])[ksw] = mfccb;//(D.f[ dirSW ])[ksw ] = mfccb;// - c1over54 ; (D.f[ dirSW ])[ksw ]
+ (D.f[dirSE])[ks] = mfacb;//(D.f[ dirSE ])[kse ] = mfacb;// - c1over54 ; (D.f[ dirSE ])[ks ]
+ (D.f[dirNW])[kw] = mfcab;//(D.f[ dirNW ])[knw ] = mfcab;// - c1over54 ; (D.f[ dirNW ])[kw ]
+ (D.f[dirTE])[k] = mfaba;//(D.f[ dirTE ])[kte ] = mfaba;// - c1over54 ; (D.f[ dirTE ])[k ]
+ (D.f[dirBW])[kbw] = mfcbc;//(D.f[ dirBW ])[kbw ] = mfcbc;// - c1over54 ; (D.f[ dirBW ])[kbw ]
+ (D.f[dirBE])[kb] = mfabc;//(D.f[ dirBE ])[kbe ] = mfabc;// - c1over54 ; (D.f[ dirBE ])[kb ]
+ (D.f[dirTW])[kw] = mfcba;//(D.f[ dirTW ])[ktw ] = mfcba;// - c1over54 ; (D.f[ dirTW ])[kw ]
+ (D.f[dirTN])[k] = mfbaa;//(D.f[ dirTN ])[ktn ] = mfbaa;// - c1over54 ; (D.f[ dirTN ])[k ]
+ (D.f[dirBS])[kbs] = mfbcc;//(D.f[ dirBS ])[kbs ] = mfbcc;// - c1over54 ; (D.f[ dirBS ])[kbs ]
+ (D.f[dirBN])[kb] = mfbac;//(D.f[ dirBN ])[kbn ] = mfbac;// - c1over54 ; (D.f[ dirBN ])[kb ]
+ (D.f[dirTS])[ks] = mfbca;//(D.f[ dirTS ])[kts ] = mfbca;// - c1over54 ; (D.f[ dirTS ])[ks ]
+ (D.f[dirZERO])[k] = mfbbb;//(D.f[ dirZERO])[kzero] = mfbbb;// - c8over27 ; (D.f[ dirZERO])[k ]
+ (D.f[dirTNE])[k] = mfaaa;//(D.f[ dirTNE ])[ktne ] = mfaaa;// - c1over216; (D.f[ dirTNE ])[k ]
+ (D.f[dirTSE])[ks] = mfaca;//(D.f[ dirTSE ])[ktse ] = mfaca;// - c1over216; (D.f[ dirTSE ])[ks ]
+ (D.f[dirBNE])[kb] = mfaac;//(D.f[ dirBNE ])[kbne ] = mfaac;// - c1over216; (D.f[ dirBNE ])[kb ]
+ (D.f[dirBSE])[kbs] = mfacc;//(D.f[ dirBSE ])[kbse ] = mfacc;// - c1over216; (D.f[ dirBSE ])[kbs ]
+ (D.f[dirTNW])[kw] = mfcaa;//(D.f[ dirTNW ])[ktnw ] = mfcaa;// - c1over216; (D.f[ dirTNW ])[kw ]
+ (D.f[dirTSW])[ksw] = mfcca;//(D.f[ dirTSW ])[ktsw ] = mfcca;// - c1over216; (D.f[ dirTSW ])[ksw ]
+ (D.f[dirBNW])[kbw] = mfcac;//(D.f[ dirBNW ])[kbnw ] = mfcac;// - c1over216; (D.f[ dirBNW ])[kbw ]
+ (D.f[dirBSW])[kbsw] = mfccc;//(D.f[ dirBSW ])[kbsw ] = mfccc;// - c1over216; (D.f[ dirBSW ])[kbsw]
+ ////////////////////////////////////////////////////////////////////////////////////
+ }
+ }
}
////////////////////////////////////////////////////////////////////////////////
@@ -1002,758 +958,758 @@ extern "C" __global__ void Cumulant_One_preconditioned_errorDiffusion_chim_Comp_
////////////////////////////////////////////////////////////////////////////////
extern "C" __global__ void Cumulant_One_preconditioned_chim_Comp_SP_27(
- real omega,
- unsigned int* bcMatD,
- unsigned int* neighborX,
- unsigned int* neighborY,
- unsigned int* neighborZ,
- real* DDStart,
- int size_Mat,
- int level,
- real* forces,
- bool EvenOrOdd)
+ real omega,
+ unsigned int* bcMatD,
+ unsigned int* neighborX,
+ unsigned int* neighborY,
+ unsigned int* neighborZ,
+ real* DDStart,
+ int size_Mat,
+ int level,
+ real* forces,
+ bool EvenOrOdd)
{
- ////////////////////////////////////////////////////////////////////////////////
- const unsigned x = threadIdx.x; // Globaler x-Index
- const unsigned y = blockIdx.x; // Globaler y-Index
- const unsigned z = blockIdx.y; // Globaler z-Index
-
- const unsigned nx = blockDim.x;
- const unsigned ny = gridDim.x;
-
- const unsigned k = nx*(ny*z + y) + x;
- //////////////////////////////////////////////////////////////////////////
-
- if (k<size_Mat)
- {
- ////////////////////////////////////////////////////////////////////////////////
- unsigned int BC;
- BC = bcMatD[k];
-
- if (BC >= GEO_FLUID/*(BC != GEO_SOLID) && (BC != GEO_VOID)*/)
- {
- Distributions27 D;
- if (EvenOrOdd == true)
- {
- D.f[dirE] = &DDStart[dirE *size_Mat];
- D.f[dirW] = &DDStart[dirW *size_Mat];
- D.f[dirN] = &DDStart[dirN *size_Mat];
- D.f[dirS] = &DDStart[dirS *size_Mat];
- D.f[dirT] = &DDStart[dirT *size_Mat];
- D.f[dirB] = &DDStart[dirB *size_Mat];
- D.f[dirNE] = &DDStart[dirNE *size_Mat];
- D.f[dirSW] = &DDStart[dirSW *size_Mat];
- D.f[dirSE] = &DDStart[dirSE *size_Mat];
- D.f[dirNW] = &DDStart[dirNW *size_Mat];
- D.f[dirTE] = &DDStart[dirTE *size_Mat];
- D.f[dirBW] = &DDStart[dirBW *size_Mat];
- D.f[dirBE] = &DDStart[dirBE *size_Mat];
- D.f[dirTW] = &DDStart[dirTW *size_Mat];
- D.f[dirTN] = &DDStart[dirTN *size_Mat];
- D.f[dirBS] = &DDStart[dirBS *size_Mat];
- D.f[dirBN] = &DDStart[dirBN *size_Mat];
- D.f[dirTS] = &DDStart[dirTS *size_Mat];
- D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
- D.f[dirTNE] = &DDStart[dirTNE *size_Mat];
- D.f[dirTSW] = &DDStart[dirTSW *size_Mat];
- D.f[dirTSE] = &DDStart[dirTSE *size_Mat];
- D.f[dirTNW] = &DDStart[dirTNW *size_Mat];
- D.f[dirBNE] = &DDStart[dirBNE *size_Mat];
- D.f[dirBSW] = &DDStart[dirBSW *size_Mat];
- D.f[dirBSE] = &DDStart[dirBSE *size_Mat];
- D.f[dirBNW] = &DDStart[dirBNW *size_Mat];
- }
- else
- {
- D.f[dirW] = &DDStart[dirE *size_Mat];
- D.f[dirE] = &DDStart[dirW *size_Mat];
- D.f[dirS] = &DDStart[dirN *size_Mat];
- D.f[dirN] = &DDStart[dirS *size_Mat];
- D.f[dirB] = &DDStart[dirT *size_Mat];
- D.f[dirT] = &DDStart[dirB *size_Mat];
- D.f[dirSW] = &DDStart[dirNE *size_Mat];
- D.f[dirNE] = &DDStart[dirSW *size_Mat];
- D.f[dirNW] = &DDStart[dirSE *size_Mat];
- D.f[dirSE] = &DDStart[dirNW *size_Mat];
- D.f[dirBW] = &DDStart[dirTE *size_Mat];
- D.f[dirTE] = &DDStart[dirBW *size_Mat];
- D.f[dirTW] = &DDStart[dirBE *size_Mat];
- D.f[dirBE] = &DDStart[dirTW *size_Mat];
- D.f[dirBS] = &DDStart[dirTN *size_Mat];
- D.f[dirTN] = &DDStart[dirBS *size_Mat];
- D.f[dirTS] = &DDStart[dirBN *size_Mat];
- D.f[dirBN] = &DDStart[dirTS *size_Mat];
- D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
- D.f[dirBSW] = &DDStart[dirTNE *size_Mat];
- D.f[dirBNE] = &DDStart[dirTSW *size_Mat];
- D.f[dirBNW] = &DDStart[dirTSE *size_Mat];
- D.f[dirBSE] = &DDStart[dirTNW *size_Mat];
- D.f[dirTSW] = &DDStart[dirBNE *size_Mat];
- D.f[dirTNE] = &DDStart[dirBSW *size_Mat];
- D.f[dirTNW] = &DDStart[dirBSE *size_Mat];
- D.f[dirTSE] = &DDStart[dirBNW *size_Mat];
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- //index
- //unsigned int kzero= k;
- //unsigned int ke = k;
- unsigned int kw = neighborX[k];
- //unsigned int kn = k;
- unsigned int ks = neighborY[k];
- //unsigned int kt = k;
- unsigned int kb = neighborZ[k];
- unsigned int ksw = neighborY[kw];
- //unsigned int kne = k;
- //unsigned int kse = ks;
- //unsigned int knw = kw;
- unsigned int kbw = neighborZ[kw];
- //unsigned int kte = k;
- //unsigned int kbe = kb;
- //unsigned int ktw = kw;
- unsigned int kbs = neighborZ[ks];
- //unsigned int ktn = k;
- //unsigned int kbn = kb;
- //unsigned int kts = ks;
- //unsigned int ktse = ks;
- //unsigned int kbnw = kbw;
- //unsigned int ktnw = kw;
- //unsigned int kbse = kbs;
- //unsigned int ktsw = ksw;
- //unsigned int kbne = kb;
- //unsigned int ktne = k;
- unsigned int kbsw = neighborZ[ksw];
-
-
-
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- real mfcbb = (D.f[dirE])[k];//[ke ];// + c2over27 ;(D.f[dirE ])[k ];//ke
- real mfabb = (D.f[dirW])[kw];//[kw ];// + c2over27 ;(D.f[dirW ])[kw ];
- real mfbcb = (D.f[dirN])[k];//[kn ];// + c2over27 ;(D.f[dirN ])[k ];//kn
- real mfbab = (D.f[dirS])[ks];//[ks ];// + c2over27 ;(D.f[dirS ])[ks ];
- real mfbbc = (D.f[dirT])[k];//[kt ];// + c2over27 ;(D.f[dirT ])[k ];//kt
- real mfbba = (D.f[dirB])[kb];//[kb ];// + c2over27 ;(D.f[dirB ])[kb ];
- real mfccb = (D.f[dirNE])[k];//[kne ];// + c1over54 ;(D.f[dirNE ])[k ];//kne
- real mfaab = (D.f[dirSW])[ksw];//[ksw ];// + c1over54 ;(D.f[dirSW ])[ksw];
- real mfcab = (D.f[dirSE])[ks];//[kse ];// + c1over54 ;(D.f[dirSE ])[ks ];//kse
- real mfacb = (D.f[dirNW])[kw];//[knw ];// + c1over54 ;(D.f[dirNW ])[kw ];//knw
- real mfcbc = (D.f[dirTE])[k];//[kte ];// + c1over54 ;(D.f[dirTE ])[k ];//kte
- real mfaba = (D.f[dirBW])[kbw];//[kbw ];// + c1over54 ;(D.f[dirBW ])[kbw];
- real mfcba = (D.f[dirBE])[kb];//[kbe ];// + c1over54 ;(D.f[dirBE ])[kb ];//kbe
- real mfabc = (D.f[dirTW])[kw];//[ktw ];// + c1over54 ;(D.f[dirTW ])[kw ];//ktw
- real mfbcc = (D.f[dirTN])[k];//[ktn ];// + c1over54 ;(D.f[dirTN ])[k ];//ktn
- real mfbaa = (D.f[dirBS])[kbs];//[kbs ];// + c1over54 ;(D.f[dirBS ])[kbs];
- real mfbca = (D.f[dirBN])[kb];//[kbn ];// + c1over54 ;(D.f[dirBN ])[kb ];//kbn
- real mfbac = (D.f[dirTS])[ks];//[kts ];// + c1over54 ;(D.f[dirTS ])[ks ];//kts
- real mfbbb = (D.f[dirZERO])[k];//[kzero];// + c8over27 ;(D.f[dirZERO])[k ];//kzero
- real mfccc = (D.f[dirTNE])[k];//[ktne ];// + c1over216;(D.f[dirTNE ])[k ];//ktne
- real mfaac = (D.f[dirTSW])[ksw];//[ktsw ];// + c1over216;(D.f[dirTSW ])[ksw];//ktsw
- real mfcac = (D.f[dirTSE])[ks];//[ktse ];// + c1over216;(D.f[dirTSE ])[ks ];//ktse
- real mfacc = (D.f[dirTNW])[kw];//[ktnw ];// + c1over216;(D.f[dirTNW ])[kw ];//ktnw
- real mfcca = (D.f[dirBNE])[kb];//[kbne ];// + c1over216;(D.f[dirBNE ])[kb ];//kbne
- real mfaaa = (D.f[dirBSW])[kbsw];//[kbsw ];// + c1over216;(D.f[dirBSW ])[kbsw];
- real mfcaa = (D.f[dirBSE])[kbs];//[kbse ];// + c1over216;(D.f[dirBSE ])[kbs];//kbse
- real mfaca = (D.f[dirBNW])[kbw];//[kbnw ];// + c1over216;(D.f[dirBNW ])[kbw];//kbnw
- ////////////////////////////////////////////////////////////////////////////////////
- real drho = ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
- (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
- ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
-
- real rho = c1o1 + drho;
- ////////////////////////////////////////////////////////////////////////////////////
- real vvx = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfcaa - mfacc) + (mfcca - mfaac))) +
- (((mfcba - mfabc) + (mfcbc - mfaba)) + ((mfcab - mfacb) + (mfccb - mfaab))) +
- (mfcbb - mfabb)) / rho;
- real vvy = ((((mfccc - mfaaa) + (mfaca - mfcac)) + ((mfacc - mfcaa) + (mfcca - mfaac))) +
- (((mfbca - mfbac) + (mfbcc - mfbaa)) + ((mfacb - mfcab) + (mfccb - mfaab))) +
- (mfbcb - mfbab)) / rho;
- real vvz = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfacc - mfcaa) + (mfaac - mfcca))) +
- (((mfbac - mfbca) + (mfbcc - mfbaa)) + ((mfabc - mfcba) + (mfcbc - mfaba))) +
- (mfbbc - mfbba)) / rho;
- ////////////////////////////////////////////////////////////////////////////////////
- //the force be with you
- real fx = forces[0] / (pow((double)c2o1, (double)level)); //zero;//0.0032653/(pow(two,level)); //0.000000005;//(two/1600000.0) / 120.0; //
- real fy = forces[1] / (pow((double)c2o1, (double)level)); //zero;
- real fz = forces[2] / (pow((double)c2o1, (double)level)); //zero;
- vvx += fx*c1o2;
- vvy += fy*c1o2;
- vvz += fz*c1o2;
- ////////////////////////////////////////////////////////////////////////////////////
- //real omega = omega_in;
- ////////////////////////////////////////////////////////////////////////////////////
- //fast
- //real oMdrho = c1o1; // comp special
- //real m0, m1, m2;
- real vx2;
- real vy2;
- real vz2;
- vx2 = vvx*vvx;
- vy2 = vvy*vvy;
- vz2 = vvz*vvz;
- ////////////////////////////////////////////////////////////////////////////////////
- //real wadjust;
- //real qudricLimitP = c1o100;// * 0.0001f;
- //real qudricLimitM = c1o100;// * 0.0001f;
- //real qudricLimitD = c1o100;// * 0.001f;
- //real s9 = minusomega;
- //test
- //s9 = 0.;
-
-
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- real EQcbb = c0o1;
- real EQabb = c0o1;
- real EQbcb = c0o1;
- real EQbab = c0o1;
- real EQbbc = c0o1;
- real EQbba = c0o1;
- real EQccb = c0o1;
- real EQaab = c0o1;
- real EQcab = c0o1;
- real EQacb = c0o1;
- real EQcbc = c0o1;
- real EQaba = c0o1;
- real EQcba = c0o1;
- real EQabc = c0o1;
- real EQbcc = c0o1;
- real EQbaa = c0o1;
- real EQbca = c0o1;
- real EQbac = c0o1;
- real EQbbb = c0o1;
- real EQccc = drho * c1o27;
- real EQaac = drho * c1o3;
- real EQcac = drho * c1o9;
- real EQacc = drho * c1o9;
- real EQcca = drho * c1o9;
- real EQaaa = drho;
- real EQcaa = drho * c1o3;
- real EQaca = drho * c1o3;
- ////////////////////////////////////////////////////////////////////////////////////
- backwardChimeraWithK(EQaaa, EQaab, EQaac, vvz, vz2, c1o1);
- backwardChimeraWithK(EQaca, EQacb, EQacc, vvz, vz2, c1o3);
- ///////////////////////////////////////////////////////////
- EQcaa = EQaca; EQcab = EQacb; EQcac = EQacc;
- ///////////////////////////////////////////////////////////
- backwardChimeraWithK(EQcca, EQccb, EQccc, vvz, vz2, c1o9);
-
- backwardChimeraWithK(EQaaa, EQaba, EQaca, vvy, vy2, c1o6);
- backwardChimeraWithK(EQaab, EQabb, EQacb, vvy, vy2, c2o3);
- backwardChimeraWithK(EQaac, EQabc, EQacc, vvy, vy2, c1o6);
- backwardChimeraWithK(EQcaa, EQcba, EQcca, vvy, vy2, c1o18);
- backwardChimeraWithK(EQcab, EQcbb, EQccb, vvy, vy2, c2o9);
- backwardChimeraWithK(EQcac, EQcbc, EQccc, vvy, vy2, c1o18);
-
- backwardChimeraWithK(EQaaa, EQbaa, EQcaa, vvx, vx2, c1o36);
- backwardChimeraWithK(EQaab, EQbab, EQcab, vvx, vx2, c1o9);
- backwardChimeraWithK(EQaac, EQbac, EQcac, vvx, vx2, c1o36);
- backwardChimeraWithK(EQaba, EQbba, EQcba, vvx, vx2, c1o9);
- backwardChimeraWithK(EQabb, EQbbb, EQcbb, vvx, vx2, c4o9);
- backwardChimeraWithK(EQabc, EQbbc, EQcbc, vvx, vx2, c1o9);
- backwardChimeraWithK(EQaca, EQbca, EQcca, vvx, vx2, c1o36);
- backwardChimeraWithK(EQacb, EQbcb, EQccb, vvx, vx2, c1o9);
- backwardChimeraWithK(EQacc, EQbcc, EQccc, vvx, vx2, c1o36);
-
- ////////////////////////////////////////////////////////////////////////////////////
- //Pre-condition
- mfcbb -= EQcbb;
- mfabb -= EQabb;
- mfbcb -= EQbcb;
- mfbab -= EQbab;
- mfbbc -= EQbbc;
- mfbba -= EQbba;
- mfccb -= EQccb;
- mfaab -= EQaab;
- mfcab -= EQcab;
- mfacb -= EQacb;
- mfcbc -= EQcbc;
- mfaba -= EQaba;
- mfcba -= EQcba;
- mfabc -= EQabc;
- mfbcc -= EQbcc;
- mfbaa -= EQbaa;
- mfbca -= EQbca;
- mfbac -= EQbac;
- mfbbb -= EQbbb;
- mfccc -= EQccc;
- mfaac -= EQaac;
- mfcac -= EQcac;
- mfacc -= EQacc;
- mfcca -= EQcca;
- mfaaa -= EQaaa;
- mfcaa -= EQcaa;
- mfaca -= EQaca;
-
- ////////////////////////////////////////////////////////////////////////////////////
- //Hin
- ////////////////////////////////////////////////////////////////////////////////////
- forwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
- forwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
- forwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
- forwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
- forwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
- forwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
- forwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
- forwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
- forwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
-
- forwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
- forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
- forwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
- forwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
- forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
- forwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
- forwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
- forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
- forwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
-
- forwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
- forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
- forwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
- forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
- forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
- forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
- forwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
- forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
- forwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
-
- //////////////////////////////////////////////////////////////////////////////////////
- ////Hin
- //////////////////////////////////////////////////////////////////////////////////////
- //// mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Z - Dir
- //forwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, c4o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //// mit 1/6, 0, 1/18, 2/3, 0, 2/9, 1/6, 0, 1/18 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Y - Dir
- //forwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o18);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, c2o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, c2o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //// mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// X - Dir
- //forwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, one);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
- //////////////////////////////////////////////////////////////////////////////////////
- //forwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
-
-
- ////////////////////////////////////////////////////////////////////////////////////
- // Cumulants
- ////////////////////////////////////////////////////////////////////////////////////
- real OxxPyyPzz = c1o1; //omega; // one; //set the bulk viscosity one is high / two is very low and zero is (too) high
-
- ////////////////////////////////////////////////////////////
- //3.
- //////////////////////////////
- real OxyyPxzz = c1o1;
- real OxyyMxzz = c1o1;
- //real Oxyz = c1o1;
- ////////////////////////////////////////////////////////////
- //4.
- //////////////////////////////
- real O4 = c1o1;
- ////////////////////////////////////////////////////////////
- //5.
- //////////////////////////////
- real O5 = c1o1;
- ////////////////////////////////////////////////////////////
- //6.
- //////////////////////////////
- real O6 = c1o1;
- ////////////////////////////////////////////////////////////
-
-
- //central moments to cumulants
- //4.
- real CUMcbb = mfcbb - ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
- real CUMbcb = mfbcb - ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
- real CUMbbc = mfbbc - ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
-
- real CUMcca = mfcca - (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
- real CUMcac = mfcac - (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
- real CUMacc = mfacc - (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
-
- //5.
- real CUMbcc = mfbcc - ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
- real CUMcbc = mfcbc - ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
- real CUMccb = mfccb - ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
-
- //6.
-
- real CUMccc = mfccc + ((-c4o1 * mfbbb * mfbbb
- - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
- - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
- - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
- + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
- + c2o1 * (mfcaa * mfaca * mfaac)
- + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
- - c1o3 * (mfacc + mfcac + mfcca) / rho
- - c1o9 * (mfcaa + mfaca + mfaac) / rho
- + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
- + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
- + c1o27*((drho * drho - drho) / (rho*rho)));
-
-
-
-
- //2.
- // linear combinations
- real mxxPyyPzz = mfcaa + mfaca + mfaac;
- real mxxMyy = mfcaa - mfaca;
- real mxxMzz = mfcaa - mfaac;
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //incl. correction (hat noch nicht so gut funktioniert...Optimierungsbedarf??)
- {
- real dxux = c1o2 * (-omega) *(mxxMyy + mxxMzz) + c1o2 * OxxPyyPzz * (mfaaa - mxxPyyPzz);
- real dyuy = dxux + omega * c3o2 * mxxMyy;
- real dzuz = dxux + omega * c3o2 * mxxMzz;
-
- //relax
- mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz) - c3o1 * (c1o1 - c1o2 * OxxPyyPzz) * (vx2 * dxux + vy2 * dyuy + vz2 * dzuz);//-magicBulk*OxxPyyPzz;
- mxxMyy += omega * (-mxxMyy) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vy2 * dyuy);
- mxxMzz += omega * (-mxxMzz) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vz2 * dzuz);
-
- }
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////no correction
- //mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz);//-magicBulk*OxxPyyPzz;
- //mxxMyy += -(-omega) * (-mxxMyy);
- //mxxMzz += -(-omega) * (-mxxMzz);
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- mfabb += omega * (-mfabb);
- mfbab += omega * (-mfbab);
- mfbba += omega * (-mfbba);
-
- //////////////////////////////////////////////////////////////////////////
-
- // linear combinations back
- mfcaa = c1o3 * (mxxMyy + mxxMzz + mxxPyyPzz);
- mfaca = c1o3 * (-c2o1* mxxMyy + mxxMzz + mxxPyyPzz);
- mfaac = c1o3 * (mxxMyy - c2o1* mxxMzz + mxxPyyPzz);
-
- //3.
- // linear combinations
-
- real mxxyPyzz = mfcba + mfabc;
- real mxxyMyzz = mfcba - mfabc;
-
- real mxxzPyyz = mfcab + mfacb;
- real mxxzMyyz = mfcab - mfacb;
-
- real mxyyPxzz = mfbca + mfbac;
- real mxyyMxzz = mfbca - mfbac;
-
- //relax
- //////////////////////////////////////////////////////////////////////////
- mfbbb += OxyyMxzz * (-mfbbb);
- mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
- mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
- mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
- mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
- mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
- mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
- //////////////////////////////////////////////////////////////////////////
-
- mfcba = (mxxyMyzz + mxxyPyzz) * c1o2;
- mfabc = (-mxxyMyzz + mxxyPyzz) * c1o2;
- mfcab = (mxxzMyyz + mxxzPyyz) * c1o2;
- mfacb = (-mxxzMyyz + mxxzPyyz) * c1o2;
- mfbca = (mxyyMxzz + mxyyPxzz) * c1o2;
- mfbac = (-mxyyMxzz + mxyyPxzz) * c1o2;
-
- //4.
- //////////////////////////////////////////////////////////////////////////
- CUMacc += O4 * (-CUMacc);
- CUMcac += O4 * (-CUMcac);
- CUMcca += O4 * (-CUMcca);
-
- CUMbbc += O4 * (-CUMbbc);
- CUMbcb += O4 * (-CUMbcb);
- CUMcbb += O4 * (-CUMcbb);
- //////////////////////////////////////////////////////////////////////////
-
-
- //5.
- CUMbcc += O5 * (-CUMbcc);
- CUMcbc += O5 * (-CUMcbc);
- CUMccb += O5 * (-CUMccb);
-
- //6.
- CUMccc += O6 * (-CUMccc);
-
-
-
- //back cumulants to central moments
- //4.
- mfcbb = CUMcbb + ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
- mfbcb = CUMbcb + ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
- mfbbc = CUMbbc + ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
-
- mfcca = CUMcca + (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
- mfcac = CUMcac + (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
- mfacc = CUMacc + (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
-
- //5.
- mfbcc = CUMbcc + ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
- mfcbc = CUMcbc + ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
- mfccb = CUMccb + ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
-
- //6.
- mfccc = CUMccc - ((-c4o1 * mfbbb * mfbbb
- - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
- - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
- - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
- + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
- + c2o1 * (mfcaa * mfaca * mfaac)
- + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
- - c1o3 * (mfacc + mfcac + mfcca) / rho
- - c1o9 * (mfcaa + mfaca + mfaac) / rho
- + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
- + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
- + c1o27*((drho * drho - drho) / (rho*rho)));
-
- ////////////////////////////////////////////////////////////////////////////////////
- //the force be with you
- mfbaa = -mfbaa;
- mfaba = -mfaba;
- mfaab = -mfaab;
- ////////////////////////////////////////////////////////////////////////////////////
-
-
- ////////////////////////////////////////////////////////////////////////////////////
- //back
- ////////////////////////////////////////////////////////////////////////////////////
- backwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
- backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
- backwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
- backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
- backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
- backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
- backwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
- backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
- backwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
-
- backwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
- backwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
- backwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
- backwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
- backwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
- backwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
- backwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
- backwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
- backwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
-
- backwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
- backwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
- backwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
- backwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
- backwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
- backwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
- backwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
- backwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
- backwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
-
- ////////////////////////////////////////////////////////////////////////////////////
- mfcbb+=EQcbb;
- mfabb+=EQabb;
- mfbcb+=EQbcb;
- mfbab+=EQbab;
- mfbbc+=EQbbc;
- mfbba+=EQbba;
- mfccb+=EQccb;
- mfaab+=EQaab;
- mfcab+=EQcab;
- mfacb+=EQacb;
- mfcbc+=EQcbc;
- mfaba+=EQaba;
- mfcba+=EQcba;
- mfabc+=EQabc;
- mfbcc+=EQbcc;
- mfbaa+=EQbaa;
- mfbca+=EQbca;
- mfbac+=EQbac;
- mfbbb+=EQbbb;
- mfccc+=EQccc;
- mfaac+=EQaac;
- mfcac+=EQcac;
- mfacc+=EQacc;
- mfcca+=EQcca;
- mfaaa+=EQaaa;
- mfcaa+=EQcaa;
- mfaca+=EQaca;
-
-
- //////////////////////////////////////////////////////////////////////////////////////
- ////back
- //////////////////////////////////////////////////////////////////////////////////////
- ////mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Z - Dir
- //backwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, one);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o3);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- ////mit 1/6, 2/3, 1/6, 0, 0, 0, 1/18, 2/9, 1/18 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// Y - Dir
- //backwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaab, mfabb, mfacb, vvy, vy2, c2o3);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o6);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbaa, mfbba, mfbca, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbab, mfbbb, mfbcb, vvz, vz2);
- ///////////b//////////////////////////////////////////////////////////////////////////
- //backwardChimera(mfbac, mfbbc, mfbcc, vvz, vz2);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o18);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcab, mfcbb, mfccb, vvy, vy2, c2o9);
- ///////////c//////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- ////mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
- //////////////////////////////////////////////////////////////////////////////////////
- //// X - Dir
- //backwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaba, mfbba, mfcba, vvx, vx2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaab, mfbab, mfcab, vvx, vx2, c1o9);
- /////////////b////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfabb, mfbbb, mfcbb, vvx, vx2, c4o9);
- /////////////b////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfacb, mfbcb, mfccb, vvx, vx2, c1o9);
- //////////////////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o36);
- /////////////c////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfabc, mfbbc, mfcbc, vvx, vx2, c1o9);
- /////////////c////////////////////////////////////////////////////////////////////////
- //backwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o36);
- //////////////////////////////////////////////////////////////////////////////////////
-
- //////////////////////////////////////////////////////////////////////////////////////
- real drhoPost =
- ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
- (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
- ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
- mfbbb += drho - drhoPost;
- ////////////////////////////////////////////////////////////////////////////////////
- (D.f[dirE])[k] = mfabb;//(D.f[ dirE ])[ke ] = mfabb;// - c2over27 ; (D.f[ dirE ])[k ]
- (D.f[dirW])[kw] = mfcbb;//(D.f[ dirW ])[kw ] = mfcbb;// - c2over27 ; (D.f[ dirW ])[kw ]
- (D.f[dirN])[k] = mfbab;//(D.f[ dirN ])[kn ] = mfbab;// - c2over27 ; (D.f[ dirN ])[k ]
- (D.f[dirS])[ks] = mfbcb;//(D.f[ dirS ])[ks ] = mfbcb;// - c2over27 ; (D.f[ dirS ])[ks ]
- (D.f[dirT])[k] = mfbba;//(D.f[ dirT ])[kt ] = mfbba;// - c2over27 ; (D.f[ dirT ])[k ]
- (D.f[dirB])[kb] = mfbbc;//(D.f[ dirB ])[kb ] = mfbbc;// - c2over27 ; (D.f[ dirB ])[kb ]
- (D.f[dirNE])[k] = mfaab;//(D.f[ dirNE ])[kne ] = mfaab;// - c1over54 ; (D.f[ dirNE ])[k ]
- (D.f[dirSW])[ksw] = mfccb;//(D.f[ dirSW ])[ksw ] = mfccb;// - c1over54 ; (D.f[ dirSW ])[ksw ]
- (D.f[dirSE])[ks] = mfacb;//(D.f[ dirSE ])[kse ] = mfacb;// - c1over54 ; (D.f[ dirSE ])[ks ]
- (D.f[dirNW])[kw] = mfcab;//(D.f[ dirNW ])[knw ] = mfcab;// - c1over54 ; (D.f[ dirNW ])[kw ]
- (D.f[dirTE])[k] = mfaba;//(D.f[ dirTE ])[kte ] = mfaba;// - c1over54 ; (D.f[ dirTE ])[k ]
- (D.f[dirBW])[kbw] = mfcbc;//(D.f[ dirBW ])[kbw ] = mfcbc;// - c1over54 ; (D.f[ dirBW ])[kbw ]
- (D.f[dirBE])[kb] = mfabc;//(D.f[ dirBE ])[kbe ] = mfabc;// - c1over54 ; (D.f[ dirBE ])[kb ]
- (D.f[dirTW])[kw] = mfcba;//(D.f[ dirTW ])[ktw ] = mfcba;// - c1over54 ; (D.f[ dirTW ])[kw ]
- (D.f[dirTN])[k] = mfbaa;//(D.f[ dirTN ])[ktn ] = mfbaa;// - c1over54 ; (D.f[ dirTN ])[k ]
- (D.f[dirBS])[kbs] = mfbcc;//(D.f[ dirBS ])[kbs ] = mfbcc;// - c1over54 ; (D.f[ dirBS ])[kbs ]
- (D.f[dirBN])[kb] = mfbac;//(D.f[ dirBN ])[kbn ] = mfbac;// - c1over54 ; (D.f[ dirBN ])[kb ]
- (D.f[dirTS])[ks] = mfbca;//(D.f[ dirTS ])[kts ] = mfbca;// - c1over54 ; (D.f[ dirTS ])[ks ]
- (D.f[dirZERO])[k] = mfbbb;//(D.f[ dirZERO])[kzero] = mfbbb;// - c8over27 ; (D.f[ dirZERO])[k ]
- (D.f[dirTNE])[k] = mfaaa;//(D.f[ dirTNE ])[ktne ] = mfaaa;// - c1over216; (D.f[ dirTNE ])[k ]
- (D.f[dirTSE])[ks] = mfaca;//(D.f[ dirTSE ])[ktse ] = mfaca;// - c1over216; (D.f[ dirTSE ])[ks ]
- (D.f[dirBNE])[kb] = mfaac;//(D.f[ dirBNE ])[kbne ] = mfaac;// - c1over216; (D.f[ dirBNE ])[kb ]
- (D.f[dirBSE])[kbs] = mfacc;//(D.f[ dirBSE ])[kbse ] = mfacc;// - c1over216; (D.f[ dirBSE ])[kbs ]
- (D.f[dirTNW])[kw] = mfcaa;//(D.f[ dirTNW ])[ktnw ] = mfcaa;// - c1over216; (D.f[ dirTNW ])[kw ]
- (D.f[dirTSW])[ksw] = mfcca;//(D.f[ dirTSW ])[ktsw ] = mfcca;// - c1over216; (D.f[ dirTSW ])[ksw ]
- (D.f[dirBNW])[kbw] = mfcac;//(D.f[ dirBNW ])[kbnw ] = mfcac;// - c1over216; (D.f[ dirBNW ])[kbw ]
- (D.f[dirBSW])[kbsw] = mfccc;//(D.f[ dirBSW ])[kbsw ] = mfccc;// - c1over216; (D.f[ dirBSW ])[kbsw]
- ////////////////////////////////////////////////////////////////////////////////////
- }
- }
+ ////////////////////////////////////////////////////////////////////////////////
+ const unsigned x = threadIdx.x; // Globaler x-Index
+ const unsigned y = blockIdx.x; // Globaler y-Index
+ const unsigned z = blockIdx.y; // Globaler z-Index
+
+ const unsigned nx = blockDim.x;
+ const unsigned ny = gridDim.x;
+
+ const unsigned k = nx*(ny*z + y) + x;
+ //////////////////////////////////////////////////////////////////////////
+
+ if (k<size_Mat)
+ {
+ ////////////////////////////////////////////////////////////////////////////////
+ unsigned int BC;
+ BC = bcMatD[k];
+
+ if (BC >= GEO_FLUID/*(BC != GEO_SOLID) && (BC != GEO_VOID)*/)
+ {
+ Distributions27 D;
+ if (EvenOrOdd == true)
+ {
+ D.f[dirE] = &DDStart[dirE *size_Mat];
+ D.f[dirW] = &DDStart[dirW *size_Mat];
+ D.f[dirN] = &DDStart[dirN *size_Mat];
+ D.f[dirS] = &DDStart[dirS *size_Mat];
+ D.f[dirT] = &DDStart[dirT *size_Mat];
+ D.f[dirB] = &DDStart[dirB *size_Mat];
+ D.f[dirNE] = &DDStart[dirNE *size_Mat];
+ D.f[dirSW] = &DDStart[dirSW *size_Mat];
+ D.f[dirSE] = &DDStart[dirSE *size_Mat];
+ D.f[dirNW] = &DDStart[dirNW *size_Mat];
+ D.f[dirTE] = &DDStart[dirTE *size_Mat];
+ D.f[dirBW] = &DDStart[dirBW *size_Mat];
+ D.f[dirBE] = &DDStart[dirBE *size_Mat];
+ D.f[dirTW] = &DDStart[dirTW *size_Mat];
+ D.f[dirTN] = &DDStart[dirTN *size_Mat];
+ D.f[dirBS] = &DDStart[dirBS *size_Mat];
+ D.f[dirBN] = &DDStart[dirBN *size_Mat];
+ D.f[dirTS] = &DDStart[dirTS *size_Mat];
+ D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
+ D.f[dirTNE] = &DDStart[dirTNE *size_Mat];
+ D.f[dirTSW] = &DDStart[dirTSW *size_Mat];
+ D.f[dirTSE] = &DDStart[dirTSE *size_Mat];
+ D.f[dirTNW] = &DDStart[dirTNW *size_Mat];
+ D.f[dirBNE] = &DDStart[dirBNE *size_Mat];
+ D.f[dirBSW] = &DDStart[dirBSW *size_Mat];
+ D.f[dirBSE] = &DDStart[dirBSE *size_Mat];
+ D.f[dirBNW] = &DDStart[dirBNW *size_Mat];
+ }
+ else
+ {
+ D.f[dirW] = &DDStart[dirE *size_Mat];
+ D.f[dirE] = &DDStart[dirW *size_Mat];
+ D.f[dirS] = &DDStart[dirN *size_Mat];
+ D.f[dirN] = &DDStart[dirS *size_Mat];
+ D.f[dirB] = &DDStart[dirT *size_Mat];
+ D.f[dirT] = &DDStart[dirB *size_Mat];
+ D.f[dirSW] = &DDStart[dirNE *size_Mat];
+ D.f[dirNE] = &DDStart[dirSW *size_Mat];
+ D.f[dirNW] = &DDStart[dirSE *size_Mat];
+ D.f[dirSE] = &DDStart[dirNW *size_Mat];
+ D.f[dirBW] = &DDStart[dirTE *size_Mat];
+ D.f[dirTE] = &DDStart[dirBW *size_Mat];
+ D.f[dirTW] = &DDStart[dirBE *size_Mat];
+ D.f[dirBE] = &DDStart[dirTW *size_Mat];
+ D.f[dirBS] = &DDStart[dirTN *size_Mat];
+ D.f[dirTN] = &DDStart[dirBS *size_Mat];
+ D.f[dirTS] = &DDStart[dirBN *size_Mat];
+ D.f[dirBN] = &DDStart[dirTS *size_Mat];
+ D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
+ D.f[dirBSW] = &DDStart[dirTNE *size_Mat];
+ D.f[dirBNE] = &DDStart[dirTSW *size_Mat];
+ D.f[dirBNW] = &DDStart[dirTSE *size_Mat];
+ D.f[dirBSE] = &DDStart[dirTNW *size_Mat];
+ D.f[dirTSW] = &DDStart[dirBNE *size_Mat];
+ D.f[dirTNE] = &DDStart[dirBSW *size_Mat];
+ D.f[dirTNW] = &DDStart[dirBSE *size_Mat];
+ D.f[dirTSE] = &DDStart[dirBNW *size_Mat];
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ //index
+ //unsigned int kzero= k;
+ //unsigned int ke = k;
+ unsigned int kw = neighborX[k];
+ //unsigned int kn = k;
+ unsigned int ks = neighborY[k];
+ //unsigned int kt = k;
+ unsigned int kb = neighborZ[k];
+ unsigned int ksw = neighborY[kw];
+ //unsigned int kne = k;
+ //unsigned int kse = ks;
+ //unsigned int knw = kw;
+ unsigned int kbw = neighborZ[kw];
+ //unsigned int kte = k;
+ //unsigned int kbe = kb;
+ //unsigned int ktw = kw;
+ unsigned int kbs = neighborZ[ks];
+ //unsigned int ktn = k;
+ //unsigned int kbn = kb;
+ //unsigned int kts = ks;
+ //unsigned int ktse = ks;
+ //unsigned int kbnw = kbw;
+ //unsigned int ktnw = kw;
+ //unsigned int kbse = kbs;
+ //unsigned int ktsw = ksw;
+ //unsigned int kbne = kb;
+ //unsigned int ktne = k;
+ unsigned int kbsw = neighborZ[ksw];
+
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ real mfcbb = (D.f[dirE])[k];//[ke ];// + c2over27 ;(D.f[dirE ])[k ];//ke
+ real mfabb = (D.f[dirW])[kw];//[kw ];// + c2over27 ;(D.f[dirW ])[kw ];
+ real mfbcb = (D.f[dirN])[k];//[kn ];// + c2over27 ;(D.f[dirN ])[k ];//kn
+ real mfbab = (D.f[dirS])[ks];//[ks ];// + c2over27 ;(D.f[dirS ])[ks ];
+ real mfbbc = (D.f[dirT])[k];//[kt ];// + c2over27 ;(D.f[dirT ])[k ];//kt
+ real mfbba = (D.f[dirB])[kb];//[kb ];// + c2over27 ;(D.f[dirB ])[kb ];
+ real mfccb = (D.f[dirNE])[k];//[kne ];// + c1over54 ;(D.f[dirNE ])[k ];//kne
+ real mfaab = (D.f[dirSW])[ksw];//[ksw ];// + c1over54 ;(D.f[dirSW ])[ksw];
+ real mfcab = (D.f[dirSE])[ks];//[kse ];// + c1over54 ;(D.f[dirSE ])[ks ];//kse
+ real mfacb = (D.f[dirNW])[kw];//[knw ];// + c1over54 ;(D.f[dirNW ])[kw ];//knw
+ real mfcbc = (D.f[dirTE])[k];//[kte ];// + c1over54 ;(D.f[dirTE ])[k ];//kte
+ real mfaba = (D.f[dirBW])[kbw];//[kbw ];// + c1over54 ;(D.f[dirBW ])[kbw];
+ real mfcba = (D.f[dirBE])[kb];//[kbe ];// + c1over54 ;(D.f[dirBE ])[kb ];//kbe
+ real mfabc = (D.f[dirTW])[kw];//[ktw ];// + c1over54 ;(D.f[dirTW ])[kw ];//ktw
+ real mfbcc = (D.f[dirTN])[k];//[ktn ];// + c1over54 ;(D.f[dirTN ])[k ];//ktn
+ real mfbaa = (D.f[dirBS])[kbs];//[kbs ];// + c1over54 ;(D.f[dirBS ])[kbs];
+ real mfbca = (D.f[dirBN])[kb];//[kbn ];// + c1over54 ;(D.f[dirBN ])[kb ];//kbn
+ real mfbac = (D.f[dirTS])[ks];//[kts ];// + c1over54 ;(D.f[dirTS ])[ks ];//kts
+ real mfbbb = (D.f[dirZERO])[k];//[kzero];// + c8over27 ;(D.f[dirZERO])[k ];//kzero
+ real mfccc = (D.f[dirTNE])[k];//[ktne ];// + c1over216;(D.f[dirTNE ])[k ];//ktne
+ real mfaac = (D.f[dirTSW])[ksw];//[ktsw ];// + c1over216;(D.f[dirTSW ])[ksw];//ktsw
+ real mfcac = (D.f[dirTSE])[ks];//[ktse ];// + c1over216;(D.f[dirTSE ])[ks ];//ktse
+ real mfacc = (D.f[dirTNW])[kw];//[ktnw ];// + c1over216;(D.f[dirTNW ])[kw ];//ktnw
+ real mfcca = (D.f[dirBNE])[kb];//[kbne ];// + c1over216;(D.f[dirBNE ])[kb ];//kbne
+ real mfaaa = (D.f[dirBSW])[kbsw];//[kbsw ];// + c1over216;(D.f[dirBSW ])[kbsw];
+ real mfcaa = (D.f[dirBSE])[kbs];//[kbse ];// + c1over216;(D.f[dirBSE ])[kbs];//kbse
+ real mfaca = (D.f[dirBNW])[kbw];//[kbnw ];// + c1over216;(D.f[dirBNW ])[kbw];//kbnw
+ ////////////////////////////////////////////////////////////////////////////////////
+ real drho = ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
+ (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
+ ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
+
+ real rho = c1o1 + drho;
+ ////////////////////////////////////////////////////////////////////////////////////
+ real vvx = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfcaa - mfacc) + (mfcca - mfaac))) +
+ (((mfcba - mfabc) + (mfcbc - mfaba)) + ((mfcab - mfacb) + (mfccb - mfaab))) +
+ (mfcbb - mfabb)) / rho;
+ real vvy = ((((mfccc - mfaaa) + (mfaca - mfcac)) + ((mfacc - mfcaa) + (mfcca - mfaac))) +
+ (((mfbca - mfbac) + (mfbcc - mfbaa)) + ((mfacb - mfcab) + (mfccb - mfaab))) +
+ (mfbcb - mfbab)) / rho;
+ real vvz = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfacc - mfcaa) + (mfaac - mfcca))) +
+ (((mfbac - mfbca) + (mfbcc - mfbaa)) + ((mfabc - mfcba) + (mfcbc - mfaba))) +
+ (mfbbc - mfbba)) / rho;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //the force be with you
+ real fx = forces[0] / (pow((double)c2o1, (double)level)); //zero;//0.0032653/(pow(two,level)); //0.000000005;//(two/1600000.0) / 120.0; //
+ real fy = forces[1] / (pow((double)c2o1, (double)level)); //zero;
+ real fz = forces[2] / (pow((double)c2o1, (double)level)); //zero;
+ vvx += fx*c1o2;
+ vvy += fy*c1o2;
+ vvz += fz*c1o2;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //real omega = omega_in;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //fast
+ //real oMdrho = c1o1; // comp special
+ //real m0, m1, m2;
+ real vx2;
+ real vy2;
+ real vz2;
+ vx2 = vvx*vvx;
+ vy2 = vvy*vvy;
+ vz2 = vvz*vvz;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //real wadjust;
+ //real qudricLimitP = c1o100;// * 0.0001f;
+ //real qudricLimitM = c1o100;// * 0.0001f;
+ //real qudricLimitD = c1o100;// * 0.001f;
+ //real s9 = minusomega;
+ //test
+ //s9 = 0.;
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ real EQcbb = c0o1;
+ real EQabb = c0o1;
+ real EQbcb = c0o1;
+ real EQbab = c0o1;
+ real EQbbc = c0o1;
+ real EQbba = c0o1;
+ real EQccb = c0o1;
+ real EQaab = c0o1;
+ real EQcab = c0o1;
+ real EQacb = c0o1;
+ real EQcbc = c0o1;
+ real EQaba = c0o1;
+ real EQcba = c0o1;
+ real EQabc = c0o1;
+ real EQbcc = c0o1;
+ real EQbaa = c0o1;
+ real EQbca = c0o1;
+ real EQbac = c0o1;
+ real EQbbb = c0o1;
+ real EQccc = drho * c1o27;
+ real EQaac = drho * c1o3;
+ real EQcac = drho * c1o9;
+ real EQacc = drho * c1o9;
+ real EQcca = drho * c1o9;
+ real EQaaa = drho;
+ real EQcaa = drho * c1o3;
+ real EQaca = drho * c1o3;
+ ////////////////////////////////////////////////////////////////////////////////////
+ vf::lbm::backwardChimeraWithK(EQaaa, EQaab, EQaac, vvz, vz2, c1o1);
+ vf::lbm::backwardChimeraWithK(EQaca, EQacb, EQacc, vvz, vz2, c1o3);
+ ///////////////////////////////////////////////////////////
+ EQcaa = EQaca; EQcab = EQacb; EQcac = EQacc;
+ ///////////////////////////////////////////////////////////
+ vf::lbm::backwardChimeraWithK(EQcca, EQccb, EQccc, vvz, vz2, c1o9);
+
+ vf::lbm::backwardChimeraWithK(EQaaa, EQaba, EQaca, vvy, vy2, c1o6);
+ vf::lbm::backwardChimeraWithK(EQaab, EQabb, EQacb, vvy, vy2, c2o3);
+ vf::lbm::backwardChimeraWithK(EQaac, EQabc, EQacc, vvy, vy2, c1o6);
+ vf::lbm::backwardChimeraWithK(EQcaa, EQcba, EQcca, vvy, vy2, c1o18);
+ vf::lbm::backwardChimeraWithK(EQcab, EQcbb, EQccb, vvy, vy2, c2o9);
+ vf::lbm::backwardChimeraWithK(EQcac, EQcbc, EQccc, vvy, vy2, c1o18);
+
+ vf::lbm::backwardChimeraWithK(EQaaa, EQbaa, EQcaa, vvx, vx2, c1o36);
+ vf::lbm::backwardChimeraWithK(EQaab, EQbab, EQcab, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQaac, EQbac, EQcac, vvx, vx2, c1o36);
+ vf::lbm::backwardChimeraWithK(EQaba, EQbba, EQcba, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQabb, EQbbb, EQcbb, vvx, vx2, c4o9);
+ vf::lbm::backwardChimeraWithK(EQabc, EQbbc, EQcbc, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQaca, EQbca, EQcca, vvx, vx2, c1o36);
+ vf::lbm::backwardChimeraWithK(EQacb, EQbcb, EQccb, vvx, vx2, c1o9);
+ vf::lbm::backwardChimeraWithK(EQacc, EQbcc, EQccc, vvx, vx2, c1o36);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //Pre-condition
+ mfcbb -= EQcbb;
+ mfabb -= EQabb;
+ mfbcb -= EQbcb;
+ mfbab -= EQbab;
+ mfbbc -= EQbbc;
+ mfbba -= EQbba;
+ mfccb -= EQccb;
+ mfaab -= EQaab;
+ mfcab -= EQcab;
+ mfacb -= EQacb;
+ mfcbc -= EQcbc;
+ mfaba -= EQaba;
+ mfcba -= EQcba;
+ mfabc -= EQabc;
+ mfbcc -= EQbcc;
+ mfbaa -= EQbaa;
+ mfbca -= EQbca;
+ mfbac -= EQbac;
+ mfbbb -= EQbbb;
+ mfccc -= EQccc;
+ mfaac -= EQaac;
+ mfcac -= EQcac;
+ mfacc -= EQacc;
+ mfcca -= EQcca;
+ mfaaa -= EQaaa;
+ mfcaa -= EQcaa;
+ mfaca -= EQaca;
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //Hin
+ ////////////////////////////////////////////////////////////////////////////////////
+ vf::lbm::forwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
+ vf::lbm::forwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
+ vf::lbm::forwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
+ vf::lbm::forwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
+ vf::lbm::forwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
+ vf::lbm::forwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
+ vf::lbm::forwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
+ vf::lbm::forwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
+ vf::lbm::forwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
+
+ vf::lbm::forwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
+ vf::lbm::forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::forwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
+ vf::lbm::forwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
+ vf::lbm::forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::forwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
+ vf::lbm::forwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
+ vf::lbm::forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::forwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
+
+ vf::lbm::forwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
+ vf::lbm::forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::forwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
+ vf::lbm::forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::forwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
+ vf::lbm::forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::forwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
+
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////Hin
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Z - Dir
+ //forwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, c4o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// mit 1/6, 0, 1/18, 2/3, 0, 2/9, 1/6, 0, 1/18 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Y - Dir
+ //forwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o18);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, c2o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, c2o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// X - Dir
+ //forwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, one);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //forwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Cumulants
+ ////////////////////////////////////////////////////////////////////////////////////
+ real OxxPyyPzz = c1o1; //omega; // one; //set the bulk viscosity one is high / two is very low and zero is (too) high
+
+ ////////////////////////////////////////////////////////////
+ //3.
+ //////////////////////////////
+ real OxyyPxzz = c1o1;
+ real OxyyMxzz = c1o1;
+ //real Oxyz = c1o1;
+ ////////////////////////////////////////////////////////////
+ //4.
+ //////////////////////////////
+ real O4 = c1o1;
+ ////////////////////////////////////////////////////////////
+ //5.
+ //////////////////////////////
+ real O5 = c1o1;
+ ////////////////////////////////////////////////////////////
+ //6.
+ //////////////////////////////
+ real O6 = c1o1;
+ ////////////////////////////////////////////////////////////
+
+
+ //central moments to cumulants
+ //4.
+ real CUMcbb = mfcbb - ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
+ real CUMbcb = mfbcb - ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
+ real CUMbbc = mfbbc - ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
+
+ real CUMcca = mfcca - (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
+ real CUMcac = mfcac - (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
+ real CUMacc = mfacc - (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
+
+ //5.
+ real CUMbcc = mfbcc - ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
+ real CUMcbc = mfcbc - ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
+ real CUMccb = mfccb - ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
+
+ //6.
+
+ real CUMccc = mfccc + ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
+ - c1o3 * (mfacc + mfcac + mfcca) / rho
+ - c1o9 * (mfcaa + mfaca + mfaac) / rho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
+ + c1o27*((drho * drho - drho) / (rho*rho)));
+
+
+
+
+ //2.
+ // linear combinations
+ real mxxPyyPzz = mfcaa + mfaca + mfaac;
+ real mxxMyy = mfcaa - mfaca;
+ real mxxMzz = mfcaa - mfaac;
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //incl. correction (hat noch nicht so gut funktioniert...Optimierungsbedarf??)
+ {
+ real dxux = c1o2 * (-omega) *(mxxMyy + mxxMzz) + c1o2 * OxxPyyPzz * (mfaaa - mxxPyyPzz);
+ real dyuy = dxux + omega * c3o2 * mxxMyy;
+ real dzuz = dxux + omega * c3o2 * mxxMzz;
+
+ //relax
+ mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz) - c3o1 * (c1o1 - c1o2 * OxxPyyPzz) * (vx2 * dxux + vy2 * dyuy + vz2 * dzuz);//-magicBulk*OxxPyyPzz;
+ mxxMyy += omega * (-mxxMyy) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vy2 * dyuy);
+ mxxMzz += omega * (-mxxMzz) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vz2 * dzuz);
+
+ }
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////no correction
+ //mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz);//-magicBulk*OxxPyyPzz;
+ //mxxMyy += -(-omega) * (-mxxMyy);
+ //mxxMzz += -(-omega) * (-mxxMzz);
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ mfabb += omega * (-mfabb);
+ mfbab += omega * (-mfbab);
+ mfbba += omega * (-mfbba);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ // linear combinations back
+ mfcaa = c1o3 * (mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaca = c1o3 * (-c2o1* mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaac = c1o3 * (mxxMyy - c2o1* mxxMzz + mxxPyyPzz);
+
+ //3.
+ // linear combinations
+
+ real mxxyPyzz = mfcba + mfabc;
+ real mxxyMyzz = mfcba - mfabc;
+
+ real mxxzPyyz = mfcab + mfacb;
+ real mxxzMyyz = mfcab - mfacb;
+
+ real mxyyPxzz = mfbca + mfbac;
+ real mxyyMxzz = mfbca - mfbac;
+
+ //relax
+ //////////////////////////////////////////////////////////////////////////
+ mfbbb += OxyyMxzz * (-mfbbb);
+ mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
+ mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
+ mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
+ mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
+ mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
+ mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
+ //////////////////////////////////////////////////////////////////////////
+
+ mfcba = (mxxyMyzz + mxxyPyzz) * c1o2;
+ mfabc = (-mxxyMyzz + mxxyPyzz) * c1o2;
+ mfcab = (mxxzMyyz + mxxzPyyz) * c1o2;
+ mfacb = (-mxxzMyyz + mxxzPyyz) * c1o2;
+ mfbca = (mxyyMxzz + mxyyPxzz) * c1o2;
+ mfbac = (-mxyyMxzz + mxyyPxzz) * c1o2;
+
+ //4.
+ //////////////////////////////////////////////////////////////////////////
+ CUMacc += O4 * (-CUMacc);
+ CUMcac += O4 * (-CUMcac);
+ CUMcca += O4 * (-CUMcca);
+
+ CUMbbc += O4 * (-CUMbbc);
+ CUMbcb += O4 * (-CUMbcb);
+ CUMcbb += O4 * (-CUMcbb);
+ //////////////////////////////////////////////////////////////////////////
+
+
+ //5.
+ CUMbcc += O5 * (-CUMbcc);
+ CUMcbc += O5 * (-CUMcbc);
+ CUMccb += O5 * (-CUMccb);
+
+ //6.
+ CUMccc += O6 * (-CUMccc);
+
+
+
+ //back cumulants to central moments
+ //4.
+ mfcbb = CUMcbb + ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) / rho;
+ mfbcb = CUMbcb + ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) / rho;
+ mfbbc = CUMbbc + ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) / rho;
+
+ mfcca = CUMcca + (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) / rho - c1o9*(drho / rho));
+ mfcac = CUMcac + (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) / rho - c1o9*(drho / rho));
+ mfacc = CUMacc + (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) / rho - c1o9*(drho / rho));
+
+ //5.
+ mfbcc = CUMbcc + ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) / rho;
+ mfcbc = CUMcbc + ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) / rho;
+ mfccb = CUMccb + ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) / rho;
+
+ //6.
+ mfccc = CUMccc - ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) / rho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) / (rho * rho)
+ - c1o3 * (mfacc + mfcac + mfcca) / rho
+ - c1o9 * (mfcaa + mfaca + mfaac) / rho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) / (rho * rho) * c2o3
+ + c1o27*((drho * drho - drho) / (rho*rho)));
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //the force be with you
+ mfbaa = -mfbaa;
+ mfaba = -mfaba;
+ mfaab = -mfaab;
+ ////////////////////////////////////////////////////////////////////////////////////
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //back
+ ////////////////////////////////////////////////////////////////////////////////////
+ vf::lbm::backwardChimera(mfaaa, mfaab, mfaac, vvz, vz2);
+ vf::lbm::backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
+ vf::lbm::backwardChimera(mfaca, mfacb, mfacc, vvz, vz2);
+ vf::lbm::backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
+ vf::lbm::backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
+ vf::lbm::backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
+ vf::lbm::backwardChimera(mfcaa, mfcab, mfcac, vvz, vz2);
+ vf::lbm::backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
+ vf::lbm::backwardChimera(mfcca, mfccb, mfccc, vvz, vz2);
+
+ vf::lbm::backwardChimera(mfaaa, mfaba, mfaca, vvy, vy2);
+ vf::lbm::backwardChimera(mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::backwardChimera(mfaac, mfabc, mfacc, vvy, vy2);
+ vf::lbm::backwardChimera(mfbaa, mfbba, mfbca, vvy, vy2);
+ vf::lbm::backwardChimera(mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::backwardChimera(mfbac, mfbbc, mfbcc, vvy, vy2);
+ vf::lbm::backwardChimera(mfcaa, mfcba, mfcca, vvy, vy2);
+ vf::lbm::backwardChimera(mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::backwardChimera(mfcac, mfcbc, mfccc, vvy, vy2);
+
+ vf::lbm::backwardChimera(mfaaa, mfbaa, mfcaa, vvx, vx2);
+ vf::lbm::backwardChimera(mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::backwardChimera(mfaac, mfbac, mfcac, vvx, vx2);
+ vf::lbm::backwardChimera(mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::backwardChimera(mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::backwardChimera(mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::backwardChimera(mfaca, mfbca, mfcca, vvx, vx2);
+ vf::lbm::backwardChimera(mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::backwardChimera(mfacc, mfbcc, mfccc, vvx, vx2);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ mfcbb+=EQcbb;
+ mfabb+=EQabb;
+ mfbcb+=EQbcb;
+ mfbab+=EQbab;
+ mfbbc+=EQbbc;
+ mfbba+=EQbba;
+ mfccb+=EQccb;
+ mfaab+=EQaab;
+ mfcab+=EQcab;
+ mfacb+=EQacb;
+ mfcbc+=EQcbc;
+ mfaba+=EQaba;
+ mfcba+=EQcba;
+ mfabc+=EQabc;
+ mfbcc+=EQbcc;
+ mfbaa+=EQbaa;
+ mfbca+=EQbca;
+ mfbac+=EQbac;
+ mfbbb+=EQbbb;
+ mfccc+=EQccc;
+ mfaac+=EQaac;
+ mfcac+=EQcac;
+ mfacc+=EQacc;
+ mfcca+=EQcca;
+ mfaaa+=EQaaa;
+ mfcaa+=EQcaa;
+ mfaca+=EQaca;
+
+
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////back
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Z - Dir
+ //backwardChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, one);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfaba, mfabb, mfabc, vvz, vz2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c1o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbaa, mfbab, mfbac, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbba, mfbbb, mfbbc, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbca, mfbcb, mfbcc, vvz, vz2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c1o3);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfcba, mfcbb, mfcbc, vvz, vz2);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////mit 1/6, 2/3, 1/6, 0, 0, 0, 1/18, 2/9, 1/18 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// Y - Dir
+ //backwardChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaab, mfabb, mfacb, vvy, vy2, c2o3);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c1o6);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbaa, mfbba, mfbca, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbab, mfbbb, mfbcb, vvz, vz2);
+ ///////////b//////////////////////////////////////////////////////////////////////////
+ //backwardChimera(mfbac, mfbbc, mfbcc, vvz, vz2);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c1o18);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcab, mfcbb, mfccb, vvy, vy2, c2o9);
+ ///////////c//////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c1o18);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ ////mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
+ //////////////////////////////////////////////////////////////////////////////////////
+ //// X - Dir
+ //backwardChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaba, mfbba, mfcba, vvx, vx2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaab, mfbab, mfcab, vvx, vx2, c1o9);
+ /////////////b////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfabb, mfbbb, mfcbb, vvx, vx2, c4o9);
+ /////////////b////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfacb, mfbcb, mfccb, vvx, vx2, c1o9);
+ //////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c1o36);
+ /////////////c////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfabc, mfbbc, mfcbc, vvx, vx2, c1o9);
+ /////////////c////////////////////////////////////////////////////////////////////////
+ //backwardChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c1o36);
+ //////////////////////////////////////////////////////////////////////////////////////
+
+ //////////////////////////////////////////////////////////////////////////////////////
+ real drhoPost =
+ ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
+ (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
+ ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
+ mfbbb += drho - drhoPost;
+ ////////////////////////////////////////////////////////////////////////////////////
+ (D.f[dirE])[k] = mfabb;//(D.f[ dirE ])[ke ] = mfabb;// - c2over27 ; (D.f[ dirE ])[k ]
+ (D.f[dirW])[kw] = mfcbb;//(D.f[ dirW ])[kw ] = mfcbb;// - c2over27 ; (D.f[ dirW ])[kw ]
+ (D.f[dirN])[k] = mfbab;//(D.f[ dirN ])[kn ] = mfbab;// - c2over27 ; (D.f[ dirN ])[k ]
+ (D.f[dirS])[ks] = mfbcb;//(D.f[ dirS ])[ks ] = mfbcb;// - c2over27 ; (D.f[ dirS ])[ks ]
+ (D.f[dirT])[k] = mfbba;//(D.f[ dirT ])[kt ] = mfbba;// - c2over27 ; (D.f[ dirT ])[k ]
+ (D.f[dirB])[kb] = mfbbc;//(D.f[ dirB ])[kb ] = mfbbc;// - c2over27 ; (D.f[ dirB ])[kb ]
+ (D.f[dirNE])[k] = mfaab;//(D.f[ dirNE ])[kne ] = mfaab;// - c1over54 ; (D.f[ dirNE ])[k ]
+ (D.f[dirSW])[ksw] = mfccb;//(D.f[ dirSW ])[ksw ] = mfccb;// - c1over54 ; (D.f[ dirSW ])[ksw ]
+ (D.f[dirSE])[ks] = mfacb;//(D.f[ dirSE ])[kse ] = mfacb;// - c1over54 ; (D.f[ dirSE ])[ks ]
+ (D.f[dirNW])[kw] = mfcab;//(D.f[ dirNW ])[knw ] = mfcab;// - c1over54 ; (D.f[ dirNW ])[kw ]
+ (D.f[dirTE])[k] = mfaba;//(D.f[ dirTE ])[kte ] = mfaba;// - c1over54 ; (D.f[ dirTE ])[k ]
+ (D.f[dirBW])[kbw] = mfcbc;//(D.f[ dirBW ])[kbw ] = mfcbc;// - c1over54 ; (D.f[ dirBW ])[kbw ]
+ (D.f[dirBE])[kb] = mfabc;//(D.f[ dirBE ])[kbe ] = mfabc;// - c1over54 ; (D.f[ dirBE ])[kb ]
+ (D.f[dirTW])[kw] = mfcba;//(D.f[ dirTW ])[ktw ] = mfcba;// - c1over54 ; (D.f[ dirTW ])[kw ]
+ (D.f[dirTN])[k] = mfbaa;//(D.f[ dirTN ])[ktn ] = mfbaa;// - c1over54 ; (D.f[ dirTN ])[k ]
+ (D.f[dirBS])[kbs] = mfbcc;//(D.f[ dirBS ])[kbs ] = mfbcc;// - c1over54 ; (D.f[ dirBS ])[kbs ]
+ (D.f[dirBN])[kb] = mfbac;//(D.f[ dirBN ])[kbn ] = mfbac;// - c1over54 ; (D.f[ dirBN ])[kb ]
+ (D.f[dirTS])[ks] = mfbca;//(D.f[ dirTS ])[kts ] = mfbca;// - c1over54 ; (D.f[ dirTS ])[ks ]
+ (D.f[dirZERO])[k] = mfbbb;//(D.f[ dirZERO])[kzero] = mfbbb;// - c8over27 ; (D.f[ dirZERO])[k ]
+ (D.f[dirTNE])[k] = mfaaa;//(D.f[ dirTNE ])[ktne ] = mfaaa;// - c1over216; (D.f[ dirTNE ])[k ]
+ (D.f[dirTSE])[ks] = mfaca;//(D.f[ dirTSE ])[ktse ] = mfaca;// - c1over216; (D.f[ dirTSE ])[ks ]
+ (D.f[dirBNE])[kb] = mfaac;//(D.f[ dirBNE ])[kbne ] = mfaac;// - c1over216; (D.f[ dirBNE ])[kb ]
+ (D.f[dirBSE])[kbs] = mfacc;//(D.f[ dirBSE ])[kbse ] = mfacc;// - c1over216; (D.f[ dirBSE ])[kbs ]
+ (D.f[dirTNW])[kw] = mfcaa;//(D.f[ dirTNW ])[ktnw ] = mfcaa;// - c1over216; (D.f[ dirTNW ])[kw ]
+ (D.f[dirTSW])[ksw] = mfcca;//(D.f[ dirTSW ])[ktsw ] = mfcca;// - c1over216; (D.f[ dirTSW ])[ksw ]
+ (D.f[dirBNW])[kbw] = mfcac;//(D.f[ dirBNW ])[kbnw ] = mfcac;// - c1over216; (D.f[ dirBNW ])[kbw ]
+ (D.f[dirBSW])[kbsw] = mfccc;//(D.f[ dirBSW ])[kbsw ] = mfccc;// - c1over216; (D.f[ dirBSW ])[kbsw]
+ ////////////////////////////////////////////////////////////////////////////////////
+ }
+ }
}
////////////////////////////////////////////////////////////////////////////////
@@ -1798,483 +1754,483 @@ extern "C" __global__ void Cumulant_One_preconditioned_chim_Comp_SP_27(
////////////////////////////////////////////////////////////////////////////////
extern "C" __global__ void Cumulant_One_chim_Comp_SP_27(
- real omega,
- unsigned int* bcMatD,
- unsigned int* neighborX,
- unsigned int* neighborY,
- unsigned int* neighborZ,
- real* DDStart,
- int size_Mat,
- int level,
- real* forces,
- bool EvenOrOdd)
+ real omega,
+ unsigned int* bcMatD,
+ unsigned int* neighborX,
+ unsigned int* neighborY,
+ unsigned int* neighborZ,
+ real* DDStart,
+ int size_Mat,
+ int level,
+ real* forces,
+ bool EvenOrOdd)
{
- ////////////////////////////////////////////////////////////////////////////////
- const unsigned x = threadIdx.x; // Globaler x-Index
- const unsigned y = blockIdx.x; // Globaler y-Index
- const unsigned z = blockIdx.y; // Globaler z-Index
-
- const unsigned nx = blockDim.x;
- const unsigned ny = gridDim.x;
-
- const unsigned k = nx*(ny*z + y) + x;
- //////////////////////////////////////////////////////////////////////////
-
- if (k<size_Mat)
- {
- ////////////////////////////////////////////////////////////////////////////////
- unsigned int BC;
- BC = bcMatD[k];
-
- if (BC >= GEO_FLUID/*(BC != GEO_SOLID) && (BC != GEO_VOID)*/)
- {
- Distributions27 D;
- if (EvenOrOdd == true)
- {
- D.f[dirE ] = &DDStart[dirE *size_Mat];
- D.f[dirW ] = &DDStart[dirW *size_Mat];
- D.f[dirN ] = &DDStart[dirN *size_Mat];
- D.f[dirS ] = &DDStart[dirS *size_Mat];
- D.f[dirT ] = &DDStart[dirT *size_Mat];
- D.f[dirB ] = &DDStart[dirB *size_Mat];
- D.f[dirNE ] = &DDStart[dirNE *size_Mat];
- D.f[dirSW ] = &DDStart[dirSW *size_Mat];
- D.f[dirSE ] = &DDStart[dirSE *size_Mat];
- D.f[dirNW ] = &DDStart[dirNW *size_Mat];
- D.f[dirTE ] = &DDStart[dirTE *size_Mat];
- D.f[dirBW ] = &DDStart[dirBW *size_Mat];
- D.f[dirBE ] = &DDStart[dirBE *size_Mat];
- D.f[dirTW ] = &DDStart[dirTW *size_Mat];
- D.f[dirTN ] = &DDStart[dirTN *size_Mat];
- D.f[dirBS ] = &DDStart[dirBS *size_Mat];
- D.f[dirBN ] = &DDStart[dirBN *size_Mat];
- D.f[dirTS ] = &DDStart[dirTS *size_Mat];
- D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
- D.f[dirTNE ] = &DDStart[dirTNE *size_Mat];
- D.f[dirTSW ] = &DDStart[dirTSW *size_Mat];
- D.f[dirTSE ] = &DDStart[dirTSE *size_Mat];
- D.f[dirTNW ] = &DDStart[dirTNW *size_Mat];
- D.f[dirBNE ] = &DDStart[dirBNE *size_Mat];
- D.f[dirBSW ] = &DDStart[dirBSW *size_Mat];
- D.f[dirBSE ] = &DDStart[dirBSE *size_Mat];
- D.f[dirBNW ] = &DDStart[dirBNW *size_Mat];
- }
- else
- {
- D.f[dirW ] = &DDStart[dirE *size_Mat];
- D.f[dirE ] = &DDStart[dirW *size_Mat];
- D.f[dirS ] = &DDStart[dirN *size_Mat];
- D.f[dirN ] = &DDStart[dirS *size_Mat];
- D.f[dirB ] = &DDStart[dirT *size_Mat];
- D.f[dirT ] = &DDStart[dirB *size_Mat];
- D.f[dirSW ] = &DDStart[dirNE *size_Mat];
- D.f[dirNE ] = &DDStart[dirSW *size_Mat];
- D.f[dirNW ] = &DDStart[dirSE *size_Mat];
- D.f[dirSE ] = &DDStart[dirNW *size_Mat];
- D.f[dirBW ] = &DDStart[dirTE *size_Mat];
- D.f[dirTE ] = &DDStart[dirBW *size_Mat];
- D.f[dirTW ] = &DDStart[dirBE *size_Mat];
- D.f[dirBE ] = &DDStart[dirTW *size_Mat];
- D.f[dirBS ] = &DDStart[dirTN *size_Mat];
- D.f[dirTN ] = &DDStart[dirBS *size_Mat];
- D.f[dirTS ] = &DDStart[dirBN *size_Mat];
- D.f[dirBN ] = &DDStart[dirTS *size_Mat];
- D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
- D.f[dirBSW ] = &DDStart[dirTNE *size_Mat];
- D.f[dirBNE ] = &DDStart[dirTSW *size_Mat];
- D.f[dirBNW ] = &DDStart[dirTSE *size_Mat];
- D.f[dirBSE ] = &DDStart[dirTNW *size_Mat];
- D.f[dirTSW ] = &DDStart[dirBNE *size_Mat];
- D.f[dirTNE ] = &DDStart[dirBSW *size_Mat];
- D.f[dirTNW ] = &DDStart[dirBSE *size_Mat];
- D.f[dirTSE ] = &DDStart[dirBNW *size_Mat];
- }
- ////////////////////////////////////////////////////////////////////////////////
- //index
- unsigned int kw = neighborX[k];
- unsigned int ks = neighborY[k];
- unsigned int kb = neighborZ[k];
- unsigned int ksw = neighborY[kw];
- unsigned int kbw = neighborZ[kw];
- unsigned int kbs = neighborZ[ks];
- unsigned int kbsw = neighborZ[ksw];
- ////////////////////////////////////////////////////////////////////////////////////
- real mfcbb = (D.f[dirE ])[k ];
- real mfabb = (D.f[dirW ])[kw ];
- real mfbcb = (D.f[dirN ])[k ];
- real mfbab = (D.f[dirS ])[ks ];
- real mfbbc = (D.f[dirT ])[k ];
- real mfbba = (D.f[dirB ])[kb ];
- real mfccb = (D.f[dirNE ])[k ];
- real mfaab = (D.f[dirSW ])[ksw ];
- real mfcab = (D.f[dirSE ])[ks ];
- real mfacb = (D.f[dirNW ])[kw ];
- real mfcbc = (D.f[dirTE ])[k ];
- real mfaba = (D.f[dirBW ])[kbw ];
- real mfcba = (D.f[dirBE ])[kb ];
- real mfabc = (D.f[dirTW ])[kw ];
- real mfbcc = (D.f[dirTN ])[k ];
- real mfbaa = (D.f[dirBS ])[kbs ];
- real mfbca = (D.f[dirBN ])[kb ];
- real mfbac = (D.f[dirTS ])[ks ];
- real mfbbb = (D.f[dirZERO])[k ];
- real mfccc = (D.f[dirTNE ])[k ];
- real mfaac = (D.f[dirTSW ])[ksw ];
- real mfcac = (D.f[dirTSE ])[ks ];
- real mfacc = (D.f[dirTNW ])[kw ];
- real mfcca = (D.f[dirBNE ])[kb ];
- real mfaaa = (D.f[dirBSW ])[kbsw];
- real mfcaa = (D.f[dirBSE ])[kbs ];
- real mfaca = (D.f[dirBNW ])[kbw ];
- ////////////////////////////////////////////////////////////////////////////////////
- real drho = ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
- (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
- ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
-
- real rho = c1o1 + drho;
- real OOrho = c1o1 / rho;
- ////////////////////////////////////////////////////////////////////////////////////
- real vvx = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfcaa - mfacc) + (mfcca - mfaac))) +
- (((mfcba - mfabc) + (mfcbc - mfaba)) + ((mfcab - mfacb) + (mfccb - mfaab))) +
- (mfcbb - mfabb)) * OOrho;
- real vvy = ((((mfccc - mfaaa) + (mfaca - mfcac)) + ((mfacc - mfcaa) + (mfcca - mfaac))) +
- (((mfbca - mfbac) + (mfbcc - mfbaa)) + ((mfacb - mfcab) + (mfccb - mfaab))) +
- (mfbcb - mfbab)) * OOrho;
- real vvz = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfacc - mfcaa) + (mfaac - mfcca))) +
- (((mfbac - mfbca) + (mfbcc - mfbaa)) + ((mfabc - mfcba) + (mfcbc - mfaba))) +
- (mfbbc - mfbba)) * OOrho;
- ////////////////////////////////////////////////////////////////////////////////////
- //the force be with you
- real fx = forces[0] / (pow((double)c2o1, (double)level)); //zero;//0.0032653/(pow(two,level)); //0.000000005;//(two/1600000.0) / 120.0; //
- real fy = forces[1] / (pow((double)c2o1, (double)level)); //zero;
- real fz = forces[2] / (pow((double)c2o1, (double)level)); //zero;
- vvx += fx*c1o2;
- vvy += fy*c1o2;
- vvz += fz*c1o2;
- ////////////////////////////////////////////////////////////////////////////////////
- //real omega = omega_in;
- ////////////////////////////////////////////////////////////////////////////////////
- //fast
- //real oMdrho = c1o1; // comp special
- //real m0, m1, m2;
- real vx2;
- real vy2;
- real vz2;
- vx2 = vvx*vvx;
- vy2 = vvy*vvy;
- vz2 = vvz*vvz;
- ////////////////////////////////////////////////////////////////////////////////////
- //real wadjust;
- //real qudricLimitP = c1o100;// * 0.0001f;
- //real qudricLimitM = c1o100;// * 0.0001f;
- //real qudricLimitD = c1o100;// * 0.001f;
- ////////////////////////////////////////////////////////////////////////////////////
- //Hin
- ////////////////////////////////////////////////////////////////////////////////////
- // mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
- ////////////////////////////////////////////////////////////////////////////////////
- // Z - Dir
- forwardInverseChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, 36.0f, c1o36);
- forwardInverseChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, 9.0f , c1o9 );
- forwardInverseChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, 36.0f, c1o36);
- forwardInverseChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, 9.0f , c1o9 );
- forwardInverseChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, 2.25f, c4o9 );
- forwardInverseChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, 9.0f , c1o9 );
- forwardInverseChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, 36.0f, c1o36);
- forwardInverseChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, 9.0f , c1o9 );
- forwardInverseChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, 36.0f, c1o36);
-
- ////////////////////////////////////////////////////////////////////////////////////
- // mit 1/6, 0, 1/18, 2/3, 0, 2/9, 1/6, 0, 1/18 Konditionieren
- ////////////////////////////////////////////////////////////////////////////////////
- // Y - Dir
- forwardInverseChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, 6.0f , c1o6 );
- forwardChimera( mfaab, mfabb, mfacb, vvy, vy2);
- forwardInverseChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, 18.0f, c1o18);
- forwardInverseChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, 1.5f , c2o3 );
- forwardChimera( mfbab, mfbbb, mfbcb, vvy, vy2);
- forwardInverseChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, 4.5f , c2o9 );
- forwardInverseChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, 6.0f , c1o6 );
- forwardChimera( mfcab, mfcbb, mfccb, vvy, vy2);
- forwardInverseChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, 18.0f, c1o18);
-
- ////////////////////////////////////////////////////////////////////////////////////
- // mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
- ////////////////////////////////////////////////////////////////////////////////////
- // X - Dir
- forwardInverseChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o1, c1o1);
- forwardChimera( mfaba, mfbba, mfcba, vvx, vx2);
- forwardInverseChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, 3.0f, c1o3);
- forwardChimera( mfaab, mfbab, mfcab, vvx, vx2);
- forwardChimera( mfabb, mfbbb, mfcbb, vvx, vx2);
- forwardChimera( mfacb, mfbcb, mfccb, vvx, vx2);
- forwardInverseChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, 3.0f, c1o3);
- forwardChimera( mfabc, mfbbc, mfcbc, vvx, vx2);
- forwardInverseChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, 9.0f, c1o9);
-
- ////////////////////////////////////////////////////////////////////////////////////
- // Cumulants
- ////////////////////////////////////////////////////////////////////////////////////
- real OxxPyyPzz = c1o1;
- ////////////////////////////////////////////////////////////
- //3.
- //////////////////////////////
- real OxyyPxzz = c1o1;
- real OxyyMxzz = c1o1;
- //real Oxyz = c1o1;
- ////////////////////////////////////////////////////////////
- //4.
- //////////////////////////////
- real O4 = c1o1;
- ////////////////////////////////////////////////////////////
- //5.
- //////////////////////////////
- real O5 = c1o1;
- ////////////////////////////////////////////////////////////
- //6.
- //////////////////////////////
- real O6 = c1o1;
- ////////////////////////////////////////////////////////////
-
-
- //central moments to cumulants
- //4.
- real CUMcbb = mfcbb - ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) * OOrho;
- real CUMbcb = mfbcb - ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) * OOrho;
- real CUMbbc = mfbbc - ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) * OOrho;
-
- real CUMcca = mfcca - (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) * OOrho - c1o9*(drho * OOrho));
- real CUMcac = mfcac - (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) * OOrho - c1o9*(drho * OOrho));
- real CUMacc = mfacc - (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) * OOrho - c1o9*(drho * OOrho));
-
- //5.
- real CUMbcc = mfbcc - ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) * OOrho;
- real CUMcbc = mfcbc - ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) * OOrho;
- real CUMccb = mfccb - ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) * OOrho;
-
- //6.
- real CUMccc = mfccc + ((-c4o1 * mfbbb * mfbbb
- - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
- - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
- - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) * OOrho
- + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
- + c2o1 * (mfcaa * mfaca * mfaac)
- + c16o1 * mfbba * mfbab * mfabb) * OOrho * OOrho
- - c1o3 * (mfacc + mfcac + mfcca) * OOrho
- - c1o9 * (mfcaa + mfaca + mfaac) * OOrho
- + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
- + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) * OOrho * OOrho * c2o3
- + c1o27*((drho * drho - drho) * OOrho * OOrho ));
-
-
- //2.
- // linear combinations
- real mxxPyyPzz = mfcaa + mfaca + mfaac;
- real mxxMyy = mfcaa - mfaca;
- real mxxMzz = mfcaa - mfaac;
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //incl. correction (hat noch nicht so gut funktioniert...Optimierungsbedarf??)
- {
- real dxux = c1o2 * (-omega) *(mxxMyy + mxxMzz) + c1o2 * OxxPyyPzz * (mfaaa - mxxPyyPzz);
- real dyuy = dxux + omega * c3o2 * mxxMyy;
- real dzuz = dxux + omega * c3o2 * mxxMzz;
-
- //relax
- mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz)- c3o1 * (c1o1 - c1o2 * OxxPyyPzz) * (vx2 * dxux + vy2 * dyuy + vz2 * dzuz);//-magicBulk*OxxPyyPzz;
- mxxMyy += omega * (-mxxMyy) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vy2 * dyuy);
- mxxMzz += omega * (-mxxMzz) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vz2 * dzuz);
-
- }
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////no correction
- //mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz);//-magicBulk*OxxPyyPzz;
- //mxxMyy += -(-omega) * (-mxxMyy);
- //mxxMzz += -(-omega) * (-mxxMzz);
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- mfabb += omega * (-mfabb);
- mfbab += omega * (-mfbab);
- mfbba += omega * (-mfbba);
-
- //////////////////////////////////////////////////////////////////////////
-
- // linear combinations back
- mfcaa = c1o3 * (mxxMyy + mxxMzz + mxxPyyPzz);
- mfaca = c1o3 * (-c2o1* mxxMyy + mxxMzz + mxxPyyPzz);
- mfaac = c1o3 * (mxxMyy - c2o1* mxxMzz + mxxPyyPzz);
-
- //3.
- // linear combinations
-
- real mxxyPyzz = mfcba + mfabc;
- real mxxyMyzz = mfcba - mfabc;
-
- real mxxzPyyz = mfcab + mfacb;
- real mxxzMyyz = mfcab - mfacb;
-
- real mxyyPxzz = mfbca + mfbac;
- real mxyyMxzz = mfbca - mfbac;
-
- //relax
- //////////////////////////////////////////////////////////////////////////
- mfbbb += OxyyMxzz * (-mfbbb);
- mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
- mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
- mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
- mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
- mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
- mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
- //////////////////////////////////////////////////////////////////////////
-
- mfcba = (mxxyMyzz + mxxyPyzz) * c1o2;
- mfabc = (-mxxyMyzz + mxxyPyzz) * c1o2;
- mfcab = (mxxzMyyz + mxxzPyyz) * c1o2;
- mfacb = (-mxxzMyyz + mxxzPyyz) * c1o2;
- mfbca = (mxyyMxzz + mxyyPxzz) * c1o2;
- mfbac = (-mxyyMxzz + mxyyPxzz) * c1o2;
-
- //4.
- //////////////////////////////////////////////////////////////////////////
- CUMacc += O4 * (-CUMacc);
- CUMcac += O4 * (-CUMcac);
- CUMcca += O4 * (-CUMcca);
-
- CUMbbc += O4 * (-CUMbbc);
- CUMbcb += O4 * (-CUMbcb);
- CUMcbb += O4 * (-CUMcbb);
- //////////////////////////////////////////////////////////////////////////
-
-
- //5.
- CUMbcc += O5 * (-CUMbcc);
- CUMcbc += O5 * (-CUMcbc);
- CUMccb += O5 * (-CUMccb);
-
- //6.
- CUMccc += O6 * (-CUMccc);
-
-
-
- //back cumulants to central moments
- //4.
- mfcbb = CUMcbb + c1o3*((c3o1*mfcaa + c1o1) * mfabb + c6o1 * mfbba * mfbab) * OOrho;
- mfbcb = CUMbcb + c1o3*((c3o1*mfaca + c1o1) * mfbab + c6o1 * mfbba * mfabb) * OOrho;
- mfbbc = CUMbbc + c1o3*((c3o1*mfaac + c1o1) * mfbba + c6o1 * mfbab * mfabb) * OOrho;
-
- mfcca = CUMcca + (((mfcaa * mfaca + c2o1 * mfbba * mfbba)*c9o1 + c3o1 * (mfcaa + mfaca)) * OOrho - (drho * OOrho))*c1o9;
- mfcac = CUMcac + (((mfcaa * mfaac + c2o1 * mfbab * mfbab)*c9o1 + c3o1 * (mfcaa + mfaac)) * OOrho - (drho * OOrho))*c1o9;
- mfacc = CUMacc + (((mfaac * mfaca + c2o1 * mfabb * mfabb)*c9o1 + c3o1 * (mfaac + mfaca)) * OOrho - (drho * OOrho))*c1o9;
-
- //5.
- mfbcc = CUMbcc + c1o3 *(c3o1*(mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + (mfbca + mfbac)) * OOrho;
- mfcbc = CUMcbc + c1o3 *(c3o1*(mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + (mfcba + mfabc)) * OOrho;
- mfccb = CUMccb + c1o3 *(c3o1*(mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + (mfacb + mfcab)) * OOrho;
-
- //6.
- mfccc =
- CUMccc - ((-c4o1 * mfbbb * mfbbb
- - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
- - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
- - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) * OOrho
- + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
- + c2o1 * (mfcaa * mfaca * mfaac)
- + c16o1 * mfbba * mfbab * mfabb) * OOrho * OOrho
- - c1o3 * (mfacc + mfcac + mfcca) * OOrho
- - c1o9 * (mfcaa + mfaca + mfaac) * OOrho
- + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
- + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) * OOrho * OOrho * c2o3
- + c1o27*((drho * drho - drho) * OOrho * OOrho ));
-
- ////////////////////////////////////////////////////////////////////////////////////
- //the force be with you
- mfbaa = -mfbaa;
- mfaba = -mfaba;
- mfaab = -mfaab;
- ////////////////////////////////////////////////////////////////////////////////////
-
-
- ////////////////////////////////////////////////////////////////////////////////////
- //back
- ////////////////////////////////////////////////////////////////////////////////////
- //mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
- ////////////////////////////////////////////////////////////////////////////////////
- // X - Dir
- backwardInverseChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o1, c1o1);
- backwardChimera( mfaba, mfbba, mfcba, vvx, vx2);
- backwardInverseChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, 3.0f, c1o3);
- backwardChimera( mfaab, mfbab, mfcab, vvx, vx2);
- backwardChimera( mfabb, mfbbb, mfcbb, vvx, vx2);
- backwardChimera( mfacb, mfbcb, mfccb, vvx, vx2);
- backwardInverseChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, 3.0f, c1o3);
- backwardChimera( mfabc, mfbbc, mfcbc, vvx, vx2);
- backwardInverseChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, 9.0f, c1o9);
-
- ////////////////////////////////////////////////////////////////////////////////////
- //mit 1/6, 2/3, 1/6, 0, 0, 0, 1/18, 2/9, 1/18 Konditionieren
- ////////////////////////////////////////////////////////////////////////////////////
- // Y - Dir
- backwardInverseChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, 6.0f , c1o6 );
- backwardChimera( mfaab, mfabb, mfacb, vvy, vy2);
- backwardInverseChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, 18.0f, c1o18);
- backwardInverseChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, 1.5f , c2o3 );
- backwardChimera( mfbab, mfbbb, mfbcb, vvy, vy2);
- backwardInverseChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, 4.5f , c2o9 );
- backwardInverseChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, 6.0f , c1o6 );
- backwardChimera( mfcab, mfcbb, mfccb, vvy, vy2);
- backwardInverseChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, 18.0f, c1o18);
-
- ////////////////////////////////////////////////////////////////////////////////////
- //mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
- ////////////////////////////////////////////////////////////////////////////////////
- // Z - Dir
- backwardInverseChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, 36.0f, c1o36);
- backwardInverseChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, 9.0f , c1o9 );
- backwardInverseChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, 36.0f, c1o36);
- backwardInverseChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, 9.0f , c1o9 );
- backwardInverseChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, 2.25f, c4o9 );
- backwardInverseChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, 9.0f , c1o9 );
- backwardInverseChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, 36.0f, c1o36);
- backwardInverseChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, 9.0f , c1o9 );
- backwardInverseChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, 36.0f, c1o36);
-
- //////////////////////////////////////////////////////////////////////////////////////
- real drhoPost =
- ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
- (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
- ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
- mfbbb += drho - drhoPost;
- ////////////////////////////////////////////////////////////////////////////////////
- (D.f[dirE ])[k ] = mfabb;
- (D.f[dirW ])[kw ] = mfcbb;
- (D.f[dirN ])[k ] = mfbab;
- (D.f[dirS ])[ks ] = mfbcb;
- (D.f[dirT ])[k ] = mfbba;
- (D.f[dirB ])[kb ] = mfbbc;
- (D.f[dirNE ])[k ] = mfaab;
- (D.f[dirSW ])[ksw ] = mfccb;
- (D.f[dirSE ])[ks ] = mfacb;
- (D.f[dirNW ])[kw ] = mfcab;
- (D.f[dirTE ])[k ] = mfaba;
- (D.f[dirBW ])[kbw ] = mfcbc;
- (D.f[dirBE ])[kb ] = mfabc;
- (D.f[dirTW ])[kw ] = mfcba;
- (D.f[dirTN ])[k ] = mfbaa;
- (D.f[dirBS ])[kbs ] = mfbcc;
- (D.f[dirBN ])[kb ] = mfbac;
- (D.f[dirTS ])[ks ] = mfbca;
- (D.f[dirZERO])[k ] = mfbbb;
- (D.f[dirTNE ])[k ] = mfaaa;
- (D.f[dirTSE ])[ks ] = mfaca;
- (D.f[dirBNE ])[kb ] = mfaac;
- (D.f[dirBSE ])[kbs ] = mfacc;
- (D.f[dirTNW ])[kw ] = mfcaa;
- (D.f[dirTSW ])[ksw ] = mfcca;
- (D.f[dirBNW ])[kbw ] = mfcac;
- (D.f[dirBSW ])[kbsw] = mfccc;
- }
- }
+ ////////////////////////////////////////////////////////////////////////////////
+ const unsigned x = threadIdx.x; // Globaler x-Index
+ const unsigned y = blockIdx.x; // Globaler y-Index
+ const unsigned z = blockIdx.y; // Globaler z-Index
+
+ const unsigned nx = blockDim.x;
+ const unsigned ny = gridDim.x;
+
+ const unsigned k = nx*(ny*z + y) + x;
+ //////////////////////////////////////////////////////////////////////////
+
+ if (k<size_Mat)
+ {
+ ////////////////////////////////////////////////////////////////////////////////
+ unsigned int BC;
+ BC = bcMatD[k];
+
+ if (BC >= GEO_FLUID/*(BC != GEO_SOLID) && (BC != GEO_VOID)*/)
+ {
+ Distributions27 D;
+ if (EvenOrOdd == true)
+ {
+ D.f[dirE ] = &DDStart[dirE *size_Mat];
+ D.f[dirW ] = &DDStart[dirW *size_Mat];
+ D.f[dirN ] = &DDStart[dirN *size_Mat];
+ D.f[dirS ] = &DDStart[dirS *size_Mat];
+ D.f[dirT ] = &DDStart[dirT *size_Mat];
+ D.f[dirB ] = &DDStart[dirB *size_Mat];
+ D.f[dirNE ] = &DDStart[dirNE *size_Mat];
+ D.f[dirSW ] = &DDStart[dirSW *size_Mat];
+ D.f[dirSE ] = &DDStart[dirSE *size_Mat];
+ D.f[dirNW ] = &DDStart[dirNW *size_Mat];
+ D.f[dirTE ] = &DDStart[dirTE *size_Mat];
+ D.f[dirBW ] = &DDStart[dirBW *size_Mat];
+ D.f[dirBE ] = &DDStart[dirBE *size_Mat];
+ D.f[dirTW ] = &DDStart[dirTW *size_Mat];
+ D.f[dirTN ] = &DDStart[dirTN *size_Mat];
+ D.f[dirBS ] = &DDStart[dirBS *size_Mat];
+ D.f[dirBN ] = &DDStart[dirBN *size_Mat];
+ D.f[dirTS ] = &DDStart[dirTS *size_Mat];
+ D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
+ D.f[dirTNE ] = &DDStart[dirTNE *size_Mat];
+ D.f[dirTSW ] = &DDStart[dirTSW *size_Mat];
+ D.f[dirTSE ] = &DDStart[dirTSE *size_Mat];
+ D.f[dirTNW ] = &DDStart[dirTNW *size_Mat];
+ D.f[dirBNE ] = &DDStart[dirBNE *size_Mat];
+ D.f[dirBSW ] = &DDStart[dirBSW *size_Mat];
+ D.f[dirBSE ] = &DDStart[dirBSE *size_Mat];
+ D.f[dirBNW ] = &DDStart[dirBNW *size_Mat];
+ }
+ else
+ {
+ D.f[dirW ] = &DDStart[dirE *size_Mat];
+ D.f[dirE ] = &DDStart[dirW *size_Mat];
+ D.f[dirS ] = &DDStart[dirN *size_Mat];
+ D.f[dirN ] = &DDStart[dirS *size_Mat];
+ D.f[dirB ] = &DDStart[dirT *size_Mat];
+ D.f[dirT ] = &DDStart[dirB *size_Mat];
+ D.f[dirSW ] = &DDStart[dirNE *size_Mat];
+ D.f[dirNE ] = &DDStart[dirSW *size_Mat];
+ D.f[dirNW ] = &DDStart[dirSE *size_Mat];
+ D.f[dirSE ] = &DDStart[dirNW *size_Mat];
+ D.f[dirBW ] = &DDStart[dirTE *size_Mat];
+ D.f[dirTE ] = &DDStart[dirBW *size_Mat];
+ D.f[dirTW ] = &DDStart[dirBE *size_Mat];
+ D.f[dirBE ] = &DDStart[dirTW *size_Mat];
+ D.f[dirBS ] = &DDStart[dirTN *size_Mat];
+ D.f[dirTN ] = &DDStart[dirBS *size_Mat];
+ D.f[dirTS ] = &DDStart[dirBN *size_Mat];
+ D.f[dirBN ] = &DDStart[dirTS *size_Mat];
+ D.f[dirZERO] = &DDStart[dirZERO*size_Mat];
+ D.f[dirBSW ] = &DDStart[dirTNE *size_Mat];
+ D.f[dirBNE ] = &DDStart[dirTSW *size_Mat];
+ D.f[dirBNW ] = &DDStart[dirTSE *size_Mat];
+ D.f[dirBSE ] = &DDStart[dirTNW *size_Mat];
+ D.f[dirTSW ] = &DDStart[dirBNE *size_Mat];
+ D.f[dirTNE ] = &DDStart[dirBSW *size_Mat];
+ D.f[dirTNW ] = &DDStart[dirBSE *size_Mat];
+ D.f[dirTSE ] = &DDStart[dirBNW *size_Mat];
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+ //index
+ unsigned int kw = neighborX[k];
+ unsigned int ks = neighborY[k];
+ unsigned int kb = neighborZ[k];
+ unsigned int ksw = neighborY[kw];
+ unsigned int kbw = neighborZ[kw];
+ unsigned int kbs = neighborZ[ks];
+ unsigned int kbsw = neighborZ[ksw];
+ ////////////////////////////////////////////////////////////////////////////////////
+ real mfcbb = (D.f[dirE ])[k ];
+ real mfabb = (D.f[dirW ])[kw ];
+ real mfbcb = (D.f[dirN ])[k ];
+ real mfbab = (D.f[dirS ])[ks ];
+ real mfbbc = (D.f[dirT ])[k ];
+ real mfbba = (D.f[dirB ])[kb ];
+ real mfccb = (D.f[dirNE ])[k ];
+ real mfaab = (D.f[dirSW ])[ksw ];
+ real mfcab = (D.f[dirSE ])[ks ];
+ real mfacb = (D.f[dirNW ])[kw ];
+ real mfcbc = (D.f[dirTE ])[k ];
+ real mfaba = (D.f[dirBW ])[kbw ];
+ real mfcba = (D.f[dirBE ])[kb ];
+ real mfabc = (D.f[dirTW ])[kw ];
+ real mfbcc = (D.f[dirTN ])[k ];
+ real mfbaa = (D.f[dirBS ])[kbs ];
+ real mfbca = (D.f[dirBN ])[kb ];
+ real mfbac = (D.f[dirTS ])[ks ];
+ real mfbbb = (D.f[dirZERO])[k ];
+ real mfccc = (D.f[dirTNE ])[k ];
+ real mfaac = (D.f[dirTSW ])[ksw ];
+ real mfcac = (D.f[dirTSE ])[ks ];
+ real mfacc = (D.f[dirTNW ])[kw ];
+ real mfcca = (D.f[dirBNE ])[kb ];
+ real mfaaa = (D.f[dirBSW ])[kbsw];
+ real mfcaa = (D.f[dirBSE ])[kbs ];
+ real mfaca = (D.f[dirBNW ])[kbw ];
+ ////////////////////////////////////////////////////////////////////////////////////
+ real drho = ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
+ (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
+ ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
+
+ real rho = c1o1 + drho;
+ real OOrho = c1o1 / rho;
+ ////////////////////////////////////////////////////////////////////////////////////
+ real vvx = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfcaa - mfacc) + (mfcca - mfaac))) +
+ (((mfcba - mfabc) + (mfcbc - mfaba)) + ((mfcab - mfacb) + (mfccb - mfaab))) +
+ (mfcbb - mfabb)) * OOrho;
+ real vvy = ((((mfccc - mfaaa) + (mfaca - mfcac)) + ((mfacc - mfcaa) + (mfcca - mfaac))) +
+ (((mfbca - mfbac) + (mfbcc - mfbaa)) + ((mfacb - mfcab) + (mfccb - mfaab))) +
+ (mfbcb - mfbab)) * OOrho;
+ real vvz = ((((mfccc - mfaaa) + (mfcac - mfaca)) + ((mfacc - mfcaa) + (mfaac - mfcca))) +
+ (((mfbac - mfbca) + (mfbcc - mfbaa)) + ((mfabc - mfcba) + (mfcbc - mfaba))) +
+ (mfbbc - mfbba)) * OOrho;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //the force be with you
+ real fx = forces[0] / (pow((double)c2o1, (double)level)); //zero;//0.0032653/(pow(two,level)); //0.000000005;//(two/1600000.0) / 120.0; //
+ real fy = forces[1] / (pow((double)c2o1, (double)level)); //zero;
+ real fz = forces[2] / (pow((double)c2o1, (double)level)); //zero;
+ vvx += fx*c1o2;
+ vvy += fy*c1o2;
+ vvz += fz*c1o2;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //real omega = omega_in;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //fast
+ //real oMdrho = c1o1; // comp special
+ //real m0, m1, m2;
+ real vx2;
+ real vy2;
+ real vz2;
+ vx2 = vvx*vvx;
+ vy2 = vvy*vvy;
+ vz2 = vvz*vvz;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //real wadjust;
+ //real qudricLimitP = c1o100;// * 0.0001f;
+ //real qudricLimitM = c1o100;// * 0.0001f;
+ //real qudricLimitD = c1o100;// * 0.001f;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //Hin
+ ////////////////////////////////////////////////////////////////////////////////////
+ // mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Z - Dir
+ vf::lbm::forwardInverseChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, 36.0f, c1o36);
+ vf::lbm::forwardInverseChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::forwardInverseChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, 36.0f, c1o36);
+ vf::lbm::forwardInverseChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::forwardInverseChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, 2.25f, c4o9 );
+ vf::lbm::forwardInverseChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::forwardInverseChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, 36.0f, c1o36);
+ vf::lbm::forwardInverseChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::forwardInverseChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, 36.0f, c1o36);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ // mit 1/6, 0, 1/18, 2/3, 0, 2/9, 1/6, 0, 1/18 Konditionieren
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Y - Dir
+ vf::lbm::forwardInverseChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, 6.0f , c1o6 );
+ vf::lbm::forwardChimera( mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::forwardInverseChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, 18.0f, c1o18);
+ vf::lbm::forwardInverseChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, 1.5f , c2o3 );
+ vf::lbm::forwardChimera( mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::forwardInverseChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, 4.5f , c2o9 );
+ vf::lbm::forwardInverseChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, 6.0f , c1o6 );
+ vf::lbm::forwardChimera( mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::forwardInverseChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, 18.0f, c1o18);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ // mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
+ ////////////////////////////////////////////////////////////////////////////////////
+ // X - Dir
+ vf::lbm::forwardInverseChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o1, c1o1);
+ vf::lbm::forwardChimera( mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::forwardInverseChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, 3.0f, c1o3);
+ vf::lbm::forwardChimera( mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::forwardChimera( mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::forwardChimera( mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::forwardInverseChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, 3.0f, c1o3);
+ vf::lbm::forwardChimera( mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::forwardInverseChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, 9.0f, c1o9);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Cumulants
+ ////////////////////////////////////////////////////////////////////////////////////
+ real OxxPyyPzz = c1o1;
+ ////////////////////////////////////////////////////////////
+ //3.
+ //////////////////////////////
+ real OxyyPxzz = c1o1;
+ real OxyyMxzz = c1o1;
+ //real Oxyz = c1o1;
+ ////////////////////////////////////////////////////////////
+ //4.
+ //////////////////////////////
+ real O4 = c1o1;
+ ////////////////////////////////////////////////////////////
+ //5.
+ //////////////////////////////
+ real O5 = c1o1;
+ ////////////////////////////////////////////////////////////
+ //6.
+ //////////////////////////////
+ real O6 = c1o1;
+ ////////////////////////////////////////////////////////////
+
+
+ //central moments to cumulants
+ //4.
+ real CUMcbb = mfcbb - ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) * OOrho;
+ real CUMbcb = mfbcb - ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) * OOrho;
+ real CUMbbc = mfbbc - ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) * OOrho;
+
+ real CUMcca = mfcca - (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) * OOrho - c1o9*(drho * OOrho));
+ real CUMcac = mfcac - (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) * OOrho - c1o9*(drho * OOrho));
+ real CUMacc = mfacc - (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) * OOrho - c1o9*(drho * OOrho));
+
+ //5.
+ real CUMbcc = mfbcc - ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) * OOrho;
+ real CUMcbc = mfcbc - ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) * OOrho;
+ real CUMccb = mfccb - ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) * OOrho;
+
+ //6.
+ real CUMccc = mfccc + ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) * OOrho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) * OOrho * OOrho
+ - c1o3 * (mfacc + mfcac + mfcca) * OOrho
+ - c1o9 * (mfcaa + mfaca + mfaac) * OOrho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) * OOrho * OOrho * c2o3
+ + c1o27*((drho * drho - drho) * OOrho * OOrho ));
+
+
+ //2.
+ // linear combinations
+ real mxxPyyPzz = mfcaa + mfaca + mfaac;
+ real mxxMyy = mfcaa - mfaca;
+ real mxxMzz = mfcaa - mfaac;
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //incl. correction (hat noch nicht so gut funktioniert...Optimierungsbedarf??)
+ {
+ real dxux = c1o2 * (-omega) *(mxxMyy + mxxMzz) + c1o2 * OxxPyyPzz * (mfaaa - mxxPyyPzz);
+ real dyuy = dxux + omega * c3o2 * mxxMyy;
+ real dzuz = dxux + omega * c3o2 * mxxMzz;
+
+ //relax
+ mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz)- c3o1 * (c1o1 - c1o2 * OxxPyyPzz) * (vx2 * dxux + vy2 * dyuy + vz2 * dzuz);//-magicBulk*OxxPyyPzz;
+ mxxMyy += omega * (-mxxMyy) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vy2 * dyuy);
+ mxxMzz += omega * (-mxxMzz) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vz2 * dzuz);
+
+ }
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////no correction
+ //mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz);//-magicBulk*OxxPyyPzz;
+ //mxxMyy += -(-omega) * (-mxxMyy);
+ //mxxMzz += -(-omega) * (-mxxMzz);
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ mfabb += omega * (-mfabb);
+ mfbab += omega * (-mfbab);
+ mfbba += omega * (-mfbba);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ // linear combinations back
+ mfcaa = c1o3 * (mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaca = c1o3 * (-c2o1* mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaac = c1o3 * (mxxMyy - c2o1* mxxMzz + mxxPyyPzz);
+
+ //3.
+ // linear combinations
+
+ real mxxyPyzz = mfcba + mfabc;
+ real mxxyMyzz = mfcba - mfabc;
+
+ real mxxzPyyz = mfcab + mfacb;
+ real mxxzMyyz = mfcab - mfacb;
+
+ real mxyyPxzz = mfbca + mfbac;
+ real mxyyMxzz = mfbca - mfbac;
+
+ //relax
+ //////////////////////////////////////////////////////////////////////////
+ mfbbb += OxyyMxzz * (-mfbbb);
+ mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
+ mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
+ mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
+ mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
+ mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
+ mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
+ //////////////////////////////////////////////////////////////////////////
+
+ mfcba = (mxxyMyzz + mxxyPyzz) * c1o2;
+ mfabc = (-mxxyMyzz + mxxyPyzz) * c1o2;
+ mfcab = (mxxzMyyz + mxxzPyyz) * c1o2;
+ mfacb = (-mxxzMyyz + mxxzPyyz) * c1o2;
+ mfbca = (mxyyMxzz + mxyyPxzz) * c1o2;
+ mfbac = (-mxyyMxzz + mxyyPxzz) * c1o2;
+
+ //4.
+ //////////////////////////////////////////////////////////////////////////
+ CUMacc += O4 * (-CUMacc);
+ CUMcac += O4 * (-CUMcac);
+ CUMcca += O4 * (-CUMcca);
+
+ CUMbbc += O4 * (-CUMbbc);
+ CUMbcb += O4 * (-CUMbcb);
+ CUMcbb += O4 * (-CUMcbb);
+ //////////////////////////////////////////////////////////////////////////
+
+
+ //5.
+ CUMbcc += O5 * (-CUMbcc);
+ CUMcbc += O5 * (-CUMcbc);
+ CUMccb += O5 * (-CUMccb);
+
+ //6.
+ CUMccc += O6 * (-CUMccc);
+
+
+
+ //back cumulants to central moments
+ //4.
+ mfcbb = CUMcbb + c1o3*((c3o1*mfcaa + c1o1) * mfabb + c6o1 * mfbba * mfbab) * OOrho;
+ mfbcb = CUMbcb + c1o3*((c3o1*mfaca + c1o1) * mfbab + c6o1 * mfbba * mfabb) * OOrho;
+ mfbbc = CUMbbc + c1o3*((c3o1*mfaac + c1o1) * mfbba + c6o1 * mfbab * mfabb) * OOrho;
+
+ mfcca = CUMcca + (((mfcaa * mfaca + c2o1 * mfbba * mfbba)*c9o1 + c3o1 * (mfcaa + mfaca)) * OOrho - (drho * OOrho))*c1o9;
+ mfcac = CUMcac + (((mfcaa * mfaac + c2o1 * mfbab * mfbab)*c9o1 + c3o1 * (mfcaa + mfaac)) * OOrho - (drho * OOrho))*c1o9;
+ mfacc = CUMacc + (((mfaac * mfaca + c2o1 * mfabb * mfabb)*c9o1 + c3o1 * (mfaac + mfaca)) * OOrho - (drho * OOrho))*c1o9;
+
+ //5.
+ mfbcc = CUMbcc + c1o3 *(c3o1*(mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + (mfbca + mfbac)) * OOrho;
+ mfcbc = CUMcbc + c1o3 *(c3o1*(mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + (mfcba + mfabc)) * OOrho;
+ mfccb = CUMccb + c1o3 *(c3o1*(mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + (mfacb + mfcab)) * OOrho;
+
+ //6.
+ mfccc =
+ CUMccc - ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) * OOrho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) * OOrho * OOrho
+ - c1o3 * (mfacc + mfcac + mfcca) * OOrho
+ - c1o9 * (mfcaa + mfaca + mfaac) * OOrho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) * OOrho * OOrho * c2o3
+ + c1o27*((drho * drho - drho) * OOrho * OOrho ));
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //the force be with you
+ mfbaa = -mfbaa;
+ mfaba = -mfaba;
+ mfaab = -mfaab;
+ ////////////////////////////////////////////////////////////////////////////////////
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //back
+ ////////////////////////////////////////////////////////////////////////////////////
+ //mit 1, 0, 1/3, 0, 0, 0, 1/3, 0, 1/9 Konditionieren
+ ////////////////////////////////////////////////////////////////////////////////////
+ // X - Dir
+ vf::lbm::backwardInverseChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o1, c1o1);
+ vf::lbm::backwardChimera( mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::backwardInverseChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, 3.0f, c1o3);
+ vf::lbm::backwardChimera( mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::backwardChimera( mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::backwardChimera( mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::backwardInverseChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, 3.0f, c1o3);
+ vf::lbm::backwardChimera( mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::backwardInverseChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, 9.0f, c1o9);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //mit 1/6, 2/3, 1/6, 0, 0, 0, 1/18, 2/9, 1/18 Konditionieren
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Y - Dir
+ vf::lbm::backwardInverseChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, 6.0f , c1o6 );
+ vf::lbm::backwardChimera( mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::backwardInverseChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, 18.0f, c1o18);
+ vf::lbm::backwardInverseChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, 1.5f , c2o3 );
+ vf::lbm::backwardChimera( mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::backwardInverseChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, 4.5f , c2o9 );
+ vf::lbm::backwardInverseChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, 6.0f , c1o6 );
+ vf::lbm::backwardChimera( mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::backwardInverseChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, 18.0f, c1o18);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //mit 1/36, 1/9, 1/36, 1/9, 4/9, 1/9, 1/36, 1/9, 1/36 Konditionieren
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Z - Dir
+ vf::lbm::backwardInverseChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, 36.0f, c1o36);
+ vf::lbm::backwardInverseChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::backwardInverseChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, 36.0f, c1o36);
+ vf::lbm::backwardInverseChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::backwardInverseChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, 2.25f, c4o9 );
+ vf::lbm::backwardInverseChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::backwardInverseChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, 36.0f, c1o36);
+ vf::lbm::backwardInverseChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, 9.0f , c1o9 );
+ vf::lbm::backwardInverseChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, 36.0f, c1o36);
+
+ //////////////////////////////////////////////////////////////////////////////////////
+ real drhoPost =
+ ((((mfccc + mfaaa) + (mfaca + mfcac)) + ((mfacc + mfcaa) + (mfaac + mfcca))) +
+ (((mfbac + mfbca) + (mfbaa + mfbcc)) + ((mfabc + mfcba) + (mfaba + mfcbc)) + ((mfacb + mfcab) + (mfaab + mfccb))) +
+ ((mfabb + mfcbb) + (mfbab + mfbcb) + (mfbba + mfbbc))) + mfbbb;
+ mfbbb += drho - drhoPost;
+ ////////////////////////////////////////////////////////////////////////////////////
+ (D.f[dirE ])[k ] = mfabb;
+ (D.f[dirW ])[kw ] = mfcbb;
+ (D.f[dirN ])[k ] = mfbab;
+ (D.f[dirS ])[ks ] = mfbcb;
+ (D.f[dirT ])[k ] = mfbba;
+ (D.f[dirB ])[kb ] = mfbbc;
+ (D.f[dirNE ])[k ] = mfaab;
+ (D.f[dirSW ])[ksw ] = mfccb;
+ (D.f[dirSE ])[ks ] = mfacb;
+ (D.f[dirNW ])[kw ] = mfcab;
+ (D.f[dirTE ])[k ] = mfaba;
+ (D.f[dirBW ])[kbw ] = mfcbc;
+ (D.f[dirBE ])[kb ] = mfabc;
+ (D.f[dirTW ])[kw ] = mfcba;
+ (D.f[dirTN ])[k ] = mfbaa;
+ (D.f[dirBS ])[kbs ] = mfbcc;
+ (D.f[dirBN ])[kb ] = mfbac;
+ (D.f[dirTS ])[ks ] = mfbca;
+ (D.f[dirZERO])[k ] = mfbbb;
+ (D.f[dirTNE ])[k ] = mfaaa;
+ (D.f[dirTSE ])[ks ] = mfaca;
+ (D.f[dirBNE ])[kb ] = mfaac;
+ (D.f[dirBSE ])[kbs ] = mfacc;
+ (D.f[dirTNW ])[kw ] = mfcaa;
+ (D.f[dirTSW ])[ksw ] = mfcca;
+ (D.f[dirBNW ])[kbw ] = mfcac;
+ (D.f[dirBSW ])[kbsw] = mfccc;
+ }
+ }
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h b/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h
index 3589bcea15dd73771ff0f7579401e65da7010389..dfdbac44d197e55e3e78eb794692fd9443cb7ab6 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h
+++ b/src/gpu/VirtualFluids_GPU/GPU/GPU_Interface.h
@@ -131,6 +131,7 @@ extern "C" void KernelKumNewSP27( unsigned int numberOfThreads,
int size_Mat,
bool EvenOrOdd);
+
extern "C" void CumulantOnePreconditionedErrorDiffusionChimCompSP27(
unsigned int numberOfThreads,
real s9,
diff --git a/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh b/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh
index b41724df488f7aea97ed5e9e2bcf9282ff6bc370..288db43e7bcd36dc4d187982b86178d345601094 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh
+++ b/src/gpu/VirtualFluids_GPU/GPU/GPU_Kernels.cuh
@@ -140,7 +140,6 @@ extern "C" __global__ void LB_Kernel_Kum_Comp_SP_27(real s9,
int size_Mat,
bool EvenOrOdd);
-
extern "C" __global__ void Cumulant_One_preconditioned_errorDiffusion_chim_Comp_SP_27(
real omega,
unsigned int* bcMatD,
diff --git a/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu b/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
index a203cca15bfd0fccac53d1d86555a023063ea86a..8b80e5ea9dbed3deef4c4332b2d43bf62ba9e48b 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
@@ -353,6 +353,7 @@ extern "C" void KernelKumNewCompSP27(unsigned int numberOfThreads,
// EvenOrOdd);
//getLastCudaError("LB_Kernel_Kum_New_Comp_SP_27 execution failed");
}
+
//////////////////////////////////////////////////////////////////////////
extern "C" void CumulantOnePreconditionedErrorDiffusionChimCompSP27(unsigned int numberOfThreads,
real s9,
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernel.h b/src/gpu/VirtualFluids_GPU/Kernel/Kernel.h
index 8932dadb3f92256cba279121193f94dbabdc0a6d..213127e64c5e7bfe2b3d4c9d1154c11d374f9552 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/Kernel.h
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernel.h
@@ -1,26 +1,19 @@
-#ifndef KERNEL_H
-#define KERNEL_H
+#ifndef GPU_KERNEL_H
+#define GPU_KERNEL_H
-#include <DataTypes.h>
-
-#include <cuda_runtime.h>
-#include <helper_functions.h>
-#include <helper_cuda.h>
+#include <vector>
#include "Kernel/Utilities/KernelGroup.h"
#include "PreProcessor/PreProcessorType.h"
-#include <vector>
-
-
class Kernel
{
public:
- virtual ~Kernel() = default;
- virtual void run() = 0;
+ virtual ~Kernel() = default;
+ virtual void run() = 0;
- virtual bool checkParameter() = 0;
- virtual std::vector<PreProcessorType> getPreProcessorTypes() = 0;
- virtual KernelGroup getKernelGroup() = 0;
+ virtual bool checkParameter() = 0;
+ virtual std::vector<PreProcessorType> getPreProcessorTypes() = 0;
+ virtual KernelGroup getKernelGroup() = 0;
};
-#endif
\ No newline at end of file
+#endif
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.cpp b/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.cpp
index 6d06d4c9175c7935bb609c2e342b29c50c42846d..5e4c5aa08e37e88008da13466bfeed6893ec94f6 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.cpp
+++ b/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.cpp
@@ -2,26 +2,26 @@
#include "Kernel/Utilities/CheckParameterStrategy/CheckParameterStrategy.h"
-bool KernelImp::checkParameter()
-{
- return checkStrategy->checkParameter(para);
+bool KernelImp::checkParameter()
+{
+ return checkStrategy->checkParameter(para);
}
-std::vector<PreProcessorType> KernelImp::getPreProcessorTypes()
-{
- return myPreProcessorTypes;
+std::vector<PreProcessorType> KernelImp::getPreProcessorTypes()
+{
+ return myPreProcessorTypes;
}
-KernelGroup KernelImp::getKernelGroup()
-{
- return myKernelGroup;
+KernelGroup KernelImp::getKernelGroup()
+{
+ return myKernelGroup;
}
void KernelImp::setCheckParameterStrategy(std::shared_ptr<CheckParameterStrategy> strategy)
{
- this->checkStrategy = strategy;
+ this->checkStrategy = strategy;
}
-KernelImp::KernelImp()
-{
-}
+KernelImp::KernelImp(std::shared_ptr<Parameter> para, int level) : para(para), level(level) {}
+
+KernelImp::KernelImp() {}
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.h b/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.h
index f902a7aaec82acd1eb0a55e97f5a4f31f4334575..08b71d42e79564d9eac887289a1ae36824095c46 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.h
+++ b/src/gpu/VirtualFluids_GPU/Kernel/KernelImp.h
@@ -5,28 +5,33 @@
#include <memory>
+#include "Utilities/CudaGrid.h"
+
class CheckParameterStrategy;
class Parameter;
class KernelImp : public Kernel
{
public:
- virtual void run() = 0;
+ virtual void run() = 0;
- bool checkParameter();
- std::vector<PreProcessorType> getPreProcessorTypes();
- KernelGroup getKernelGroup();
+ bool checkParameter();
+ std::vector<PreProcessorType> getPreProcessorTypes();
+ KernelGroup getKernelGroup();
- void setCheckParameterStrategy(std::shared_ptr<CheckParameterStrategy> strategy);
+ void setCheckParameterStrategy(std::shared_ptr<CheckParameterStrategy> strategy);
protected:
- KernelImp();
+ KernelImp(std::shared_ptr<Parameter> para, int level);
+ KernelImp();
- std::shared_ptr< Parameter> para;
- std::shared_ptr<CheckParameterStrategy> checkStrategy;
- int level;
- std::vector<PreProcessorType> myPreProcessorTypes;
- KernelGroup myKernelGroup;
+ std::shared_ptr<Parameter> para;
+ std::shared_ptr<CheckParameterStrategy> checkStrategy;
+ int level;
+ std::vector<PreProcessorType> myPreProcessorTypes;
+ KernelGroup myKernelGroup;
+ vf::gpu::CudaGrid cudaGrid;
};
-#endif
\ No newline at end of file
+
+#endif
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKUnified/BGKUnified.cu b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKUnified/BGKUnified.cu
new file mode 100644
index 0000000000000000000000000000000000000000..4c82851996646590d8c246df5f940b58a308d52c
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKUnified/BGKUnified.cu
@@ -0,0 +1,56 @@
+#include "BGKUnified.h"
+
+#include <stdexcept>
+
+#include "Parameter/Parameter.h"
+#include "../RunLBMKernel.cuh"
+#include "Kernel/Utilities/CudaGrid.h"
+
+#include <lbm/BGK.h>
+
+
+namespace vf
+{
+namespace gpu
+{
+
+
+BGKUnified::BGKUnified(std::shared_ptr<Parameter> para, int level)
+ : KernelImp(para, level)
+{
+#ifndef BUILD_CUDA_LTO
+ throw std::invalid_argument("To use the BKGUnified kernel, pass -DBUILD_CUDA_LTO=ON to cmake. Requires: CUDA 11.2 & cc 5.0");
+#endif
+
+ myPreProcessorTypes.push_back(InitCompSP27);
+
+ myKernelGroup = BasicKernel;
+
+ this->cudaGrid = CudaGrid(para->getParD(level)->numberofthreads, para->getParD(level)->size_Mat_SP);
+}
+
+
+void BGKUnified::run()
+{
+ GPUKernelParameter kernelParameter{ para->getParD(level)->omega,
+ para->getParD(level)->geoSP,
+ para->getParD(level)->neighborX_SP,
+ para->getParD(level)->neighborY_SP,
+ para->getParD(level)->neighborZ_SP,
+ para->getParD(level)->d0SP.f[0],
+ (int)para->getParD(level)->size_Mat_SP,
+ nullptr, /* forces not used in bgk kernel */
+ para->getParD(level)->evenOrOdd };
+
+ auto lambda = [] __device__(lbm::KernelParameter parameter) {
+ return lbm::bgk(parameter);
+ };
+
+ runKernel<<<cudaGrid.grid, cudaGrid.threads>>>(lambda, kernelParameter);
+
+ getLastCudaError("LB_Kernel_BGKUnified execution failed");
+}
+
+
+}
+}
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKUnified/BGKUnified.h b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKUnified/BGKUnified.h
new file mode 100644
index 0000000000000000000000000000000000000000..762eaaa5935bd01fa6ae002521a40e45cd239dfd
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKUnified/BGKUnified.h
@@ -0,0 +1,22 @@
+#ifndef GPU_BKGUnified_H
+#define GPU_BKGUnified_H
+
+#include "Kernel/KernelImp.h"
+
+namespace vf
+{
+namespace gpu
+{
+
+class BGKUnified : public KernelImp
+{
+public:
+ BGKUnified(std::shared_ptr<Parameter> para, int level);
+
+ void run();
+};
+
+}
+}
+
+#endif
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15/CumulantK15Comp_Device.cuh b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15/CumulantK15Comp_Device.cuh
index 6a8eede33bc210eacad184afb42a7011dd684708..208fbec553507812bfe4339577734292b248c027 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15/CumulantK15Comp_Device.cuh
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15/CumulantK15Comp_Device.cuh
@@ -14,4 +14,4 @@ extern "C" __global__ void LB_Kernel_CumulantK15Comp( real omega,
int level,
real* forces,
bool EvenOrOdd);
-#endif
\ No newline at end of file
+#endif
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Unified/CumulantK15Unified.cu b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Unified/CumulantK15Unified.cu
new file mode 100644
index 0000000000000000000000000000000000000000..b6f5d21ccf909f1ce3bcf11a4558f4771d87d021
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Unified/CumulantK15Unified.cu
@@ -0,0 +1,54 @@
+#include "CumulantK15Unified.h"
+
+#include <stdexcept>
+
+#include "../RunLBMKernel.cuh"
+
+#include "Parameter/Parameter.h"
+
+#include <lbm/CumulantChimera.h>
+
+namespace vf
+{
+namespace gpu
+{
+
+CumulantK15Unified::CumulantK15Unified(std::shared_ptr<Parameter> para, int level)
+ : KernelImp(para, level)
+{
+#ifndef BUILD_CUDA_LTO
+ throw std::invalid_argument(
+ "To use the CumulantK15Unified kernel, pass -DBUILD_CUDA_LTO=ON to cmake. Requires: CUDA 11.2 & cc 5.0");
+#endif
+
+ myPreProcessorTypes.push_back(InitCompSP27);
+
+ myKernelGroup = BasicKernel;
+
+ this->cudaGrid = CudaGrid(para->getParD(level)->numberofthreads, para->getParD(level)->size_Mat_SP);
+}
+
+void CumulantK15Unified::run()
+{
+ GPUKernelParameter kernelParameter{ para->getParD(level)->omega,
+ para->getParD(level)->geoSP,
+ para->getParD(level)->neighborX_SP,
+ para->getParD(level)->neighborY_SP,
+ para->getParD(level)->neighborZ_SP,
+ para->getParD(level)->d0SP.f[0],
+ (int)para->getParD(level)->size_Mat_SP,
+ para->getParD(level)->forcing,
+ para->getParD(level)->evenOrOdd };
+
+ auto lambda = [] __device__(lbm::KernelParameter parameter) {
+ return lbm::cumulantChimera(parameter, lbm::setRelaxationRatesK15);
+ };
+
+ vf::gpu::runKernel<<<cudaGrid.grid, cudaGrid.threads>>>(lambda, kernelParameter);
+
+ getLastCudaError("LB_Kernel_CumulantK15Comp execution failed");
+}
+
+
+}
+}
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Unified/CumulantK15Unified.h b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Unified/CumulantK15Unified.h
new file mode 100644
index 0000000000000000000000000000000000000000..8756253950484e00773af89327589c3d8f157729
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Unified/CumulantK15Unified.h
@@ -0,0 +1,21 @@
+#ifndef CUMULANT_K15_UNIFIED_COMP_H
+#define CUMULANT_K15_UNIFIED_COMP_H
+
+#include "Kernel/KernelImp.h"
+
+namespace vf
+{
+namespace gpu
+{
+class CumulantK15Unified : public KernelImp
+{
+public:
+ CumulantK15Unified(std::shared_ptr<Parameter> para, int level);
+
+ void run();
+};
+
+}
+}
+
+#endif
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Unified/CumulantK17Unified.cu b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Unified/CumulantK17Unified.cu
new file mode 100644
index 0000000000000000000000000000000000000000..989fce0c5e797ef90d644845f6c502bee700f6e1
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Unified/CumulantK17Unified.cu
@@ -0,0 +1,56 @@
+#include "CumulantK17Unified.h"
+
+#include <stdexcept>
+
+#include "Parameter/Parameter.h"
+#include "../RunLBMKernel.cuh"
+#include "Kernel/Utilities/CudaGrid.h"
+
+#include <lbm/CumulantChimera.h>
+
+namespace vf
+{
+namespace gpu
+{
+
+
+CumulantK17Unified::CumulantK17Unified(std::shared_ptr<Parameter> para, int level)
+ : KernelImp(para, level)
+{
+#ifndef BUILD_CUDA_LTO
+ throw std::invalid_argument("To use the CumulantK17Unified kernel, pass -DBUILD_CUDA_LTO=ON to cmake. Requires: CUDA 11.2 & cc 5.0");
+#endif
+
+ myPreProcessorTypes.push_back(InitCompSP27);
+
+ myKernelGroup = BasicKernel;
+
+ this->cudaGrid = CudaGrid(para->getParD(level)->numberofthreads, para->getParD(level)->size_Mat_SP);
+}
+
+
+
+void CumulantK17Unified::run()
+{
+ GPUKernelParameter kernelParameter{ para->getParD(level)->omega,
+ para->getParD(level)->geoSP,
+ para->getParD(level)->neighborX_SP,
+ para->getParD(level)->neighborY_SP,
+ para->getParD(level)->neighborZ_SP,
+ para->getParD(level)->d0SP.f[0],
+ (int)para->getParD(level)->size_Mat_SP,
+ para->getParD(level)->forcing,
+ para->getParD(level)->evenOrOdd };
+
+ auto lambda = [] __device__(lbm::KernelParameter parameter) {
+ return lbm::cumulantChimera(parameter, lbm::setRelaxationRatesK17);
+ };
+
+ runKernel<<<cudaGrid.grid, cudaGrid.threads>>>(lambda, kernelParameter);
+
+ getLastCudaError("LB_Kernel_CumulantK17Unified execution failed");
+}
+
+
+}
+}
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Unified/CumulantK17Unified.h b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Unified/CumulantK17Unified.h
new file mode 100644
index 0000000000000000000000000000000000000000..af8470b717ad7a98e7a3fcd507976353d9e8bd41
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Unified/CumulantK17Unified.h
@@ -0,0 +1,23 @@
+#ifndef CUMULANT_K17_UNIFIED_H
+#define CUMULANT_K17_UNIFIED_H
+
+#include "Kernel/KernelImp.h"
+
+namespace vf
+{
+namespace gpu
+{
+
+
+class CumulantK17Unified : public KernelImp
+{
+public:
+ CumulantK17Unified(std::shared_ptr<Parameter> para, int level);
+
+ void run();
+};
+
+}
+}
+
+#endif
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/FluidFlowCompStrategy.h b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/FluidFlowCompStrategy.h
index 5bdf2e9bb0f00e3e2ae3642baa42545079f93c2c..c9a6675bd7a4b82442c55b23bac6f9b49b811938 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/FluidFlowCompStrategy.h
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/FluidFlowCompStrategy.h
@@ -15,4 +15,4 @@ private:
FluidFlowCompStrategy();
};
-#endif
\ No newline at end of file
+#endif
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/RunLBMKernel.cuh b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/RunLBMKernel.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..b4097851b251b7447f6ce06856d0b9187999a20b
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Kernels/BasicKernels/FluidFlow/Compressible/RunLBMKernel.cuh
@@ -0,0 +1,59 @@
+#ifndef GPU_CUMULANT_KERNEL_H
+#define GPU_CUMULANT_KERNEL_H
+
+
+#include <DataTypes.h>
+#include <cuda_runtime.h>
+
+#include <lbm/KernelParameter.h>
+
+#include "Kernel/Utilities/DistributionHelper.cuh"
+
+namespace vf
+{
+namespace gpu
+{
+
+
+struct GPUKernelParameter
+{
+ real omega;
+ unsigned int* typeOfGridNode;
+ unsigned int* neighborX;
+ unsigned int* neighborY;
+ unsigned int* neighborZ;
+ real* distributions;
+ int size_Mat;
+ real* forces;
+ bool isEvenTimestep;
+};
+
+template<typename KernelFunctor>
+__global__ void runKernel(KernelFunctor kernel, GPUKernelParameter kernelParameter)
+{
+ const uint k = getNodeIndex();
+ const uint nodeType = kernelParameter.typeOfGridNode[k];
+
+ if (!isValidFluidNode(k, kernelParameter.size_Mat, nodeType))
+ return;
+
+ DistributionWrapper distributionWrapper {
+ kernelParameter.distributions,
+ kernelParameter.size_Mat,
+ kernelParameter.isEvenTimestep,
+ k,
+ kernelParameter.neighborX,
+ kernelParameter.neighborY,
+ kernelParameter.neighborZ
+ };
+
+ lbm::KernelParameter parameter {distributionWrapper.distribution, kernelParameter.omega, kernelParameter.forces};
+ kernel(parameter);
+
+ distributionWrapper.write();
+}
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Utilities/CudaGrid.cpp b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/CudaGrid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa17bf449915eba509dbabbe71f556c19fa43bcf
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/CudaGrid.cpp
@@ -0,0 +1,27 @@
+#include "CudaGrid.h"
+
+
+
+namespace vf
+{
+namespace gpu
+{
+
+CudaGrid::CudaGrid(unsigned int numberOfThreads, unsigned int size_matrix)
+{
+ int Grid = (size_matrix / numberOfThreads) + 1;
+ int Grid1, Grid2;
+ if (Grid > 512) {
+ Grid1 = 512;
+ Grid2 = (Grid / Grid1) + 1;
+ } else {
+ Grid1 = 1;
+ Grid2 = Grid;
+ }
+
+ grid = dim3(Grid1, Grid2);
+ threads = dim3(numberOfThreads, 1, 1);
+}
+
+}
+}
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Utilities/CudaGrid.h b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/CudaGrid.h
new file mode 100644
index 0000000000000000000000000000000000000000..27a18a58843b0de064009ab0f837518e3bb44b9d
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/CudaGrid.h
@@ -0,0 +1,25 @@
+#ifndef GPU_CUDA_GRID_H
+#define GPU_CUDA_GRID_H
+
+
+#include <cuda_runtime.h>
+
+namespace vf
+{
+namespace gpu
+{
+
+
+struct CudaGrid
+{
+ dim3 threads;
+ dim3 grid;
+
+ CudaGrid(unsigned int numberOfEntities, unsigned int threadsPerBlock);
+ CudaGrid() = default;
+};
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelper.cu b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelper.cu
new file mode 100644
index 0000000000000000000000000000000000000000..bbb01d95410612d36d55f1e0113175a8741b9ade
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelper.cu
@@ -0,0 +1,169 @@
+#include "DistributionHelper.cuh"
+
+#include <cuda_runtime.h>
+
+#include "LBM/D3Q27.h"
+
+#include <lbm/constants/NumericConstants.h>
+#include <lbm/constants/D3Q27.h>
+
+namespace vf
+{
+namespace gpu
+{
+
+__device__ __host__ DistributionReferences27 getDistributionReferences27(real *distributions, unsigned int size_Mat, bool isEvenTimestep)
+{
+ DistributionReferences27 distribution_references;
+
+ if (isEvenTimestep) {
+ distribution_references.f[dirE] = &distributions[dirE * size_Mat];
+ distribution_references.f[dirW] = &distributions[dirW * size_Mat];
+ distribution_references.f[dirN] = &distributions[dirN * size_Mat];
+ distribution_references.f[dirS] = &distributions[dirS * size_Mat];
+ distribution_references.f[dirT] = &distributions[dirT * size_Mat];
+ distribution_references.f[dirB] = &distributions[dirB * size_Mat];
+ distribution_references.f[dirNE] = &distributions[dirNE * size_Mat];
+ distribution_references.f[dirSW] = &distributions[dirSW * size_Mat];
+ distribution_references.f[dirSE] = &distributions[dirSE * size_Mat];
+ distribution_references.f[dirNW] = &distributions[dirNW * size_Mat];
+ distribution_references.f[dirTE] = &distributions[dirTE * size_Mat];
+ distribution_references.f[dirBW] = &distributions[dirBW * size_Mat];
+ distribution_references.f[dirBE] = &distributions[dirBE * size_Mat];
+ distribution_references.f[dirTW] = &distributions[dirTW * size_Mat];
+ distribution_references.f[dirTN] = &distributions[dirTN * size_Mat];
+ distribution_references.f[dirBS] = &distributions[dirBS * size_Mat];
+ distribution_references.f[dirBN] = &distributions[dirBN * size_Mat];
+ distribution_references.f[dirTS] = &distributions[dirTS * size_Mat];
+ distribution_references.f[dirREST] = &distributions[dirREST * size_Mat];
+ distribution_references.f[dirTNE] = &distributions[dirTNE * size_Mat];
+ distribution_references.f[dirTSW] = &distributions[dirTSW * size_Mat];
+ distribution_references.f[dirTSE] = &distributions[dirTSE * size_Mat];
+ distribution_references.f[dirTNW] = &distributions[dirTNW * size_Mat];
+ distribution_references.f[dirBNE] = &distributions[dirBNE * size_Mat];
+ distribution_references.f[dirBSW] = &distributions[dirBSW * size_Mat];
+ distribution_references.f[dirBSE] = &distributions[dirBSE * size_Mat];
+ distribution_references.f[dirBNW] = &distributions[dirBNW * size_Mat];
+ } else {
+ distribution_references.f[dirW] = &distributions[dirE * size_Mat];
+ distribution_references.f[dirE] = &distributions[dirW * size_Mat];
+ distribution_references.f[dirS] = &distributions[dirN * size_Mat];
+ distribution_references.f[dirN] = &distributions[dirS * size_Mat];
+ distribution_references.f[dirB] = &distributions[dirT * size_Mat];
+ distribution_references.f[dirT] = &distributions[dirB * size_Mat];
+ distribution_references.f[dirSW] = &distributions[dirNE * size_Mat];
+ distribution_references.f[dirNE] = &distributions[dirSW * size_Mat];
+ distribution_references.f[dirNW] = &distributions[dirSE * size_Mat];
+ distribution_references.f[dirSE] = &distributions[dirNW * size_Mat];
+ distribution_references.f[dirBW] = &distributions[dirTE * size_Mat];
+ distribution_references.f[dirTE] = &distributions[dirBW * size_Mat];
+ distribution_references.f[dirTW] = &distributions[dirBE * size_Mat];
+ distribution_references.f[dirBE] = &distributions[dirTW * size_Mat];
+ distribution_references.f[dirBS] = &distributions[dirTN * size_Mat];
+ distribution_references.f[dirTN] = &distributions[dirBS * size_Mat];
+ distribution_references.f[dirTS] = &distributions[dirBN * size_Mat];
+ distribution_references.f[dirBN] = &distributions[dirTS * size_Mat];
+ distribution_references.f[dirREST] = &distributions[dirREST * size_Mat];
+ distribution_references.f[dirBSW] = &distributions[dirTNE * size_Mat];
+ distribution_references.f[dirBNE] = &distributions[dirTSW * size_Mat];
+ distribution_references.f[dirBNW] = &distributions[dirTSE * size_Mat];
+ distribution_references.f[dirBSE] = &distributions[dirTNW * size_Mat];
+ distribution_references.f[dirTSW] = &distributions[dirBNE * size_Mat];
+ distribution_references.f[dirTNE] = &distributions[dirBSW * size_Mat];
+ distribution_references.f[dirTNW] = &distributions[dirBSE * size_Mat];
+ distribution_references.f[dirTSE] = &distributions[dirBNW * size_Mat];
+ }
+ return distribution_references;
+}
+
+__device__ DistributionWrapper::DistributionWrapper(real *distributions, unsigned int size_Mat, bool isEvenTimestep,
+ uint k, uint *neighborX, uint *neighborY, uint *neighborZ)
+ : distribution_references(getDistributionReferences27(distributions, size_Mat, isEvenTimestep)), k(k), kw(neighborX[k]), ks(neighborY[k]),
+ kb(neighborZ[k]), ksw(neighborY[kw]), kbw(neighborZ[kw]), kbs(neighborZ[ks]), kbsw(neighborZ[ksw])
+{
+ read();
+}
+
+__device__ void DistributionWrapper::read()
+{
+ distribution.f[vf::lbm::dir::PZZ] = (distribution_references.f[dirE])[k];
+ distribution.f[vf::lbm::dir::MZZ] = (distribution_references.f[dirW])[kw];
+ distribution.f[vf::lbm::dir::ZPZ] = (distribution_references.f[dirN])[k];
+ distribution.f[vf::lbm::dir::ZMZ] = (distribution_references.f[dirS])[ks];
+ distribution.f[vf::lbm::dir::ZZP] = (distribution_references.f[dirT])[k];
+ distribution.f[vf::lbm::dir::ZZM] = (distribution_references.f[dirB])[kb];
+ distribution.f[vf::lbm::dir::PPZ] = (distribution_references.f[dirNE])[k];
+ distribution.f[vf::lbm::dir::MMZ] = (distribution_references.f[dirSW])[ksw];
+ distribution.f[vf::lbm::dir::PMZ] = (distribution_references.f[dirSE])[ks];
+ distribution.f[vf::lbm::dir::MPZ] = (distribution_references.f[dirNW])[kw];
+ distribution.f[vf::lbm::dir::PZP] = (distribution_references.f[dirTE])[k];
+ distribution.f[vf::lbm::dir::MZM] = (distribution_references.f[dirBW])[kbw];
+ distribution.f[vf::lbm::dir::PZM] = (distribution_references.f[dirBE])[kb];
+ distribution.f[vf::lbm::dir::MZP] = (distribution_references.f[dirTW])[kw];
+ distribution.f[vf::lbm::dir::ZPP] = (distribution_references.f[dirTN])[k];
+ distribution.f[vf::lbm::dir::ZMM] = (distribution_references.f[dirBS])[kbs];
+ distribution.f[vf::lbm::dir::ZPM] = (distribution_references.f[dirBN])[kb];
+ distribution.f[vf::lbm::dir::ZMP] = (distribution_references.f[dirTS])[ks];
+ distribution.f[vf::lbm::dir::PPP] = (distribution_references.f[dirTNE])[k];
+ distribution.f[vf::lbm::dir::MPP] = (distribution_references.f[dirTNW])[kw];
+ distribution.f[vf::lbm::dir::PMP] = (distribution_references.f[dirTSE])[ks];
+ distribution.f[vf::lbm::dir::MMP] = (distribution_references.f[dirTSW])[ksw];
+ distribution.f[vf::lbm::dir::PPM] = (distribution_references.f[dirBNE])[kb];
+ distribution.f[vf::lbm::dir::MPM] = (distribution_references.f[dirBNW])[kbw];
+ distribution.f[vf::lbm::dir::PMM] = (distribution_references.f[dirBSE])[kbs];
+ distribution.f[vf::lbm::dir::MMM] = (distribution_references.f[dirBSW])[kbsw];
+ distribution.f[vf::lbm::dir::ZZZ] = (distribution_references.f[dirREST])[k];
+}
+
+__device__ void DistributionWrapper::write()
+{
+ (distribution_references.f[dirE])[k] = distribution.f[vf::lbm::dir::PZZ];
+ (distribution_references.f[dirW])[kw] = distribution.f[vf::lbm::dir::MZZ];
+ (distribution_references.f[dirN])[k] = distribution.f[vf::lbm::dir::ZPZ];
+ (distribution_references.f[dirS])[ks] = distribution.f[vf::lbm::dir::ZMZ];
+ (distribution_references.f[dirT])[k] = distribution.f[vf::lbm::dir::ZZP];
+ (distribution_references.f[dirB])[kb] = distribution.f[vf::lbm::dir::ZZM];
+ (distribution_references.f[dirNE])[k] = distribution.f[vf::lbm::dir::PPZ];
+ (distribution_references.f[dirSW])[ksw] = distribution.f[vf::lbm::dir::MMZ];
+ (distribution_references.f[dirSE])[ks] = distribution.f[vf::lbm::dir::PMZ];
+ (distribution_references.f[dirNW])[kw] = distribution.f[vf::lbm::dir::MPZ];
+ (distribution_references.f[dirTE])[k] = distribution.f[vf::lbm::dir::PZP];
+ (distribution_references.f[dirBW])[kbw] = distribution.f[vf::lbm::dir::MZM];
+ (distribution_references.f[dirBE])[kb] = distribution.f[vf::lbm::dir::PZM];
+ (distribution_references.f[dirTW])[kw] = distribution.f[vf::lbm::dir::MZP];
+ (distribution_references.f[dirTN])[k] = distribution.f[vf::lbm::dir::ZPP];
+ (distribution_references.f[dirBS])[kbs] = distribution.f[vf::lbm::dir::ZMM];
+ (distribution_references.f[dirBN])[kb] = distribution.f[vf::lbm::dir::ZPM];
+ (distribution_references.f[dirTS])[ks] = distribution.f[vf::lbm::dir::ZMP];
+ (distribution_references.f[dirTNE])[k] = distribution.f[vf::lbm::dir::PPP];
+ (distribution_references.f[dirTNW])[kw] = distribution.f[vf::lbm::dir::MPP];
+ (distribution_references.f[dirTSE])[ks] = distribution.f[vf::lbm::dir::PMP];
+ (distribution_references.f[dirTSW])[ksw] = distribution.f[vf::lbm::dir::MMP];
+ (distribution_references.f[dirBNE])[kb] = distribution.f[vf::lbm::dir::PPM];
+ (distribution_references.f[dirBNW])[kbw] = distribution.f[vf::lbm::dir::MPM];
+ (distribution_references.f[dirBSE])[kbs] = distribution.f[vf::lbm::dir::PMM];
+ (distribution_references.f[dirBSW])[kbsw] = distribution.f[vf::lbm::dir::MMM];
+ (distribution_references.f[dirREST])[k] = distribution.f[vf::lbm::dir::ZZZ];
+}
+
+__device__ unsigned int getNodeIndex()
+{
+ const unsigned x = threadIdx.x;
+ const unsigned y = blockIdx.x;
+ const unsigned z = blockIdx.y;
+
+ const unsigned nx = blockDim.x;
+ const unsigned ny = gridDim.x;
+
+ return nx * (ny * z + y) + x;
+}
+
+__device__ bool isValidFluidNode(uint k, int size_Mat, uint nodeType)
+{
+ return (k < size_Mat) &&
+ (nodeType == GEO_FLUID || nodeType == GEO_PM_0 || nodeType == GEO_PM_1 || nodeType == GEO_PM_2);
+}
+
+
+} // namespace gpu
+} // namespace vf
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelper.cuh b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelper.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..935030701924233d959fb69b74a7c3087feb0834
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelper.cuh
@@ -0,0 +1,98 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file Cumulant27chim.cu
+//! \ingroup GPU
+//! \author Martin Schoenherr, Soeren Peters
+//=======================================================================================
+#ifndef DISTRIBUTUION_HELPER_CUH
+#define DISTRIBUTUION_HELPER_CUH
+
+#include "LBM/LB.h"
+
+#include <lbm/KernelParameter.h>
+
+namespace vf
+{
+namespace gpu
+{
+
+/**
+* Getting references to the 27 directions.
+* @params distributions 1D real* array containing all data (number of elements = 27 * matrix_size)
+* @params matrix_size number of discretizations nodes
+* @params isEvenTimestep: stored data dependent on timestep is based on the esoteric twist algorithm
+* @return a data struct containing the addresses to the 27 directions within the 1D distribution array
+*/
+__device__ __host__ DistributionReferences27 getDistributionReferences27(real* distributions, unsigned int matrix_size, bool isEvenTimestep);
+
+
+/**
+* Holds the references to all directions and the concrete distributions for a single node.
+* After instantiation the distributions are read to the member "distribution" from "distribution_references".
+* After computation the data can be written back to "distribution_references".
+*/
+struct DistributionWrapper
+{
+ __device__ DistributionWrapper(
+ real* distributions,
+ unsigned int size_Mat,
+ bool isEvenTimestep,
+ uint k,
+ uint* neighborX,
+ uint* neighborY,
+ uint* neighborZ);
+
+ __device__ void read();
+
+ __device__ void write();
+
+ // origin distributions to read from and write to after computation
+ DistributionReferences27 distribution_references;
+
+ // distribution pass to kernel computation
+ vf::lbm::Distribution27 distribution;
+
+ const uint k;
+ const uint kw;
+ const uint ks;
+ const uint kb;
+ const uint ksw;
+ const uint kbw;
+ const uint kbs;
+ const uint kbsw;
+};
+
+__device__ unsigned int getNodeIndex();
+
+__device__ bool isValidFluidNode(uint k, int size_Mat, uint nodeType);
+
+}
+}
+
+#endif
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelperTests.cpp b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelperTests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..46d3fe890fd2f412251044cce6ade51f08ba0185
--- /dev/null
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/DistributionHelperTests.cpp
@@ -0,0 +1,93 @@
+#include <gmock/gmock.h>
+
+#include "DistributionHelper.cuh"
+
+#include "LBM/D3Q27.h"
+
+
+auto RealEq = [](auto value) {
+#ifdef VF_DOUBLE_ACCURACY
+ return testing::DoubleEq(value);
+#else
+ return testing::FloatEq(value);
+#endif
+};
+
+
+TEST(DistributionHelperTests, getPointerToDistribution_WhenEvenTimeStep_ShouldBeEqualToInput)
+{
+ real distributions_in[27];
+ for (int i = 0; i < 27; i++)
+ distributions_in[i] = i;
+ const uint size_Mat = 1;
+ const bool isEvenTimeStep = true;
+
+ Distributions27 distribution_out = vf::gpu::getDistributionReferences27(distributions_in, size_Mat, isEvenTimeStep);
+
+ EXPECT_THAT(*distribution_out.f[dirE], RealEq(distributions_in[dirE]));
+ EXPECT_THAT(*distribution_out.f[dirW], RealEq(distributions_in[dirW]));
+ EXPECT_THAT(*distribution_out.f[dirN], RealEq(distributions_in[dirN]));
+ EXPECT_THAT(*distribution_out.f[dirS], RealEq(distributions_in[dirS]));
+ EXPECT_THAT(*distribution_out.f[dirT], RealEq(distributions_in[dirT]));
+ EXPECT_THAT(*distribution_out.f[dirB], RealEq(distributions_in[dirB]));
+ EXPECT_THAT(*distribution_out.f[dirNE], RealEq(distributions_in[dirNE]));
+ EXPECT_THAT(*distribution_out.f[dirSW], RealEq(distributions_in[dirSW]));
+ EXPECT_THAT(*distribution_out.f[dirSE], RealEq(distributions_in[dirSE]));
+ EXPECT_THAT(*distribution_out.f[dirNW], RealEq(distributions_in[dirNW]));
+ EXPECT_THAT(*distribution_out.f[dirTE], RealEq(distributions_in[dirTE]));
+ EXPECT_THAT(*distribution_out.f[dirBW], RealEq(distributions_in[dirBW]));
+ EXPECT_THAT(*distribution_out.f[dirBE], RealEq(distributions_in[dirBE]));
+ EXPECT_THAT(*distribution_out.f[dirTW], RealEq(distributions_in[dirTW]));
+ EXPECT_THAT(*distribution_out.f[dirTN], RealEq(distributions_in[dirTN]));
+ EXPECT_THAT(*distribution_out.f[dirBS], RealEq(distributions_in[dirBS]));
+ EXPECT_THAT(*distribution_out.f[dirBN], RealEq(distributions_in[dirBN]));
+ EXPECT_THAT(*distribution_out.f[dirTS], RealEq(distributions_in[dirTS]));
+ EXPECT_THAT(*distribution_out.f[dirREST], RealEq(distributions_in[dirREST]));
+ EXPECT_THAT(*distribution_out.f[dirTNE], RealEq(distributions_in[dirTNE]));
+ EXPECT_THAT(*distribution_out.f[dirTSW], RealEq(distributions_in[dirTSW]));
+ EXPECT_THAT(*distribution_out.f[dirTSE], RealEq(distributions_in[dirTSE]));
+ EXPECT_THAT(*distribution_out.f[dirTNW], RealEq(distributions_in[dirTNW]));
+ EXPECT_THAT(*distribution_out.f[dirBNE], RealEq(distributions_in[dirBNE]));
+ EXPECT_THAT(*distribution_out.f[dirBSW], RealEq(distributions_in[dirBSW]));
+ EXPECT_THAT(*distribution_out.f[dirBSE], RealEq(distributions_in[dirBSE]));
+ EXPECT_THAT(*distribution_out.f[dirBNW], RealEq(distributions_in[dirBNW]));
+}
+
+TEST(DistributionHelperTests, getPointerToDistribution_WhenOddTimeStep_ShouldBeSwapped)
+{
+ real distributions_in[27];
+ for (int i = 0; i < 27; i++)
+ distributions_in[i] = i;
+ const int size_Mat = 1;
+ const bool isEvenTimeStep = false;
+
+ Distributions27 distribution_out = vf::gpu::getDistributionReferences27(distributions_in, size_Mat, isEvenTimeStep);
+
+ EXPECT_THAT(*distribution_out.f[dirW], RealEq(distributions_in[dirE]));
+ EXPECT_THAT(*distribution_out.f[dirE], RealEq(distributions_in[dirW]));
+ EXPECT_THAT(*distribution_out.f[dirS], RealEq(distributions_in[dirN]));
+ EXPECT_THAT(*distribution_out.f[dirN], RealEq(distributions_in[dirS]));
+ EXPECT_THAT(*distribution_out.f[dirB], RealEq(distributions_in[dirT]));
+ EXPECT_THAT(*distribution_out.f[dirT], RealEq(distributions_in[dirB]));
+ EXPECT_THAT(*distribution_out.f[dirSW], RealEq(distributions_in[dirNE]));
+ EXPECT_THAT(*distribution_out.f[dirNE], RealEq(distributions_in[dirSW]));
+ EXPECT_THAT(*distribution_out.f[dirNW], RealEq(distributions_in[dirSE]));
+ EXPECT_THAT(*distribution_out.f[dirSE], RealEq(distributions_in[dirNW]));
+ EXPECT_THAT(*distribution_out.f[dirBW], RealEq(distributions_in[dirTE]));
+ EXPECT_THAT(*distribution_out.f[dirTE], RealEq(distributions_in[dirBW]));
+ EXPECT_THAT(*distribution_out.f[dirTW], RealEq(distributions_in[dirBE]));
+ EXPECT_THAT(*distribution_out.f[dirBE], RealEq(distributions_in[dirTW]));
+ EXPECT_THAT(*distribution_out.f[dirBS], RealEq(distributions_in[dirTN]));
+ EXPECT_THAT(*distribution_out.f[dirTN], RealEq(distributions_in[dirBS]));
+ EXPECT_THAT(*distribution_out.f[dirTS], RealEq(distributions_in[dirBN]));
+ EXPECT_THAT(*distribution_out.f[dirBN], RealEq(distributions_in[dirTS]));
+ EXPECT_THAT(*distribution_out.f[dirREST], RealEq(distributions_in[dirREST]));
+ EXPECT_THAT(*distribution_out.f[dirBSW], RealEq(distributions_in[dirTNE]));
+ EXPECT_THAT(*distribution_out.f[dirBNE], RealEq(distributions_in[dirTSW]));
+ EXPECT_THAT(*distribution_out.f[dirBNW], RealEq(distributions_in[dirTSE]));
+ EXPECT_THAT(*distribution_out.f[dirBSE], RealEq(distributions_in[dirTNW]));
+ EXPECT_THAT(*distribution_out.f[dirTSW], RealEq(distributions_in[dirBNE]));
+ EXPECT_THAT(*distribution_out.f[dirTNE], RealEq(distributions_in[dirBSW]));
+ EXPECT_THAT(*distribution_out.f[dirTNW], RealEq(distributions_in[dirBSE]));
+ EXPECT_THAT(*distribution_out.f[dirTSE], RealEq(distributions_in[dirBNW]));
+}
diff --git a/src/gpu/VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.cpp b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.cpp
index b0d167974275a227b99da6a0ac8e32e1f2976c13..5f63df1c9afc17a62a9a47ce82401ebba4453872 100644
--- a/src/gpu/VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.cpp
+++ b/src/gpu/VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.cpp
@@ -4,16 +4,19 @@
//LBM kernel (compressible)
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGK/BGKCompSP27.h"
+#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKUnified/BGKUnified.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/BGKPlus/BGKPlusCompSP27.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/Cascade/CascadeCompSP27.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/Cumulant/CumulantCompSP27.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17/CumulantK17Comp.h"
+#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Unified/CumulantK17Unified.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17chim/CumulantK17CompChim.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK17Bulk/CumulantK17BulkComp.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantAll4/CumulantAll4CompSP27.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK18/CumulantK18Comp.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK20/CumulantK20Comp.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15/CumulantK15Comp.h"
+#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Unified/CumulantK15Unified.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Bulk/CumulantK15BulkComp.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/CumulantK15Sponge/CumulantK15SpongeComp.h"
#include "Kernel/Kernels/BasicKernels/FluidFlow/Compressible/MRT/MRTCompSP27.h"
@@ -96,13 +99,17 @@ void KernelFactoryImp::setKernelAtLevel(std::vector<std::shared_ptr<Kernel>> ker
std::shared_ptr<Kernel> KernelFactoryImp::makeKernel(std::shared_ptr<Parameter> para, std::string kernel, int level)
{
+ printf("Instantiating Kernel: %s\n", kernel.c_str());
std::shared_ptr<KernelImp> newKernel;
std::shared_ptr<CheckParameterStrategy> checkStrategy;
- if ( kernel == "BGKCompSP27") {
- newKernel = BGKCompSP27::getNewInstance(para, level); // compressible
- checkStrategy = FluidFlowCompStrategy::getInstance(); // ||
- } else if (kernel == "BGKPlusCompSP27") { // \/
+ if (kernel == "BGKCompSP27") {
+ newKernel = BGKCompSP27::getNewInstance(para, level); // compressible
+ checkStrategy = FluidFlowCompStrategy::getInstance(); // ||
+ } else if (kernel == "BGKUnified") { // \/
+ newKernel = std::make_shared<vf::gpu::BGKUnified>(para, level);
+ checkStrategy = FluidFlowCompStrategy::getInstance();
+ } else if (kernel == "BGKPlusCompSP27") {
newKernel = BGKPlusCompSP27::getNewInstance(para, level);
checkStrategy = FluidFlowCompStrategy::getInstance();
} else if (kernel == "MRTCompSP27") {
@@ -117,6 +124,12 @@ std::shared_ptr<Kernel> KernelFactoryImp::makeKernel(std::shared_ptr<Parameter>
} else if (kernel == "CumulantK17Comp") {
newKernel = CumulantK17Comp::getNewInstance(para, level);
checkStrategy = FluidFlowCompStrategy::getInstance();
+ } else if (kernel == "CumulantK15Unified") {
+ newKernel = std::make_shared<vf::gpu::CumulantK15Unified>(para, level);
+ checkStrategy = FluidFlowCompStrategy::getInstance();
+ } else if (kernel == "CumulantK17Unified") {
+ newKernel = std::make_shared<vf::gpu::CumulantK17Unified>(para, level);
+ checkStrategy = FluidFlowCompStrategy::getInstance();
} else if (kernel == "CumulantK17BulkComp") {
newKernel = CumulantK17BulkComp::getNewInstance(para, level);
checkStrategy = FluidFlowCompStrategy::getInstance();
diff --git a/src/gpu/VirtualFluids_GPU/LBM/D3Q27.h b/src/gpu/VirtualFluids_GPU/LBM/D3Q27.h
index 546dccd463a96ad3173517d09f222acde11e2448..5e769b603e7c6677b7f9e1189f5c4fe27051f795 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/D3Q27.h
+++ b/src/gpu/VirtualFluids_GPU/LBM/D3Q27.h
@@ -21,6 +21,7 @@
#define dirBN /*f17*/ 16
#define dirTS /*f18*/ 17
#define dirZERO /*f0 */ 18
+#define dirREST /*f0 */ 18
#define dirTNE /*f */ 19
#define dirBNE /*f */ 20
diff --git a/src/gpu/VirtualFluids_GPU/LBM/LB.h b/src/gpu/VirtualFluids_GPU/LBM/LB.h
index f5f91738739b95f897a1192cb7c1d77a6cfea9cb..52f932c7b751b0d31e9bf733a4f3b5c439a6755f 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/LB.h
+++ b/src/gpu/VirtualFluids_GPU/LBM/LB.h
@@ -144,7 +144,7 @@ typedef struct Distri19{
// Distribution functions f 27
typedef struct Distri27{
real* f[27];
-} Distributions27;
+} Distributions27, DistributionReferences27;
//Q for second order BCs
typedef struct QforBC{
diff --git a/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp b/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp
index 6f468507949a62933c278b1c17801ea25536b07f..7dc916a47cbe08e543cc73d3c6c6cf5f163a16e7 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp
+++ b/src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp
@@ -1,4 +1,10 @@
#include "Simulation.h"
+
+#include <stdio.h>
+#include <vector>
+
+#include <helper_timer.h>
+
#include "LBM/LB.h"
#include "Communication/Communicator.h"
#include "Communication/ExchangeData27.h"
@@ -85,12 +91,13 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
para->setNumprocs(comm->getNummberOfProcess());
devCheck(comm->mapCudaDevice(para->getMyID(), para->getNumprocs(), para->getDevices(), para->getMaxDev()));
+ para->initParameter();
+
gridProvider->allocAndCopyForcing();
gridProvider->allocAndCopyQuadricLimiters();
gridProvider->setDimensions();
gridProvider->setBoundingBox();
- para->initParameter();
para->setRe(para->getVelocity() * (real)1.0 / para->getViscosity());
para->setPhi((real) 0.0);
para->setlimitOfNodesForVTK(30000000); //max 30 Million nodes per VTK file
diff --git a/src/gpu/VirtualFluids_GPU/LBM/Simulation.h b/src/gpu/VirtualFluids_GPU/LBM/Simulation.h
index ae46034ce3e6080e0b9f03a92dd0326d640c6f32..d6c6702c4db8a671d4f6dbfea4c90cdf8f48356d 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/Simulation.h
+++ b/src/gpu/VirtualFluids_GPU/LBM/Simulation.h
@@ -5,13 +5,12 @@
#include <vector>
#include <PointerDefinitions.h>
-
-
#include "Output/LogWriter.hpp"
#include "GPU/KineticEnergyAnalyzer.h"
#include "GPU/EnstrophyAnalyzer.h"
#include "Utilities/Buffer2D.hpp"
#include "LBM/LB.h"
+
#include "VirtualFluids_GPU_export.h"
namespace vf
diff --git a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
index 25946704edcad12513d1b8a2c70cd551eb1dd619..ccb13e83bcc68b9c9d85725666a02ea1c23ec293 100644
--- a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
+++ b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
@@ -186,6 +186,7 @@ struct ParameterStruct{
//velocities to fit the force
real *VxForce, *VyForce, *VzForce;
//////////////////////////////////////////////////////////////////////////
+ real *forcing;
//Measure Points/////////
std::vector<MeasurePoints> MP;
diff --git a/src/gpu/VirtualFluids_GPU/Restart/RestartObjectTests.cpp b/src/gpu/VirtualFluids_GPU/Restart/RestartObjectTests.cpp
index a9b485ab25871066c201e631b97022bc6f7e08fb..c30f514c60ba1af2fb852ed8a68b36121ebced04 100644
--- a/src/gpu/VirtualFluids_GPU/Restart/RestartObjectTests.cpp
+++ b/src/gpu/VirtualFluids_GPU/Restart/RestartObjectTests.cpp
@@ -8,7 +8,7 @@ void saveAndLoad()
{
std::shared_ptr<RestartObject> write_object = std::make_shared<Type>();
- write_object->fs = std::vector<std::vector<float>> {
+ write_object->fs = std::vector<std::vector<real>> {
{ 1,2,3 },
{ 4,5,6 }
};
diff --git a/src/lbm/BGK.cpp b/src/lbm/BGK.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa3af6777a0492687768dd4945cbf1e9b186f514
--- /dev/null
+++ b/src/lbm/BGK.cpp
@@ -0,0 +1,140 @@
+#include "BGK.h"
+
+
+#include <basics/Core/DataTypes.h>
+#include <basics/Core/RealConstants.h>
+
+#include "constants/NumericConstants.h"
+#include "constants/D3Q27.h"
+
+#include "MacroscopicQuantities.h"
+
+namespace vf
+{
+namespace lbm
+{
+
+using namespace constant;
+
+
+
+__host__ __device__ void bgk(KernelParameter parameter)
+{
+ auto& distribution = parameter.distribution;
+ const auto omega = parameter.omega;
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Read distributions: style of reading and writing the distributions from/to
+ //! stored arrays dependent on timestep is based on the esoteric twist algorithm
+ //! <a href="https://doi.org/10.3390/computation5020019"><b>[ M. Geier et al. (2017), DOI:10.3390/computation5020019 ]</b></a>
+ //!
+ real mfcbb = distribution.f[dir::PZZ];
+ real mfabb = distribution.f[dir::MZZ];
+ real mfbcb = distribution.f[dir::ZPZ];
+ real mfbab = distribution.f[dir::ZMZ];
+ real mfbbc = distribution.f[dir::ZZP];
+ real mfbba = distribution.f[dir::ZZM];
+ real mfccb = distribution.f[dir::PPZ];
+ real mfaab = distribution.f[dir::MMZ];
+ real mfcab = distribution.f[dir::PMZ];
+ real mfacb = distribution.f[dir::MPZ];
+ real mfcbc = distribution.f[dir::PZP];
+ real mfaba = distribution.f[dir::MZM];
+ real mfcba = distribution.f[dir::PZM];
+ real mfabc = distribution.f[dir::MZP];
+ real mfbcc = distribution.f[dir::ZPP];
+ real mfbaa = distribution.f[dir::ZMM];
+ real mfbca = distribution.f[dir::ZPM];
+ real mfbac = distribution.f[dir::ZMP];
+ real mfccc = distribution.f[dir::PPP];
+ real mfacc = distribution.f[dir::MPP];
+ real mfcac = distribution.f[dir::PMP];
+ real mfaac = distribution.f[dir::MMP];
+ real mfcca = distribution.f[dir::PPM];
+ real mfaca = distribution.f[dir::MPM];
+ real mfcaa = distribution.f[dir::PMM];
+ real mfaaa = distribution.f[dir::MMM];
+ real mfbbb = distribution.f[dir::ZZZ];
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Acquire macroscopic quantities
+ const real drho = getDensity(distribution.f);
+ const real rho = c1o1 + drho;
+ const real OOrho = constant::c1o1 / (constant::c1o1 + drho);
+
+ const real vvx = getIncompressibleVelocityX1(distribution.f) * OOrho;
+ const real vvy = getIncompressibleVelocityX2(distribution.f) * OOrho;
+ const real vvz = getIncompressibleVelocityX3(distribution.f) * OOrho;
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - BGK computation
+ const real cusq = c3o2*(vvx*vvx + vvy*vvy + vvz*vvz);
+
+ mfbbb = mfbbb *(c1o1 + (-omega)) - (-omega)* c8o27* (drho - rho * cusq);
+ mfcbb = mfcbb *(c1o1 + (-omega)) - (-omega)* c2o27* (drho + rho * (c3o1*(vvx)+c9o2*(vvx)*(vvx)-cusq));
+ mfabb = mfabb *(c1o1 + (-omega)) - (-omega)* c2o27* (drho + rho * (c3o1*(-vvx) + c9o2*(-vvx)*(-vvx) - cusq));
+ mfbcb = mfbcb *(c1o1 + (-omega)) - (-omega)* c2o27* (drho + rho * (c3o1*(vvy)+c9o2*(vvy)*(vvy)-cusq));
+ mfbab = mfbab *(c1o1 + (-omega)) - (-omega)* c2o27* (drho + rho * (c3o1*(-vvy) + c9o2*(-vvy)*(-vvy) - cusq));
+ mfbbc = mfbbc *(c1o1 + (-omega)) - (-omega)* c2o27* (drho + rho * (c3o1*(vvz)+c9o2*(vvz)*(vvz)-cusq));
+ mfbba = mfbba *(c1o1 + (-omega)) - (-omega)* c2o27* (drho + rho * (c3o1*(-vvz) + c9o2*(-vvz)*(-vvz) - cusq));
+ mfccb = mfccb *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(vvx + vvy) + c9o2*(vvx + vvy)*(vvx + vvy) - cusq));
+ mfaab = mfaab *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(-vvx - vvy) + c9o2*(-vvx - vvy)*(-vvx - vvy) - cusq));
+ mfcab = mfcab *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(vvx - vvy) + c9o2*(vvx - vvy)*(vvx - vvy) - cusq));
+ mfacb = mfacb *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(-vvx + vvy) + c9o2*(-vvx + vvy)*(-vvx + vvy) - cusq));
+ mfcbc = mfcbc *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(vvx + vvz) + c9o2*(vvx + vvz)*(vvx + vvz) - cusq));
+ mfaba = mfaba *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(-vvx - vvz) + c9o2*(-vvx - vvz)*(-vvx - vvz) - cusq));
+ mfcba = mfcba *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(vvx - vvz) + c9o2*(vvx - vvz)*(vvx - vvz) - cusq));
+ mfabc = mfabc *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(-vvx + vvz) + c9o2*(-vvx + vvz)*(-vvx + vvz) - cusq));
+ mfbcc = mfbcc *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(vvy + vvz) + c9o2*(vvy + vvz)*(vvy + vvz) - cusq));
+ mfbaa = mfbaa *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(-vvy - vvz) + c9o2*(-vvy - vvz)*(-vvy - vvz) - cusq));
+ mfbca = mfbca *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(vvy - vvz) + c9o2*(vvy - vvz)*(vvy - vvz) - cusq));
+ mfbac = mfbac *(c1o1 + (-omega)) - (-omega)* c1o54* (drho + rho * (c3o1*(-vvy + vvz) + c9o2*(-vvy + vvz)*(-vvy + vvz) - cusq));
+ mfccc = mfccc *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(vvx + vvy + vvz) + c9o2*(vvx + vvy + vvz)*(vvx + vvy + vvz) - cusq));
+ mfaaa = mfaaa *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(-vvx - vvy - vvz) + c9o2*(-vvx - vvy - vvz)*(-vvx - vvy - vvz) - cusq));
+ mfcca = mfcca *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(vvx + vvy - vvz) + c9o2*(vvx + vvy - vvz)*(vvx + vvy - vvz) - cusq));
+ mfaac = mfaac *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(-vvx - vvy + vvz) + c9o2*(-vvx - vvy + vvz)*(-vvx - vvy + vvz) - cusq));
+ mfcac = mfcac *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(vvx - vvy + vvz) + c9o2*(vvx - vvy + vvz)*(vvx - vvy + vvz) - cusq));
+ mfaca = mfaca *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(-vvx + vvy - vvz) + c9o2*(-vvx + vvy - vvz)*(-vvx + vvy - vvz) - cusq));
+ mfcaa = mfcaa *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(vvx - vvy - vvz) + c9o2*(vvx - vvy - vvz)*(vvx - vvy - vvz) - cusq));
+ mfacc = mfacc *(c1o1 + (-omega)) - (-omega)* c1o216*(drho + rho * (c3o1*(-vvx + vvy + vvz) + c9o2*(-vvx + vvy + vvz)*(-vvx + vvy + vvz) - cusq));
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Write distributions: style of reading and writing the distributions from/to
+ //! stored arrays dependent on timestep is based on the esoteric twist algorithm
+ //! <a href="https://doi.org/10.3390/computation5020019"><b>[ M. Geier et al. (2017), DOI:10.3390/computation5020019 ]</b></a>
+ //!
+ distribution.f[dir::MZZ] = mfcbb;
+ distribution.f[dir::PZZ] = mfabb;
+ distribution.f[dir::ZMZ] = mfbcb;
+ distribution.f[dir::ZPZ] = mfbab;
+ distribution.f[dir::ZZM] = mfbbc;
+ distribution.f[dir::ZZP] = mfbba;
+ distribution.f[dir::MMZ] = mfccb;
+ distribution.f[dir::PPZ] = mfaab;
+ distribution.f[dir::MPZ] = mfcab;
+ distribution.f[dir::PMZ] = mfacb;
+ distribution.f[dir::MZM] = mfcbc;
+ distribution.f[dir::PZP] = mfaba;
+ distribution.f[dir::MZP] = mfcba;
+ distribution.f[dir::PZM] = mfabc;
+ distribution.f[dir::ZMM] = mfbcc;
+ distribution.f[dir::ZPP] = mfbaa;
+ distribution.f[dir::ZMP] = mfbca;
+ distribution.f[dir::ZPM] = mfbac;
+ distribution.f[dir::MMM] = mfccc;
+ distribution.f[dir::PMM] = mfacc;
+ distribution.f[dir::MPM] = mfcac;
+ distribution.f[dir::PPM] = mfaac;
+ distribution.f[dir::MMP] = mfcca;
+ distribution.f[dir::PMP] = mfaca;
+ distribution.f[dir::MPP] = mfcaa;
+ distribution.f[dir::PPP] = mfaaa;
+ distribution.f[dir::ZZZ] = mfbbb;
+}
+
+
+}
+}
+
diff --git a/src/lbm/BGK.h b/src/lbm/BGK.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c82f5bd445ee008954add02fd0d6d6093364e90
--- /dev/null
+++ b/src/lbm/BGK.h
@@ -0,0 +1,24 @@
+#ifndef LBM_BGK_H
+#define LBM_BGK_H
+
+#ifndef __host__
+#define __host__
+#endif
+#ifndef __device__
+#define __device__
+#endif
+
+#include <basics/Core/DataTypes.h>
+
+#include "KernelParameter.h"
+
+namespace vf
+{
+namespace lbm
+{
+
+__host__ __device__ void bgk(KernelParameter parameter);
+
+}
+}
+#endif
diff --git a/src/lbm/CMakeLists.txt b/src/lbm/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6e9f76793825ccf4e4e9e921e9fd4b6ab3584707
--- /dev/null
+++ b/src/lbm/CMakeLists.txt
@@ -0,0 +1,10 @@
+project(lbm LANGUAGES CXX)
+
+vf_add_library(NAME lbm PUBLIC_LINK basics)
+
+if(BUILD_VF_GPU)
+ add_subdirectory(cuda)
+endif()
+
+
+vf_add_tests()
diff --git a/src/lbm/Chimera.h b/src/lbm/Chimera.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ffa0918aac4e6303efe4db82aa98ee645dc63e8
--- /dev/null
+++ b/src/lbm/Chimera.h
@@ -0,0 +1,121 @@
+#ifndef LBM_CHIMERA_H
+#define LBM_CHIMERA_H
+
+#ifndef __host__
+#define __host__
+#endif
+#ifndef __device__
+#define __device__
+#endif
+
+#include <basics/Core/DataTypes.h>
+
+#include <lbm/constants/NumericConstants.h>
+
+namespace vf
+{
+namespace lbm
+{
+
+using namespace constant;
+
+////////////////////////////////////////////////////////////////////////////////
+//! \brief forward chimera transformation \ref forwardInverseChimeraWithK
+//! Transformation from distributions to central moments according to Eq. (6)-(14) in
+//! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05.040 ]</b></a>
+//! Modified for lower round-off errors.
+////////////////////////////////////////////////////////////////////////////////
+inline __host__ __device__ void forwardInverseChimeraWithK(real &mfa, real &mfb, real &mfc, real vv,
+ real v2, real Kinverse, real K)
+{
+ const real m2 = mfa + mfc;
+ const real m1 = mfc - mfa;
+ real m0 = m2 + mfb;
+
+ mfa = m0;
+ m0 *= Kinverse;
+ m0 += c1o1;
+ mfb = (m1 * Kinverse - m0 * vv) * K;
+ mfc = ((m2 - c2o1 * m1 * vv) * Kinverse + v2 * m0) * K;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! \brief backward chimera transformation \ref backwardInverseChimeraWithK
+//! Transformation from central moments to distributions according to Eq. (57)-(65) in
+//! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05.040 ]</b></a>
+//! ] Modified for lower round-off errors.
+////////////////////////////////////////////////////////////////////////////////
+inline __host__ __device__ void backwardInverseChimeraWithK(real &mfa, real &mfb, real &mfc, real vv,
+ real v2, real Kinverse, real K)
+{
+ const real m0 = (((mfc - mfb) * c1o2 + mfb * vv) * Kinverse + (mfa * Kinverse + c1o1) * (v2 - vv) * c1o2) * K;
+ const real m1 = (((mfa - mfc) - c2o1 * mfb * vv) * Kinverse + (mfa * Kinverse + c1o1) * (-v2)) * K;
+
+ mfc = (((mfc + mfb) * c1o2 + mfb * vv) * Kinverse + (mfa * Kinverse + c1o1) * (v2 + vv) * c1o2) * K;
+ mfa = m0;
+ mfb = m1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! \brief forward chimera transformation \ref forwardChimera
+//! Transformation from distributions to central moments according to Eq. (6)-(14) in
+//! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05.040 ]</b></a>
+//! for \f$ K_{abc}=0 \f$. This is to avoid unnessary floating point operations.
+//! Modified for lower round-off errors.
+////////////////////////////////////////////////////////////////////////////////
+inline __host__ __device__ void forwardChimera(real &mfa, real &mfb, real &mfc, real vv, real v2)
+{
+ const real m1 = (mfa + mfc) + mfb;
+ const real m2 = mfc - mfa;
+
+ mfc = (mfc + mfa) + (v2 * m1 - c2o1 * vv * m2);
+ mfb = m2 - vv * m1;
+ mfa = m1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! \brief backward chimera transformation \ref backwardChimera
+//! Transformation from central moments to distributions according to Eq. (57)-(65) in
+//! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05.040 ]</b></a>
+//! for \f$ K_{abc}=0 \f$. This is to avoid unnessary floating point operations.
+//! Modified for lower round-off errors.
+////////////////////////////////////////////////////////////////////////////////
+inline __host__ __device__ void backwardChimera(real &mfa, real &mfb, real &mfc, real vv, real v2)
+{
+ const real ma = (mfc + mfa * (v2 - vv)) * c1o2 + mfb * (vv - c1o2);
+ const real mb = ((mfa - mfc) - mfa * v2) - c2o1 * mfb * vv;
+
+ mfc = (mfc + mfa * (v2 + vv)) * c1o2 + mfb * (vv + c1o2);
+ mfb = mb;
+ mfa = ma;
+}
+
+
+inline __host__ __device__ void forwardChimeraWithK(real &mfa, real &mfb, real &mfc, real vv, real v2, real K)
+{
+
+ const real m2 = mfa + mfc;
+ const real m1 = mfc - mfa;
+ const real m0 = m2 + mfb;
+ mfa = m0;
+ //m0 += K;
+ mfb = (m1 - K*vv) - m0 * vv;
+ mfc = ((m2 - c2o1* m1 * vv) + v2*K) + v2 * m0;
+ //m0 += K;
+ //mfb = m1 - m0 * vv;
+ //mfc = m2 - two* m1 * vv + v2 * m0;
+}
+
+
+inline __host__ __device__ void backwardChimeraWithK(real &mfa, real &mfb, real &mfc, real vv, real v2, real K)
+{
+ const real m0 = (mfc - mfb)* c1o2 + mfb * (vv)+(mfa + K) * (v2 - vv) * c1o2;
+ const real m1 = (mfa - mfc) - c2o1* mfb * vv + (mfa + K) * (-v2);
+ mfc = (mfc + mfb)* c1o2 + mfb * (vv)+(mfa + K) * (v2 + vv) * c1o2;
+ mfa = m0;
+ mfb = m1;
+}
+
+}
+}
+#endif
diff --git a/src/lbm/ChimeraTests.cpp b/src/lbm/ChimeraTests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..01abbe82764c276f53a4cdd479d333536199c3a9
--- /dev/null
+++ b/src/lbm/ChimeraTests.cpp
@@ -0,0 +1,133 @@
+#include <gmock/gmock.h>
+
+#include "Chimera.h"
+
+#ifdef VF_DOUBLE_ACCURACY
+#define REAL_EQ(a) testing::DoubleEq(a)
+#else
+#define REAL_EQ(a) testing::FloatEq(a)
+#endif
+
+/*
+* InverseChimeraWithK
+*/
+TEST(ChimeraTest, forwardInverseChimeraWithK)
+{
+ real mfa = 1;
+ real mfb = 1;
+ real mfc = 1;
+
+ const real vv = 1.;
+ const real v2 = 1.;
+
+ const real K = 1.;
+ const real Kinverse = 1 / K;
+
+ vf::lbm::forwardInverseChimeraWithK(mfa, mfb, mfc, vv, v2, K, Kinverse);
+
+ EXPECT_THAT(mfa, REAL_EQ(3.)); // mfa + mfb + mfc
+ EXPECT_THAT(mfb, REAL_EQ(-4.)); // -(mfa + mfb + mfc + 1)
+ EXPECT_THAT(mfc, REAL_EQ(6.)); // (mfa + mfc) + (mfa + mfb + mfc + 1)
+}
+
+
+TEST(ChimeraTest, backwardInverseChimeraWithK)
+{
+ // starting with the result values from the test above.
+ real mfa = 3.;
+ real mfb = -4.;
+ real mfc = 6.;
+
+ const real vv = 1.;
+ const real v2 = 1.;
+
+ const real K = 1.;
+ const real Kinverse = 1 / K;
+
+ vf::lbm::backwardInverseChimeraWithK(mfa, mfb, mfc, vv, v2, K, Kinverse);
+
+ // resulting in the start values from the test above.
+ EXPECT_THAT(mfa, REAL_EQ(1.));
+ EXPECT_THAT(mfb, REAL_EQ(1.));
+ EXPECT_THAT(mfc, REAL_EQ(1.));
+}
+
+/*
+* Chimera
+*/
+TEST(ChimeraTest, forwardChimera)
+{
+ real mfa = 1;
+ real mfb = 1;
+ real mfc = 1;
+
+ const real vv = 1.;
+ const real v2 = 1.;
+
+ vf::lbm::forwardChimera(mfa, mfb, mfc, vv, v2);
+
+ EXPECT_THAT(mfa, REAL_EQ(3.)); // mfa + mfb + mfc
+ EXPECT_THAT(mfb, REAL_EQ(-3.)); // -(mfa + mfb + mfc)
+ EXPECT_THAT(mfc, REAL_EQ(5.)); // (mfa + mfc) + (mfa + mfb + mfc)
+}
+
+
+TEST(ChimeraTest, backwardChimera)
+{
+ // starting with the result values from the test above.
+ real mfa = 3.;
+ real mfb = -3.;
+ real mfc = 5.;
+
+ const real vv = 1.;
+ const real v2 = 1.;
+
+ vf::lbm::backwardChimera(mfa, mfb, mfc, vv, v2);
+
+ // resulting in the start values from the test above.
+ EXPECT_THAT(mfa, REAL_EQ(1.));
+ EXPECT_THAT(mfb, REAL_EQ(1.));
+ EXPECT_THAT(mfc, REAL_EQ(1.));
+}
+
+/*
+* ChimeraWithK
+*/
+TEST(ChimeraTest, forwardChimeraWithK)
+{
+ real mfa = 1;
+ real mfb = 1;
+ real mfc = 1;
+
+ const real vv = 1.;
+ const real v2 = 1.;
+
+ const real K = 1.;
+
+ vf::lbm::forwardChimeraWithK(mfa, mfb, mfc, vv, v2, K);
+
+ EXPECT_THAT(mfa, REAL_EQ(3.)); // mfa + mfb + mfc
+ EXPECT_THAT(mfb, REAL_EQ(-4.)); // -(mfa + mfb + mfc)
+ EXPECT_THAT(mfc, REAL_EQ(6.)); // (mfa + mfc) + (mfa + mfb + mfc)
+}
+
+
+TEST(ChimeraTest, backwardChimeraWithK)
+{
+ // starting with the result values from the test above.
+ real mfa = 3.;
+ real mfb = -4.;
+ real mfc = 6.;
+
+ const real vv = 1.;
+ const real v2 = 1.;
+
+ const real K = 1.;
+
+ vf::lbm::backwardChimeraWithK(mfa, mfb, mfc, vv, v2, K);
+
+ // resulting in the start values from the test above.
+ EXPECT_THAT(mfa, REAL_EQ(1.));
+ EXPECT_THAT(mfb, REAL_EQ(1.));
+ EXPECT_THAT(mfc, REAL_EQ(1.));
+}
diff --git a/src/lbm/CumulantChimera.cpp b/src/lbm/CumulantChimera.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65dc9b1f82f409447fda54fc0bc5f460533aad1b
--- /dev/null
+++ b/src/lbm/CumulantChimera.cpp
@@ -0,0 +1,453 @@
+#include "CumulantChimera.h"
+
+#include <cmath>
+
+#include <basics/Core/DataTypes.h>
+#include <basics/Core/RealConstants.h>
+
+#include "constants/NumericConstants.h"
+#include "constants/D3Q27.h"
+
+#include "Chimera.h"
+#include "MacroscopicQuantities.h"
+
+namespace vf
+{
+namespace lbm
+{
+
+using namespace constant;
+
+
+////////////////////////////////////////////////////////////////////////////////////
+//! - Setting relaxation rates for non-hydrodynamic cumulants (default values). Variable names and equations according to
+//! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+//! => [NAME IN PAPER]=[NAME IN CODE]=[DEFAULT VALUE].
+//! - Trace of second order cumulants \f$ C_{200}+C_{020}+C_{002} \f$ used to adjust bulk viscosity:\f$\omega_2=OxxPyyPzz=1.0 \f$.
+//! - Third order cumulants \f$ C_{120}+C_{102}, C_{210}+C_{012}, C_{201}+C_{021} \f$: \f$ \omega_3=OxyyPxzz \f$ set according to Eq. (111) with simplifications assuming \f$ \omega_2=1.0\f$.
+//! - Third order cumulants \f$ C_{120}-C_{102}, C_{210}-C_{012}, C_{201}-C_{021} \f$: \f$ \omega_4 = OxyyMxzz \f$ set according to Eq. (112) with simplifications assuming \f$ \omega_2 = 1.0\f$.
+//! - Third order cumulants \f$ C_{111} \f$: \f$ \omega_5 = Oxyz \f$ set according to Eq. (113) with simplifications assuming \f$ \omega_2 = 1.0\f$ (modify for different bulk viscosity).
+//! - Fourth order cumulants \f$ C_{220}, C_{202}, C_{022}, C_{211}, C_{121}, C_{112} \f$: for simplification all set to the same default value \f$ \omega_6=\omega_7=\omega_8=O4=1.0 \f$.
+//! - Fifth order cumulants \f$ C_{221}, C_{212}, C_{122}\f$: \f$\omega_9=O5=1.0\f$.
+//! - Sixth order cumulant \f$ C_{222}\f$: \f$\omega_{10}=O6=1.0\f$.
+//////////////////////////////////////////////////////////////////////////
+__host__ __device__ void setRelaxationRatesK17(real omega, real &OxxPyyPzz, real &OxyyPxzz, real &OxyyMxzz, real &Oxyz,
+ real &O4, real &O5, real &O6)
+{
+ OxxPyyPzz = c1o1;
+
+ OxyyPxzz = c8o1 * (-c2o1 + omega) * (c1o1 + c2o1 * omega) / (-c8o1 - c14o1 * omega + c7o1 * omega * omega);
+ OxyyMxzz = c8o1 * (-c2o1 + omega) * (-c7o1 + c4o1 * omega) / (c56o1 - c50o1 * omega + c9o1 * omega * omega);
+ Oxyz = c24o1 * (-c2o1 + omega) * (-c2o1 - c7o1 * omega + c3o1 * omega * omega) /
+ (c48o1 + c152o1 * omega - c130o1 * omega * omega + c29o1 * omega * omega * omega);
+
+ O4 = c1o1;
+
+ O5 = c1o1;
+
+ O6 = c1o1;
+}
+
+
+__host__ __device__ void setRelaxationRatesK15(real omega, real &OxxPyyPzz, real &OxyyPxzz, real &OxyyMxzz, real &Oxyz,
+ real &O4, real &O5, real &O6)
+{
+ OxxPyyPzz = c1o1;
+
+ OxyyPxzz = c1o1;
+ OxyyMxzz = c1o1;
+ Oxyz = c1o1;
+
+ O4 = c1o1;
+
+ O5 = c1o1;
+
+ O6 = c1o1;
+}
+
+//////////////////////////////////////////////////////////////////////////
+//! Cumulant K17 Kernel is based on \ref
+//! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05.040 ]</b></a>
+//! and \ref
+//! <a href="https://doi.org/10.1016/j.jcp.2017.07.004"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.07.004 ]</b></a>
+//////////////////////////////////////////////////////////////////////////
+__host__ __device__ void cumulantChimera(KernelParameter parameter, RelaxationRatesFunctor setRelaxationRates)
+{
+ auto& distribution = parameter.distribution;
+ const auto omega = parameter.omega;
+ const auto* forces = parameter.forces;
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Read distributions: style of reading and writing the distributions from/to
+ //! stored arrays dependent on timestep is based on the esoteric twist algorithm
+ //! <a href="https://doi.org/10.3390/computation5020019"><b>[ M. Geier et al. (2017), DOI:10.3390/computation5020019 ]</b></a>
+ //!
+ real mfcbb = distribution.f[dir::PZZ];
+ real mfabb = distribution.f[dir::MZZ];
+ real mfbcb = distribution.f[dir::ZPZ];
+ real mfbab = distribution.f[dir::ZMZ];
+ real mfbbc = distribution.f[dir::ZZP];
+ real mfbba = distribution.f[dir::ZZM];
+ real mfccb = distribution.f[dir::PPZ];
+ real mfaab = distribution.f[dir::MMZ];
+ real mfcab = distribution.f[dir::PMZ];
+ real mfacb = distribution.f[dir::MPZ];
+ real mfcbc = distribution.f[dir::PZP];
+ real mfaba = distribution.f[dir::MZM];
+ real mfcba = distribution.f[dir::PZM];
+ real mfabc = distribution.f[dir::MZP];
+ real mfbcc = distribution.f[dir::ZPP];
+ real mfbaa = distribution.f[dir::ZMM];
+ real mfbca = distribution.f[dir::ZPM];
+ real mfbac = distribution.f[dir::ZMP];
+ real mfccc = distribution.f[dir::PPP];
+ real mfacc = distribution.f[dir::MPP];
+ real mfcac = distribution.f[dir::PMP];
+ real mfaac = distribution.f[dir::MMP];
+ real mfcca = distribution.f[dir::PPM];
+ real mfaca = distribution.f[dir::MPM];
+ real mfcaa = distribution.f[dir::PMM];
+ real mfaaa = distribution.f[dir::MMM];
+ real mfbbb = distribution.f[dir::ZZZ];
+
+
+ const real drho = getDensity(distribution.f);
+ const real OOrho = c1o1 / (c1o1 + drho);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Add half of the acceleration (body force) to the velocity as in Eq. (42) \ref
+ //! <a href="https://doi.org/10.1016/j.camwa.2015.05.001"><b>[ M. Geier et al. (2015), DOI:10.1016/j.camwa 2015.05.001 ]</b></a>
+ //!
+ const real vvx = getIncompressibleVelocityX1(distribution.f) * OOrho + forces[0] * c1o2;
+ const real vvy = getIncompressibleVelocityX2(distribution.f) * OOrho + forces[0] * c1o2;
+ const real vvz = getIncompressibleVelocityX3(distribution.f) * OOrho + forces[0] * c1o2;
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ // calculate the square of velocities for this lattice node
+ const real vx2 = vvx*vvx;
+ const real vy2 = vvy*vvy;
+ const real vz2 = vvz*vvz;
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Chimera transform from well conditioned distributions to central moments as defined in Appendix J in \ref
+ //! <a href="https://doi.org/10.1016/j.camwa.2015.05.001"><b>[ M. Geier et al. (2015), DOI:10.1016/j.camwa 2015.05.001 ]</b></a>
+ //! see also Eq. (6)-(14) in \ref
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //!
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Z - Dir
+ vf::lbm::forwardInverseChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, c36o1, c1o36);
+ vf::lbm::forwardInverseChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, c9o1, c1o9);
+ vf::lbm::forwardInverseChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c36o1, c1o36);
+ vf::lbm::forwardInverseChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, c9o1, c1o9);
+ vf::lbm::forwardInverseChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, c9o4, c4o9);
+ vf::lbm::forwardInverseChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, c9o1, c1o9);
+ vf::lbm::forwardInverseChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c36o1, c1o36);
+ vf::lbm::forwardInverseChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, c9o1, c1o9);
+ vf::lbm::forwardInverseChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c36o1, c1o36);
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Y - Dir
+ vf::lbm::forwardInverseChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c6o1, c1o6);
+ vf::lbm::forwardChimera( mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::forwardInverseChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c18o1, c1o18);
+ vf::lbm::forwardInverseChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, c3o2, c2o3);
+ vf::lbm::forwardChimera( mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::forwardInverseChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, c9o2, c2o9);
+ vf::lbm::forwardInverseChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c6o1, c1o6);
+ vf::lbm::forwardChimera( mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::forwardInverseChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c18o1, c1o18);
+ ////////////////////////////////////////////////////////////////////////////////////
+ // X - Dir
+ vf::lbm::forwardInverseChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o1, c1o1);
+ vf::lbm::forwardChimera( mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::forwardInverseChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c3o1, c1o3);
+ vf::lbm::forwardChimera( mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::forwardChimera( mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::forwardChimera( mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::forwardInverseChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c3o1, c1o3);
+ vf::lbm::forwardChimera( mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::forwardInverseChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c3o1, c1o9);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Setting relaxation rates for non-hydrodynamic cumulants (default values). Variable names and equations
+ real OxxPyyPzz;
+ real OxyyPxzz;
+ real OxyyMxzz;
+ real Oxyz;
+ real O4;
+ real O5;
+ real O6;
+
+ setRelaxationRates(omega, OxxPyyPzz, OxyyPxzz, OxyyMxzz, Oxyz, O4, O5, O6);
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - A and B: parameters for fourth order convergence of the diffusion term according to Eq. (114) and (115)
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //! with simplifications assuming \f$ \omega_2 = 1.0 \f$ (modify for different bulk viscosity).
+ //!
+ const real A = (c4o1 + c2o1*omega - c3o1*omega*omega) / (c2o1 - c7o1*omega + c5o1*omega*omega);
+ const real B = (c4o1 + c28o1*omega - c14o1*omega*omega) / (c6o1 - c21o1*omega + c15o1*omega*omega);
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Compute cumulants from central moments according to Eq. (20)-(23) in
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //!
+ ////////////////////////////////////////////////////////////
+ //4.
+ real CUMcbb = mfcbb - ((mfcaa + c1o3) * mfabb + c2o1 * mfbba * mfbab) * OOrho;
+ real CUMbcb = mfbcb - ((mfaca + c1o3) * mfbab + c2o1 * mfbba * mfabb) * OOrho;
+ real CUMbbc = mfbbc - ((mfaac + c1o3) * mfbba + c2o1 * mfbab * mfabb) * OOrho;
+ real CUMcca = mfcca - (((mfcaa * mfaca + c2o1 * mfbba * mfbba) + c1o3 * (mfcaa + mfaca)) * OOrho - c1o9*(drho * OOrho));
+ real CUMcac = mfcac - (((mfcaa * mfaac + c2o1 * mfbab * mfbab) + c1o3 * (mfcaa + mfaac)) * OOrho - c1o9*(drho * OOrho));
+ real CUMacc = mfacc - (((mfaac * mfaca + c2o1 * mfabb * mfabb) + c1o3 * (mfaac + mfaca)) * OOrho - c1o9*(drho * OOrho));
+ ////////////////////////////////////////////////////////////
+ //5.
+ real CUMbcc = mfbcc - ((mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + c1o3 * (mfbca + mfbac)) * OOrho;
+ real CUMcbc = mfcbc - ((mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + c1o3 * (mfcba + mfabc)) * OOrho;
+ real CUMccb = mfccb - ((mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + c1o3 * (mfacb + mfcab)) * OOrho;
+ ////////////////////////////////////////////////////////////
+ //6.
+ real CUMccc = mfccc + ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) * OOrho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) * OOrho * OOrho
+ - c1o3 * (mfacc + mfcac + mfcca) * OOrho
+ - c1o9 * (mfcaa + mfaca + mfaac) * OOrho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) * OOrho * OOrho * c2o3
+ + c1o27*((drho * drho - drho) * OOrho * OOrho));
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Compute linear combinations of second and third order cumulants
+ //!
+ ////////////////////////////////////////////////////////////
+ //2.
+ real mxxPyyPzz = mfcaa + mfaca + mfaac;
+ real mxxMyy = mfcaa - mfaca;
+ real mxxMzz = mfcaa - mfaac;
+ ////////////////////////////////////////////////////////////
+ //3.
+ real mxxyPyzz = mfcba + mfabc;
+ real mxxyMyzz = mfcba - mfabc;
+ real mxxzPyyz = mfcab + mfacb;
+ real mxxzMyyz = mfcab - mfacb;
+ real mxyyPxzz = mfbca + mfbac;
+ real mxyyMxzz = mfbca - mfbac;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //incl. correction
+ ////////////////////////////////////////////////////////////
+ //! - Compute velocity gradients from second order cumulants according to Eq. (27)-(32)
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //! Further explanations of the correction in viscosity in Appendix H of
+ //! <a href="https://doi.org/10.1016/j.camwa.2015.05.001"><b>[ M. Geier et al. (2015), DOI:10.1016/j.camwa 2015.05.001 ]</b></a>
+ //! Note that the division by rho is omitted here as we need rho times the gradients later.
+ //!
+ const real Dxy = -c3o1*omega*mfbba;
+ const real Dxz = -c3o1*omega*mfbab;
+ const real Dyz = -c3o1*omega*mfabb;
+ const real dxux = c1o2 * (-omega) *(mxxMyy + mxxMzz) + c1o2 * OxxPyyPzz * (mfaaa - mxxPyyPzz);
+ const real dyuy = dxux + omega * c3o2 * mxxMyy;
+ const real dzuz = dxux + omega * c3o2 * mxxMzz;
+ ////////////////////////////////////////////////////////////
+ //! - Relaxation of second order cumulants with correction terms according to Eq. (33)-(35) in
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //!
+ mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz) - c3o1 * (c1o1 - c1o2 * OxxPyyPzz) * (vx2 * dxux + vy2 * dyuy + vz2 * dzuz);
+ mxxMyy += omega * (-mxxMyy) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vy2 * dyuy);
+ mxxMzz += omega * (-mxxMzz) - c3o1 * (c1o1 + c1o2 * (-omega)) * (vx2 * dxux - vz2 * dzuz);
+ ////////////////////////////////////////////////////////////////////////////////////
+ ////no correction
+ //mxxPyyPzz += OxxPyyPzz*(mfaaa - mxxPyyPzz);
+ //mxxMyy += -(-omega) * (-mxxMyy);
+ //mxxMzz += -(-omega) * (-mxxMzz);
+ //////////////////////////////////////////////////////////////////////////
+ mfabb += omega * (-mfabb);
+ mfbab += omega * (-mfbab);
+ mfbba += omega * (-mfbba);
+ ////////////////////////////////////////////////////////////////////////////////////
+ //relax
+ //////////////////////////////////////////////////////////////////////////
+ // incl. limiter
+ //! Set relaxation limiters for third order cumulants to default value \f$ \lambda=0.001 \f$ according to section 6 in \ref
+ //! - Relaxation of third order cumulants including limiter according to Eq. (116)-(123)
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //!
+
+ const real qudricLimitP = c1o100;
+ const real qudricLimitM = c1o100;
+ const real qudricLimitD = c1o100;
+
+ real wadjust = Oxyz + (c1o1 - Oxyz)*abs_internal(mfbbb) / (abs_internal(mfbbb) + qudricLimitD);
+ mfbbb += wadjust * (-mfbbb);
+ wadjust = OxyyPxzz + (c1o1 - OxyyPxzz)*abs_internal(mxxyPyzz) / (abs_internal(mxxyPyzz) + qudricLimitP);
+ mxxyPyzz += wadjust * (-mxxyPyzz);
+ wadjust = OxyyMxzz + (c1o1 - OxyyMxzz)*abs_internal(mxxyMyzz) / (abs_internal(mxxyMyzz) + qudricLimitM);
+ mxxyMyzz += wadjust * (-mxxyMyzz);
+ wadjust = OxyyPxzz + (c1o1 - OxyyPxzz)*abs_internal(mxxzPyyz) / (abs_internal(mxxzPyyz) + qudricLimitP);
+ mxxzPyyz += wadjust * (-mxxzPyyz);
+ wadjust = OxyyMxzz + (c1o1 - OxyyMxzz)*abs_internal(mxxzMyyz) / (abs_internal(mxxzMyyz) + qudricLimitM);
+ mxxzMyyz += wadjust * (-mxxzMyyz);
+ wadjust = OxyyPxzz + (c1o1 - OxyyPxzz)*abs_internal(mxyyPxzz) / (abs_internal(mxyyPxzz) + qudricLimitP);
+ mxyyPxzz += wadjust * (-mxyyPxzz);
+ wadjust = OxyyMxzz + (c1o1 - OxyyMxzz)*abs_internal(mxyyMxzz) / (abs_internal(mxyyMxzz) + qudricLimitM);
+ mxyyMxzz += wadjust * (-mxyyMxzz);
+ //////////////////////////////////////////////////////////////////////////
+ // no limiter
+ //mfbbb += OxyyMxzz * (-mfbbb);
+ //mxxyPyzz += OxyyPxzz * (-mxxyPyzz);
+ //mxxyMyzz += OxyyMxzz * (-mxxyMyzz);
+ //mxxzPyyz += OxyyPxzz * (-mxxzPyyz);
+ //mxxzMyyz += OxyyMxzz * (-mxxzMyyz);
+ //mxyyPxzz += OxyyPxzz * (-mxyyPxzz);
+ //mxyyMxzz += OxyyMxzz * (-mxyyMxzz);
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Compute inverse linear combinations of second and third order cumulants
+ //!
+ mfcaa = c1o3 * (mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaca = c1o3 * (-c2o1* mxxMyy + mxxMzz + mxxPyyPzz);
+ mfaac = c1o3 * (mxxMyy - c2o1* mxxMzz + mxxPyyPzz);
+ mfcba = ( mxxyMyzz + mxxyPyzz) * c1o2;
+ mfabc = (-mxxyMyzz + mxxyPyzz) * c1o2;
+ mfcab = ( mxxzMyyz + mxxzPyyz) * c1o2;
+ mfacb = (-mxxzMyyz + mxxzPyyz) * c1o2;
+ mfbca = ( mxyyMxzz + mxyyPxzz) * c1o2;
+ mfbac = (-mxyyMxzz + mxyyPxzz) * c1o2;
+ //////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////
+ //4.
+ // no limiter
+ //! - Relax fourth order cumulants to modified equilibrium for fourth order convergence of diffusion according to Eq. (43)-(48)
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //!
+ CUMacc = -O4*(c1o1 / omega - c1o2) * (dyuy + dzuz) * c2o3 * A + (c1o1 - O4) * (CUMacc);
+ CUMcac = -O4*(c1o1 / omega - c1o2) * (dxux + dzuz) * c2o3 * A + (c1o1 - O4) * (CUMcac);
+ CUMcca = -O4*(c1o1 / omega - c1o2) * (dyuy + dxux) * c2o3 * A + (c1o1 - O4) * (CUMcca);
+ CUMbbc = -O4*(c1o1 / omega - c1o2) * Dxy * c1o3 * B + (c1o1 - O4) * (CUMbbc);
+ CUMbcb = -O4*(c1o1 / omega - c1o2) * Dxz * c1o3 * B + (c1o1 - O4) * (CUMbcb);
+ CUMcbb = -O4*(c1o1 / omega - c1o2) * Dyz * c1o3 * B + (c1o1 - O4) * (CUMcbb);
+ //////////////////////////////////////////////////////////////////////////
+ //5.
+ CUMbcc += O5 * (-CUMbcc);
+ CUMcbc += O5 * (-CUMcbc);
+ CUMccb += O5 * (-CUMccb);
+ //////////////////////////////////////////////////////////////////////////
+ //6.
+ CUMccc += O6 * (-CUMccc);
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Compute central moments from post collision cumulants according to Eq. (53)-(56) in
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //!
+ //////////////////////////////////////////////////////////////////////////
+ //4.
+ mfcbb = CUMcbb + c1o3*((c3o1*mfcaa + c1o1) * mfabb + c6o1 * mfbba * mfbab) * OOrho;
+ mfbcb = CUMbcb + c1o3*((c3o1*mfaca + c1o1) * mfbab + c6o1 * mfbba * mfabb) * OOrho;
+ mfbbc = CUMbbc + c1o3*((c3o1*mfaac + c1o1) * mfbba + c6o1 * mfbab * mfabb) * OOrho;
+ mfcca = CUMcca + (((mfcaa * mfaca + c2o1 * mfbba * mfbba)*c9o1 + c3o1 * (mfcaa + mfaca)) * OOrho - (drho * OOrho))*c1o9;
+ mfcac = CUMcac + (((mfcaa * mfaac + c2o1 * mfbab * mfbab)*c9o1 + c3o1 * (mfcaa + mfaac)) * OOrho - (drho * OOrho))*c1o9;
+ mfacc = CUMacc + (((mfaac * mfaca + c2o1 * mfabb * mfabb)*c9o1 + c3o1 * (mfaac + mfaca)) * OOrho - (drho * OOrho))*c1o9;
+ //////////////////////////////////////////////////////////////////////////
+ //5.
+ mfbcc = CUMbcc + c1o3 *(c3o1*(mfaac * mfbca + mfaca * mfbac + c4o1 * mfabb * mfbbb + c2o1 * (mfbab * mfacb + mfbba * mfabc)) + (mfbca + mfbac)) * OOrho;
+ mfcbc = CUMcbc + c1o3 *(c3o1*(mfaac * mfcba + mfcaa * mfabc + c4o1 * mfbab * mfbbb + c2o1 * (mfabb * mfcab + mfbba * mfbac)) + (mfcba + mfabc)) * OOrho;
+ mfccb = CUMccb + c1o3 *(c3o1*(mfcaa * mfacb + mfaca * mfcab + c4o1 * mfbba * mfbbb + c2o1 * (mfbab * mfbca + mfabb * mfcba)) + (mfacb + mfcab)) * OOrho;
+ //////////////////////////////////////////////////////////////////////////
+ //6.
+ mfccc = CUMccc - ((-c4o1 * mfbbb * mfbbb
+ - (mfcaa * mfacc + mfaca * mfcac + mfaac * mfcca)
+ - c4o1 * (mfabb * mfcbb + mfbab * mfbcb + mfbba * mfbbc)
+ - c2o1 * (mfbca * mfbac + mfcba * mfabc + mfcab * mfacb)) * OOrho
+ + (c4o1 * (mfbab * mfbab * mfaca + mfabb * mfabb * mfcaa + mfbba * mfbba * mfaac)
+ + c2o1 * (mfcaa * mfaca * mfaac)
+ + c16o1 * mfbba * mfbab * mfabb) * OOrho * OOrho
+ - c1o3 * (mfacc + mfcac + mfcca) * OOrho
+ - c1o9 * (mfcaa + mfaca + mfaac) * OOrho
+ + (c2o1 * (mfbab * mfbab + mfabb * mfabb + mfbba * mfbba)
+ + (mfaac * mfaca + mfaac * mfcaa + mfaca * mfcaa) + c1o3 *(mfaac + mfaca + mfcaa)) * OOrho * OOrho * c2o3
+ + c1o27*((drho * drho - drho) * OOrho * OOrho));
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Add acceleration (body force) to first order cumulants according to Eq. (85)-(87) in
+ //! <a href="https://doi.org/10.1016/j.camwa.2015.05.001"><b>[ M. Geier et al. (2015), DOI:10.1016/j.camwa 2015.05.001 ]</b></a>
+ //!
+ mfbaa = -mfbaa;
+ mfaba = -mfaba;
+ mfaab = -mfaab;
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Chimera transform from central moments to well conditioned distributions as defined in Appendix J in
+ //! <a href="https://doi.org/10.1016/j.camwa.2015.05.001"><b>[ M. Geier et al. (2015), DOI:10.1016/j.camwa 2015.05.001 ]</b></a>
+ //! see also Eq. (88)-(96) in
+ //! <a href="https://doi.org/10.1016/j.jcp.2017.05.040"><b>[ M. Geier et al. (2017), DOI:10.1016/j.jcp.2017.05 040 ]</b></a>
+ //!
+ ////////////////////////////////////////////////////////////////////////////////////
+ // X - Dir
+ vf::lbm::backwardInverseChimeraWithK(mfaaa, mfbaa, mfcaa, vvx, vx2, c1o1, c1o1);
+ vf::lbm::backwardChimera( mfaba, mfbba, mfcba, vvx, vx2);
+ vf::lbm::backwardInverseChimeraWithK(mfaca, mfbca, mfcca, vvx, vx2, c3o1, c1o3);
+ vf::lbm::backwardChimera( mfaab, mfbab, mfcab, vvx, vx2);
+ vf::lbm::backwardChimera( mfabb, mfbbb, mfcbb, vvx, vx2);
+ vf::lbm::backwardChimera( mfacb, mfbcb, mfccb, vvx, vx2);
+ vf::lbm::backwardInverseChimeraWithK(mfaac, mfbac, mfcac, vvx, vx2, c3o1, c1o3);
+ vf::lbm::backwardChimera( mfabc, mfbbc, mfcbc, vvx, vx2);
+ vf::lbm::backwardInverseChimeraWithK(mfacc, mfbcc, mfccc, vvx, vx2, c9o1, c1o9);
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Y - Dir
+ vf::lbm::backwardInverseChimeraWithK(mfaaa, mfaba, mfaca, vvy, vy2, c6o1, c1o6);
+ vf::lbm::backwardChimera( mfaab, mfabb, mfacb, vvy, vy2);
+ vf::lbm::backwardInverseChimeraWithK(mfaac, mfabc, mfacc, vvy, vy2, c18o1, c1o18);
+ vf::lbm::backwardInverseChimeraWithK(mfbaa, mfbba, mfbca, vvy, vy2, c3o2, c2o3);
+ vf::lbm::backwardChimera( mfbab, mfbbb, mfbcb, vvy, vy2);
+ vf::lbm::backwardInverseChimeraWithK(mfbac, mfbbc, mfbcc, vvy, vy2, c9o2, c2o9);
+ vf::lbm::backwardInverseChimeraWithK(mfcaa, mfcba, mfcca, vvy, vy2, c6o1, c1o6);
+ vf::lbm::backwardChimera( mfcab, mfcbb, mfccb, vvy, vy2);
+ vf::lbm::backwardInverseChimeraWithK(mfcac, mfcbc, mfccc, vvy, vy2, c18o1, c1o18);
+ ////////////////////////////////////////////////////////////////////////////////////
+ // Z - Dir
+ vf::lbm::backwardInverseChimeraWithK(mfaaa, mfaab, mfaac, vvz, vz2, c36o1, c1o36);
+ vf::lbm::backwardInverseChimeraWithK(mfaba, mfabb, mfabc, vvz, vz2, c9o1, c1o9);
+ vf::lbm::backwardInverseChimeraWithK(mfaca, mfacb, mfacc, vvz, vz2, c36o1, c1o36);
+ vf::lbm::backwardInverseChimeraWithK(mfbaa, mfbab, mfbac, vvz, vz2, c9o1, c1o9);
+ vf::lbm::backwardInverseChimeraWithK(mfbba, mfbbb, mfbbc, vvz, vz2, c9o4, c4o9);
+ vf::lbm::backwardInverseChimeraWithK(mfbca, mfbcb, mfbcc, vvz, vz2, c9o1, c1o9);
+ vf::lbm::backwardInverseChimeraWithK(mfcaa, mfcab, mfcac, vvz, vz2, c36o1, c1o36);
+ vf::lbm::backwardInverseChimeraWithK(mfcba, mfcbb, mfcbc, vvz, vz2, c9o1, c1o9);
+ vf::lbm::backwardInverseChimeraWithK(mfcca, mfccb, mfccc, vvz, vz2, c36o1, c1o36);
+
+
+ ////////////////////////////////////////////////////////////////////////////////////
+ //! - Write distributions: style of reading and writing the distributions from/to
+ //! stored arrays dependent on timestep is based on the esoteric twist algorithm
+ //! <a href="https://doi.org/10.3390/computation5020019"><b>[ M. Geier et al. (2017), DOI:10.3390/computation5020019 ]</b></a>
+ //!
+ distribution.f[dir::MZZ] = mfcbb;
+ distribution.f[dir::PZZ] = mfabb;
+ distribution.f[dir::ZMZ] = mfbcb;
+ distribution.f[dir::ZPZ] = mfbab;
+ distribution.f[dir::ZZM] = mfbbc;
+ distribution.f[dir::ZZP] = mfbba;
+ distribution.f[dir::MMZ] = mfccb;
+ distribution.f[dir::PPZ] = mfaab;
+ distribution.f[dir::MPZ] = mfcab;
+ distribution.f[dir::PMZ] = mfacb;
+ distribution.f[dir::MZM] = mfcbc;
+ distribution.f[dir::PZP] = mfaba;
+ distribution.f[dir::MZP] = mfcba;
+ distribution.f[dir::PZM] = mfabc;
+ distribution.f[dir::ZMM] = mfbcc;
+ distribution.f[dir::ZPP] = mfbaa;
+ distribution.f[dir::ZMP] = mfbca;
+ distribution.f[dir::ZPM] = mfbac;
+ distribution.f[dir::MMM] = mfccc;
+ distribution.f[dir::PMM] = mfacc;
+ distribution.f[dir::MPM] = mfcac;
+ distribution.f[dir::PPM] = mfaac;
+ distribution.f[dir::MMP] = mfcca;
+ distribution.f[dir::PMP] = mfaca;
+ distribution.f[dir::MPP] = mfcaa;
+ distribution.f[dir::PPP] = mfaaa;
+ distribution.f[dir::ZZZ] = mfbbb;
+}
+
+
+}
+}
+
diff --git a/src/lbm/CumulantChimera.h b/src/lbm/CumulantChimera.h
new file mode 100644
index 0000000000000000000000000000000000000000..e8740c7d3f5b988a6fdc5c3b16ab6a90e0a28b83
--- /dev/null
+++ b/src/lbm/CumulantChimera.h
@@ -0,0 +1,34 @@
+#ifndef LBM_CUMULANT_CHIMERA_H
+#define LBM_CUMULANT_CHIMERA_H
+
+#ifndef __host__
+#define __host__
+#endif
+#ifndef __device__
+#define __device__
+#endif
+
+#include <basics/Core/DataTypes.h>
+
+#include "KernelParameter.h"
+
+namespace vf
+{
+namespace lbm
+{
+
+__host__ __device__ void setRelaxationRatesK17(real omega, real &OxxPyyPzz, real &OxyyPxzz, real &OxyyMxzz, real &Oxyz,
+ real &O4, real &O5, real &O6);
+
+__host__ __device__ void setRelaxationRatesK15(real omega, real &OxxPyyPzz, real &OxyyPxzz, real &OxyyMxzz, real &Oxyz,
+ real &O4, real &O5, real &O6);
+
+using RelaxationRatesFunctor = void(*)(real omega, real &OxxPyyPzz, real &OxyyPxzz, real &OxyyMxzz, real &Oxyz,
+ real &O4, real &O5, real &O6);
+
+
+__host__ __device__ void cumulantChimera(KernelParameter parameter, RelaxationRatesFunctor setRelaxationRates);
+
+}
+}
+#endif
diff --git a/src/lbm/KernelParameter.cpp b/src/lbm/KernelParameter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15a0f9c445fa4fc7b1fba4b0482da29068b72951
--- /dev/null
+++ b/src/lbm/KernelParameter.cpp
@@ -0,0 +1,32 @@
+#include "KernelParameter.h"
+
+
+#include "MacroscopicQuantities.h"
+
+
+namespace vf
+{
+namespace lbm
+{
+
+
+
+inline __host__ __device__ real Distribution27::getDensity_() const
+{
+ return getDensity(f);
+}
+
+
+
+__host__ __device__ real abs_internal(real value)
+{
+#ifdef __CUDA_ARCH__
+ return ::abs(value);
+#else
+ return std::abs(value);
+#endif
+}
+
+
+}
+}
diff --git a/src/lbm/KernelParameter.h b/src/lbm/KernelParameter.h
new file mode 100644
index 0000000000000000000000000000000000000000..95226628110637f3794c8a1f7e6f6c1f6dda937b
--- /dev/null
+++ b/src/lbm/KernelParameter.h
@@ -0,0 +1,43 @@
+#ifndef LBM_KERNEL_PARAMETER_H
+#define LBM_KERNEL_PARAMETER_H
+
+#ifndef __host__
+#define __host__
+#endif
+#ifndef __device__
+#define __device__
+#endif
+
+#include <basics/Core/DataTypes.h>
+
+
+namespace vf
+{
+namespace lbm
+{
+
+struct Distribution27
+{
+ real f[27];
+
+ __host__ __device__ real getDensity_() const;
+};
+
+
+__host__ __device__ real abs_internal(real value);
+
+
+struct KernelParameter
+{
+ Distribution27& distribution;
+ real omega;
+ real* forces;
+};
+
+
+
+
+}
+}
+
+#endif
diff --git a/src/lbm/MacroscopicQuantities.h b/src/lbm/MacroscopicQuantities.h
new file mode 100644
index 0000000000000000000000000000000000000000..c37791294ff5b4edad21795f4ce0a32a18c5d236
--- /dev/null
+++ b/src/lbm/MacroscopicQuantities.h
@@ -0,0 +1,98 @@
+#ifndef LBM_CALCMAC_H
+#define LBM_CALCMAC_H
+
+#ifndef __host__
+#define __host__
+#endif
+#ifndef __device__
+#define __device__
+#endif
+
+#include <basics/Core/DataTypes.h>
+
+#include "constants/NumericConstants.h"
+#include "constants/D3Q27.h"
+
+namespace vf
+{
+namespace lbm
+{
+
+////////////////////////////////////////////////////////////////////////////////////
+//! - Calculate density and velocity using pyramid summation for low round-off errors as in Eq. (J1)-(J3) \ref
+//! <a href="https://doi.org/10.1016/j.camwa.2015.05.001"><b>[ M. Geier et al. (2015), DOI:10.1016/j.camwa 2015.05.001 ]</b></a>
+//!
+
+inline __host__ __device__ real getDensity(const real *const &f /*[27]*/)
+{
+ return ((f[dir::TNE] + f[dir::BSW]) + (f[dir::TSE] + f[dir::BNW])) + ((f[dir::BSE] + f[dir::TNW]) + (f[dir::TSW] + f[dir::BNE])) +
+ (((f[dir::NE] + f[dir::SW]) + (f[dir::SE] + f[dir::NW])) + ((f[dir::TE] + f[dir::BW]) + (f[dir::BE] + f[dir::TW])) +
+ ((f[dir::BN] + f[dir::TS]) + (f[dir::TN] + f[dir::BS]))) +
+ ((f[dir::E] + f[dir::W]) + (f[dir::N] + f[dir::S]) + (f[dir::T] + f[dir::B])) + f[dir::REST];
+}
+
+/*
+* Incompressible Macroscopic Quantities
+*/
+inline __host__ __device__ real getIncompressibleVelocityX1(const real *const &f /*[27]*/)
+{
+ return ((((f[dir::TNE] - f[dir::BSW]) + (f[dir::TSE] - f[dir::BNW])) + ((f[dir::BSE] - f[dir::TNW]) + (f[dir::BNE] - f[dir::TSW]))) +
+ (((f[dir::BE] - f[dir::TW]) + (f[dir::TE] - f[dir::BW])) + ((f[dir::SE] - f[dir::NW]) + (f[dir::NE] - f[dir::SW]))) + (f[dir::E] - f[dir::W]));
+}
+
+
+inline __host__ __device__ real getIncompressibleVelocityX2(const real *const &f /*[27]*/)
+{
+ return ((((f[dir::TNE] - f[dir::BSW]) + (f[dir::BNW] - f[dir::TSE])) + ((f[dir::TNW] - f[dir::BSE]) + (f[dir::BNE] - f[dir::TSW]))) +
+ (((f[dir::BN] - f[dir::TS]) + (f[dir::TN] - f[dir::BS])) + ((f[dir::NW] - f[dir::SE]) + (f[dir::NE] - f[dir::SW]))) + (f[dir::N] - f[dir::S]));
+}
+
+
+inline __host__ __device__ real getIncompressibleVelocityX3(const real *const &f /*[27]*/)
+{
+ return ((((f[dir::TNE] - f[dir::BSW]) + (f[dir::TSE] - f[dir::BNW])) + ((f[dir::TNW] - f[dir::BSE]) + (f[dir::TSW] - f[dir::BNE]))) +
+ (((f[dir::TS] - f[dir::BN]) + (f[dir::TN] - f[dir::BS])) + ((f[dir::TW] - f[dir::BE]) + (f[dir::TE] - f[dir::BW]))) + (f[dir::T] - f[dir::B]));
+}
+
+
+
+/*
+* Compressible Macroscopic Quantities
+*/
+inline __host__ __device__ real getCompressibleVelocityX1(const real *const &f27, const real& rho)
+{
+ return getIncompressibleVelocityX1(f27) / (rho + constant::c1o1);
+}
+
+
+inline __host__ __device__ real getCompressibleVelocityX2(const real *const &f27, const real& rho)
+{
+ return getIncompressibleVelocityX2(f27) / (rho + constant::c1o1);
+}
+
+
+inline __host__ __device__ real getCompressibleVelocityX3(const real *const &f27, const real& rho)
+{
+ return getIncompressibleVelocityX3(f27) / (rho + constant::c1o1);
+}
+
+/*
+* Pressure
+*/
+inline __host__ __device__ real getPressure(const real *const &f27, const real& rho, const real& vx, const real& vy, const real& vz)
+{
+ return (f27[dir::E] + f27[dir::W] + f27[dir::N] + f27[dir::S] + f27[dir::T] + f27[dir::B] +
+ constant::c2o1 * (f27[dir::NE] + f27[dir::SW] + f27[dir::SE] + f27[dir::NW] + f27[dir::TE] +
+ f27[dir::BW] + f27[dir::BE] + f27[dir::TW] + f27[dir::TN] + f27[dir::BS] +
+ f27[dir::BN] + f27[dir::TS]) +
+ constant::c3o1 * (f27[dir::TNE] + f27[dir::TSW] + f27[dir::TSE] + f27[dir::TNW] +
+ f27[dir::BNE] + f27[dir::BSW] + f27[dir::BSE] + f27[dir::BNW]) -
+ rho - (vx * vx + vy * vy + vz * vz) * (constant::c1o1 + rho)) *
+ constant::c1o2 + rho; // times zero for incompressible case
+ // Attention: op defined directly to op = 1 ; ^^^^(1.0/op-0.5)=0.5
+}
+
+}
+}
+
+#endif
diff --git a/src/lbm/MacroscopicQuantitiesTests.cpp b/src/lbm/MacroscopicQuantitiesTests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52f89943a3e6a99fcab13eba22de9959229a289d
--- /dev/null
+++ b/src/lbm/MacroscopicQuantitiesTests.cpp
@@ -0,0 +1,71 @@
+#include <gmock/gmock.h>
+
+#include "MacroscopicQuantities.h"
+#include "constants/D3Q27.h"
+
+
+/*
+* given distributions, which are all one.
+*/
+real f[27] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+
+using namespace vf::lbm;
+
+
+TEST(MacroscopicQuantitiesTest, check_density)
+{
+ const double density = getDensity(f);
+
+ const double expected_density = 27.;
+ ASSERT_THAT(density, testing::DoubleEq(expected_density));
+}
+
+TEST(MacroscopicQuantitiesTest, whenFsAreEqual_velocityInEachDirectionShouldBeZero)
+{
+ const double velocityX1 = getIncompressibleVelocityX1(f);
+ const double velocityX2 = getIncompressibleVelocityX2(f);
+ const double velocityX3 = getIncompressibleVelocityX3(f);
+
+ const double expected_velocity = 0.;
+ EXPECT_THAT(velocityX1, testing::DoubleEq(expected_velocity));
+ EXPECT_THAT(velocityX2, testing::DoubleEq(expected_velocity));
+ EXPECT_THAT(velocityX3, testing::DoubleEq(expected_velocity));
+}
+
+TEST(MacroscopicQuantitiesTest, givenAllFsAreOne_when_Eis2_velocityInX1ShouldBeOne)
+{
+ f[dir::E] = 2.;
+
+ const double velocityX1 = getIncompressibleVelocityX1(f);
+ const double velocityX2 = getIncompressibleVelocityX2(f);
+ const double velocityX3 = getIncompressibleVelocityX3(f);
+
+ const double expected_velocity_x1 = 1.;
+ const double expected_velocity_x2 = 0.;
+ const double expected_velocity_x3 = 0.;
+
+ EXPECT_THAT(velocityX1, testing::DoubleEq(expected_velocity_x1));
+ EXPECT_THAT(velocityX2, testing::DoubleEq(expected_velocity_x2));
+ EXPECT_THAT(velocityX3, testing::DoubleEq(expected_velocity_x3));
+}
+
+TEST(MacroscopicQuantitiesTest, givenAllFsAreOne_when_Nis2_velocityInX2ShouldBeOne)
+{
+ f[dir::N] = 2.;
+
+ const double velocity = getIncompressibleVelocityX2(f);
+
+ const double expected_velocity = 1.;
+ ASSERT_THAT(velocity, testing::DoubleEq(expected_velocity));
+}
+
+
+TEST(MacroscopicQuantitiesTest, givenAllFsAreOne_when_Tis2_velocityInX3ShouldBeOne)
+{
+ f[dir::T] = 2.;
+
+ const double velocity = getIncompressibleVelocityX3(f);
+
+ const double expected_velocity = 1.;
+ ASSERT_THAT(velocity, testing::DoubleEq(expected_velocity));
+}
diff --git a/src/lbm/constants/D3Q27.h b/src/lbm/constants/D3Q27.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b2cbfdd44e84af590fa2c2be4bf319cbfd4c815
--- /dev/null
+++ b/src/lbm/constants/D3Q27.h
@@ -0,0 +1,71 @@
+#ifndef LBM_D3Q27_H
+#define LBM_D3Q27_H
+
+namespace vf
+{
+namespace lbm
+{
+namespace dir
+{
+
+static constexpr int E = 0;
+static constexpr int W = 1;
+static constexpr int N = 2;
+static constexpr int S = 3;
+static constexpr int T = 4;
+static constexpr int B = 5;
+static constexpr int NE = 6;
+static constexpr int SW = 7;
+static constexpr int SE = 8;
+static constexpr int NW = 9;
+static constexpr int TE = 10;
+static constexpr int BW = 11;
+static constexpr int BE = 12;
+static constexpr int TW = 13;
+static constexpr int TN = 14;
+static constexpr int BS = 15;
+static constexpr int BN = 16;
+static constexpr int TS = 17;
+static constexpr int TNE = 18;
+static constexpr int TNW = 19;
+static constexpr int TSE = 20;
+static constexpr int TSW = 21;
+static constexpr int BNE = 22;
+static constexpr int BNW = 23;
+static constexpr int BSE = 24;
+static constexpr int BSW = 25;
+static constexpr int REST = 26;
+
+static constexpr int PZZ = 0;
+static constexpr int MZZ = 1;
+static constexpr int ZPZ = 2;
+static constexpr int ZMZ = 3;
+static constexpr int ZZP = 4;
+static constexpr int ZZM = 5;
+static constexpr int PPZ = 6;
+static constexpr int MMZ = 7;
+static constexpr int PMZ = 8;
+static constexpr int MPZ = 9;
+static constexpr int PZP = 10;
+static constexpr int MZM = 11;
+static constexpr int PZM = 12;
+static constexpr int MZP = 13;
+static constexpr int ZPP = 14;
+static constexpr int ZMM = 15;
+static constexpr int ZPM = 16;
+static constexpr int ZMP = 17;
+static constexpr int PPP = 18;
+static constexpr int MPP = 19;
+static constexpr int PMP = 20;
+static constexpr int MMP = 21;
+static constexpr int PPM = 22;
+static constexpr int MPM = 23;
+static constexpr int PMM = 24;
+static constexpr int MMM = 25;
+static constexpr int ZZZ = 26;
+
+}
+}
+}
+
+#endif
diff --git a/src/lbm/cuda/CMakeLists.txt b/src/lbm/cuda/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be16988a480650cbab416652655af9766bcf8ec7
--- /dev/null
+++ b/src/lbm/cuda/CMakeLists.txt
@@ -0,0 +1,12 @@
+project(lbmCuda LANGUAGES CUDA CXX)
+
+
+vf_add_library(NAME lbmCuda BUILDTYPE static PUBLIC_LINK basics FOLDER ../../lbm)
+
+
+set_target_properties(lbmCuda PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+set_source_files_properties(../KernelParameter.cpp PROPERTIES LANGUAGE CUDA)
+
+set_source_files_properties(../CumulantChimera.cpp PROPERTIES LANGUAGE CUDA)
+set_source_files_properties(../BGK.cpp PROPERTIES LANGUAGE CUDA)
\ No newline at end of file