diff --git a/CMake/cmake_config_files/MOLLOK.config.cmake b/CMake/cmake_config_files/MOLLOK.config.cmake
index 4bb199d69dd2f88f786752374d244c643ca51d8a..2407cda6287cd0e171453d1559ab6585b0a09a33 100644
--- a/CMake/cmake_config_files/MOLLOK.config.cmake
+++ b/CMake/cmake_config_files/MOLLOK.config.cmake
@@ -5,8 +5,6 @@
#################################################################################
#SET TO CORRECT PATH:
-SET(BOOST_ROOT "D:/libraries/boost_1_74_0" CACHE PATH "BOOST_ROOT")
-SET(BOOST_LIBRARYDIR "D:/libraries/boost_1_74_0/stageMSVC64VS2019/lib" CACHE PATH "BOOST_LIBRARYDIR")
SET(CMAKE_CUDA_ARCHITECTURES 52)
SET(PATH_NUMERICAL_TESTS "D:/out/numericalTests/")
diff --git a/apps/gpu/LBM/WTG_RUB/CMakeLists.txt b/apps/gpu/LBM/WTG_RUB/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8bac54bf335a26aaecbf8cbb5a1474e67bd99b89
--- /dev/null
+++ b/apps/gpu/LBM/WTG_RUB/CMakeLists.txt
@@ -0,0 +1,5 @@
+PROJECT(WTG_RUB LANGUAGES CUDA CXX)
+
+vf_add_library(BUILDTYPE binary PRIVATE_LINK basics VirtualFluids_GPU GridGenerator MPI::MPI_CXX FILES WTG_RUB.cpp)
+
+set_source_files_properties(WTG_RUB.cpp PROPERTIES LANGUAGE CUDA)
diff --git a/apps/gpu/LBM/WTG_RUB/WTG_RUB.cpp b/apps/gpu/LBM/WTG_RUB/WTG_RUB.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..12bc850bc718952278b5f0e9e10470eea3ff18b3
--- /dev/null
+++ b/apps/gpu/LBM/WTG_RUB/WTG_RUB.cpp
@@ -0,0 +1,514 @@
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <stdexcept>
+#include <fstream>
+#include <exception>
+#include <memory>
+
+#include "mpi.h"
+
+//////////////////////////////////////////////////////////////////////////
+
+#include "Core/DataTypes.h"
+#include "PointerDefinitions.h"
+
+#include "Core/LbmOrGks.h"
+#include "Core/Input/Input.h"
+#include "Core/StringUtilities/StringUtil.h"
+#include "Core/Input/ConfigFileReader/ConfigFileReader.h"
+
+#include "Core/VectorTypes.h"
+#include "Core/Logger/Logger.h"
+
+//////////////////////////////////////////////////////////////////////////
+
+#include "GridGenerator/grid/GridBuilder/LevelGridBuilder.h"
+#include "GridGenerator/grid/GridBuilder/MultipleGridBuilder.h"
+#include "GridGenerator/grid/BoundaryConditions/Side.h"
+#include "GridGenerator/grid/GridFactory.h"
+#include "GridGenerator/geometries/TriangularMesh/TriangularMesh.h"
+#include "GridGenerator/geometries/Conglomerate/Conglomerate.h"
+
+#include "GridGenerator/io/SimulationFileWriter/SimulationFileWriter.h"
+#include "GridGenerator/io/GridVTKWriter/GridVTKWriter.h"
+#include "GridGenerator/io/STLReaderWriter/STLReader.h"
+#include "GridGenerator/io/STLReaderWriter/STLWriter.h"
+
+//////////////////////////////////////////////////////////////////////////
+
+#include "VirtualFluids_GPU/LBM/Simulation.h"
+#include "VirtualFluids_GPU/Communication/Communicator.h"
+#include "VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h"
+#include "VirtualFluids_GPU/DataStructureInitializer/GridProvider.h"
+#include "VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.h"
+#include "VirtualFluids_GPU/Parameter/Parameter.h"
+#include "VirtualFluids_GPU/Output/FileWriter.h"
+
+#include "VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.h"
+#include "VirtualFluids_GPU/PreProcessor/PreProcessorFactory/PreProcessorFactoryImp.h"
+
+#include "VirtualFluids_GPU/GPU/CudaMemoryManager.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// U s e r s e t t i n g s
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+LbmOrGks lbmOrGks = LBM;
+
+const real L = 1.0;
+
+const real Re = 500.0;// 1000.0;
+
+const real velocity = 1.0;
+
+int variant = 1;
+real rotationOfCity;
+real z_offset = 0.0; // only if baseplate is in use (currently not!! not important)
+
+// 1: original setup of Lennard Lux (6 level, 4.0 cm -> 1.25 mm)
+// 2: setup 1 of MSch (4 level, 1.0 cm -> 1.25 mm)
+// 3: setup 2 of MSch (5 level, 1.6 cm -> 1.0 mm)
+int setupDomain = 3;
+
+
+
+std::string path("D:/out/WTG_RUB"); //Mollok
+std::string inputPath("D:/out/WTG_RUB/input/");
+
+std::string simulationName("RUB");
+
+const uint timeStepStartOut = 0;
+const uint timeStepOut = 10000;
+const uint timeStepEnd = 100000;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void addFineGrids(SPtr<MultipleGridBuilder> gridBuilder, uint &maxLevel, real &rotationOfCity);
+
+std::string chooseVariation();
+
+void multipleLevel(const std::string& configPath)
+{
+ logging::Logger::addStream(&std::cout);
+ logging::Logger::setDebugLevel(logging::Logger::Level::INFO_LOW);
+ logging::Logger::timeStamp(logging::Logger::ENABLE);
+ logging::Logger::enablePrintedRankNumbers(logging::Logger::ENABLE);
+
+ auto gridFactory = GridFactory::make();
+ gridFactory->setGridStrategy(Device::CPU);
+ gridFactory->setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod::POINT_IN_OBJECT);
+
+ auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+
+ vf::gpu::Communicator* comm = vf::gpu::Communicator::getInstanz();
+ SPtr<ConfigFileReader> configReader = ConfigFileReader::getNewInstance();
+
+ std::cout << configPath << std::endl;
+ SPtr<ConfigData> configData = configReader->readConfigFile(configPath.c_str());
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ real dx = 0;
+ real viscosityLB = (real)1.0e-03;
+ uint maxLevel = 1;
+
+ if (setupDomain == 1) {
+ dx = (real)4;
+ maxLevel = 5;
+ viscosityLB = (real)3.75e-06; // LB units
+ } else if (setupDomain == 2) {
+ dx = (real)1;
+ maxLevel = 3;
+ viscosityLB = (real)1.5e-05; // LB units
+ } else if (setupDomain == 3) {
+ dx = (real)1.6;
+ maxLevel = 4;
+ viscosityLB = (real)9.375e-06; // LB units
+ }
+
+ real x_min = 0.0;
+ real x_max = 1250.0;
+ real y_min = 0.0;
+ real y_max = 190.0;
+ real z_min = 0.0 + z_offset;
+ real z_max = 160.0 + z_offset;
+
+ //TriangularMesh *RubSTL = TriangularMesh::make(inputPath + "stl/Var02_0deg_FD_b.stl");
+ TriangularMesh *RubSTL = TriangularMesh::make(inputPath + "stl/" + chooseVariation() + ".stl");
+ // vector<real> originOfCityXY = { 600.0, y_max / 2, z_offset };
+
+
+ gridBuilder->addCoarseGrid(x_min, y_min, z_min,
+ x_max, y_max, z_max, dx);
+
+ gridBuilder->setNumberOfLayers(0, 0);
+
+ addFineGrids(gridBuilder, maxLevel, rotationOfCity);
+
+ //// adding solid CityGeometry to gridbuilder
+ gridBuilder->addGeometry(RubSTL);
+
+ gridBuilder->setPeriodicBoundaryCondition(false, false, false);
+
+ gridBuilder->buildGrids(lbmOrGks, false); // buildGrids() has to be called before setting the BCs!!!!
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ SPtr<Parameter> para = Parameter::make(configData, comm);
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ const real velocityLB = (real)0.0844; // LB units
+
+ //const real vx = velocityLB / (real)sqrt(2.0); // LB units
+ //const real vy = velocityLB / (real)sqrt(2.0); // LB units
+
+ *logging::out << logging::Logger::INFO_HIGH << "velocity [dx/dt] = " << velocityLB << " \n";
+ *logging::out << logging::Logger::INFO_HIGH << "viscosity [dx^2/dt] = " << viscosityLB << "\n";
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ para->setDevices(std::vector<uint>{(uint)0});
+
+ para->setOutputPath( path );
+ para->setOutputPrefix( simulationName );
+
+ para->setFName(para->getOutputPath() + "/" + para->getOutputPrefix());
+
+ para->setPrintFiles(true);
+
+ para->setMaxLevel(maxLevel);
+
+ para->setVelocity(velocityLB);
+ para->setViscosity(viscosityLB);
+
+ para->setVelocityRatio(velocity/ velocityLB);
+
+ para->setMainKernel("CumulantK17CompChim");
+
+ para->setInitialCondition([&](real coordX, real coordY, real coordZ, real &rho, real &vx, real &vy, real &vz) {
+ rho = (real)0.0;
+ vx = (real)0.0; //(6 * velocityLB * coordZ * (L - coordZ) / (L * L));
+ vy = (real)0.0;
+ vz = (real)0.0;
+ });
+
+ para->setTOut( timeStepOut );
+ para->setTEnd( timeStepEnd );
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::MX, velocityLB, 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PY, 0.0, 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MY, 0.0, 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PZ, 0.0, 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MZ, 0.0, 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ SPtr<CudaMemoryManager> cudaMemoryManager = CudaMemoryManager::make(para);
+
+ SPtr<GridProvider> gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+
+ Simulation sim;
+ SPtr<FileWriter> fileWriter = SPtr<FileWriter>(new FileWriter());
+ SPtr<KernelFactoryImp> kernelFactory = KernelFactoryImp::getInstance();
+ SPtr<PreProcessorFactoryImp> preProcessorFactory = PreProcessorFactoryImp::getInstance();
+ sim.setFactories(kernelFactory, preProcessorFactory);
+ sim.init(para, gridGenerator, fileWriter, cudaMemoryManager);
+ sim.run();
+ sim.free();
+
+}
+
+void addFineGrids(SPtr<MultipleGridBuilder> gridBuilder, uint &maxLevel, real &rotationOfCity)
+{
+ if (setupDomain == 1) {
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+ // creates Cuboids (FG1 to FG3, lvl 1 to lvl 3) and add STLs (FG4 to FG5, lvl 4 to lvl 5) depending on maxLevel
+ // and rotationOfCity; also adds FineGrids(FGs) to gridbuilder
+
+ // GridList(CG = coarse grid, fg = fine grid)
+ // CG -> dx = 4 cm; lvl 0
+ // FG1 -> dx = 2 cm; lvl 1
+ // FG2 -> dx = 1 cm; lvl 2
+ // FG3 -> dx = 5 mm; lvl 3
+ // FG4 -> dx = 2,5 mm; lvl 4
+ // FG5 -> dx = 1,25 mm; lvl 5
+ //
+ // FineGrid Level 1 ->dx = 2 cm; lvl 1
+ auto FG1 = new Cuboid(-20, -20, -5 + z_offset, 800, 200, 75 + z_offset);
+
+ // FineGrid Level 2 -> dx = 1 cm; lvl 2
+ auto FG2_1 = new Cuboid(-20, -20, -5 + z_offset, 760, 200, 10 + z_offset);
+ auto FG2_2 = new Cuboid(500, -20, 5 + z_offset, 680, 210, 50 + z_offset);
+ auto FG2 = new Conglomerate();
+ FG2->add(FG2_1);
+ FG2->add(FG2_2);
+
+ // FineGrid Level 3 ->dx = 5 mm; lvl 3
+ auto FG3_1 = new Cuboid(517, -20, -5 + z_offset, 665, 200, 30 + z_offset);
+ auto FG3_2 = new Cuboid(550, 58, -5 + z_offset, 650, 132, 40 + z_offset);
+ auto FG3 = new Conglomerate();
+ FG3->add(FG3_1);
+ FG3->add(FG3_2);
+
+ // Adding FineGrids 1 to 5 depending on maxLevel, FG4 and FG5 require different STL-files depending on
+ // rotationOfCity
+ if (maxLevel >= 1) {
+ gridBuilder->addGrid(FG1, 1);
+ if (maxLevel >= 2) {
+ gridBuilder->addGrid(FG2, 2);
+ if (maxLevel >= 3) {
+ gridBuilder->addGrid(FG3, 3);
+ if (maxLevel >= 4) {
+ if (rotationOfCity == 0.0) {
+ TriangularMesh *FG4 = TriangularMesh::make(inputPath + "stl/FG4_0deg.stl");
+ gridBuilder->addGrid(FG4, 4);
+ } else {
+ TriangularMesh *FG4 = TriangularMesh::make(inputPath + "stl/FG4_63deg.stl");
+ gridBuilder->addGrid(FG4, 4);
+ }
+
+ if (maxLevel == 5) {
+ if (rotationOfCity == 0.0) {
+ TriangularMesh *FG5 = TriangularMesh::make(inputPath + "stl/FG5_0deg.stl");
+ gridBuilder->addGrid(FG5, 5);
+ } else {
+ TriangularMesh *FG5 = TriangularMesh::make(inputPath + "stl/FG5_63deg.stl");
+ gridBuilder->addGrid(FG5, 5);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else if (setupDomain == 2) {
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+ // creates Cuboids (FG1, lvl 1) and add STLs (FG2 to FG3, lvl 2 to lvl 3) depending on maxLevel
+ // and rotationOfCity; also adds FineGrids(FGs) to gridbuilder
+ //
+ // GridList(CG = coarse grid, fg = fine grid)
+ // CG -> dx = 1 cm; lvl 0
+ // FG1 -> dx = 5 mm; lvl 1
+ // FG2 -> dx = 2,5 mm; lvl 2
+ // FG3 -> dx = 1,25 mm; lvl 3
+ //
+ // FineGrid Level 1 -> dx = 5 mm; lvl 1
+ //auto FG1_1 = new Cuboid(-20, -20, -5 + z_offset, 760, 200, 10 + z_offset);
+ auto FG1_1 = new Cuboid(-20, -20, -5 + z_offset, 760, 200, 20 + z_offset);
+ auto FG1_2 = new Cuboid(500, -20, 5 + z_offset, 680, 210, 50 + z_offset);
+ auto FG1 = new Conglomerate();
+ FG1->add(FG1_1);
+ FG1->add(FG1_2);
+
+ // Adding FineGrids 1 to 5 depending on maxLevel, FG4 and FG5 require different STL-files depending on
+ // rotationOfCity
+ if (maxLevel >= 1) {
+ gridBuilder->addGrid(FG1, 1);
+ if (maxLevel >= 2) {
+ if (rotationOfCity == 0.0) {
+ TriangularMesh *FG2 = TriangularMesh::make(inputPath + "stl/FG4_0deg.stl");
+ gridBuilder->addGrid(FG2, 2);
+ } else {
+ TriangularMesh *FG2 = TriangularMesh::make(inputPath + "stl/FG4_63deg.stl");
+ gridBuilder->addGrid(FG2, 2);
+ }
+
+ if (maxLevel == 3) {
+ if (rotationOfCity == 0.0) {
+ TriangularMesh *FG3 = TriangularMesh::make(inputPath + "stl/FG5_0deg.stl");
+ gridBuilder->addGrid(FG3, 3);
+ } else {
+ TriangularMesh *FG3 = TriangularMesh::make(inputPath + "stl/FG5_63deg.stl");
+ gridBuilder->addGrid(FG3, 3);
+ }
+ }
+ }
+ }
+ }
+ else if (setupDomain == 3) {
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+ // creates Cuboids (FG1 to FG2, lvl 1 to lvl 2) and add STLs (FG3 to FG4, lvl 3 to lvl 4) depending on maxLevel
+ // and rotationOfCity; also adds FineGrids(FGs) to gridbuilder
+
+ // GridList(CG = coarse grid, fg = fine grid)
+ // CG -> dx = 1.6 cm; lvl 0
+ // FG1 -> dx = 8.0 mm; lvl 1
+ // FG2 -> dx = 4.0 mm; lvl 2
+ // FG3 -> dx = 2.0 mm; lvl 3
+ // FG4 -> dx = 1.0 mm; lvl 4
+ //
+ //// FineGrid Level 1 ->dx = 8.0 mm; lvl 1
+ //auto FG1 = new Cuboid(-20, -20, -5 + z_offset, 800, 200, 75 + z_offset);
+
+ // FineGrid Level 1 -> dx = 8.0 mm; lvl 1
+ auto FG1_1 = new Cuboid(-20, -20, -5 + z_offset, 780, 200, 30 + z_offset);
+ auto FG1_2 = new Cuboid(500, -20, 5 + z_offset, 720, 210, 75 + z_offset);
+ auto FG1 = new Conglomerate();
+ FG1->add(FG1_1);
+ FG1->add(FG1_2);
+
+ // FineGrid Level 2 -> dx = 4.0 mm; lvl 2
+ auto FG2_1 = new Cuboid(-20, -20, -5 + z_offset, 760, 200, 10 + z_offset);
+ auto FG2_2 = new Cuboid(520, -20, 5 + z_offset, 700, 210, 50 + z_offset);
+ auto FG2 = new Conglomerate();
+ FG2->add(FG2_1);
+ FG2->add(FG2_2);
+
+ // Adding FineGrids 1 to 4 depending on maxLevel, FG3 and FG4 require different STL-files depending on
+ // rotationOfCity
+ if (maxLevel >= 1) {
+ gridBuilder->addGrid(FG1, 1);
+ if (maxLevel >= 2) {
+ gridBuilder->addGrid(FG2, 2);
+ if (maxLevel >= 3) {
+ if (rotationOfCity == 0.0) {
+ TriangularMesh *FG3 = TriangularMesh::make(inputPath + "stl/FG4_0deg.stl");
+ gridBuilder->addGrid(FG3, 3);
+ } else {
+ TriangularMesh *FG3 = TriangularMesh::make(inputPath + "stl/FG4_63deg.stl");
+ gridBuilder->addGrid(FG3, 3);
+ }
+
+ if (maxLevel == 4) {
+ if (rotationOfCity == 0.0) {
+ TriangularMesh *FG4 = TriangularMesh::make(inputPath + "stl/FG5_0deg.stl");
+ gridBuilder->addGrid(FG4, 4);
+ } else {
+ TriangularMesh *FG4 = TriangularMesh::make(inputPath + "stl/FG5_63deg.stl");
+ gridBuilder->addGrid(FG4, 4);
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+
+}
+
+std::string chooseVariation()
+{
+ switch (variant) {
+ case 1:
+ simulationName = "Var01_0deg_FD_a";
+ break;
+ case 2:
+ simulationName = "Var02_0deg_FD_b";
+ break;
+ case 3:
+ simulationName = "Var03_0deg_FD_c";
+ break;
+ case 4:
+ simulationName = "Var04_0deg_SD_a";
+ break;
+ case 5:
+ simulationName = "Var05_0deg_SD_b";
+ break;
+ case 6:
+ simulationName = "Var06_0deg_SD_c";
+ break;
+ case 7:
+ simulationName = "Var07_63deg_FD_a";
+ break;
+ case 8:
+ simulationName = "Var08_63deg_FD_b";
+ break;
+ case 9:
+ simulationName = "Var09_63deg_FD_c";
+ break;
+ case 10:
+ simulationName = "Var10_63deg_SD_a";
+ break;
+ case 11:
+ simulationName = "Var11_63deg_SD_b";
+ break;
+ case 12:
+ simulationName = "Var12_63deg_SD_c";
+ break;
+ default:
+ std::cerr << "Warning: no variant selected. Running with Default variant V01!" << std::endl;
+ simulationName = "Var01_0deg_FD_a";
+ rotationOfCity = 0.0;
+ return simulationName;
+ }
+
+ if ((0 < variant) && (variant <= 6))
+ rotationOfCity = (real)0.0;
+ else if ((6 < variant) && (variant <= 12))
+ rotationOfCity = (real)63.295;
+
+ std::cout << "Variant selected. Simulation name is: " << simulationName << std::endl;
+ std::cout << "Rotation selected: " << rotationOfCity << std::endl;
+
+ return simulationName;
+}
+
+
+int main( int argc, char* argv[])
+{
+ MPI_Init(&argc, &argv);
+ std::string str, str2;
+ if ( argv != NULL )
+ {
+ //str = static_cast<std::string>(argv[0]);
+
+ try
+ {
+ //////////////////////////////////////////////////////////////////////////
+
+ std::string targetPath;
+
+ targetPath = __FILE__;
+
+ targetPath = targetPath.substr(0, targetPath.find_last_of('/') + 1);
+
+
+
+ std::cout << targetPath << std::endl;
+
+ multipleLevel(targetPath + "configDrivenCavity.txt");
+
+ //////////////////////////////////////////////////////////////////////////
+ }
+ catch (const std::bad_alloc& e)
+ {
+ *logging::out << logging::Logger::LOGGER_ERROR << "Bad Alloc:" << e.what() << "\n";
+ }
+ catch (const std::exception& e)
+ {
+ *logging::out << logging::Logger::LOGGER_ERROR << e.what() << "\n";
+ }
+ catch (...)
+ {
+ *logging::out << logging::Logger::LOGGER_ERROR << "Unknown exception!\n";
+ }
+ }
+
+ MPI_Finalize();
+ return 0;
+}
diff --git a/apps/gpu/LBM/WTG_RUB/configDrivenCavity.txt b/apps/gpu/LBM/WTG_RUB/configDrivenCavity.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a3d6622d50700e554dcf3429f0c51e07f5c83ead
--- /dev/null
+++ b/apps/gpu/LBM/WTG_RUB/configDrivenCavity.txt
@@ -0,0 +1,36 @@
+##################################################
+#GPU Mapping
+##################################################
+#Devices="0 1 2 3"
+#NumberOfDevices=4
+
+##################################################
+#informations for Writing
+##################################################
+#Path="E:/DrivenCavity/results"
+#Path="F:/Work/Computations/out/DrivenCavity/"
+#Prefix="DrivenCavity"
+#WriteGrid=true
+##################################################
+#informations for reading
+##################################################
+#GridPath="E:/DrivenCavity/dummy"
+GridPath="C:"
+
+##################################################
+#number of grid levels
+##################################################
+#NOGL=1
+
+##################################################
+#LBM Version
+##################################################
+#D3Qxx=27
+#MainKernelName=CumulantAA2016CompSP27
+
+##################################################
+#simulation parameter
+##################################################
+#TimeEnd=100000
+#TimeOut=1000
+#TimeStartOut=0
\ No newline at end of file
diff --git a/gpu.cmake b/gpu.cmake
index b982a1abf933a241e81bea71865184764f847311..5e795cf3cbbddf9c0ef6ab021f6775caf692a753 100644
--- a/gpu.cmake
+++ b/gpu.cmake
@@ -40,6 +40,7 @@ IF (BUILD_VF_GPU)
#add_subdirectory(targets/apps/LBM/BaselMultiGPU)
add_subdirectory(apps/gpu/LBM/DrivenCavity)
+ #add_subdirectory(apps/gpu/LBM/WTG_RUB)
#add_subdirectory(apps/gpu/LBM/gridGeneratorTest)
#add_subdirectory(apps/gpu/LBM/TGV_3D)
#add_subdirectory(apps/gpu/LBM/TGV_3D_MultiGPU)
diff --git a/src/gpu/VirtualFluids_GPU/Calculation/CalcMedian.cpp b/src/gpu/VirtualFluids_GPU/Calculation/CalcMedian.cpp
index 066c55b9f30bd7537dfb829f3b953fb8a99a2cae..1adb709c5eb4f391756d455a53717a0d9cf72858 100644
--- a/src/gpu/VirtualFluids_GPU/Calculation/CalcMedian.cpp
+++ b/src/gpu/VirtualFluids_GPU/Calculation/CalcMedian.cpp
@@ -74,7 +74,7 @@ void allocMedianAD(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev = para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaAllocMedianOutAD(lev);
+ cudaManager->cudaAllocMedianOutAD(lev);
for (unsigned int i = 0; i < para->getParH(lev)->size_Mat_SP; i++)
{
para->getParH(lev)->vx_SP_Med_Out[i] = (real)0.0;
diff --git a/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp b/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
index cecb2fdbf86505ff3976e2d13b2ff0539eae98f5..9b90e03648c3485dc496dac86deadeb7247e6a58 100644
--- a/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
+++ b/src/gpu/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
@@ -336,13 +336,21 @@ void postCollisionBC(Parameter* para, int level, unsigned int t)
// para->getParD(level)->size_Mat_SP, para->getParD(level)->evenOrOdd);
//getLastCudaError("QDevComp27 (Geom) execution failed");
- QVelDevComp27(para->getParD(level)->numberofthreads, para->getParD(level)->nx, para->getParD(level)->ny,
- para->getParD(level)->QGeom.Vx, para->getParD(level)->QGeom.Vy, para->getParD(level)->QGeom.Vz,
- para->getParD(level)->d0SP.f[0], para->getParD(level)->QGeom.k, para->getParD(level)->QGeom.q27[0],
- para->getParD(level)->QGeom.kQ, para->getParD(level)->QGeom.kQ, para->getParD(level)->omega,
- para->getParD(level)->neighborX_SP, para->getParD(level)->neighborY_SP, para->getParD(level)->neighborZ_SP,
- para->getParD(level)->size_Mat_SP, para->getParD(level)->evenOrOdd);
- getLastCudaError("QVelDevComp27 execution failed");
+ //QVelDevComp27(para->getParD(level)->numberofthreads, para->getParD(level)->nx, para->getParD(level)->ny,
+ // para->getParD(level)->QGeom.Vx, para->getParD(level)->QGeom.Vy, para->getParD(level)->QGeom.Vz,
+ // para->getParD(level)->d0SP.f[0], para->getParD(level)->QGeom.k, para->getParD(level)->QGeom.q27[0],
+ // para->getParD(level)->QGeom.kQ, para->getParD(level)->QGeom.kQ, para->getParD(level)->omega,
+ // para->getParD(level)->neighborX_SP, para->getParD(level)->neighborY_SP, para->getParD(level)->neighborZ_SP,
+ // para->getParD(level)->size_Mat_SP, para->getParD(level)->evenOrOdd);
+ //getLastCudaError("QVelDevComp27 execution failed");
+
+ QVelDevCompZeroPress27( para->getParD(0)->numberofthreads, para->getParD(0)->nx, para->getParD(0)->ny,
+ para->getParD(0)->QGeom.Vx, para->getParD(0)->QGeom.Vy, para->getParD(0)->QGeom.Vz,
+ para->getParD(0)->d0SP.f[0], para->getParD(0)->QGeom.k, para->getParD(0)->QGeom.q27[0],
+ para->getParD(0)->QGeom.kQ, para->getParD(0)->QGeom.kQ, para->getParD(0)->omega,
+ para->getParD(0)->neighborX_SP, para->getParD(0)->neighborY_SP, para->getParD(0)->neighborZ_SP,
+ para->getParD(0)->size_Mat_SP, para->getParD(0)->evenOrOdd);
+ getLastCudaError("QVelDevCompZeroPress27 execution failed");
//QDev3rdMomentsComp27( para->getParD(level)->numberofthreads, para->getParD(level)->nx, para->getParD(level)->ny,
// para->getParD(level)->d0SP.f[0], para->getParD(level)->QGeom.k, para->getParD(level)->QGeom.q27[0],
diff --git a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
index 2582e6918bd105d81964aba56dcdb661b59025bf..3ce1093d1847743962f3b76cbe62445cbacef312 100644
--- a/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
+++ b/src/gpu/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
@@ -58,7 +58,7 @@ void GridGenerator::allocArrays_CoordNeighborGeo()
cudaMemoryManager->cudaAllocCoord(level);
cudaMemoryManager->cudaAllocSP(level);
- para->cudaAllocF3SP(level);
+ //cudaMemoryManager->cudaAllocF3SP(level);
cudaMemoryManager->cudaAllocNeighborWSB(level);
if(para->getUseWale())
@@ -102,9 +102,9 @@ void GridGenerator::allocArrays_BoundaryValues()
para->getParD(level)->kPressQread = numberOfPressureValues * para->getD3Qxx();
if (numberOfPressureValues > 1)
{
- para->cudaAllocPress(level);
+ cudaMemoryManager->cudaAllocPress(level);
builder->getPressureValues(para->getParH(level)->QPress.RhoBC, para->getParH(level)->QPress.k, para->getParH(level)->QPress.kN, level);
- para->cudaCopyPress(level);
+ cudaMemoryManager->cudaCopyPress(level);
}
}
@@ -127,7 +127,7 @@ void GridGenerator::allocArrays_BoundaryValues()
if (numberOfVelocityValues > 1)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaAllocVeloBC(level);
+ cudaMemoryManager->cudaAllocVeloBC(level);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
builder->getVelocityValues(para->getParH(level)->Qinflow.Vx, para->getParH(level)->Qinflow.Vy, para->getParH(level)->Qinflow.Vz, para->getParH(level)->Qinflow.k, level);
@@ -146,7 +146,7 @@ void GridGenerator::allocArrays_BoundaryValues()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaCopyVeloBC(level);
+ cudaMemoryManager->cudaCopyVeloBC(level);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// advection - diffusion stuff
@@ -157,7 +157,7 @@ void GridGenerator::allocArrays_BoundaryValues()
std::cout << "getTemperatureInit = " << para->getTemperatureInit() << std::endl;
std::cout << "getTemperatureBC = " << para->getTemperatureBC() << std::endl;
//////////////////////////////////////////////////////////////////////////
- para->cudaAllocTempVeloBC(level);
+ cudaMemoryManager->cudaAllocTempVeloBC(level);
//cout << "nach alloc " << endl;
//////////////////////////////////////////////////////////////////////////
for (int m = 0; m < numberOfVelocityValues; m++)
@@ -169,7 +169,7 @@ void GridGenerator::allocArrays_BoundaryValues()
}
//////////////////////////////////////////////////////////////////////////
//cout << "vor copy " << endl;
- para->cudaCopyTempVeloBCHD(level);
+ cudaMemoryManager->cudaCopyTempVeloBCHD(level);
//cout << "nach copy " << endl;
//////////////////////////////////////////////////////////////////////////
}
@@ -191,7 +191,7 @@ void GridGenerator::allocArrays_BoundaryValues()
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaAllocGeomValuesBC(i);
+ cudaMemoryManager->cudaAllocGeomValuesBC(i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Indexarray
@@ -219,7 +219,7 @@ void GridGenerator::allocArrays_BoundaryValues()
// para->getParH(i)->QGeom.Vz[m] = 0.0f;
//}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaCopyGeomValuesBC(i);
+ cudaMemoryManager->cudaCopyGeomValuesBC(i);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//// advection - diffusion stuff
//if (para->getDiffOn()==true){
@@ -671,7 +671,7 @@ void GridGenerator::allocArrays_BoundaryQs()
para->getParD(i)->TempPress.kTemp = numberOfPressureValues;
std::cout << "Groesse TempPress.kTemp = " << para->getParH(i)->TempPress.kTemp << std::endl;
//////////////////////////////////////////////////////////////////////////
- para->cudaAllocTempPressBC(i);
+ cudaMemoryManager->cudaAllocTempPressBC(i);
//cout << "nach alloc" << endl;
//////////////////////////////////////////////////////////////////////////
for (int m = 0; m < numberOfPressureValues; m++)
@@ -682,12 +682,12 @@ void GridGenerator::allocArrays_BoundaryQs()
}
//////////////////////////////////////////////////////////////////////////
//cout << "vor copy" << endl;
- para->cudaCopyTempPressBCHD(i);
+ cudaMemoryManager->cudaCopyTempPressBCHD(i);
//cout << "nach copy" << endl;
//////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaCopyPress(i);
+ cudaMemoryManager->cudaCopyPress(i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}//ende if
}//ende oberste for schleife
@@ -743,7 +743,7 @@ void GridGenerator::allocArrays_BoundaryQs()
std::cout << "getTemperatureInit = " << para->getTemperatureInit() << std::endl;
std::cout << "getTemperatureBC = " << para->getTemperatureBC() << std::endl;
//////////////////////////////////////////////////////////////////////////
- para->cudaAllocTempVeloBC(i);
+ cudaMemoryManager->cudaAllocTempVeloBC(i);
//cout << "nach alloc " << std::endl;
//////////////////////////////////////////////////////////////////////////
for (int m = 0; m < numberOfVelocityNodes; m++)
@@ -755,11 +755,11 @@ void GridGenerator::allocArrays_BoundaryQs()
}
//////////////////////////////////////////////////////////////////////////
//cout << "vor copy " << std::endl;
- para->cudaCopyTempVeloBCHD(i);
+ cudaMemoryManager->cudaCopyTempVeloBCHD(i);
//cout << "nach copy " << std::endl;
//////////////////////////////////////////////////////////////////////////
}
- para->cudaCopyVeloBC(i);
+ cudaMemoryManager->cudaCopyVeloBC(i);
}
}
@@ -777,7 +777,7 @@ void GridGenerator::allocArrays_BoundaryQs()
//para->getParH(i)->QGeom.kQ = temp4;
//para->getParD(i)->QGeom.kQ = para->getParH(i)->QGeom.kQ;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaAllocGeomBC(i);
+ cudaMemoryManager->cudaAllocGeomBC(i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
@@ -840,7 +840,7 @@ void GridGenerator::allocArrays_BoundaryQs()
para->getParD(i)->Temp.kTemp = numberOfGeometryNodes;
std::cout << "Groesse Temp.kTemp = " << para->getParH(i)->Temp.kTemp << std::endl;
//////////////////////////////////////////////////////////////////////////
- para->cudaAllocTempNoSlipBC(i);
+ cudaMemoryManager->cudaAllocTempNoSlipBC(i);
//////////////////////////////////////////////////////////////////////////
for (int m = 0; m < numberOfGeometryNodes; m++)
{
@@ -848,11 +848,11 @@ void GridGenerator::allocArrays_BoundaryQs()
para->getParH(i)->Temp.k[m] = para->getParH(i)->QGeom.k[m];
}
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyTempNoSlipBCHD(i);
+ cudaMemoryManager->cudaCopyTempNoSlipBCHD(i);
//////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaCopyGeomBC(i);
+ cudaMemoryManager->cudaCopyGeomBC(i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
diff --git a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
index bc414530f64193223e63e673412c67bfc6aef745..6c1585bd689a5f2e2da603d5e9fdb81cbc175aab 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
+++ b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
@@ -248,7 +248,7 @@ void CudaMemoryManager::cudaAllocOutflowBC(int lev)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->Qoutflow.RhoBC), mem_size_outflow_Q_q ));
//////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_outflow_Q_k + 2. * (double)mem_size_outflow_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_outflow_Q_q;
+ double tmp = (double)mem_size_outflow_Q_q + 2. * (double)mem_size_outflow_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_outflow_Q_q;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyOutflowBC(int lev)
@@ -387,7 +387,7 @@ void CudaMemoryManager::cudaAllocForcing()
//Device
checkCudaErrors( cudaMalloc((void**) ¶meter->forcingD, mem_size));
//////////////////////////////////////////////////////////////////////////
- double tmp = (real)mem_size;
+ double tmp = (double)mem_size;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyForcingToDevice()
@@ -416,7 +416,7 @@ void CudaMemoryManager::cudaAllocQuadricLimiters()
//Device
checkCudaErrors( cudaMalloc((void**) ¶meter->quadricLimitersD, mem_size));
//////////////////////////////////////////////////////////////////////////
- double tmp = (real)mem_size;
+ double tmp = (double)mem_size;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyQuadricLimitersToDevice()
@@ -436,15 +436,15 @@ void CudaMemoryManager::cudaFreeQuadricLimiters()
void CudaMemoryManager::cudaAllocProcessNeighborX(int lev, unsigned int processNeighbor)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].memsizeFs ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborX[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborX[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborX[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborX[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborX[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->sendProcessNeighborX[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborX[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborX[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborX[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborX[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborX[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->recvProcessNeighborX[processNeighbor].memsizeFs ));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -491,15 +491,15 @@ void CudaMemoryManager::cudaFreeProcessNeighborX(int lev, unsigned int processNe
void CudaMemoryManager::cudaAllocProcessNeighborY(int lev, unsigned int processNeighbor)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].memsizeFs ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborY[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborY[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborY[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->sendProcessNeighborY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborY[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborY[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborY[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->recvProcessNeighborY[processNeighbor].memsizeFs ));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -546,15 +546,15 @@ void CudaMemoryManager::cudaFreeProcessNeighborY(int lev, unsigned int processNe
void CudaMemoryManager::cudaAllocProcessNeighborZ(int lev, unsigned int processNeighbor)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].memsizeFs ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborZ[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborZ[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborZ[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->sendProcessNeighborZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborZ[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborZ[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborZ[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->recvProcessNeighborZ[processNeighbor].memsizeFs ));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -831,7 +831,7 @@ void CudaMemoryManager::cudaAllocTurbulentViscosity(int lev)
checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDyvz), parameter->getParD(lev)->mem_size_real_SP));
checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDzvz), parameter->getParD(lev)->mem_size_real_SP));
//////////////////////////////////////////////////////////////////////////
- double tmp = (double)parameter->getParH(lev)->mem_size_real_SP;
+ double tmp = (double)parameter->getParH(lev)->mem_size_real_SP * 12.0;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyTurbulentViscosityHD(int lev)
@@ -1166,19 +1166,19 @@ void CudaMemoryManager::cudaAllocGeomNormals(int lev)
//Host
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalX.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalX.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalX.k), mem_size_Q_k ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalY.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalY.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalY.k), mem_size_Q_k ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalZ.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalZ.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeomNormalZ.k), mem_size_Q_k ));
//Device
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalX.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalX.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalX.k), mem_size_Q_k ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalY.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalY.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalY.k), mem_size_Q_k ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalZ.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalZ.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeomNormalZ.k), mem_size_Q_k ));
//////////////////////////////////////////////////////////////////////////
double tmp = 3.0 * (double)mem_size_Q_k + 3.0 * (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
@@ -1213,19 +1213,19 @@ void CudaMemoryManager::cudaAllocInflowNormals(int lev)
//Host
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalX.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalX.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalX.k), mem_size_Q_k ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalY.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalY.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalY.k), mem_size_Q_k ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalZ.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalZ.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInflowNormalZ.k), mem_size_Q_k ));
//Device
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalX.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalX.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalX.k), mem_size_Q_k ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalY.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalY.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalY.k), mem_size_Q_k ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalZ.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalZ.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInflowNormalZ.k), mem_size_Q_k ));
//////////////////////////////////////////////////////////////////////////
double tmp = 3.0 * (double)mem_size_Q_k + 3.0 * (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
@@ -1260,19 +1260,19 @@ void CudaMemoryManager::cudaAllocOutflowNormals(int lev)
//Host
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalX.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalX.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalX.k), mem_size_Q_k ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalY.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalY.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalY.k), mem_size_Q_k ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalZ.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalZ.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutflowNormalZ.k), mem_size_Q_k ));
//Device
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalX.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalX.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalX.k), mem_size_Q_k ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalY.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalY.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalY.k), mem_size_Q_k ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalZ.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalZ.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutflowNormalZ.k), mem_size_Q_k ));
//////////////////////////////////////////////////////////////////////////
double tmp = 3.0 * (double)mem_size_Q_k + 3.0 * (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
@@ -1309,13 +1309,13 @@ void CudaMemoryManager::cudaAllocSlipBC(int lev)
//Host
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QSlip.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QSlip.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QSlip.k), mem_size_Q_k ));
//checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QSlip.qread), mem_size_Q_q_read ));//Geller
//checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QSlip.valueQ), mem_size_Q_value ));//Geller
//Device
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QSlip.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QSlip.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QSlip.k), mem_size_Q_k ));
//////////////////////////////////////////////////////////////////////////
double tmp = (double)mem_size_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
@@ -1346,7 +1346,7 @@ void CudaMemoryManager::cudaAllocTestRE(int lev, unsigned int size)
//Device
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kDistTestRE.f[0]), (1+parameter->getD3Qxx())*mem_size));
//////////////////////////////////////////////////////////////////////////
- double tmp = (double)size;
+ double tmp = (double)((1. + parameter->getD3Qxx()) * mem_size);
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyTestREtoDevice(int lev, unsigned int size)
@@ -1552,18 +1552,18 @@ void CudaMemoryManager::cudaFreeVeloPropeller(int lev)
void CudaMemoryManager::cudaAllocMeasurePointsIndex(int lev)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kMP), parameter->getParH(lev)->memSizeIntkMP ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kMP), parameter->getParH(lev)->memSizeIntkMP ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->VxMP), parameter->getParH(lev)->memSizerealkMP ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->VyMP), parameter->getParH(lev)->memSizerealkMP ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->VzMP), parameter->getParH(lev)->memSizerealkMP ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->RhoMP), parameter->getParH(lev)->memSizerealkMP ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->RhoMP), parameter->getParH(lev)->memSizerealkMP ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kMP), parameter->getParD(lev)->memSizeIntkMP ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kMP), parameter->getParD(lev)->memSizeIntkMP ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->VxMP), parameter->getParD(lev)->memSizerealkMP ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->VyMP), parameter->getParD(lev)->memSizerealkMP ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->VzMP), parameter->getParD(lev)->memSizerealkMP ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->RhoMP), parameter->getParD(lev)->memSizerealkMP ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->RhoMP), parameter->getParD(lev)->memSizerealkMP ));
//////////////////////////////////////////////////////////////////////////
double tmp = (double)parameter->getParH(lev)->memSizeIntkMP + 4. * (double)parameter->getParH(lev)->memSizerealkMP;
@@ -1615,17 +1615,17 @@ void CudaMemoryManager::cudaAllocDragLift(int lev, int numofelem)
unsigned int mem_size = sizeof(double)*numofelem;
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPreX), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPreY), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPreZ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPreX), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPreY), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPreZ), mem_size ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPostX), mem_size ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPostY), mem_size ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->DragPostZ), mem_size ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPreX), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPreY), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPreZ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPreX), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPreY), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPreZ), mem_size ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPostX), mem_size ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPostY), mem_size ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPostZ), mem_size ));
@@ -1674,7 +1674,7 @@ void CudaMemoryManager::cudaAlloc2ndMoments(int lev, int numofelem)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxxMzzFromfcNEQ), mem_size ));
//////////////////////////////////////////////////////////////////////////
- double tmp = 5. * (real)mem_size;
+ double tmp = 5. * (double)mem_size;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopy2ndMoments(int lev, int numofelem)
@@ -1719,7 +1719,7 @@ void CudaMemoryManager::cudaAlloc3rdMoments(int lev, int numofelem)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcab ), mem_size ));
//////////////////////////////////////////////////////////////////////////
- double tmp = 7. * (real)mem_size;
+ double tmp = 7. * (double)mem_size;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopy3rdMoments(int lev, int numofelem)
@@ -1774,7 +1774,7 @@ void CudaMemoryManager::cudaAllocHigherMoments(int lev, int numofelem)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMccc ), mem_size ));
//////////////////////////////////////////////////////////////////////////
- double tmp = 7. * (real)mem_size;
+ double tmp = 10. * (double)mem_size;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyHigherMoments(int lev, int numofelem)
@@ -1821,7 +1821,7 @@ void CudaMemoryManager::cudaAllocForceVelo(int lev, int numofelem)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->VzForce ), mem_size ));
//////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (real)mem_size;
+ double tmp = 3. * (double)mem_size;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyForceVelo(int lev, int numofelem)
@@ -1992,8 +1992,12 @@ void CudaMemoryManager::cudaAllocParticles(int lev)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.hot), parameter->getParD(lev)->plp.memSizeBoolBC ));
//////////////////////////////////////////////////////////////////////////
- double tmp = (double)parameter->getParD(lev)->plp.memSizerealAll * (double)9.0 + (double)parameter->getParD(lev)->plp.memSizeID * (double)2.0 + (double)parameter->getParD(lev)->plp.memSizeTimestep
- + (double)parameter->getParD(lev)->plp.memSizeBool + (double)parameter->getParD(lev)->plp.memSizeBoolBC;
+ double tmp =
+ (double)parameter->getParD(lev)->plp.memSizerealAll * (double)9.0 +
+ (double)parameter->getParD(lev)->plp.memSizeID * (double)2.0 +
+ (double)parameter->getParD(lev)->plp.memSizeTimestep +
+ (double)parameter->getParD(lev)->plp.memSizeBool +
+ (double)parameter->getParD(lev)->plp.memSizeBoolBC;
setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyParticles(int lev)
@@ -2033,6 +2037,9 @@ void CudaMemoryManager::cudaAllocRandomValues()
{
//Device
checkCudaErrors( cudaMalloc((void**)(parameter->getRandomState()), (sizeof(curandState)*parameter->getParD(parameter->getFine())->plp.numberOfParticles) ));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)(sizeof(curandState) * parameter->getParD(parameter->getFine())->plp.numberOfParticles);
+ setMemsizeGPU(tmp, false);
}
//////////////////////////////////////////////////////////////////////////
//porous media
@@ -2078,6 +2085,9 @@ void CudaMemoryManager::cudaAllocConc(int lev)
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->Conc), parameter->getParH(lev)->mem_size_real_SP));
//Device
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->Conc), parameter->getParD(lev)->mem_size_real_SP));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)parameter->getParH(lev)->mem_size_real_SP;
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyConcDH(int lev)
{
@@ -2103,6 +2113,9 @@ void CudaMemoryManager::cudaAllocTempFs(int lev)
{
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->d27.f[0]), parameter->getDiffMod()*parameter->getParH(lev)->mem_size_real_SP));
}
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)(parameter->getDiffMod() * parameter->getParH(lev)->mem_size_real_SP);
+ setMemsizeGPU(tmp, false);
}
//////////////////////////////////////////////////////////////////////////
void CudaMemoryManager::cudaAllocTempPressBC(int lev)
@@ -2119,7 +2132,9 @@ void CudaMemoryManager::cudaAllocTempPressBC(int lev)
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->TempPress.temp, mem_size_TempPress_q));
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->TempPress.velo, mem_size_TempPress_q));
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->TempPress.k, mem_size_TempPress_k));
-
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)(2.0 * mem_size_TempPress_q) + (double)(mem_size_TempPress_k);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyTempPressBCHD(int lev)
{
@@ -2154,6 +2169,9 @@ void CudaMemoryManager::cudaAllocTempVeloBC(int lev)
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->TempVel.tempPulse, mem_size_TempVel_q));
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->TempVel.velo, mem_size_TempVel_q));
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->TempVel.k, mem_size_TempVel_k));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)(3.0 * mem_size_TempVel_q) + (double)(mem_size_TempVel_k);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyTempVeloBCHD(int lev)
{
@@ -2186,7 +2204,9 @@ void CudaMemoryManager::cudaAllocTempNoSlipBC(int lev)
// Device Memory
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->Temp.temp, mem_size_Temp_q));
checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->Temp.k, mem_size_Temp_k));
-
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)(mem_size_Temp_q) + (double)(mem_size_Temp_k);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyTempNoSlipBCHD(int lev)
{
@@ -2286,6 +2306,26 @@ void CudaMemoryManager::cudaFreeConcFile(int lev)
checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->concIndex));
}
//////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocMedianOutAD(int lev)
+{
+ //Host
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->rho_SP_Med_Out), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->vx_SP_Med_Out), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->vy_SP_Med_Out), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->vz_SP_Med_Out), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->press_SP_Med_Out), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->Conc_Med_Out), parameter->getParH(lev)->mem_size_real_SP));
+}
+void CudaMemoryManager::cudaFreeMedianOutAD(int lev)
+{
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->vx_SP_Med_Out));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->vy_SP_Med_Out));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->vz_SP_Med_Out));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->rho_SP_Med_Out));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->press_SP_Med_Out));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->Conc_Med_Out));
+}
+
//////////////////////////////////////////////////////////////////////////
//Process Neighbors
@@ -2293,20 +2333,23 @@ void CudaMemoryManager::cudaFreeConcFile(int lev)
void CudaMemoryManager::cudaAllocProcessNeighbor(int lev, unsigned int processNeighbor)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeFs ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].f[0] ), parameter->getD3Qxx() * parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].memsizeFs ));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeFs +
- (double)parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeFs;
+ double tmp =
+ (double)parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeIndex +
+ (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeFs +
+ (double)parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeIndex +
+ (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeFs;
setMemsizeGPU(tmp, false);
//printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
}
@@ -2363,8 +2406,11 @@ void CudaMemoryManager::cudaAllocProcessNeighborADX(int lev, unsigned int proces
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADX[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParD(lev)->recvProcessNeighborADX[processNeighbor].memsizeFs ));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].memsizeIndex + (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].memsizeFs +
- (double)parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].memsizeIndex + (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].memsizeFs;
+ double tmp =
+ (double)parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].memsizeIndex +
+ (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].memsizeFs +
+ (double)parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].memsizeIndex +
+ (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].memsizeFs;
setMemsizeGPU(tmp, false);
//printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
}
@@ -2406,20 +2452,23 @@ void CudaMemoryManager::cudaFreeProcessNeighborADX(int lev, unsigned int process
void CudaMemoryManager::cudaAllocProcessNeighborADY(int lev, unsigned int processNeighbor)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeFs ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].memsizeFs ));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeIndex + (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeFs +
- (double)parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeIndex + (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeFs;
+ double tmp =
+ (double)parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeIndex +
+ (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeFs +
+ (double)parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeIndex +
+ (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeFs;
setMemsizeGPU(tmp, false);
//printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
}
@@ -2461,20 +2510,23 @@ void CudaMemoryManager::cudaFreeProcessNeighborADY(int lev, unsigned int process
void CudaMemoryManager::cudaAllocProcessNeighborADZ(int lev, unsigned int processNeighbor)
{
//Host
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeFs ));
//Device
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].memsizeIndex ));
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].memsizeFs ));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeIndex + (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeFs +
- (double)parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeIndex + (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeFs;
+ double tmp =
+ (double)parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeIndex +
+ (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeFs +
+ (double)parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeIndex +
+ (double)parameter->getDiffMod()*(double)parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeFs;
setMemsizeGPU(tmp, false);
//printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
}
diff --git a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h
index f96b93ba39ed9c37efa7922373d91d30f0cb5eb8..c26db65afd384ac7a4e6c436c4dea2c46647ae95 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h
+++ b/src/gpu/VirtualFluids_GPU/GPU/CudaMemoryManager.h
@@ -135,6 +135,9 @@ public:
void cudaAllocMedianOut(int lev);
void cudaFreeMedianOut(int lev);
+
+ void cudaAllocMedianOutAD(int lev);
+ void cudaFreeMedianOutAD(int lev);
void cudaAllocInterfaceCF(int lev);
void cudaCopyInterfaceCF(int lev);
diff --git a/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu b/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
index 41bde987cb1b5f517c6303226966bfd5909702a2..a203cca15bfd0fccac53d1d86555a023063ea86a 100644
--- a/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
+++ b/src/gpu/VirtualFluids_GPU/GPU/LBMKernel.cu
@@ -30,7 +30,7 @@ extern "C" void KernelCas27( unsigned int grid_nx,
dim3 threads ( grid_nx, 1, 1 );
dim3 grid ( grid_ny, grid_nz ); // Gitter fuer Kollision und Propagation
- LB_Kernel_Casc27<< < grid, threads >>>( s9,
+ LB_Kernel_Casc27<<< grid, threads >>>( s9,
bcMatD,
neighborX,
neighborY,
@@ -3324,21 +3324,21 @@ extern "C" void QVelDevCompZeroPress27( unsigned int numberOfThreads,
unsigned int size_Mat,
bool evenOrOdd)
{
- int Grid = kArray / numberOfThreads;
- //int Grid = (kQ / numberOfThreads)+1;
- //int Grid1, Grid2;
- //if (Grid>512)
- //{
- // Grid1 = 512;
- // Grid2 = (Grid/Grid1)+1;
- //}
- //else
- //{
- // Grid1 = 1;
- // Grid2 = Grid;
- //}
- //dim3 gridQ(Grid1, Grid2);
- dim3 gridQ(Grid, 1, 1);
+ //int Grid = kArray / numberOfThreads;
+ int Grid = (sizeQ / numberOfThreads)+1;
+ int Grid1, Grid2;
+ if (Grid>512)
+ {
+ Grid1 = 512;
+ Grid2 = (Grid/Grid1)+1;
+ }
+ else
+ {
+ Grid1 = 1;
+ Grid2 = Grid;
+ }
+ dim3 gridQ(Grid1, Grid2);
+ //dim3 gridQ(Grid, 1, 1);
dim3 threads(numberOfThreads, 1, 1 );
QVelDeviceCompZeroPress27<<< gridQ, threads >>> ( nx,
@@ -3357,7 +3357,7 @@ extern "C" void QVelDevCompZeroPress27( unsigned int numberOfThreads,
neighborZ,
size_Mat,
evenOrOdd);
- getLastCudaError("QVelDeviceComp27 execution failed");
+ getLastCudaError("QVelDeviceCompZeroPress27 execution failed");
}
//////////////////////////////////////////////////////////////////////////
extern "C" void QVelDevIncompHighNu27(unsigned int numberOfThreads,
diff --git a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
index 410cde34340c5ec139addb98b701abb97ec078ee..0446608cfc5d200efd21e95deac5a5eaf395d102 100644
--- a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
+++ b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.cpp
@@ -966,2402 +966,6 @@ void Parameter::copyMeasurePointsArrayToVector(int lev)
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//cuda-alloc-methods
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//full
-void Parameter::cudaAllocFull(int lev)
-{
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->geo ), parH[lev]->mem_size_int ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->k ), parH[lev]->mem_size_int ));
-}
-void Parameter::cudaFreeFull(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->geo ));
- checkCudaErrors( cudaFreeHost(parH[lev]->k ));
-}
-//coord
-void Parameter::cudaAllocCoord(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->coordX_SP ), parH[lev]->mem_size_real_SP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->coordY_SP ), parH[lev]->mem_size_real_SP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->coordZ_SP ), parH[lev]->mem_size_real_SP ));
- //Device (spinning ship)
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->coordX_SP ), parH[lev]->mem_size_real_SP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->coordY_SP ), parH[lev]->mem_size_real_SP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->coordZ_SP ), parH[lev]->mem_size_real_SP ));
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (double)parH[lev]->mem_size_real_SP;
- setMemsizeGPU(tmp, false);
- //printf("Coord = %f MB",tmp/1000000.);
-}
-void Parameter::cudaCopyCoord(int lev)
-{
- //copy host to device
- checkCudaErrors( cudaMemcpy(parD[lev]->coordX_SP, parH[lev]->coordX_SP, parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->coordY_SP, parH[lev]->coordY_SP, parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->coordZ_SP, parH[lev]->coordZ_SP, parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeCoord(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->coordX_SP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->coordY_SP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->coordZ_SP ));
-}
-//print
-void Parameter::cudaCopyPrint(int lev)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->vx_SP , parD[lev]->vx_SP , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->vy_SP , parD[lev]->vy_SP , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->vz_SP , parD[lev]->vz_SP , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->rho_SP , parD[lev]->rho_SP , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->press_SP, parD[lev]->press_SP, parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaCopyMedianPrint(int lev)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->vx_SP_Med , parD[lev]->vx_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->vy_SP_Med , parD[lev]->vy_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->vz_SP_Med , parD[lev]->vz_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->rho_SP_Med , parD[lev]->rho_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->press_SP_Med, parD[lev]->press_SP_Med, parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaCopyMedianADPrint(int lev)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->vx_SP_Med , parD[lev]->vx_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->vy_SP_Med , parD[lev]->vy_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->vz_SP_Med , parD[lev]->vz_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->rho_SP_Med , parD[lev]->rho_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->press_SP_Med, parD[lev]->press_SP_Med, parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->Conc_Med , parD[lev]->Conc_Med , parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
-}
-//sparse
-void Parameter::cudaAllocSP(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->geoSP ), parH[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->neighborX_SP ), parH[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->neighborY_SP ), parH[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->neighborZ_SP ), parH[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->rho_SP ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vx_SP ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vy_SP ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vz_SP ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->press_SP ), parH[lev]->mem_size_real_SP));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->geoSP ), parD[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->neighborX_SP ), parD[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->neighborY_SP ), parD[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->neighborZ_SP ), parD[lev]->mem_size_int_SP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->rho_SP ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->vx_SP ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->vy_SP ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->vz_SP ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->press_SP ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->d0SP.f[0] ), (unsigned long long)getD3Qxx()*(unsigned long long)parD[lev]->mem_size_real_SP));
- //////////////////////////////////////////////////////////////////////////
- //double tmp = 4. * (double)parH[lev]->mem_size_int_SP + 10. * (double)parH[lev]->mem_size_real_SP + (double)getD3Qxx() * (double)parH[lev]->mem_size_real_SP;
- double tmp = 4. * (double)parH[lev]->mem_size_int_SP + 5. * (double)parH[lev]->mem_size_real_SP + (double)getD3Qxx() * (double)parH[lev]->mem_size_real_SP;
- setMemsizeGPU(tmp, false);
-
- //int test = sizeof(int);
- //printf("\n sizeof int = %d \n",test);
-
- //printf("AlocSP = %f MB \n",tmp/1000000.);
- //int test = sizeof(float*);
- //printf("float* = %d \n",test);
- //unsigned long long test2 = (unsigned long long)getD3Qxx()*(unsigned long long)parD[lev]->mem_size_real_SP;
- //test2 = test2 / 1000000000;
- //printf("test2 = %d \n",test2);
-}
-void Parameter::cudaCopySP(int lev)
-{
- //copy host to device
- checkCudaErrors( cudaMemcpy(parD[lev]->geoSP , parH[lev]->geoSP , parH[lev]->mem_size_int_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->neighborX_SP, parH[lev]->neighborX_SP, parH[lev]->mem_size_int_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->neighborY_SP, parH[lev]->neighborY_SP, parH[lev]->mem_size_int_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->neighborZ_SP, parH[lev]->neighborZ_SP, parH[lev]->mem_size_int_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->rho_SP , parH[lev]->rho_SP , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->vx_SP , parH[lev]->vx_SP , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->vy_SP , parH[lev]->vy_SP , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->vz_SP , parH[lev]->vz_SP , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->press_SP , parH[lev]->press_SP , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeSP(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->geoSP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->vx_SP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->vy_SP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->vz_SP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->rho_SP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->press_SP ));
- checkCudaErrors( cudaFreeHost(parH[lev]->neighborX_SP));
- checkCudaErrors( cudaFreeHost(parH[lev]->neighborY_SP));
- checkCudaErrors( cudaFreeHost(parH[lev]->neighborZ_SP));
-}
-//F3
-void Parameter::cudaAllocF3SP(int lev)
-{
- //Device
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->g6.g[0]), (unsigned long long)6*(unsigned long long)parD[lev]->mem_size_real_SP));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)6 * (double)parH[lev]->mem_size_real_SP;
- setMemsizeGPU(tmp, false);
-}
-//negative neighbor (WSB)
-void Parameter::cudaAllocNeighborWSB(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->neighborWSB_SP ), parH[lev]->mem_size_int_SP ));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->neighborWSB_SP ), parD[lev]->mem_size_int_SP ));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->mem_size_int_SP;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyNeighborWSB(int lev)
-{
- //copy host to device
- checkCudaErrors( cudaMemcpy(parD[lev]->neighborWSB_SP, parH[lev]->neighborWSB_SP, parH[lev]->mem_size_int_SP , cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeNeighborWSB(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->neighborWSB_SP));
-}
-//turbulent viscosity
-void Parameter::cudaAllocTurbulentViscosity(int lev)
-{
- //Host
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->turbViscosity), parH[lev]->mem_size_real_SP));
- //Debug
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gSij ), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gSDij), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDxvx), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDyvx), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDzvx), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDxvy), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDyvy), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDzvy), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDxvz), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDyvz), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->gDzvz), parH[lev]->mem_size_real_SP));
-
- //Device
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->turbViscosity), parD[lev]->mem_size_real_SP));
- //Debug
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gSij ), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gSDij), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDxvx), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDyvx), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDzvx), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDxvy), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDyvy), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDzvy), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDxvz), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDyvz), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->gDzvz), parD[lev]->mem_size_real_SP));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->mem_size_real_SP;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyTurbulentViscosityHD(int lev)
-{
- //copy host to device
- checkCudaErrors(cudaMemcpy(parD[lev]->turbViscosity, parH[lev]->turbViscosity, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- //Debug
- checkCudaErrors(cudaMemcpy(parD[lev]->gSij , parH[lev]->gSij , parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gSDij, parH[lev]->gSDij, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDxvx, parH[lev]->gDxvx, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDyvx, parH[lev]->gDyvx, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDzvx, parH[lev]->gDzvx, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDxvy, parH[lev]->gDxvy, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDyvy, parH[lev]->gDyvy, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDzvy, parH[lev]->gDzvy, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDxvz, parH[lev]->gDxvz, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDyvz, parH[lev]->gDyvz, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->gDzvz, parH[lev]->gDzvz, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyTurbulentViscosityDH(int lev)
-{
- //copy device to host
- checkCudaErrors(cudaMemcpy(parH[lev]->turbViscosity, parD[lev]->turbViscosity, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- //Debug
- checkCudaErrors(cudaMemcpy(parH[lev]->gSij , parD[lev]->gSij , parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gSDij, parD[lev]->gSDij, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDxvx, parD[lev]->gDxvx, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDyvx, parD[lev]->gDyvx, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDzvx, parD[lev]->gDzvx, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDxvy, parD[lev]->gDxvy, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDyvy, parD[lev]->gDyvy, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDzvy, parD[lev]->gDzvy, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDxvz, parD[lev]->gDxvz, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDyvz, parD[lev]->gDyvz, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->gDzvz, parD[lev]->gDzvz, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeTurbulentViscosity(int lev)
-{
- checkCudaErrors(cudaFreeHost(parH[lev]->turbViscosity));
- //Debug
- checkCudaErrors(cudaFreeHost(parH[lev]->gSij ));
- checkCudaErrors(cudaFreeHost(parH[lev]->gSDij));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDxvx));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDyvx));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDzvx));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDxvy));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDyvy));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDzvy));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDxvz));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDyvz));
- checkCudaErrors(cudaFreeHost(parH[lev]->gDzvz));
-}
-//median
-void Parameter::cudaAllocMedianSP(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->rho_SP_Med ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vx_SP_Med ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vy_SP_Med ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vz_SP_Med ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->press_SP_Med ), parH[lev]->mem_size_real_SP));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->rho_SP_Med ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->vx_SP_Med ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->vy_SP_Med ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->vz_SP_Med ), parD[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->press_SP_Med ), parD[lev]->mem_size_real_SP));
- //////////////////////////////////////////////////////////////////////////
- double tmp = 5. * (double)parH[lev]->mem_size_real_SP;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyMedianSP(int lev)
-{
- //copy host to device
- checkCudaErrors( cudaMemcpy(parD[lev]->rho_SP_Med , parH[lev]->rho_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->vx_SP_Med , parH[lev]->vx_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->vy_SP_Med , parH[lev]->vy_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->vz_SP_Med , parH[lev]->vz_SP_Med , parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->press_SP_Med, parH[lev]->press_SP_Med, parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeMedianSP(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->vx_SP_Med ));
- checkCudaErrors( cudaFreeHost(parH[lev]->vy_SP_Med ));
- checkCudaErrors( cudaFreeHost(parH[lev]->vz_SP_Med ));
- checkCudaErrors( cudaFreeHost(parH[lev]->rho_SP_Med ));
- checkCudaErrors( cudaFreeHost(parH[lev]->press_SP_Med));
-}
-void Parameter::cudaAllocMedianOut(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->rho_SP_Med_Out ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vx_SP_Med_Out ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vy_SP_Med_Out ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->vz_SP_Med_Out ), parH[lev]->mem_size_real_SP));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->press_SP_Med_Out ), parH[lev]->mem_size_real_SP));
-}
-void Parameter::cudaFreeMedianOut(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->vx_SP_Med_Out ));
- checkCudaErrors( cudaFreeHost(parH[lev]->vy_SP_Med_Out ));
- checkCudaErrors( cudaFreeHost(parH[lev]->vz_SP_Med_Out ));
- checkCudaErrors( cudaFreeHost(parH[lev]->rho_SP_Med_Out ));
- checkCudaErrors( cudaFreeHost(parH[lev]->press_SP_Med_Out));
-}
-//median Advection-Diffusion
-void Parameter::cudaAllocMedianAD(int lev)
-{
- //Host
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->rho_SP_Med), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->vx_SP_Med), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->vy_SP_Med), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->vz_SP_Med), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->press_SP_Med), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->Conc_Med), parH[lev]->mem_size_real_SP));
- //Device
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->rho_SP_Med), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->vx_SP_Med), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->vy_SP_Med), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->vz_SP_Med), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->press_SP_Med), parD[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->Conc_Med), parD[lev]->mem_size_real_SP));
- //////////////////////////////////////////////////////////////////////////
- double tmp = 6. * (double)parH[lev]->mem_size_real_SP;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyMedianAD(int lev)
-{
- //copy host to device
- checkCudaErrors(cudaMemcpy(parD[lev]->rho_SP_Med, parH[lev]->rho_SP_Med, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->vx_SP_Med, parH[lev]->vx_SP_Med, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->vy_SP_Med, parH[lev]->vy_SP_Med, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->vz_SP_Med, parH[lev]->vz_SP_Med, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->press_SP_Med, parH[lev]->press_SP_Med, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->Conc_Med, parH[lev]->Conc_Med, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeMedianAD(int lev)
-{
- checkCudaErrors(cudaFreeHost(parH[lev]->vx_SP_Med));
- checkCudaErrors(cudaFreeHost(parH[lev]->vy_SP_Med));
- checkCudaErrors(cudaFreeHost(parH[lev]->vz_SP_Med));
- checkCudaErrors(cudaFreeHost(parH[lev]->rho_SP_Med));
- checkCudaErrors(cudaFreeHost(parH[lev]->press_SP_Med));
- checkCudaErrors(cudaFreeHost(parH[lev]->Conc_Med));
-}
-void Parameter::cudaAllocMedianOutAD(int lev)
-{
- //Host
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->rho_SP_Med_Out), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->vx_SP_Med_Out), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->vy_SP_Med_Out), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->vz_SP_Med_Out), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->press_SP_Med_Out), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->Conc_Med_Out), parH[lev]->mem_size_real_SP));
-}
-void Parameter::cudaFreeMedianOutAD(int lev)
-{
- checkCudaErrors(cudaFreeHost(parH[lev]->vx_SP_Med_Out));
- checkCudaErrors(cudaFreeHost(parH[lev]->vy_SP_Med_Out));
- checkCudaErrors(cudaFreeHost(parH[lev]->vz_SP_Med_Out));
- checkCudaErrors(cudaFreeHost(parH[lev]->rho_SP_Med_Out));
- checkCudaErrors(cudaFreeHost(parH[lev]->press_SP_Med_Out));
- checkCudaErrors(cudaFreeHost(parH[lev]->Conc_Med_Out));
-}
-
-//Interface CF
-void Parameter::cudaAllocInterfaceCF(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->intCF.ICellCFC), parH[lev]->mem_size_kCF ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->intCF.ICellCFF), parH[lev]->mem_size_kCF ));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->intCF.ICellCFC), parD[lev]->mem_size_kCF ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->intCF.ICellCFF), parD[lev]->mem_size_kCF ));
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)parH[lev]->mem_size_kCF;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyInterfaceCF(int lev)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->intCF.ICellCFC, parH[lev]->intCF.ICellCFC, parH[lev]->mem_size_kCF, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->intCF.ICellCFF, parH[lev]->intCF.ICellCFF, parH[lev]->mem_size_kCF, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeInterfaceCF(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->intCF.ICellCFC));
- checkCudaErrors( cudaFreeHost(parH[lev]->intCF.ICellCFF));
-}
-//Interface FC
-void Parameter::cudaAllocInterfaceFC(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->intFC.ICellFCF), parH[lev]->mem_size_kFC ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->intFC.ICellFCC), parH[lev]->mem_size_kFC ));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->intFC.ICellFCF), parD[lev]->mem_size_kFC ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->intFC.ICellFCC), parD[lev]->mem_size_kFC ));
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)parH[lev]->mem_size_kFC;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyInterfaceFC(int lev)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->intFC.ICellFCF, parH[lev]->intFC.ICellFCF, parH[lev]->mem_size_kFC, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->intFC.ICellFCC, parH[lev]->intFC.ICellFCC, parH[lev]->mem_size_kFC, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeInterfaceFC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->intFC.ICellFCF));
- checkCudaErrors( cudaFreeHost(parH[lev]->intFC.ICellFCC));
-}
-//Interface Offset CF
-void Parameter::cudaAllocInterfaceOffCF(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->offCF.xOffCF), parH[lev]->mem_size_kCF_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->offCF.yOffCF), parH[lev]->mem_size_kCF_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->offCF.zOffCF), parH[lev]->mem_size_kCF_off ));
- getLastCudaError("Allocate host memory");
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->offCF.xOffCF), parD[lev]->mem_size_kCF_off ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->offCF.yOffCF), parD[lev]->mem_size_kCF_off ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->offCF.zOffCF), parD[lev]->mem_size_kCF_off ));
- getLastCudaError("Allocate device memory");
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (double)parH[lev]->mem_size_kCF_off;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyInterfaceOffCF(int lev)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->offCF.xOffCF, parH[lev]->offCF.xOffCF, parH[lev]->mem_size_kCF_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->offCF.yOffCF, parH[lev]->offCF.yOffCF, parH[lev]->mem_size_kCF_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->offCF.zOffCF, parH[lev]->offCF.zOffCF, parH[lev]->mem_size_kCF_off, cudaMemcpyHostToDevice));
- getLastCudaError("Copy host memory to device");
-}
-void Parameter::cudaFreeInterfaceOffCF(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->offCF.xOffCF));
- checkCudaErrors( cudaFreeHost(parH[lev]->offCF.yOffCF));
- checkCudaErrors( cudaFreeHost(parH[lev]->offCF.zOffCF));
-}
-//Interface Offset FC
-void Parameter::cudaAllocInterfaceOffFC(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->offFC.xOffFC), parH[lev]->mem_size_kFC_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->offFC.yOffFC), parH[lev]->mem_size_kFC_off ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->offFC.zOffFC), parH[lev]->mem_size_kFC_off ));
- getLastCudaError("Allocate host memory");
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->offFC.xOffFC), parD[lev]->mem_size_kFC_off ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->offFC.yOffFC), parD[lev]->mem_size_kFC_off ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->offFC.zOffFC), parD[lev]->mem_size_kFC_off ));
- getLastCudaError("Allocate device memory");
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (double)parH[lev]->mem_size_kFC_off;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyInterfaceOffFC(int lev)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->offFC.xOffFC, parH[lev]->offFC.xOffFC, parH[lev]->mem_size_kFC_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->offFC.yOffFC, parH[lev]->offFC.yOffFC, parH[lev]->mem_size_kFC_off, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->offFC.zOffFC, parH[lev]->offFC.zOffFC, parH[lev]->mem_size_kFC_off, cudaMemcpyHostToDevice));
- getLastCudaError("Copy host memory to device");
-}
-void Parameter::cudaFreeInterfaceOffFC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->offFC.xOffFC));
- checkCudaErrors( cudaFreeHost(parH[lev]->offFC.yOffFC));
- checkCudaErrors( cudaFreeHost(parH[lev]->offFC.zOffFC));
-}
-
-//Velo
-void Parameter::cudaAllocVeloBC(int lev)
-{
- unsigned int mem_size_inflow_Q_k = sizeof(int)*parH[lev]->Qinflow.kArray;
- unsigned int mem_size_inflow_Q_q = sizeof(real)*parH[lev]->Qinflow.kArray;
- //unsigned int mem_size_inflow_Q_k = sizeof(int)*parH[lev]->Qinflow.kQ;
- //unsigned int mem_size_inflow_Q_q = sizeof(real)*parH[lev]->Qinflow.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qinflow.q27[0]), getD3Qxx()*mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qinflow.k), mem_size_inflow_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qinflow.Vx), mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qinflow.Vy), mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qinflow.Vz), mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qinflow.deltaVz), mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qinflow.RhoBC), mem_size_inflow_Q_q ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qinflow.q27[0]), getD3Qxx()*mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qinflow.k), mem_size_inflow_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qinflow.Vx), mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qinflow.Vy), mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qinflow.Vz), mem_size_inflow_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qinflow.deltaVz), mem_size_inflow_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_inflow_Q_k + 4. * (double)mem_size_inflow_Q_q + (double)getD3Qxx() * (double)mem_size_inflow_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyVeloBC(int lev)
-{
- unsigned int mem_size_inflow_Q_k = sizeof(int)*parH[lev]->Qinflow.kArray;
- unsigned int mem_size_inflow_Q_q = sizeof(real)*parH[lev]->Qinflow.kArray;
- //unsigned int mem_size_inflow_Q_k = sizeof(int)*parH[lev]->Qinflow.kQ;
- //unsigned int mem_size_inflow_Q_q = sizeof(real)*parH[lev]->Qinflow.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->Qinflow.q27[0], parH[lev]->Qinflow.q27[0], getD3Qxx()* mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qinflow.k, parH[lev]->Qinflow.k, mem_size_inflow_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qinflow.Vx, parH[lev]->Qinflow.Vx, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qinflow.Vy, parH[lev]->Qinflow.Vy, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qinflow.Vz, parH[lev]->Qinflow.Vz, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qinflow.deltaVz, parH[lev]->Qinflow.deltaVz, mem_size_inflow_Q_q, cudaMemcpyHostToDevice));
-
-}
-void Parameter::cudaFreeVeloBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->Qinflow.q27[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qinflow.k ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qinflow.Vx ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qinflow.Vy ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qinflow.Vz ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qinflow.deltaVz));
-}
-//Press
-void Parameter::cudaAllocOutflowBC(int lev)
-{
- unsigned int mem_size_outflow_Q_k = sizeof(int)*parH[lev]->Qoutflow.kQ;
- unsigned int mem_size_outflow_Q_q = sizeof(real)*parH[lev]->Qoutflow.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qoutflow.q27[0]), getD3Qxx()*mem_size_outflow_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qoutflow.k), mem_size_outflow_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qoutflow.kN), mem_size_outflow_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Qoutflow.RhoBC), mem_size_outflow_Q_q ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qoutflow.q27[0]), getD3Qxx()* mem_size_outflow_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qoutflow.k), mem_size_outflow_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qoutflow.kN), mem_size_outflow_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Qoutflow.RhoBC), mem_size_outflow_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_outflow_Q_k + 2. * (double)mem_size_outflow_Q_q + (double)getD3Qxx()*(double)mem_size_outflow_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyOutflowBC(int lev)
-{
- unsigned int mem_size_outflow_Q_k = sizeof(int)*parH[lev]->Qoutflow.kQ;
- unsigned int mem_size_outflow_Q_q = sizeof(real)*parH[lev]->Qoutflow.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->Qoutflow.q27[0], parH[lev]->Qoutflow.q27[0], getD3Qxx()* mem_size_outflow_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qoutflow.k, parH[lev]->Qoutflow.k, mem_size_outflow_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qoutflow.kN, parH[lev]->Qoutflow.kN, mem_size_outflow_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Qoutflow.RhoBC, parH[lev]->Qoutflow.RhoBC, mem_size_outflow_Q_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeOutflowBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->Qoutflow.q27[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qoutflow.k ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qoutflow.kN ));
- checkCudaErrors( cudaFreeHost(parH[lev]->Qoutflow.RhoBC ));
-}
-//Inlet
-void Parameter::cudaAllocInlet(int lev)
-{
- unsigned int mem_size_inlet_Q_k = sizeof(int)*parH[lev]->QInlet.kQ;
- unsigned int mem_size_inlet_Q_q = sizeof(real)*parH[lev]->QInlet.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInlet.q27[0]), getD3Qxx()*mem_size_inlet_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInlet.k), mem_size_inlet_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInlet.kN), mem_size_inlet_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInlet.RhoBC), mem_size_inlet_Q_q ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInlet.q27[0]), getD3Qxx()* mem_size_inlet_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInlet.k), mem_size_inlet_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInlet.kN), mem_size_inlet_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInlet.RhoBC), mem_size_inlet_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)mem_size_inlet_Q_k + (double)mem_size_inlet_Q_q + (double)getD3Qxx()*(double)mem_size_inlet_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyInlet(int lev)
-{
- unsigned int mem_size_inlet_Q_k = sizeof(int)*parH[lev]->QInlet.kQ;
- unsigned int mem_size_inlet_Q_q = sizeof(real)*parH[lev]->QInlet.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QInlet.q27[0], parH[lev]->QInlet.q27[0], getD3Qxx()* mem_size_inlet_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInlet.k, parH[lev]->QInlet.k, mem_size_inlet_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInlet.kN, parH[lev]->QInlet.kN, mem_size_inlet_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInlet.RhoBC, parH[lev]->QInlet.RhoBC, mem_size_inlet_Q_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeInlet(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QInlet.q27[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInlet.k ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInlet.kN ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInlet.RhoBC ));
-}
-//Outlet
-void Parameter::cudaAllocOutlet(int lev)
-{
- unsigned int mem_size_outlet_Q_k = sizeof(int)*parH[lev]->QOutlet.kQ;
- unsigned int mem_size_outlet_Q_q = sizeof(real)*parH[lev]->QOutlet.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutlet.q27[0]), getD3Qxx()*mem_size_outlet_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutlet.k), mem_size_outlet_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutlet.kN), mem_size_outlet_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutlet.RhoBC), mem_size_outlet_Q_q ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutlet.q27[0]), getD3Qxx()* mem_size_outlet_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutlet.k), mem_size_outlet_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutlet.kN), mem_size_outlet_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutlet.RhoBC), mem_size_outlet_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)mem_size_outlet_Q_k + (double)mem_size_outlet_Q_q + (double)getD3Qxx()*(double)mem_size_outlet_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyOutlet(int lev)
-{
- unsigned int mem_size_outlet_Q_k = sizeof(int)*parH[lev]->QOutlet.kQ;
- unsigned int mem_size_outlet_Q_q = sizeof(real)*parH[lev]->QOutlet.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutlet.q27[0], parH[lev]->QOutlet.q27[0], getD3Qxx()* mem_size_outlet_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutlet.k, parH[lev]->QOutlet.k, mem_size_outlet_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutlet.kN, parH[lev]->QOutlet.kN, mem_size_outlet_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutlet.RhoBC, parH[lev]->QOutlet.RhoBC, mem_size_outlet_Q_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeOutlet(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutlet.q27[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutlet.k ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutlet.kN ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutlet.RhoBC ));
-}
-//Wall
-void Parameter::cudaAllocWallBC(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QWall.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QWall.kQ;
- unsigned int mem_size_Q_value = sizeof(long long)*parH[lev]->QWall.kQ; //Geller
- unsigned int mem_size_Q_q_read = sizeof(real)*parH[lev]->kQread; //Geller
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QWall.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QWall.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QWall.qread), mem_size_Q_q_read ));//Geller
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QWall.valueQ), mem_size_Q_value ));//Geller
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QWall.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QWall.k), mem_size_Q_k ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_Q_k + (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyWallBC(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QWall.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QWall.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QWall.q27[0], parH[lev]->QWall.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QWall.k, parH[lev]->QWall.k, mem_size_Q_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeWallBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QWall.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QWall.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QWall.valueQ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QWall.qread));
-}
-//Geometrie
-void Parameter::cudaAllocGeomBC(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QGeom.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QGeom.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeom.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeom.k), mem_size_Q_k ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeom.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeom.k), mem_size_Q_k ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_Q_k + (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyGeomBC(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QGeom.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QGeom.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeom.q27[0], parH[lev]->QGeom.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeom.k, parH[lev]->QGeom.k, mem_size_Q_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeGeomBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeom.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeom.k));
-}
-//Geometrie inkl. Values
-void Parameter::cudaAllocGeomValuesBC(int lev)
-{
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QGeom.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeom.Vx), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeom.Vy), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeom.Vz), mem_size_Q_q ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeom.Vx), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeom.Vy), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeom.Vz), mem_size_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyGeomValuesBC(int lev)
-{
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QGeom.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeom.Vx, parH[lev]->QGeom.Vx, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeom.Vy, parH[lev]->QGeom.Vy, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeom.Vz, parH[lev]->QGeom.Vz, mem_size_Q_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeGeomValuesBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeom.Vx));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeom.Vy));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeom.Vz));
-}
-//Geometrie inkl. Normale fuer Slip
-void Parameter::cudaAllocGeomNormals(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QGeomNormalX.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QGeomNormalX.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeomNormalX.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeomNormalX.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeomNormalY.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeomNormalY.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeomNormalZ.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QGeomNormalZ.k), mem_size_Q_k ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeomNormalX.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeomNormalX.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeomNormalY.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeomNormalY.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeomNormalZ.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QGeomNormalZ.k), mem_size_Q_k ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3.0 * (double)mem_size_Q_k + 3.0 * (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyGeomNormals(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QGeomNormalX.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QGeomNormalX.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeomNormalX.q27[0], parH[lev]->QGeomNormalX.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeomNormalX.k, parH[lev]->QGeomNormalX.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeomNormalY.q27[0], parH[lev]->QGeomNormalY.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeomNormalY.k, parH[lev]->QGeomNormalY.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeomNormalZ.q27[0], parH[lev]->QGeomNormalZ.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QGeomNormalZ.k, parH[lev]->QGeomNormalZ.k, mem_size_Q_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeGeomNormals(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeomNormalX.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeomNormalX.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeomNormalY.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeomNormalY.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeomNormalZ.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QGeomNormalZ.k));
-}
-//Geometrie inkl. Normale fuer Inflow
-void Parameter::cudaAllocInflowNormals(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QInflowNormalX.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QInflowNormalX.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInflowNormalX.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInflowNormalX.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInflowNormalY.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInflowNormalY.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInflowNormalZ.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QInflowNormalZ.k), mem_size_Q_k ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInflowNormalX.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInflowNormalX.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInflowNormalY.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInflowNormalY.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInflowNormalZ.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QInflowNormalZ.k), mem_size_Q_k ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3.0 * (double)mem_size_Q_k + 3.0 * (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyInflowNormals(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QInflowNormalX.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QInflowNormalX.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QInflowNormalX.q27[0], parH[lev]->QInflowNormalX.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInflowNormalX.k, parH[lev]->QInflowNormalX.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInflowNormalY.q27[0], parH[lev]->QInflowNormalY.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInflowNormalY.k, parH[lev]->QInflowNormalY.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInflowNormalZ.q27[0], parH[lev]->QInflowNormalZ.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QInflowNormalZ.k, parH[lev]->QInflowNormalZ.k, mem_size_Q_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeInflowNormals(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QInflowNormalX.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInflowNormalX.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInflowNormalY.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInflowNormalY.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInflowNormalZ.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QInflowNormalZ.k));
-}
-//Geometrie inkl. Normale fuer Outflow
-void Parameter::cudaAllocOutflowNormals(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QOutflowNormalX.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QOutflowNormalX.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutflowNormalX.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutflowNormalX.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutflowNormalY.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutflowNormalY.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutflowNormalZ.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QOutflowNormalZ.k), mem_size_Q_k ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutflowNormalX.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutflowNormalX.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutflowNormalY.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutflowNormalY.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutflowNormalZ.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QOutflowNormalZ.k), mem_size_Q_k ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3.0 * (double)mem_size_Q_k + 3.0 * (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyOutflowNormals(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QOutflowNormalX.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QOutflowNormalX.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutflowNormalX.q27[0], parH[lev]->QOutflowNormalX.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutflowNormalX.k, parH[lev]->QOutflowNormalX.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutflowNormalY.q27[0], parH[lev]->QOutflowNormalY.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutflowNormalY.k, parH[lev]->QOutflowNormalY.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutflowNormalZ.q27[0], parH[lev]->QOutflowNormalZ.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QOutflowNormalZ.k, parH[lev]->QOutflowNormalZ.k, mem_size_Q_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeOutflowNormals(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutflowNormalX.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutflowNormalX.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutflowNormalY.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutflowNormalY.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutflowNormalZ.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QOutflowNormalZ.k));
-}
-//Slip
-void Parameter::cudaAllocSlipBC(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QSlip.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QSlip.kQ;
- //unsigned int mem_size_Q_value = sizeof(long long)*parH[lev]->QSlip.kQ; //Geller
- //unsigned int mem_size_Q_q_read = sizeof(real)*parH[lev]->kSlipQread; //Geller
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QSlip.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QSlip.k), mem_size_Q_k ));
- //checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QSlip.qread), mem_size_Q_q_read ));//Geller
- //checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QSlip.valueQ), mem_size_Q_value ));//Geller
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QSlip.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QSlip.k), mem_size_Q_k ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_Q_k + (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopySlipBC(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QSlip.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QSlip.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QSlip.q27[0], parH[lev]->QSlip.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QSlip.k, parH[lev]->QSlip.k, mem_size_Q_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeSlipBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QSlip.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QSlip.k));
- //checkCudaErrors( cudaFreeHost(parH[lev]->QSlip.valueQ));
- //checkCudaErrors( cudaFreeHost(parH[lev]->QSlip.qread));
-}
-//Press (no Geller)
-void Parameter::cudaAllocPress(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QPress.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QPress.kQ;
- //unsigned int mem_size_Q_value = sizeof(long long)*parH[lev]->QPress.kQ; //Geller
- //unsigned int mem_size_Q_q_read = sizeof(real)*parH[lev]->kPressQread; //Geller
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPress.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPress.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPress.kN), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPress.RhoBC), mem_size_Q_q ));
- //checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPress.qread), mem_size_Q_q_read ));//Geller
- //checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPress.valueQ), mem_size_Q_value ));//Geller
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPress.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPress.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPress.kN), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPress.RhoBC), mem_size_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)mem_size_Q_k + (double)mem_size_Q_q + (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyPress(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QPress.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QPress.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QPress.q27[0], parH[lev]->QPress.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPress.k, parH[lev]->QPress.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPress.kN, parH[lev]->QPress.kN, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPress.RhoBC, parH[lev]->QPress.RhoBC, mem_size_Q_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreePress(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QPress.q27[0]));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPress.k));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPress.kN));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPress.RhoBC));
- //checkCudaErrors( cudaFreeHost(parH[lev]->QPress.valueQ));//Geller
- //checkCudaErrors( cudaFreeHost(parH[lev]->QPress.qread));//Geller
-}
-//Test roundoff error
-void Parameter::cudaAllocTestRE(int lev, unsigned int size)
-{
- unsigned int mem_size = sizeof(real)*size;
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->kDistTestRE.f[0]), (1+getD3Qxx())*mem_size));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->kDistTestRE.f[0]), (1+getD3Qxx())*mem_size));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyTestREtoDevice(int lev, unsigned int size)
-{
- unsigned int mem_size = sizeof(real)*size;
- checkCudaErrors( cudaMemcpy(parD[lev]->kDistTestRE.f[0], parH[lev]->kDistTestRE.f[0], (1+getD3Qxx())*mem_size, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyTestREtoHost(int lev, unsigned int size)
-{
- unsigned int mem_size = sizeof(real)*size;
- checkCudaErrors( cudaMemcpy(parH[lev]->kDistTestRE.f[0], parD[lev]->kDistTestRE.f[0], (1+getD3Qxx())*mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeTestRE(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->kDistTestRE.f[0]));
-}
-//PressX0 = X-inflow
-void Parameter::cudaAllocPressX0(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QpressX0.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QpressX0.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.kN), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.Vx), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.Vy), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.Vz), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.RhoBC), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX0.deltaVz), mem_size_Q_q ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.kN), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.Vx), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.Vy), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.Vz), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.RhoBC), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX0.deltaVz), mem_size_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)mem_size_Q_k + 5. * (double)mem_size_Q_q + (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyPressX0(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QpressX0.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QpressX0.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.q27[0], parH[lev]->QpressX0.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.k, parH[lev]->QpressX0.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.kN, parH[lev]->QpressX0.kN, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.Vx, parH[lev]->QpressX0.Vx, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.Vy, parH[lev]->QpressX0.Vy, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.Vz, parH[lev]->QpressX0.Vz, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.RhoBC, parH[lev]->QpressX0.RhoBC, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX0.deltaVz, parH[lev]->QpressX0.deltaVz, mem_size_Q_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreePressX0(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.q27[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.k ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.kN ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.Vx ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.Vy ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.Vz ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.RhoBC ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX0.deltaVz));
-}
-//PressX1 = X-outflow
-void Parameter::cudaAllocPressX1(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QpressX1.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QpressX1.kQ;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.q27[0]), getD3Qxx()*mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.k), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.kN), mem_size_Q_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.Vx), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.Vy), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.Vz), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.RhoBC), mem_size_Q_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QpressX1.deltaVz), mem_size_Q_q ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.q27[0]), getD3Qxx()* mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.k), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.kN), mem_size_Q_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.Vx), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.Vy), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.Vz), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.RhoBC), mem_size_Q_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QpressX1.deltaVz), mem_size_Q_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2. * (double)mem_size_Q_k + 5. * (double)mem_size_Q_q + (double)getD3Qxx()*(double)mem_size_Q_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyPressX1(int lev)
-{
- unsigned int mem_size_Q_k = sizeof(int)*parH[lev]->QpressX1.kQ;
- unsigned int mem_size_Q_q = sizeof(real)*parH[lev]->QpressX1.kQ;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.q27[0], parH[lev]->QpressX1.q27[0], getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.k, parH[lev]->QpressX1.k, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.kN, parH[lev]->QpressX1.kN, mem_size_Q_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.Vx, parH[lev]->QpressX1.Vx, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.Vy, parH[lev]->QpressX1.Vy, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.Vz, parH[lev]->QpressX1.Vz, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.RhoBC, parH[lev]->QpressX1.RhoBC, mem_size_Q_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QpressX1.deltaVz, parH[lev]->QpressX1.deltaVz, mem_size_Q_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreePressX1(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.q27[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.k ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.kN ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.Vx ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.Vy ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.Vz ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.RhoBC ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QpressX1.deltaVz));
-}
-//Propeller Velocity
-void Parameter::cudaAllocVeloPropeller(int lev)
-{
- unsigned int mem_size_Propeller_k = sizeof(int)*parH[lev]->QPropeller.kQ;
- unsigned int mem_size_Propeller_q = sizeof(real)*parH[lev]->QPropeller.kQ;
-
- //Host
- //checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPropeller.q27[0]), getD3Qxx()*mem_size_Propeller_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPropeller.k), mem_size_Propeller_k ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPropeller.Vx), mem_size_Propeller_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPropeller.Vy), mem_size_Propeller_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPropeller.Vz), mem_size_Propeller_q ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->QPropeller.RhoBC), mem_size_Propeller_q ));
-
- //Device
- //checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPropeller.q27[0]), getD3Qxx()*mem_size_Propeller_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPropeller.k), mem_size_Propeller_k ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPropeller.Vx), mem_size_Propeller_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPropeller.Vy), mem_size_Propeller_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPropeller.Vz), mem_size_Propeller_q ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->QPropeller.RhoBC), mem_size_Propeller_q ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_Propeller_k + 4. * (double)mem_size_Propeller_q;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyVeloPropeller(int lev)
-{
- unsigned int mem_size_Propeller_k = sizeof(int)*parH[lev]->QPropeller.kQ;
- unsigned int mem_size_Propeller_q = sizeof(real)*parH[lev]->QPropeller.kQ;
-
- //checkCudaErrors( cudaMemcpy(parD[lev]->QPropeller.q27[0], parH[lev]->QPropeller.q27[0], getD3Qxx()* mem_size_Propeller_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPropeller.k, parH[lev]->QPropeller.k, mem_size_Propeller_k, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPropeller.Vx, parH[lev]->QPropeller.Vx, mem_size_Propeller_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPropeller.Vy, parH[lev]->QPropeller.Vy, mem_size_Propeller_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPropeller.Vz, parH[lev]->QPropeller.Vz, mem_size_Propeller_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->QPropeller.RhoBC, parH[lev]->QPropeller.RhoBC, mem_size_Propeller_q, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeVeloPropeller(int lev)
-{
- //checkCudaErrors( cudaFreeHost(parH[lev]->QPropeller.q27[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPropeller.k ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPropeller.Vx ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPropeller.Vy ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPropeller.Vz ));
- checkCudaErrors( cudaFreeHost(parH[lev]->QPropeller.RhoBC ));
-}
-//Measure Points
-//void Parameter::cudaAllocMeasurePoints(int lev, int i)
-//{
-// //Host
-// checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->MP[i].Vx), parH[lev]->memSizerealMP ));
-// checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->MP[i].Vy), parH[lev]->memSizerealMP ));
-// checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->MP[i].Vz), parH[lev]->memSizerealMP ));
-// checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->MP[i].Rho), parH[lev]->memSizerealMP ));
-//
-// //Device
-// checkCudaErrors( cudaMalloc((void**) &(parD[lev]->MP[i].Vx), parD[lev]->memSizerealMP ));
-// checkCudaErrors( cudaMalloc((void**) &(parD[lev]->MP[i].Vy), parD[lev]->memSizerealMP ));
-// checkCudaErrors( cudaMalloc((void**) &(parD[lev]->MP[i].Vz), parD[lev]->memSizerealMP ));
-// checkCudaErrors( cudaMalloc((void**) &(parD[lev]->MP[i].Rho), parD[lev]->memSizerealMP ));
-//}
-//void Parameter::cudaCopyMeasurePoints(int lev, int i)
-//{
-// checkCudaErrors( cudaMemcpy(parD[lev]->MP[i].Vx, parH[lev]->MP[i].Vx, parH[lev]->memSizerealMP, cudaMemcpyHostToDevice));
-// checkCudaErrors( cudaMemcpy(parD[lev]->MP[i].Vy, parH[lev]->MP[i].Vy, parH[lev]->memSizerealMP, cudaMemcpyHostToDevice));
-// checkCudaErrors( cudaMemcpy(parD[lev]->MP[i].Vz, parH[lev]->MP[i].Vz, parH[lev]->memSizerealMP, cudaMemcpyHostToDevice));
-// checkCudaErrors( cudaMemcpy(parD[lev]->MP[i].Rho, parH[lev]->MP[i].Rho, parH[lev]->memSizerealMP, cudaMemcpyHostToDevice));
-//}
-//void Parameter::cudaFreeMeasurePoints(int lev, int i)
-//{
-// checkCudaErrors( cudaFreeHost(parH[lev]->MP[i].Vx ));
-// checkCudaErrors( cudaFreeHost(parH[lev]->MP[i].Vy ));
-// checkCudaErrors( cudaFreeHost(parH[lev]->MP[i].Vz ));
-// checkCudaErrors( cudaFreeHost(parH[lev]->MP[i].Rho ));
-//}
-void Parameter::cudaAllocMeasurePointsIndex(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->kMP), parH[lev]->memSizeIntkMP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->VxMP), parH[lev]->memSizerealkMP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->VyMP), parH[lev]->memSizerealkMP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->VzMP), parH[lev]->memSizerealkMP ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->RhoMP), parH[lev]->memSizerealkMP ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->kMP), parD[lev]->memSizeIntkMP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->VxMP), parD[lev]->memSizerealkMP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->VyMP), parD[lev]->memSizerealkMP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->VzMP), parD[lev]->memSizerealkMP ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->RhoMP), parD[lev]->memSizerealkMP ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->memSizeIntkMP + 4. * (double)parH[lev]->memSizerealkMP;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyMeasurePointsIndex(int lev)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->kMP, parH[lev]->kMP, parH[lev]->memSizeIntkMP, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->VxMP, parH[lev]->VxMP, parH[lev]->memSizerealkMP, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->VyMP, parH[lev]->VyMP, parH[lev]->memSizerealkMP, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->VzMP, parH[lev]->VzMP, parH[lev]->memSizerealkMP, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->RhoMP, parH[lev]->RhoMP, parH[lev]->memSizerealkMP, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyMeasurePointsToHost(int lev)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->kMP, parD[lev]->kMP, parH[lev]->memSizeIntkMP, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->VxMP, parD[lev]->VxMP, parH[lev]->memSizerealkMP, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->VyMP, parD[lev]->VyMP, parH[lev]->memSizerealkMP, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->VzMP, parD[lev]->VzMP, parH[lev]->memSizerealkMP, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->RhoMP, parD[lev]->RhoMP, parH[lev]->memSizerealkMP, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeMeasurePointsIndex(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->kMP));
- checkCudaErrors( cudaFreeHost(parH[lev]->VxMP));
- checkCudaErrors( cudaFreeHost(parH[lev]->VyMP));
- checkCudaErrors( cudaFreeHost(parH[lev]->VzMP));
- checkCudaErrors( cudaFreeHost(parH[lev]->RhoMP));
-}
-void Parameter::cudaAllocFsForCheckPointAndRestart(int lev)
-{
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->d0SP.f[0] ), (unsigned long long)getD3Qxx()*(unsigned long long)parH[lev]->mem_size_real_SP));
-}
-void Parameter::cudaCopyFsForRestart(int lev)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->d0SP.f[0], parH[lev]->d0SP.f[0], (unsigned long long)getD3Qxx()*(unsigned long long)parH[lev]->mem_size_real_SP , cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyFsForCheckPoint(int lev)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->d0SP.f[0], parD[lev]->d0SP.f[0], (unsigned long long)getD3Qxx()*(unsigned long long)parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeFsForCheckPointAndRestart(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->d0SP.f[0]));
-}
-//DragLift
-void Parameter::cudaAllocDragLift(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(double)*numofelem;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->DragPreX), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->DragPreY), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->DragPreZ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->DragPostX), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->DragPostY), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->DragPostZ), mem_size ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->DragPreX), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->DragPreY), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->DragPreZ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->DragPostX), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->DragPostY), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->DragPostZ), mem_size ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 6. * (double)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyDragLift(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(double)*numofelem;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->DragPreX, parD[lev]->DragPreX, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->DragPreY, parD[lev]->DragPreY, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->DragPreZ, parD[lev]->DragPreZ, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->DragPostX, parD[lev]->DragPostX, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->DragPostY, parD[lev]->DragPostY, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->DragPostZ, parD[lev]->DragPostZ, mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeDragLift(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->DragPreX));
- checkCudaErrors( cudaFreeHost(parH[lev]->DragPreY));
- checkCudaErrors( cudaFreeHost(parH[lev]->DragPreZ));
- checkCudaErrors( cudaFreeHost(parH[lev]->DragPostX));
- checkCudaErrors( cudaFreeHost(parH[lev]->DragPostY));
- checkCudaErrors( cudaFreeHost(parH[lev]->DragPostZ));
-}
-//2ndMoments
-void Parameter::cudaAlloc2ndMoments(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->kxyFromfcNEQ ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->kyzFromfcNEQ ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->kxzFromfcNEQ ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->kxxMyyFromfcNEQ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->kxxMzzFromfcNEQ), mem_size ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->kxyFromfcNEQ ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->kyzFromfcNEQ ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->kxzFromfcNEQ ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->kxxMyyFromfcNEQ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->kxxMzzFromfcNEQ), mem_size ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 5. * (real)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopy2ndMoments(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->kxyFromfcNEQ , parD[lev]->kxyFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->kyzFromfcNEQ , parD[lev]->kyzFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->kxzFromfcNEQ , parD[lev]->kxzFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->kxxMyyFromfcNEQ, parD[lev]->kxxMyyFromfcNEQ, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->kxxMzzFromfcNEQ, parD[lev]->kxxMzzFromfcNEQ, mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFree2ndMoments(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->kxyFromfcNEQ ));
- checkCudaErrors( cudaFreeHost(parH[lev]->kyzFromfcNEQ ));
- checkCudaErrors( cudaFreeHost(parH[lev]->kxzFromfcNEQ ));
- checkCudaErrors( cudaFreeHost(parH[lev]->kxxMyyFromfcNEQ));
- checkCudaErrors( cudaFreeHost(parH[lev]->kxxMzzFromfcNEQ));
-}
-//3rdMoments
-void Parameter::cudaAlloc3rdMoments(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMbbb ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMabc ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMbac ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMbca ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMcba ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMacb ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMcab ), mem_size ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMbbb ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMabc ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMbac ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMbca ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMcba ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMacb ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMcab ), mem_size ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 7. * (real)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopy3rdMoments(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMbbb, parD[lev]->CUMbbb, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMabc, parD[lev]->CUMabc, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMbac, parD[lev]->CUMbac, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMbca, parD[lev]->CUMbca, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMcba, parD[lev]->CUMcba, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMacb, parD[lev]->CUMacb, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMcab, parD[lev]->CUMcab, mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFree3rdMoments(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMbbb ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMabc ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMbac ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMbca ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMcba ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMacb ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMcab ));
-}
-//higher order moments
-void Parameter::cudaAllocHigherMoments(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMcbb ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMbcb ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMbbc ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMcca ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMcac ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMacc ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMbcc ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMcbc ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMccb ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->CUMccc ), mem_size ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMcbb ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMbcb ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMbbc ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMcca ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMcac ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMacc ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMbcc ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMcbc ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMccb ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->CUMccc ), mem_size ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 7. * (real)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyHigherMoments(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMcbb, parD[lev]->CUMcbb, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMbcb, parD[lev]->CUMbcb, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMbbc, parD[lev]->CUMbbc, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMcca, parD[lev]->CUMcca, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMcac, parD[lev]->CUMcac, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMacc, parD[lev]->CUMacc, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMbcc, parD[lev]->CUMbcc, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMcbc, parD[lev]->CUMcbc, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMccb, parD[lev]->CUMccb, mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->CUMccc, parD[lev]->CUMccc, mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeHigherMoments(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMcbb ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMbcb ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMbbc ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMcca ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMcac ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMacc ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMbcc ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMcbc ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMccb ));
- checkCudaErrors( cudaFreeHost(parH[lev]->CUMccc ));
-}
-//Velcities to fit the Forcing
-void Parameter::cudaAllocForceVelo(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->VxForce ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->VyForce ), mem_size ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->VzForce ), mem_size ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->VxForce ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->VyForce ), mem_size ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->VzForce ), mem_size ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 3. * (real)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyForceVelo(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->VxForce , parD[lev]->VxForce , mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->VyForce , parD[lev]->VyForce , mem_size, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->VzForce , parD[lev]->VzForce , mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeForceVelo(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->VxForce ));
- checkCudaErrors( cudaFreeHost(parH[lev]->VyForce ));
- checkCudaErrors( cudaFreeHost(parH[lev]->VzForce ));
-}
-//Forcing
-void Parameter::cudaAllocForcing()
-{
- unsigned int mem_size = sizeof(real) * 3;
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(this->forcingH ), mem_size));
- //Device
- checkCudaErrors( cudaMalloc( (void**) &(this->forcingD ), mem_size));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (real)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyForcingToDevice()
-{
- unsigned int mem_size = sizeof(real) * 3;
- checkCudaErrors( cudaMemcpy(this->forcingD, this->forcingH , mem_size, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyForcingToHost()
-{
- unsigned int mem_size = sizeof(real) * 3;
- checkCudaErrors( cudaMemcpy(this->forcingH, this->forcingD , mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeForcing()
-{
- checkCudaErrors( cudaFreeHost(this->forcingH));
-}
-//cp Top
-void Parameter::cudaAllocCpTop(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpTop;
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpTop;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->cpPressTop), mem_size_double ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->cpTopIndex), mem_size_int ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->cpPressTop), mem_size_double ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->cpTopIndex), mem_size_int ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_double + (double)mem_size_int;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyCpTopInit(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpTop;
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpTop;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->cpPressTop, parH[lev]->cpPressTop, mem_size_double, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->cpTopIndex, parH[lev]->cpTopIndex, mem_size_int, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyCpTop(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpTop;
- //unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpTop;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->cpPressTop, parD[lev]->cpPressTop, mem_size_double, cudaMemcpyDeviceToHost));
- //checkCudaErrors( cudaMemcpy(parH[lev]->cpTopIndex, parD[lev]->cpTopIndex, mem_size_int, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeCpTop(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->cpPressTop));
- checkCudaErrors( cudaFreeHost(parH[lev]->cpTopIndex));
-}
-//cp Bottom
-void Parameter::cudaAllocCpBottom(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpBottom;
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpBottom;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->cpPressBottom), mem_size_double ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->cpBottomIndex), mem_size_int ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->cpPressBottom), mem_size_double ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->cpBottomIndex), mem_size_int ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_double + (double)mem_size_int;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyCpBottomInit(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpBottom;
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpBottom;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->cpPressBottom, parH[lev]->cpPressBottom, mem_size_double, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->cpBottomIndex, parH[lev]->cpBottomIndex, mem_size_int, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyCpBottom(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpBottom;
- //unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpBottom;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->cpPressBottom, parD[lev]->cpPressBottom, mem_size_double, cudaMemcpyDeviceToHost));
- //checkCudaErrors( cudaMemcpy(parH[lev]->cpBottomIndex, parD[lev]->cpBottomIndex, mem_size_int, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeCpBottom(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->cpPressBottom));
- checkCudaErrors( cudaFreeHost(parH[lev]->cpBottomIndex));
-}
-//cp Bottom 2
-void Parameter::cudaAllocCpBottom2(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpBottom2;
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpBottom2;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->cpPressBottom2), mem_size_double ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->cpBottom2Index), mem_size_int ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->cpPressBottom2), mem_size_double ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->cpBottom2Index), mem_size_int ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_double + (double)mem_size_int;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyCpBottom2Init(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpBottom2;
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsCpBottom2;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->cpPressBottom2, parH[lev]->cpPressBottom2, mem_size_double, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->cpBottom2Index, parH[lev]->cpBottom2Index, mem_size_int, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyCpBottom2(int lev)
-{
- unsigned int mem_size_double = sizeof(double) * parH[lev]->numberOfPointsCpBottom2;
-
- checkCudaErrors( cudaMemcpy(parH[lev]->cpPressBottom2, parD[lev]->cpPressBottom2, mem_size_double, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeCpBottom2(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->cpPressBottom2));
- checkCudaErrors( cudaFreeHost(parH[lev]->cpBottom2Index));
-}
-//////////////////////////////////////////////////////////////////////////
-//particles
-void Parameter::cudaAllocParticles(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.coordXlocal), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.coordYlocal), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.coordZlocal), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.coordXabsolut), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.coordYabsolut), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.coordZabsolut), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.veloX), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.veloY), parH[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.veloZ), parH[lev]->plp.memSizerealAll ));
- //checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.randomLocationInit), parH[lev]->plp.memSizereal ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.ID), parH[lev]->plp.memSizeID ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.cellBaseID), parH[lev]->plp.memSizeID ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.timestep), parH[lev]->plp.memSizeTimestep ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.stuck), parH[lev]->plp.memSizeBool ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->plp.hot), parH[lev]->plp.memSizeBoolBC ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.coordXlocal), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.coordYlocal), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.coordZlocal), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.coordXabsolut), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.coordYabsolut), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.coordZabsolut), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.veloX), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.veloY), parD[lev]->plp.memSizerealAll ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.veloZ), parD[lev]->plp.memSizerealAll ));
- //checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.randomLocationInit), parD[lev]->plp.memSizereal ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.ID), parD[lev]->plp.memSizeID ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.cellBaseID), parD[lev]->plp.memSizeID ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.timestep), parD[lev]->plp.memSizeTimestep ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.stuck), parD[lev]->plp.memSizeBool ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->plp.hot), parD[lev]->plp.memSizeBoolBC ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)parD[lev]->plp.memSizerealAll * (double)9.0 + (double)parD[lev]->plp.memSizeID * (double)2.0 + (double)parD[lev]->plp.memSizeTimestep
- + (double)parD[lev]->plp.memSizeBool + (double)parD[lev]->plp.memSizeBoolBC;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyParticles(int lev)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.coordXlocal, parD[lev]->plp.coordXlocal, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.coordYlocal, parD[lev]->plp.coordYlocal, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.coordZlocal, parD[lev]->plp.coordZlocal, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.coordXabsolut, parD[lev]->plp.coordXabsolut, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.coordYabsolut, parD[lev]->plp.coordYabsolut, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.coordZabsolut, parD[lev]->plp.coordZabsolut, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.veloX, parD[lev]->plp.veloX, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.veloY, parD[lev]->plp.veloY, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.veloZ, parD[lev]->plp.veloZ, parH[lev]->plp.memSizerealAll, cudaMemcpyDeviceToHost));
- //checkCudaErrors( cudaMemcpy(parH[lev]->plp.randomLocationInit, parD[lev]->plp.randomLocationInit, parH[lev]->plp.memSizereal, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.ID, parD[lev]->plp.ID, parH[lev]->plp.memSizeID, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.cellBaseID, parD[lev]->plp.cellBaseID, parH[lev]->plp.memSizeID, cudaMemcpyDeviceToHost));
- checkCudaErrors( cudaMemcpy(parH[lev]->plp.timestep, parD[lev]->plp.timestep, parH[lev]->plp.memSizeTimestep, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeParticles(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.coordXlocal) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.coordYlocal) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.coordZlocal) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.coordXabsolut) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.coordYabsolut) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.coordZabsolut) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.veloX) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.veloY) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.veloZ) );
- //checkCudaErrors( cudaFreeHost(parH[lev]->plp.randomLocationInit));
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.ID) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.cellBaseID) );
- checkCudaErrors( cudaFreeHost(parH[lev]->plp.timestep) );
-}
-//random values
-void Parameter::cudaAllocRandomValues()
-{
- //Device
- checkCudaErrors( cudaMalloc((void**)&(this->devState), (sizeof(curandState)*parD[getFine()]->plp.numberOfParticles) ));
-}
-//////////////////////////////////////////////////////////////////////////
-//porous media
-void Parameter::cudaAllocPorousMedia(PorousMedia* pm, int lev)
-{
- unsigned int mem_size_IDsPM = sizeof(unsigned int)*pm->getSizePM();
- unsigned int *tmpIDHost, *tmpIDDevice;
- //std::cout << "cudaMallocHost" << endl;
- //Host
- checkCudaErrors(cudaMallocHost((void**) &(tmpIDHost), mem_size_IDsPM));
-
- //std::cout << "cudaMalloc" << endl;
- //Device
- checkCudaErrors(cudaMalloc((void**) &(tmpIDDevice), mem_size_IDsPM));
-
- //std::cout << "set Host and Device arrays PM" << endl;
- //////////////////////////////////////////////////////////////////////////
- pm->setHostNodeIDsPM(tmpIDHost);
- pm->setDeviceNodeIDsPM(tmpIDDevice);
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_IDsPM;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyPorousMedia(PorousMedia* pm, int lev)
-{
- unsigned int mem_size_IDsPM = sizeof(unsigned int)*pm->getSizePM();
- unsigned int *tmpIDHost = pm->getHostNodeIDsPM();
- unsigned int *tmpIDDevice = pm->getDeviceNodeIDsPM();
- //////////////////////////////////////////////////////////////////////////
- checkCudaErrors(cudaMemcpy(tmpIDDevice, tmpIDHost, mem_size_IDsPM, cudaMemcpyHostToDevice));
- //////////////////////////////////////////////////////////////////////////
- pm->setDeviceNodeIDsPM(tmpIDDevice);
-}
-void Parameter::cudaFreePorousMedia(PorousMedia* pm, int lev)
-{
- checkCudaErrors(cudaFreeHost(pm->getHostNodeIDsPM()));
-}
-//////////////////////////////////////////////////////////////////////////
-//advection diffusion
-void Parameter::cudaAllocConc(int lev)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->Conc), parH[lev]->mem_size_real_SP));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->Conc), parD[lev]->mem_size_real_SP));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->mem_size_real_SP;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyConcDH(int lev)
-{
- printf("Rank = %d \n", getMyID());
- checkCudaErrors( cudaMemcpy(parH[lev]->Conc, parD[lev]->Conc, parH[lev]->mem_size_real_SP , cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaCopyConcHD(int lev)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->Conc, parH[lev]->Conc, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeConc(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->Conc));
-}
-//////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocTempFs(int lev)
-{
- //Device
- if (getDiffMod() == 7)
- {
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->d7.f[0]), getDiffMod()*parH[lev]->mem_size_real_SP));
- }
- else if (getDiffMod() == 27)
- {
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->d27.f[0]), getDiffMod()*parH[lev]->mem_size_real_SP));
- }
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)(getDiffMod()*parH[lev]->mem_size_real_SP);
- setMemsizeGPU(tmp, false);
-}
-//////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocTempPressBC(int lev)
-{
- unsigned int mem_size_TempPress_k = sizeof(int)*parH[lev]->TempPress.kTemp;
- unsigned int mem_size_TempPress_q = sizeof(real)*parH[lev]->TempPress.kTemp;
-
- // Host Memory
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->TempPress.temp, mem_size_TempPress_q ));
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->TempPress.velo, mem_size_TempPress_q ));
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->TempPress.k, mem_size_TempPress_k ));
-
- // Device Memory
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->TempPress.temp, mem_size_TempPress_q));
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->TempPress.velo, mem_size_TempPress_q));
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->TempPress.k, mem_size_TempPress_k));
-
-}
-void Parameter::cudaCopyTempPressBCHD(int lev)
-{
- unsigned int mem_size_TempPress_k = sizeof(int)*parH[lev]->TempPress.kTemp;
- unsigned int mem_size_TempPress_q = sizeof(real)*parH[lev]->TempPress.kTemp;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->TempPress.temp, parH[lev]->TempPress.temp, mem_size_TempPress_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->TempPress.velo, parH[lev]->TempPress.velo, mem_size_TempPress_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->TempPress.k, parH[lev]->TempPress.k, mem_size_TempPress_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeTempPressBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->TempPress.temp));
- checkCudaErrors( cudaFreeHost(parH[lev]->TempPress.velo));
- checkCudaErrors( cudaFreeHost(parH[lev]->TempPress.k ));
-}
-//////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocTempVeloBC(int lev)
-{
- unsigned int mem_size_TempVel_k = sizeof(int)*parH[lev]->TempVel.kTemp;
- unsigned int mem_size_TempVel_q = sizeof(real)*parH[lev]->TempVel.kTemp;
-
- printf("mem_size_TempVel_k = %d, mem_size_TempVel_q = %d \n", mem_size_TempVel_k, mem_size_TempVel_q);
- // Host Memory
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->TempVel.temp, mem_size_TempVel_q ));
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->TempVel.tempPulse, mem_size_TempVel_q ));
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->TempVel.velo, mem_size_TempVel_q ));
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->TempVel.k, mem_size_TempVel_k ));
-
- // Device Memory
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->TempVel.temp, mem_size_TempVel_q));
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->TempVel.tempPulse, mem_size_TempVel_q));
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->TempVel.velo, mem_size_TempVel_q));
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->TempVel.k, mem_size_TempVel_k));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)(mem_size_TempVel_q * 3.0 + mem_size_TempVel_k);
- setMemsizeGPU(tmp, false);
-
-}
-void Parameter::cudaCopyTempVeloBCHD(int lev)
-{
- unsigned int mem_size_TempVel_k = sizeof(int)*parH[lev]->TempVel.kTemp;
- unsigned int mem_size_TempVel_q = sizeof(real)*parH[lev]->TempVel.kTemp;
-
- printf("mem_size_TempVel_k = %d, mem_size_TempVel_q = %d \n", mem_size_TempVel_k, mem_size_TempVel_q);
- checkCudaErrors( cudaMemcpy(parD[lev]->TempVel.temp, parH[lev]->TempVel.temp, mem_size_TempVel_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->TempVel.tempPulse, parH[lev]->TempVel.tempPulse, mem_size_TempVel_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->TempVel.velo, parH[lev]->TempVel.velo, mem_size_TempVel_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->TempVel.k, parH[lev]->TempVel.k, mem_size_TempVel_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeTempVeloBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->TempVel.temp ));
- checkCudaErrors( cudaFreeHost(parH[lev]->TempVel.tempPulse));
- checkCudaErrors( cudaFreeHost(parH[lev]->TempVel.velo ));
- checkCudaErrors( cudaFreeHost(parH[lev]->TempVel.k ));
-}
-//////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocTempNoSlipBC(int lev)
-{
- unsigned int mem_size_Temp_k = sizeof(int)*parH[lev]->Temp.kTemp;
- unsigned int mem_size_Temp_q = sizeof(real)*parH[lev]->Temp.kTemp;
-
- // Host Memory
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->Temp.temp, mem_size_Temp_q ));
- checkCudaErrors( cudaMallocHost((void**) &parH[lev]->Temp.k, mem_size_Temp_k ));
-
- // Device Memory
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->Temp.temp, mem_size_Temp_q));
- checkCudaErrors( cudaMalloc((void**) &parD[lev]->Temp.k, mem_size_Temp_k));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)(mem_size_Temp_q + mem_size_Temp_k);
- setMemsizeGPU(tmp, false);
-
-}
-void Parameter::cudaCopyTempNoSlipBCHD(int lev)
-{
- unsigned int mem_size_Temp_k = sizeof(int)*parH[lev]->Temp.kTemp;
- unsigned int mem_size_Temp_q = sizeof(real)*parH[lev]->Temp.kTemp;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->Temp.temp, parH[lev]->Temp.temp, mem_size_Temp_q, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->Temp.k, parH[lev]->Temp.k, mem_size_Temp_k, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeTempNoSlipBC(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->Temp.temp));
- checkCudaErrors( cudaFreeHost(parH[lev]->Temp.k ));
-}
-//PlaneConc
-void Parameter::cudaAllocPlaneConcIn(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->ConcPlaneIn), mem_size ));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->ConcPlaneIn), mem_size ));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyPlaneConcIn(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
- checkCudaErrors( cudaMemcpy(parH[lev]->ConcPlaneIn, parD[lev]->ConcPlaneIn, mem_size, cudaMemcpyDeviceToHost));
-}
-//////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocPlaneConcOut1(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->ConcPlaneOut1), mem_size ));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->ConcPlaneOut1), mem_size ));
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyPlaneConcOut1(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
- checkCudaErrors( cudaMemcpy(parH[lev]->ConcPlaneOut1, parD[lev]->ConcPlaneOut1, mem_size, cudaMemcpyDeviceToHost));
-}
-//////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocPlaneConcOut2(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->ConcPlaneOut2), mem_size ));
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->ConcPlaneOut2), mem_size ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyPlaneConcOut2(int lev, int numofelem)
-{
- unsigned int mem_size = sizeof(real)*numofelem;
- checkCudaErrors( cudaMemcpy(parH[lev]->ConcPlaneOut2, parD[lev]->ConcPlaneOut2, mem_size, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreePlaneConc(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->ConcPlaneIn));
- checkCudaErrors( cudaFreeHost(parH[lev]->ConcPlaneOut1));
- checkCudaErrors( cudaFreeHost(parH[lev]->ConcPlaneOut2));
-}
-//////////////////////////////////////////////////////////////////////////
-//concentration file
-void Parameter::cudaAllocConcFile(int lev)
-{
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsConc;
- unsigned int mem_size_real = sizeof(real) * parH[lev]->numberOfPointsConc;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->concIndex), mem_size_int ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->concentration), mem_size_real ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->concIndex), mem_size_int ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->concentration), mem_size_real ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_int + (double)mem_size_real;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyConcFile(int lev)
-{
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsConc;
- unsigned int mem_size_real = sizeof(real) * parH[lev]->numberOfPointsConc;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->concIndex, parH[lev]->concIndex, mem_size_int, cudaMemcpyHostToDevice));
- checkCudaErrors( cudaMemcpy(parD[lev]->concentration, parH[lev]->concentration, mem_size_real, cudaMemcpyHostToDevice));
-}
-
-void Parameter::cudaCopyConcs(int lev)
-{
- unsigned int mem_size_real = sizeof(real) * parH[lev]->numberOfPointsConc;
-
- checkCudaErrors(cudaMemcpy(parD[lev]->concentration, parH[lev]->concentration, mem_size_real, cudaMemcpyHostToDevice));
-}
-
-void Parameter::cudaFreeConcFile(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->concIndex ));
- checkCudaErrors( cudaFreeHost(parH[lev]->concentration ));
-}
-//////////////////////////////////////////////////////////////////////////
-//street X and Y velocity fractions
-void Parameter::cudaAllocStreetVelocityFractions(int lev)
-{
- unsigned int mem_size_real = sizeof(real) * parH[lev]->numberOfStreetNodes;
- unsigned int mem_size_int = sizeof(int) * parH[lev]->numberOfStreetNodes;
- //printf("\nnumberOfStreetNodes = %d\n", parH[lev]->numberOfStreetNodes);
-
- //Host
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->streetFractionXvelocity), mem_size_real));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->streetFractionYvelocity), mem_size_real));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->naschVelocity ), mem_size_int ));
-
- //Device
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->streetFractionXvelocity), mem_size_real));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->streetFractionYvelocity), mem_size_real));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->naschVelocity ), mem_size_int ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = 2.0 * (double)mem_size_real + (double)mem_size_int;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyStreetVelocityFractions(int lev)
-{
- unsigned int mem_size_real = sizeof(real) * parH[lev]->numberOfStreetNodes;
- unsigned int mem_size_int = sizeof(int) * parH[lev]->numberOfStreetNodes;
-
- checkCudaErrors(cudaMemcpy(parD[lev]->streetFractionXvelocity, parH[lev]->streetFractionXvelocity, mem_size_real, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->streetFractionYvelocity, parH[lev]->streetFractionYvelocity, mem_size_real, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->naschVelocity, parH[lev]->naschVelocity, mem_size_int, cudaMemcpyHostToDevice));
-}
-
-void Parameter::cudaFreeStreetVelocityFractions(int lev)
-{
- checkCudaErrors(cudaFreeHost(parH[lev]->streetFractionXvelocity));
- checkCudaErrors(cudaFreeHost(parH[lev]->streetFractionYvelocity));
- checkCudaErrors(cudaFreeHost(parH[lev]->naschVelocity));
-}
-//////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////
-//Process Neighbors
-//1D domain decomposition
-void Parameter::cudaAllocProcessNeighbor(int lev, unsigned int processNeighbor)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighbor[processNeighbor].index ), parH[lev]->sendProcessNeighbor[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighbor[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->sendProcessNeighbor[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighbor[processNeighbor].index ), parH[lev]->recvProcessNeighbor[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighbor[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->recvProcessNeighbor[processNeighbor].memsizeFs ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighbor[processNeighbor].index ), parD[lev]->sendProcessNeighbor[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighbor[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->sendProcessNeighbor[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighbor[processNeighbor].index ), parD[lev]->recvProcessNeighbor[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighbor[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->recvProcessNeighbor[processNeighbor].memsizeFs ));
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->sendProcessNeighbor[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->sendProcessNeighbor[processNeighbor].memsizeFs +
- (double)parH[lev]->recvProcessNeighbor[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->recvProcessNeighbor[processNeighbor].memsizeFs;
- setMemsizeGPU(tmp, false);
- //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
-}
-void Parameter::cudaCopyProcessNeighborIndex(int lev, unsigned int processNeighbor)
-{
- //copy send Index
- checkCudaErrors( cudaMemcpy(parD[lev]->sendProcessNeighbor[processNeighbor].index,
- parH[lev]->sendProcessNeighbor[processNeighbor].index,
- parH[lev]->sendProcessNeighbor[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
- //copy recv Index
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighbor[processNeighbor].index,
- parH[lev]->recvProcessNeighbor[processNeighbor].index,
- parH[lev]->recvProcessNeighbor[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborFsHD(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighbor[processNeighbor].f[0],
- parH[lev]->recvProcessNeighbor[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->recvProcessNeighbor[processNeighbor].memsizeFs,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborFsDH(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->sendProcessNeighbor[processNeighbor].f[0],
- parD[lev]->sendProcessNeighbor[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->sendProcessNeighbor[processNeighbor].memsizeFs,
- cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeProcessNeighbor(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighbor[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighbor[processNeighbor].f[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighbor[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighbor[processNeighbor].f[0] ));
-}
-////////////////////////////////////////////////////////////////////////////////////
-// 3D domain decomposition
-// X /////////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocProcessNeighborX(int lev, unsigned int processNeighbor)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborX[processNeighbor].index ), parH[lev]->sendProcessNeighborX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborX[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->sendProcessNeighborX[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborX[processNeighbor].index ), parH[lev]->recvProcessNeighborX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborX[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->recvProcessNeighborX[processNeighbor].memsizeFs ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborX[processNeighbor].index ), parD[lev]->sendProcessNeighborX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborX[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->sendProcessNeighborX[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborX[processNeighbor].index ), parD[lev]->recvProcessNeighborX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborX[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->recvProcessNeighborX[processNeighbor].memsizeFs ));
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->sendProcessNeighborX[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->sendProcessNeighborX[processNeighbor].memsizeFs +
- (double)parH[lev]->recvProcessNeighborX[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->recvProcessNeighborX[processNeighbor].memsizeFs;
- setMemsizeGPU(tmp, false);
- //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
-}
-void Parameter::cudaCopyProcessNeighborXIndex(int lev, unsigned int processNeighbor)
-{
- //copy send Index
- checkCudaErrors( cudaMemcpy(parD[lev]->sendProcessNeighborX[processNeighbor].index,
- parH[lev]->sendProcessNeighborX[processNeighbor].index,
- parH[lev]->sendProcessNeighborX[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
- //copy recv Index
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborX[processNeighbor].index,
- parH[lev]->recvProcessNeighborX[processNeighbor].index,
- parH[lev]->recvProcessNeighborX[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborXFsHD(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborX[processNeighbor].f[0],
- parH[lev]->recvProcessNeighborX[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->recvProcessNeighborX[processNeighbor].memsizeFs,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborXFsDH(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->sendProcessNeighborX[processNeighbor].f[0],
- parD[lev]->sendProcessNeighborX[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->sendProcessNeighborX[processNeighbor].memsizeFs,
- cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeProcessNeighborX(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborX[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborX[processNeighbor].f[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborX[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborX[processNeighbor].f[0] ));
-}
-// Y /////////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocProcessNeighborY(int lev, unsigned int processNeighbor)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborY[processNeighbor].index ), parH[lev]->sendProcessNeighborY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborY[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->sendProcessNeighborY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborY[processNeighbor].index ), parH[lev]->recvProcessNeighborY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborY[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->recvProcessNeighborY[processNeighbor].memsizeFs ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborY[processNeighbor].index ), parD[lev]->sendProcessNeighborY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborY[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->sendProcessNeighborY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborY[processNeighbor].index ), parD[lev]->recvProcessNeighborY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborY[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->recvProcessNeighborY[processNeighbor].memsizeFs ));
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->sendProcessNeighborY[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->sendProcessNeighborY[processNeighbor].memsizeFs +
- (double)parH[lev]->recvProcessNeighborY[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->recvProcessNeighborY[processNeighbor].memsizeFs;
- setMemsizeGPU(tmp, false);
- //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
-}
-void Parameter::cudaCopyProcessNeighborYIndex(int lev, unsigned int processNeighbor)
-{
- //copy send Index
- checkCudaErrors( cudaMemcpy(parD[lev]->sendProcessNeighborY[processNeighbor].index,
- parH[lev]->sendProcessNeighborY[processNeighbor].index,
- parH[lev]->sendProcessNeighborY[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
- //copy recv Index
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborY[processNeighbor].index,
- parH[lev]->recvProcessNeighborY[processNeighbor].index,
- parH[lev]->recvProcessNeighborY[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborYFsHD(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborY[processNeighbor].f[0],
- parH[lev]->recvProcessNeighborY[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->recvProcessNeighborY[processNeighbor].memsizeFs,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborYFsDH(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->sendProcessNeighborY[processNeighbor].f[0],
- parD[lev]->sendProcessNeighborY[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->sendProcessNeighborY[processNeighbor].memsizeFs,
- cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeProcessNeighborY(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborY[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborY[processNeighbor].f[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborY[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborY[processNeighbor].f[0] ));
-}
-// Z /////////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocProcessNeighborZ(int lev, unsigned int processNeighbor)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborZ[processNeighbor].index ), parH[lev]->sendProcessNeighborZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborZ[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->sendProcessNeighborZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborZ[processNeighbor].index ), parH[lev]->recvProcessNeighborZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborZ[processNeighbor].f[0] ), getD3Qxx() * parH[lev]->recvProcessNeighborZ[processNeighbor].memsizeFs ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborZ[processNeighbor].index ), parD[lev]->sendProcessNeighborZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborZ[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->sendProcessNeighborZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborZ[processNeighbor].index ), parD[lev]->recvProcessNeighborZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborZ[processNeighbor].f[0] ), getD3Qxx() * parD[lev]->recvProcessNeighborZ[processNeighbor].memsizeFs ));
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->sendProcessNeighborZ[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->sendProcessNeighborZ[processNeighbor].memsizeFs +
- (double)parH[lev]->recvProcessNeighborZ[processNeighbor].memsizeIndex + (double)getD3Qxx()*(double)parH[lev]->recvProcessNeighborZ[processNeighbor].memsizeFs;
- setMemsizeGPU(tmp, false);
- //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
-}
-void Parameter::cudaCopyProcessNeighborZIndex(int lev, unsigned int processNeighbor)
-{
- //copy send Index
- checkCudaErrors( cudaMemcpy(parD[lev]->sendProcessNeighborZ[processNeighbor].index,
- parH[lev]->sendProcessNeighborZ[processNeighbor].index,
- parH[lev]->sendProcessNeighborZ[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
- //copy recv Index
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborZ[processNeighbor].index,
- parH[lev]->recvProcessNeighborZ[processNeighbor].index,
- parH[lev]->recvProcessNeighborZ[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborZFsHD(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborZ[processNeighbor].f[0],
- parH[lev]->recvProcessNeighborZ[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->recvProcessNeighborZ[processNeighbor].memsizeFs,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborZFsDH(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->sendProcessNeighborZ[processNeighbor].f[0],
- parD[lev]->sendProcessNeighborZ[processNeighbor].f[0],
- getD3Qxx() * parD[lev]->sendProcessNeighborZ[processNeighbor].memsizeFs,
- cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeProcessNeighborZ(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborZ[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborZ[processNeighbor].f[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborZ[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborZ[processNeighbor].f[0] ));
-}
-////////////////////////////////////////////////////////////////////////////////////
-// 3D domain decomposition convection diffusion
-// X /////////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocProcessNeighborADX(int lev, unsigned int processNeighbor)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborADX[processNeighbor].index ), parH[lev]->sendProcessNeighborADX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborADX[processNeighbor].f[0] ), getDiffMod() * parH[lev]->sendProcessNeighborADX[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborADX[processNeighbor].index ), parH[lev]->recvProcessNeighborADX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborADX[processNeighbor].f[0] ), getDiffMod() * parH[lev]->recvProcessNeighborADX[processNeighbor].memsizeFs ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborADX[processNeighbor].index ), parD[lev]->sendProcessNeighborADX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborADX[processNeighbor].f[0] ), getDiffMod() * parD[lev]->sendProcessNeighborADX[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborADX[processNeighbor].index ), parD[lev]->recvProcessNeighborADX[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborADX[processNeighbor].f[0] ), getDiffMod() * parD[lev]->recvProcessNeighborADX[processNeighbor].memsizeFs ));
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->sendProcessNeighborADX[processNeighbor].memsizeIndex + (double)getDiffMod()*(double)parH[lev]->sendProcessNeighborADX[processNeighbor].memsizeFs +
- (double)parH[lev]->recvProcessNeighborADX[processNeighbor].memsizeIndex + (double)getDiffMod()*(double)parH[lev]->recvProcessNeighborADX[processNeighbor].memsizeFs;
- setMemsizeGPU(tmp, false);
- //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
-}
-void Parameter::cudaCopyProcessNeighborADXIndex(int lev, unsigned int processNeighbor)
-{
- //copy send Index
- checkCudaErrors( cudaMemcpy(parD[lev]->sendProcessNeighborADX[processNeighbor].index,
- parH[lev]->sendProcessNeighborADX[processNeighbor].index,
- parH[lev]->sendProcessNeighborADX[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
- //copy recv Index
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborADX[processNeighbor].index,
- parH[lev]->recvProcessNeighborADX[processNeighbor].index,
- parH[lev]->recvProcessNeighborADX[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborADXFsHD(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborADX[processNeighbor].f[0],
- parH[lev]->recvProcessNeighborADX[processNeighbor].f[0],
- getDiffMod() * parD[lev]->recvProcessNeighborADX[processNeighbor].memsizeFs,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborADXFsDH(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->sendProcessNeighborADX[processNeighbor].f[0],
- parD[lev]->sendProcessNeighborADX[processNeighbor].f[0],
- getDiffMod() * parD[lev]->sendProcessNeighborADX[processNeighbor].memsizeFs,
- cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeProcessNeighborADX(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborADX[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborADX[processNeighbor].f[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborADX[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborADX[processNeighbor].f[0] ));
-}
-// Y /////////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocProcessNeighborADY(int lev, unsigned int processNeighbor)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborADY[processNeighbor].index ), parH[lev]->sendProcessNeighborADY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborADY[processNeighbor].f[0] ), getDiffMod() * parH[lev]->sendProcessNeighborADY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborADY[processNeighbor].index ), parH[lev]->recvProcessNeighborADY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborADY[processNeighbor].f[0] ), getDiffMod() * parH[lev]->recvProcessNeighborADY[processNeighbor].memsizeFs ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborADY[processNeighbor].index ), parD[lev]->sendProcessNeighborADY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborADY[processNeighbor].f[0] ), getDiffMod() * parD[lev]->sendProcessNeighborADY[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborADY[processNeighbor].index ), parD[lev]->recvProcessNeighborADY[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborADY[processNeighbor].f[0] ), getDiffMod() * parD[lev]->recvProcessNeighborADY[processNeighbor].memsizeFs ));
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->sendProcessNeighborADY[processNeighbor].memsizeIndex + (double)getDiffMod()*(double)parH[lev]->sendProcessNeighborADY[processNeighbor].memsizeFs +
- (double)parH[lev]->recvProcessNeighborADY[processNeighbor].memsizeIndex + (double)getDiffMod()*(double)parH[lev]->recvProcessNeighborADY[processNeighbor].memsizeFs;
- setMemsizeGPU(tmp, false);
- //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
-}
-void Parameter::cudaCopyProcessNeighborADYIndex(int lev, unsigned int processNeighbor)
-{
- //copy send Index
- checkCudaErrors( cudaMemcpy(parD[lev]->sendProcessNeighborADY[processNeighbor].index,
- parH[lev]->sendProcessNeighborADY[processNeighbor].index,
- parH[lev]->sendProcessNeighborADY[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
- //copy recv Index
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborADY[processNeighbor].index,
- parH[lev]->recvProcessNeighborADY[processNeighbor].index,
- parH[lev]->recvProcessNeighborADY[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborADYFsHD(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborADY[processNeighbor].f[0],
- parH[lev]->recvProcessNeighborADY[processNeighbor].f[0],
- getDiffMod() * parD[lev]->recvProcessNeighborADY[processNeighbor].memsizeFs,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborADYFsDH(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->sendProcessNeighborADY[processNeighbor].f[0],
- parD[lev]->sendProcessNeighborADY[processNeighbor].f[0],
- getDiffMod() * parD[lev]->sendProcessNeighborADY[processNeighbor].memsizeFs,
- cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeProcessNeighborADY(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborADY[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborADY[processNeighbor].f[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborADY[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborADY[processNeighbor].f[0] ));
-}
-// Z /////////////////////////////////////////////////////////////////////////////
-void Parameter::cudaAllocProcessNeighborADZ(int lev, unsigned int processNeighbor)
-{
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborADZ[processNeighbor].index ), parH[lev]->sendProcessNeighborADZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->sendProcessNeighborADZ[processNeighbor].f[0] ), getDiffMod() * parH[lev]->sendProcessNeighborADZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborADZ[processNeighbor].index ), parH[lev]->recvProcessNeighborADZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->recvProcessNeighborADZ[processNeighbor].f[0] ), getDiffMod() * parH[lev]->recvProcessNeighborADZ[processNeighbor].memsizeFs ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborADZ[processNeighbor].index ), parD[lev]->sendProcessNeighborADZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->sendProcessNeighborADZ[processNeighbor].f[0] ), getDiffMod() * parD[lev]->sendProcessNeighborADZ[processNeighbor].memsizeFs ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborADZ[processNeighbor].index ), parD[lev]->recvProcessNeighborADZ[processNeighbor].memsizeIndex ));
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->recvProcessNeighborADZ[processNeighbor].f[0] ), getDiffMod() * parD[lev]->recvProcessNeighborADZ[processNeighbor].memsizeFs ));
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- double tmp = (double)parH[lev]->sendProcessNeighborADZ[processNeighbor].memsizeIndex + (double)getDiffMod()*(double)parH[lev]->sendProcessNeighborADZ[processNeighbor].memsizeFs +
- (double)parH[lev]->recvProcessNeighborADZ[processNeighbor].memsizeIndex + (double)getDiffMod()*(double)parH[lev]->recvProcessNeighborADZ[processNeighbor].memsizeFs;
- setMemsizeGPU(tmp, false);
- //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
-}
-void Parameter::cudaCopyProcessNeighborADZIndex(int lev, unsigned int processNeighbor)
-{
- //copy send Index
- checkCudaErrors( cudaMemcpy(parD[lev]->sendProcessNeighborADZ[processNeighbor].index,
- parH[lev]->sendProcessNeighborADZ[processNeighbor].index,
- parH[lev]->sendProcessNeighborADZ[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
- //copy recv Index
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborADZ[processNeighbor].index,
- parH[lev]->recvProcessNeighborADZ[processNeighbor].index,
- parH[lev]->recvProcessNeighborADZ[processNeighbor].memsizeIndex,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborADZFsHD(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parD[lev]->recvProcessNeighborADZ[processNeighbor].f[0],
- parH[lev]->recvProcessNeighborADZ[processNeighbor].f[0],
- getDiffMod() * parD[lev]->recvProcessNeighborADZ[processNeighbor].memsizeFs,
- cudaMemcpyHostToDevice));
-}
-void Parameter::cudaCopyProcessNeighborADZFsDH(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaMemcpy(parH[lev]->sendProcessNeighborADZ[processNeighbor].f[0],
- parD[lev]->sendProcessNeighborADZ[processNeighbor].f[0],
- getDiffMod() * parD[lev]->sendProcessNeighborADZ[processNeighbor].memsizeFs,
- cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaFreeProcessNeighborADZ(int lev, unsigned int processNeighbor)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborADZ[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->sendProcessNeighborADZ[processNeighbor].f[0] ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborADZ[processNeighbor].index ));
- checkCudaErrors( cudaFreeHost(parH[lev]->recvProcessNeighborADZ[processNeighbor].f[0] ));
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
index c0a9daa6399e5067643f555a5046efafc478dd75..25946704edcad12513d1b8a2c70cd551eb1dd619 100644
--- a/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
+++ b/src/gpu/VirtualFluids_GPU/Parameter/Parameter.h
@@ -306,277 +306,6 @@ public:
//measure points
void copyMeasurePointsArrayToVector(int lev);
- //alloc
- void cudaAllocFull(int lev);
- void cudaFreeFull(int lev);
-
- void cudaAllocCoord(int lev);
- void cudaCopyCoord(int lev);
- void cudaFreeCoord(int lev);
-
- void cudaCopyPrint(int lev);
- void cudaCopyMedianPrint(int lev);
- void cudaCopyMedianADPrint(int lev);
-
- void cudaAllocSP(int lev);
- void cudaCopySP(int lev);
- void cudaFreeSP(int lev);
-
- void cudaAllocF3SP(int lev);
-
- void cudaAllocNeighborWSB(int lev);
- void cudaCopyNeighborWSB(int lev);
- void cudaFreeNeighborWSB(int lev);
-
- void cudaAllocTurbulentViscosity(int lev);
- void cudaCopyTurbulentViscosityHD(int lev);
- void cudaCopyTurbulentViscosityDH(int lev);
- void cudaFreeTurbulentViscosity(int lev);
-
- void cudaAllocMedianSP(int lev);
- void cudaCopyMedianSP(int lev);
- void cudaFreeMedianSP(int lev);
- void cudaAllocMedianOut(int lev);
- void cudaFreeMedianOut(int lev);
-
- void cudaAllocMedianAD(int lev);
- void cudaCopyMedianAD(int lev);
- void cudaFreeMedianAD(int lev);
- void cudaAllocMedianOutAD(int lev);
- void cudaFreeMedianOutAD(int lev);
-
- void cudaAllocInterfaceCF(int lev);
- void cudaCopyInterfaceCF(int lev);
- void cudaFreeInterfaceCF(int lev);
- void cudaAllocInterfaceFC(int lev);
- void cudaCopyInterfaceFC(int lev);
- void cudaFreeInterfaceFC(int lev);
- void cudaAllocInterfaceOffCF(int lev);
- void cudaCopyInterfaceOffCF(int lev);
- void cudaFreeInterfaceOffCF(int lev);
- void cudaAllocInterfaceOffFC(int lev);
- void cudaCopyInterfaceOffFC(int lev);
- void cudaFreeInterfaceOffFC(int lev);
-
- void cudaAllocVeloBC(int lev);
- void cudaCopyVeloBC(int lev);
- void cudaFreeVeloBC(int lev);
- void cudaAllocOutflowBC(int lev);
- void cudaCopyOutflowBC(int lev);
- void cudaFreeOutflowBC(int lev);
- void cudaAllocWallBC(int lev);
- void cudaCopyWallBC(int lev);
- void cudaFreeWallBC(int lev);
- void cudaAllocSlipBC(int lev);
- void cudaCopySlipBC(int lev);
- void cudaFreeSlipBC(int lev);
-
- void cudaAllocGeomValuesBC(int lev);
- void cudaCopyGeomValuesBC(int lev);
- void cudaFreeGeomValuesBC(int lev);
- void cudaAllocGeomBC(int lev);
- void cudaCopyGeomBC(int lev);
- void cudaFreeGeomBC(int lev);
- //Normals
- void cudaAllocGeomNormals(int lev);
- void cudaCopyGeomNormals(int lev);
- void cudaFreeGeomNormals(int lev);
- void cudaAllocInflowNormals(int lev);
- void cudaCopyInflowNormals(int lev);
- void cudaFreeInflowNormals(int lev);
- void cudaAllocOutflowNormals(int lev);
- void cudaCopyOutflowNormals(int lev);
- void cudaFreeOutflowNormals(int lev);
-
- void cudaAllocPress(int lev);
- void cudaCopyPress(int lev);
- void cudaFreePress(int lev);
- void cudaAllocTestRE(int lev, unsigned int size);
- void cudaCopyTestREtoDevice(int lev, unsigned int size);
- void cudaCopyTestREtoHost(int lev, unsigned int size);
- void cudaFreeTestRE(int lev);
-
- void cudaAllocCpTop(int lev);
- void cudaCopyCpTopInit(int lev);
- void cudaCopyCpTop(int lev);
- void cudaFreeCpTop(int lev);
-
- void cudaAllocCpBottom(int lev);
- void cudaCopyCpBottomInit(int lev);
- void cudaCopyCpBottom(int lev);
- void cudaFreeCpBottom(int lev);
-
- void cudaAllocCpBottom2(int lev);
- void cudaCopyCpBottom2Init(int lev);
- void cudaCopyCpBottom2(int lev);
- void cudaFreeCpBottom2(int lev);
-
- void cudaAllocConcFile(int lev);
- void cudaCopyConcFile(int lev);
- void cudaCopyConcs(int lev);
- void cudaFreeConcFile(int lev);
-
- void cudaAllocStreetVelocityFractions(int lev);
- void cudaCopyStreetVelocityFractions(int lev);
- void cudaFreeStreetVelocityFractions(int lev);
-
- void cudaAllocInlet(int lev);
- void cudaCopyInlet(int lev);
- void cudaFreeInlet(int lev);
- void cudaAllocOutlet(int lev);
- void cudaCopyOutlet(int lev);
- void cudaFreeOutlet(int lev);
-
-
- void cudaAllocPressX0(int lev);
- void cudaCopyPressX0(int lev);
- void cudaFreePressX0(int lev);
- void cudaAllocPressX1(int lev);
- void cudaCopyPressX1(int lev);
- void cudaFreePressX1(int lev);
-
- void cudaAllocVeloPropeller(int lev);
- void cudaCopyVeloPropeller(int lev);
- void cudaFreeVeloPropeller(int lev);
-
- void cudaAllocMeasurePoints(int lev, int i);
- void cudaCopyMeasurePoints(int lev, int i);
- void cudaFreeMeasurePoints(int lev, int i);
- void cudaAllocMeasurePointsIndex(int lev);
- void cudaCopyMeasurePointsIndex(int lev);
- void cudaCopyMeasurePointsToHost(int lev);
- void cudaFreeMeasurePointsIndex(int lev);
-
- void cudaAllocFsForCheckPointAndRestart(int lev);
- void cudaCopyFsForRestart(int lev);
- void cudaCopyFsForCheckPoint(int lev);
- void cudaFreeFsForCheckPointAndRestart(int lev);
-
- void cudaAllocDragLift(int lev, int numofelem);
- void cudaCopyDragLift(int lev, int numofelem);
- void cudaFreeDragLift(int lev);
-
- void cudaAlloc2ndMoments(int lev, int numofelem);
- void cudaCopy2ndMoments(int lev, int numofelem);
- void cudaFree2ndMoments(int lev);
-
- void cudaAlloc3rdMoments(int lev, int numofelem);
- void cudaCopy3rdMoments(int lev, int numofelem);
- void cudaFree3rdMoments(int lev);
-
- void cudaAllocHigherMoments(int lev, int numofelem);
- void cudaCopyHigherMoments(int lev, int numofelem);
- void cudaFreeHigherMoments(int lev);
-
- void cudaAllocForceVelo(int lev, int numofelem);
- void cudaCopyForceVelo(int lev, int numofelem);
- void cudaFreeForceVelo(int lev);
-
- void cudaAllocForcing();
- void cudaCopyForcingToDevice();
- void cudaCopyForcingToHost();
- void cudaFreeForcing();
-
- //////////////////////////////////////////////////////////////////////////
- //Particles
- void cudaAllocParticles(int lev);
- void cudaCopyParticles(int lev);
- void cudaFreeParticles(int lev);
- //random value
- void cudaAllocRandomValues();
- //////////////////////////////////////////////////////////////////////////
-
-
- //////////////////////////////////////////////////////////////////////////
- //Porous Media
- void cudaAllocPorousMedia(PorousMedia* pm, int lev);
- void cudaCopyPorousMedia(PorousMedia* pm, int lev);
- void cudaFreePorousMedia(PorousMedia* pm, int lev);
- //////////////////////////////////////////////////////////////////////////
-
-
- //////////////////////////////////////////////////////////////////////////
- //Temperature
- void cudaAllocConc(int lev);
- void cudaCopyConcDH(int lev);
- void cudaCopyConcHD(int lev);
- void cudaFreeConc(int lev);
- //////////////////////////////////////////////////////////////////////////
- void cudaAllocTempFs(int lev);
- //////////////////////////////////////////////////////////////////////////
- void cudaAllocTempPressBC(int lev);
- void cudaCopyTempPressBCHD(int lev);
- void cudaFreeTempPressBC(int lev);
- //////////////////////////////////////////////////////////////////////////
- void cudaAllocTempVeloBC(int lev);
- void cudaCopyTempVeloBCHD(int lev);
- void cudaFreeTempVeloBC(int lev);
- //////////////////////////////////////////////////////////////////////////
- void cudaAllocTempNoSlipBC(int lev);
- void cudaCopyTempNoSlipBCHD(int lev);
- void cudaFreeTempNoSlipBC(int lev);
- //////////////////////////////////////////////////////////////////////////
- void cudaAllocPlaneConcIn(int lev, int numofelem);
- void cudaCopyPlaneConcIn(int lev, int numofelem);
- void cudaAllocPlaneConcOut1(int lev, int numofelem);
- void cudaCopyPlaneConcOut1(int lev, int numofelem);
- void cudaAllocPlaneConcOut2(int lev, int numofelem);
- void cudaCopyPlaneConcOut2(int lev, int numofelem);
- void cudaFreePlaneConc(int lev);
- //////////////////////////////////////////////////////////////////////////
-
-
- //////////////////////////////////////////////////////////////////////////
- //1D domain decomposition
- void cudaAllocProcessNeighbor(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborFsHD(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborFsDH(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborIndex(int lev, unsigned int processNeighbor);
- void cudaFreeProcessNeighbor(int lev, unsigned int processNeighbor);
- //////////////////////////////////////////////////////////////////////////
- //3D domain decomposition
- void cudaAllocProcessNeighborX(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborXFsHD(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborXFsDH(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborXIndex(int lev, unsigned int processNeighbor);
- void cudaFreeProcessNeighborX(int lev, unsigned int processNeighbor);
- //
- void cudaAllocProcessNeighborY(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborYFsHD(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborYFsDH(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborYIndex(int lev, unsigned int processNeighbor);
- void cudaFreeProcessNeighborY(int lev, unsigned int processNeighbor);
- //
- void cudaAllocProcessNeighborZ(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborZFsHD(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborZFsDH(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborZIndex(int lev, unsigned int processNeighbor);
- void cudaFreeProcessNeighborZ(int lev, unsigned int processNeighbor);
- //////////////////////////////////////////////////////////////////////////
- //3D domain decomposition convection diffusion
- void cudaAllocProcessNeighborADX(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADXFsHD(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADXFsDH(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADXIndex(int lev, unsigned int processNeighbor);
- void cudaFreeProcessNeighborADX(int lev, unsigned int processNeighbor);
- //
- void cudaAllocProcessNeighborADY(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADYFsHD(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADYFsDH(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADYIndex(int lev, unsigned int processNeighbor);
- void cudaFreeProcessNeighborADY(int lev, unsigned int processNeighbor);
- //
- void cudaAllocProcessNeighborADZ(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADZFsHD(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADZFsDH(int lev, unsigned int processNeighbor);
- void cudaCopyProcessNeighborADZIndex(int lev, unsigned int processNeighbor);
- void cudaFreeProcessNeighborADZ(int lev, unsigned int processNeighbor);
- //////////////////////////////////////////////////////////////////////////
-
-
-
-
-
//////////////////////////////////////////////////////////////////////////
//setter
void setForcing(real forcingX, real forcingY, real forcingZ);