From 88120e950c6c6cb3bc9602a61b031762449a4a45 Mon Sep 17 00:00:00 2001
From: Timon Habenicht <t.habenicht@tu-bs.de>
Date: Thu, 13 Jun 2019 11:37:51 +0200
Subject: [PATCH] moves all CUDA functions from Parameter to CudaMemoryManager
---
.../Calculation/Calc2ndMoments.cpp | 24 +-
.../Calculation/Calc2ndMoments.h | 13 +-
.../Calculation/CalcMedian.cpp | 4 +-
.../Calculation/CalcMedian.h | 3 +-
src/VirtualFluids_GPU/Calculation/Cp.cpp | 24 +-
src/VirtualFluids_GPU/Calculation/Cp.h | 11 +-
.../Calculation/DragLift.cpp | 12 +-
src/VirtualFluids_GPU/Calculation/DragLift.h | 7 +-
.../Calculation/ForceCalculations.cpp | 8 +-
.../Calculation/ForceCalculations.h | 4 +-
.../Calculation/PlaneCalculations.cpp | 24 +-
.../Calculation/PlaneCalculations.h | 9 +-
.../Calculation/UpdateGrid27.cpp | 52 +-
.../Calculation/UpdateGrid27.h | 3 +-
.../Communication/ExchangeData27.cpp | 84 +-
.../Communication/ExchangeData27.h | 29 +-
.../DataStructureInitializer/GridProvider.cpp | 8 +-
.../DataStructureInitializer/GridProvider.h | 4 +-
.../GridReaderFiles/GridReader.cpp | 28 +-
.../GridReaderFiles/GridReader.h | 2 +-
.../GridReaderGenerator/GridGenerator.cpp | 20 +-
.../GridReaderGenerator/GridGenerator.h | 2 +-
src/VirtualFluids_GPU/FindQ/DefineBCs.cpp | 22 +-
src/VirtualFluids_GPU/FindQ/DefineBCs.h | 7 +-
.../GPU/CudaMemoryManager.cpp | 1887 +++++++++++++-
src/VirtualFluids_GPU/GPU/CudaMemoryManager.h | 224 +-
src/VirtualFluids_GPU/Init/DefineGrid.cpp | 30 +-
src/VirtualFluids_GPU/Init/DefineGrid.h | 3 +-
src/VirtualFluids_GPU/Init/InitLattice.cpp | 7 +-
src/VirtualFluids_GPU/Init/InitLattice.h | 3 +-
src/VirtualFluids_GPU/Init/VfReader.cpp | 66 +-
src/VirtualFluids_GPU/Init/VfReader.h | 24 +-
src/VirtualFluids_GPU/LBM/Simulation.cpp | 130 +-
src/VirtualFluids_GPU/LBM/Simulation.h | 4 +-
src/VirtualFluids_GPU/Output/DataWriter.h | 3 +-
src/VirtualFluids_GPU/Output/FileWriter.cpp | 5 +-
src/VirtualFluids_GPU/Output/FileWriter.h | 3 +-
src/VirtualFluids_GPU/Output/WriteData.cpp | 13 +-
src/VirtualFluids_GPU/Output/WriteData.h | 5 +-
src/VirtualFluids_GPU/Parameter/Parameter.cpp | 2322 -----------------
src/VirtualFluids_GPU/Parameter/Parameter.h | 271 +-
src/VirtualFluids_GPU/Particles/Particles.cpp | 12 +-
src/VirtualFluids_GPU/Particles/Particles.h | 7 +-
.../Temperature/FindTemperature.cpp | 28 +-
.../Temperature/FindTemperature.h | 10 +-
.../Utilities/DataWriter/ToVectorWriter.cpp | 17 +-
.../Utilities/DataWriter/ToVectorWriter.h | 2 +-
.../NumericalTestGridReader.cpp | 6 +-
.../NumericalTestGridReader.h | 4 +-
.../VirtualFluidSimulationImp.cpp | 7 +-
.../VirtualFluidSimulationImp.h | 3 +
.../VirtualFluidSimulationFactoryImp.cpp | 16 +-
.../VirtualFluidSimulationFactoryImp.h | 4 +-
53 files changed, 2537 insertions(+), 2983 deletions(-)
diff --git a/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.cpp b/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.cpp
index 0913cf627..262a49eaa 100644
--- a/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.cpp
+++ b/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.cpp
@@ -2,13 +2,13 @@
#include <cuda_runtime.h>
#include <helper_cuda.h>
-void alloc2ndMoments(Parameter* para)
+void alloc2ndMoments(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
//////////////////////////////////////////////////////////////////////////
//allocation (device-memory + host-memory)
- para->cudaAlloc2ndMoments(lev, para->getParH(lev)->size_Mat_SP);
+ cudaManager->cudaAlloc2ndMoments(lev, para->getParH(lev)->size_Mat_SP);
//////////////////////////////////////////////////////////////////////////
}
}
@@ -35,7 +35,7 @@ void init2ndMoments(Parameter* para)
-void calc2ndMoments(Parameter* para)
+void calc2ndMoments(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
@@ -56,7 +56,7 @@ void calc2ndMoments(Parameter* para)
para->getParD(lev)->evenOrOdd);
//////////////////////////////////////////////////////////////////////////
//copy results to host
- para->cudaCopy2ndMoments(lev, para->getParH(lev)->size_Mat_SP);
+ cudaManager->cudaCopy2ndMoments(lev, para->getParH(lev)->size_Mat_SP);
//////////////////////////////////////////////////////////////////////////
}
}
@@ -97,13 +97,13 @@ void calc2ndMoments(Parameter* para)
-void alloc3rdMoments(Parameter* para)
+void alloc3rdMoments(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
//////////////////////////////////////////////////////////////////////////
//allocation (device-memory + host-memory)
- para->cudaAlloc3rdMoments(lev, para->getParH(lev)->size_Mat_SP);
+ cudaManager->cudaAlloc3rdMoments(lev, para->getParH(lev)->size_Mat_SP);
//////////////////////////////////////////////////////////////////////////
}
}
@@ -132,7 +132,7 @@ void init3rdMoments(Parameter* para)
-void calc3rdMoments(Parameter* para)
+void calc3rdMoments(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
@@ -155,7 +155,7 @@ void calc3rdMoments(Parameter* para)
para->getParD(lev)->evenOrOdd);
//////////////////////////////////////////////////////////////////////////
//copy results to host
- para->cudaCopy3rdMoments(lev, para->getParH(lev)->size_Mat_SP);
+ cudaManager->cudaCopy3rdMoments(lev, para->getParH(lev)->size_Mat_SP);
//////////////////////////////////////////////////////////////////////////
}
}
@@ -196,13 +196,13 @@ void calc3rdMoments(Parameter* para)
-void allocHigherOrderMoments(Parameter* para)
+void allocHigherOrderMoments(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
//////////////////////////////////////////////////////////////////////////
//allocation (device-memory + host-memory)
- para->cudaAllocHigherMoments(lev, para->getParH(lev)->size_Mat_SP);
+ cudaManager->cudaAllocHigherMoments(lev, para->getParH(lev)->size_Mat_SP);
//////////////////////////////////////////////////////////////////////////
}
}
@@ -234,7 +234,7 @@ void initHigherOrderMoments(Parameter* para)
-void calcHigherOrderMoments(Parameter* para)
+void calcHigherOrderMoments(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
@@ -260,7 +260,7 @@ void calcHigherOrderMoments(Parameter* para)
para->getParD(lev)->evenOrOdd);
//////////////////////////////////////////////////////////////////////////
//copy results to host
- para->cudaCopyHigherMoments(lev, para->getParH(lev)->size_Mat_SP);
+ cudaManager->cudaCopyHigherMoments(lev, para->getParH(lev)->size_Mat_SP);
//////////////////////////////////////////////////////////////////////////
}
}
diff --git a/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.h b/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.h
index 2ac6a59b9..db37289c3 100644
--- a/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.h
+++ b/src/VirtualFluids_GPU/Calculation/Calc2ndMoments.h
@@ -4,20 +4,21 @@
#include "LBM/LB.h"
#include "GPU/GPU_Interface.h"
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
//2nd
-extern "C" void alloc2ndMoments(Parameter* para);
+extern "C" void alloc2ndMoments(Parameter* para, CudaMemoryManager* cudaManager);
extern "C" void init2ndMoments(Parameter* para);
-extern "C" void calc2ndMoments(Parameter* para);
+extern "C" void calc2ndMoments(Parameter* para, CudaMemoryManager* cudaManager);
//3rd
-extern "C" void alloc3rdMoments(Parameter* para);
+extern "C" void alloc3rdMoments(Parameter* para, CudaMemoryManager* cudaManager);
extern "C" void init3rdMoments(Parameter* para);
-extern "C" void calc3rdMoments(Parameter* para);
+extern "C" void calc3rdMoments(Parameter* para, CudaMemoryManager* cudaManager);
//higher order
-extern "C" void allocHigherOrderMoments(Parameter* para);
+extern "C" void allocHigherOrderMoments(Parameter* para, CudaMemoryManager* cudaManager);
extern "C" void initHigherOrderMoments(Parameter* para);
-extern "C" void calcHigherOrderMoments(Parameter* para);
+extern "C" void calcHigherOrderMoments(Parameter* para, CudaMemoryManager* cudaManager);
#endif
diff --git a/src/VirtualFluids_GPU/Calculation/CalcMedian.cpp b/src/VirtualFluids_GPU/Calculation/CalcMedian.cpp
index 4412dcc99..c023cf6f7 100644
--- a/src/VirtualFluids_GPU/Calculation/CalcMedian.cpp
+++ b/src/VirtualFluids_GPU/Calculation/CalcMedian.cpp
@@ -2,11 +2,11 @@
#include <cuda_runtime.h>
#include <helper_cuda.h>
-void allocMedian(Parameter* para)
+void allocMedian(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaAllocMedianOut(lev);
+ cudaManager->cudaAllocMedianOut(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/VirtualFluids_GPU/Calculation/CalcMedian.h b/src/VirtualFluids_GPU/Calculation/CalcMedian.h
index 70e186761..8e385c46d 100644
--- a/src/VirtualFluids_GPU/Calculation/CalcMedian.h
+++ b/src/VirtualFluids_GPU/Calculation/CalcMedian.h
@@ -4,8 +4,9 @@
#include "LBM/LB.h"
#include "GPU/GPU_Interface.h"
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
-extern "C" void allocMedian(Parameter* para);
+extern "C" void allocMedian(Parameter* para, CudaMemoryManager* cudaManager);
extern "C" void calcMedian(Parameter* para, unsigned int tdiff);
extern "C" void resetMedian(Parameter* para);
diff --git a/src/VirtualFluids_GPU/Calculation/Cp.cpp b/src/VirtualFluids_GPU/Calculation/Cp.cpp
index 3c7f56f2b..1d4039e38 100644
--- a/src/VirtualFluids_GPU/Calculation/Cp.cpp
+++ b/src/VirtualFluids_GPU/Calculation/Cp.cpp
@@ -14,13 +14,13 @@ using namespace std;
-void calcCp(Parameter* para, int lev)
+void calcCp(Parameter* para, CudaMemoryManager* cudaManager, int lev)
{
//////////////////////////////////////////////////////////////////////////
//copy to host
- para->cudaCopyCpTop(lev);
- para->cudaCopyCpBottom(lev);
- para->cudaCopyCpBottom2(lev);
+ cudaManager->cudaCopyCpTop(lev);
+ cudaManager->cudaCopyCpBottom(lev);
+ cudaManager->cudaCopyCpBottom2(lev);
//////////////////////////////////////////////////////////////////////////
//Parameter
double rhoSI = 1.204; // kg/m^3
@@ -94,7 +94,7 @@ void printCpTopIntermediateStep(Parameter* para, unsigned int t, int lev)
-void printCpTop(Parameter* para, int lev)
+void printCpTop(Parameter* para, CudaMemoryManager* cudaManager, int lev)
{
//////////////////////////////////////////////////////////////////////////
//set filename
@@ -121,13 +121,13 @@ void printCpTop(Parameter* para, int lev)
ostr.close();
//////////////////////////////////////////////////////////////////////////
para->getParH(lev)->cpTop.clear();
- para->cudaFreeCpTop(lev);
+ cudaManager->cudaFreeCpTop(lev);
//////////////////////////////////////////////////////////////////////////
}
-void printCpBottom(Parameter* para)
+void printCpBottom(Parameter* para, CudaMemoryManager* cudaManager)
{
//////////////////////////////////////////////////////////////////////////
//set level
@@ -157,13 +157,13 @@ void printCpBottom(Parameter* para)
ostr.close();
//////////////////////////////////////////////////////////////////////////
para->getParH(lev)->cpBottom.clear();
- para->cudaFreeCpBottom(lev);
+ cudaManager->cudaFreeCpBottom(lev);
//////////////////////////////////////////////////////////////////////////
}
-void printCpBottom2(Parameter* para)
+void printCpBottom2(Parameter* para, CudaMemoryManager* cudaManager)
{
//////////////////////////////////////////////////////////////////////////
//set level
@@ -193,7 +193,7 @@ void printCpBottom2(Parameter* para)
ostr.close();
//////////////////////////////////////////////////////////////////////////
para->getParH(lev)->cpBottom2.clear();
- para->cudaFreeCpBottom2(lev);
+ cudaManager->cudaFreeCpBottom2(lev);
//////////////////////////////////////////////////////////////////////////
}
@@ -280,11 +280,11 @@ void excludeGridInterfaceNodesForMirror(Parameter* para, int lev)
-void calcPressForMirror(Parameter* para, int lev)
+void calcPressForMirror(Parameter* para, CudaMemoryManager* cudaManager, int lev)
{
//////////////////////////////////////////////////////////////////////////
//copy to host
- para->cudaCopyCpTop(lev);
+ cudaManager->cudaCopyCpTop(lev);
//////////////////////////////////////////////////////////////////////////
//Parameter
double pressSI;
diff --git a/src/VirtualFluids_GPU/Calculation/Cp.h b/src/VirtualFluids_GPU/Calculation/Cp.h
index 8993e599f..203566c5a 100644
--- a/src/VirtualFluids_GPU/Calculation/Cp.h
+++ b/src/VirtualFluids_GPU/Calculation/Cp.h
@@ -5,17 +5,18 @@
#include "GPU/GPU_Interface.h"
#include "Utilities/StringUtil.hpp"
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
-extern "C" void calcCp(Parameter* para, int lev);
+extern "C" void calcCp(Parameter* para, CudaMemoryManager* cudaManager, int lev);
extern "C" void printCpTopIntermediateStep(Parameter* para, unsigned int t, int lev);
-extern "C" void printCpTop(Parameter* para, int lev);
-extern "C" void printCpBottom(Parameter* para);
-extern "C" void printCpBottom2(Parameter* para);
+extern "C" void printCpTop(Parameter* para, CudaMemoryManager* cudaManager, int lev);
+extern "C" void printCpBottom(Parameter* para, CudaMemoryManager* cudaManager);
+extern "C" void printCpBottom2(Parameter* para, CudaMemoryManager* cudaManager);
extern "C" void excludeGridInterfaceNodesForMirror(Parameter* para, int lev);
-extern "C" void calcPressForMirror(Parameter* para, int lev);
+extern "C" void calcPressForMirror(Parameter* para, CudaMemoryManager* cudaManager, int lev);
//Ensight Gold
extern "C" void printCaseFile(Parameter* para);
extern "C" void printGeoFile(Parameter* para, bool fileFormat);
diff --git a/src/VirtualFluids_GPU/Calculation/DragLift.cpp b/src/VirtualFluids_GPU/Calculation/DragLift.cpp
index 73a4e1ba8..f7e47ae13 100644
--- a/src/VirtualFluids_GPU/Calculation/DragLift.cpp
+++ b/src/VirtualFluids_GPU/Calculation/DragLift.cpp
@@ -14,13 +14,13 @@ using namespace std;
-void calcDragLift(Parameter* para, int lev)
+void calcDragLift(Parameter* para, CudaMemoryManager* cudaManager, int lev)
{
//////////////////////////////////////////////////////////////////////////
//copy to host
//finest Grid ... with the geometry nodes
//please test -> Copy == Alloc ??
- para->cudaCopyDragLift(lev, para->getParH(lev)->QGeom.kQ);
+ cudaManager->cudaCopyDragLift(lev, para->getParH(lev)->QGeom.kQ);
//////////////////////////////////////////////////////////////////////////
//calc drag
double dragX = 0., dragY = 0., dragZ = 0.;
@@ -74,7 +74,7 @@ void calcDragLift(Parameter* para, int lev)
-void allocDragLift(Parameter* para)
+void allocDragLift(Parameter* para, CudaMemoryManager* cudaManager)
{
//////////////////////////////////////////////////////////////////////////
//set level
@@ -83,14 +83,14 @@ void allocDragLift(Parameter* para)
//allocation
//finest Grid ... with the geometry nodes
//please test -> Copy == Alloc ??
- para->cudaAllocDragLift(lev, para->getParH(lev)->QGeom.kQ);
+ cudaManager->cudaAllocDragLift(lev, para->getParH(lev)->QGeom.kQ);
//////////////////////////////////////////////////////////////////////////
printf("\n Anzahl Elemente fuer Drag Lift = %d \n", para->getParH(lev)->QGeom.kQ);
}
-void printDragLift(Parameter* para, int timestep)
+void printDragLift(Parameter* para, CudaMemoryManager* cudaManager, int timestep)
{
//////////////////////////////////////////////////////////////////////////
//set level
@@ -117,7 +117,7 @@ void printDragLift(Parameter* para, int timestep)
//////////////////////////////////////////////////////////////////////////
if (timestep == para->getTEnd())
{
- para->cudaFreeDragLift(lev);
+ cudaManager->cudaFreeDragLift(lev);
}
//////////////////////////////////////////////////////////////////////////
}
\ No newline at end of file
diff --git a/src/VirtualFluids_GPU/Calculation/DragLift.h b/src/VirtualFluids_GPU/Calculation/DragLift.h
index 3ff0af9e6..31ec90fd4 100644
--- a/src/VirtualFluids_GPU/Calculation/DragLift.h
+++ b/src/VirtualFluids_GPU/Calculation/DragLift.h
@@ -5,9 +5,10 @@
#include "GPU/GPU_Interface.h"
#include "Utilities/StringUtil.hpp"
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
-extern "C" void calcDragLift(Parameter* para, int lev);
-extern "C" void allocDragLift(Parameter* para);
-extern "C" void printDragLift(Parameter* para, int timestep);
+extern "C" void calcDragLift(Parameter* para, CudaMemoryManager* cudaManager, int lev);
+extern "C" void allocDragLift(Parameter* para, CudaMemoryManager* cudaManager);
+extern "C" void printDragLift(Parameter* para, CudaMemoryManager* cudaManager, int timestep);
#endif
diff --git a/src/VirtualFluids_GPU/Calculation/ForceCalculations.cpp b/src/VirtualFluids_GPU/Calculation/ForceCalculations.cpp
index b72b692e4..6b5356d84 100644
--- a/src/VirtualFluids_GPU/Calculation/ForceCalculations.cpp
+++ b/src/VirtualFluids_GPU/Calculation/ForceCalculations.cpp
@@ -8,6 +8,8 @@
#include <fstream>
#include <sstream>
#include "utilities/StringUtil/StringUtil.h"
+#include "GPU/CudaMemoryManager.h"
+
using namespace std;
//////////////////////////////////////////////////////////////////////////
@@ -39,7 +41,7 @@ ForceCalculations::~ForceCalculations()
-void ForceCalculations::calcPIDControllerForForce(Parameter* para)
+void ForceCalculations::calcPIDControllerForForce(Parameter* para, CudaMemoryManager* cudaManager)
{
//////////////////////////////////////////////////////////////////////////
double tempVeloX = 0.0, tempVeloY = 0.0, tempVeloZ = 0.0;
@@ -69,7 +71,7 @@ void ForceCalculations::calcPIDControllerForForce(Parameter* para)
para->getParD(lev)->evenOrOdd);
getLastCudaError("CalcMacSP27 execution failed");
//////////////////////////////////////////////////////////////////
- para->cudaCopyPrint(lev);
+ cudaManager->cudaCopyPrint(lev);
// para->cudaCopyForceVelo(i,numberOfElements);
//////////////////////////////////////////////////////////////////
for (int j = 0; j < numberOfElements; j++)
@@ -114,7 +116,7 @@ void ForceCalculations::calcPIDControllerForForce(Parameter* para)
para->getForcesHost()[1] = (real)(para->getForcesHost()[1] + y) * (real)0.0;
para->getForcesHost()[2] = (real)(para->getForcesHost()[2] + y) * (real)0.0;
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyForcingToDevice();
+ cudaManager->cudaCopyForcingToDevice();
//////////////////////////////////////////////////////////////////////////
}
diff --git a/src/VirtualFluids_GPU/Calculation/ForceCalculations.h b/src/VirtualFluids_GPU/Calculation/ForceCalculations.h
index 90bd5f3ac..3f69a6119 100644
--- a/src/VirtualFluids_GPU/Calculation/ForceCalculations.h
+++ b/src/VirtualFluids_GPU/Calculation/ForceCalculations.h
@@ -7,12 +7,14 @@
#include <iostream>
#include <stdio.h>
+class CudaMemoryManager;
+
class ForceCalculations
{
public:
ForceCalculations(Parameter* para);
~ForceCalculations();
- void calcPIDControllerForForce(Parameter* para);
+ void calcPIDControllerForForce(Parameter* para, CudaMemoryManager* cudaManager);
void printForcing(Parameter* para);
private:
diff --git a/src/VirtualFluids_GPU/Calculation/PlaneCalculations.cpp b/src/VirtualFluids_GPU/Calculation/PlaneCalculations.cpp
index f0c928f6c..c4dad6256 100644
--- a/src/VirtualFluids_GPU/Calculation/PlaneCalculations.cpp
+++ b/src/VirtualFluids_GPU/Calculation/PlaneCalculations.cpp
@@ -162,7 +162,7 @@ void calcFlowRate(Parameter* para, int lev)
//advection + diffusion
//////////////////////////////////////////////////////////////////////////
-void calcPlaneConc(Parameter* para, int lev)
+void calcPlaneConc(Parameter* para, CudaMemoryManager* cudaManager, int lev)
{
//////////////////////////////////////////////////////////////////////////
//copy to host
@@ -180,9 +180,9 @@ void calcPlaneConc(Parameter* para, int lev)
////Version cp bottom
//unsigned int NoN = para->getParH(lev)->numberOfPointsCpBottom;
- para->cudaCopyPlaneConcIn(lev, NoNin);
- para->cudaCopyPlaneConcOut1(lev, NoNout1);
- para->cudaCopyPlaneConcOut2(lev, NoNout2);
+ cudaManager->cudaCopyPlaneConcIn(lev, NoNin);
+ cudaManager->cudaCopyPlaneConcOut1(lev, NoNout1);
+ cudaManager->cudaCopyPlaneConcOut2(lev, NoNout2);
////////////////////////////////////////////
//calculate concentration
double concPlaneIn = 0.;
@@ -235,7 +235,7 @@ void calcPlaneConc(Parameter* para, int lev)
-void allocPlaneConc(Parameter* para)
+void allocPlaneConc(Parameter* para, CudaMemoryManager* cudaManager)
{
//////////////////////////////////////////////////////////////////////////
//set level ---> maybe we need a loop
@@ -246,9 +246,9 @@ void allocPlaneConc(Parameter* para)
//please test -> Copy == Alloc ??
////////////////////////////////////////////
//Version Press neighbor
- para->cudaAllocPlaneConcIn(lev, para->getParH(lev)->numberOfPointsCpTop);
- para->cudaAllocPlaneConcOut1(lev, para->getParH(lev)->numberOfPointsCpBottom);
- para->cudaAllocPlaneConcOut2(lev, para->getParH(lev)->QPress.kQ);
+ cudaManager->cudaAllocPlaneConcIn(lev, para->getParH(lev)->numberOfPointsCpTop);
+ cudaManager->cudaAllocPlaneConcOut1(lev, para->getParH(lev)->numberOfPointsCpBottom);
+ cudaManager->cudaAllocPlaneConcOut2(lev, para->getParH(lev)->QPress.kQ);
printf("\n Number of elements plane concentration = %d + %d + %d \n", para->getParH(lev)->numberOfPointsCpTop, para->getParH(lev)->numberOfPointsCpBottom, para->getParH(lev)->QPress.kQ);
////////////////////////////////////////////
////Version cp top
@@ -263,7 +263,7 @@ void allocPlaneConc(Parameter* para)
-void printPlaneConc(Parameter* para)
+void printPlaneConc(Parameter* para, CudaMemoryManager* cudaManager)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//set level ---> maybe we need a loop
@@ -328,7 +328,7 @@ void printPlaneConc(Parameter* para)
//close file
ostrOut2.close();
//////////////////////////////////////////////////////////////////////////
- para->cudaFreePlaneConc(lev);
+ cudaManager->cudaFreePlaneConc(lev);
//////////////////////////////////////////////////////////////////////////
}
@@ -338,7 +338,7 @@ void printPlaneConc(Parameter* para)
//////////////////////////////////////////////////////////////////////////
//Print Test round of Error
-void printRE(Parameter* para, int timestep)
+void printRE(Parameter* para, CudaMemoryManager* cudaManager, int timestep)
{
//////////////////////////////////////////////////////////////////////////
//set level
@@ -380,7 +380,7 @@ void printRE(Parameter* para, int timestep)
//////////////////////////////////////////////////////////////////////////
if (timestep == para->getTEnd())
{
- para->cudaFreeTestRE(lev);
+ cudaManager->cudaFreeTestRE(lev);
}
//////////////////////////////////////////////////////////////////////////
}
diff --git a/src/VirtualFluids_GPU/Calculation/PlaneCalculations.h b/src/VirtualFluids_GPU/Calculation/PlaneCalculations.h
index c68196f2e..67cb7e2fe 100644
--- a/src/VirtualFluids_GPU/Calculation/PlaneCalculations.h
+++ b/src/VirtualFluids_GPU/Calculation/PlaneCalculations.h
@@ -2,6 +2,7 @@
#define PLANE_CALCULATIONS_H
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
#include "Utilities/StringUtil.hpp"
#include "basics/utilities/UbSystem.h"
@@ -13,10 +14,10 @@ extern "C" void calcPressure(Parameter* para, std::string inorout, int lev);
extern "C" void calcFlowRate(Parameter* para, int lev);
//advection + diffusion
-extern "C" void calcPlaneConc(Parameter* para, int lev);
-extern "C" void allocPlaneConc(Parameter* para);
-extern "C" void printPlaneConc(Parameter* para);
+extern "C" void calcPlaneConc(Parameter* para, CudaMemoryManager* cudaManager, int lev);
+extern "C" void allocPlaneConc(Parameter* para, CudaMemoryManager* cudaManager);
+extern "C" void printPlaneConc(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void printRE(Parameter* para, int timestep);
+extern "C" void printRE(Parameter* para, CudaMemoryManager* cudaManager, int timestep);
#endif
diff --git a/src/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp b/src/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
index bdbdc5db4..c524d9e8c 100644
--- a/src/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
+++ b/src/VirtualFluids_GPU/Calculation/UpdateGrid27.cpp
@@ -10,7 +10,7 @@
-void updateGrid27(Parameter* para, Communicator* comm, std::vector<std::shared_ptr<PorousMedia>> pm, int level, int max_level, unsigned int t)
+void updateGrid27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, std::vector<std::shared_ptr<PorousMedia>> pm, int level, int max_level, unsigned int t)
{
if ( level == para->getFine() )
{
@@ -530,21 +530,21 @@ void updateGrid27(Parameter* para, Communicator* comm, std::vector<std::shared_p
//exchangePostCollDataGPU27(para, comm, level);
//3D domain decomposition
//printf("start exchange Post X (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePostCollDataXGPU27(para, comm, level);
+ exchangePostCollDataXGPU27(para, comm, cudaManager, level);
//printf("end exchange Post X (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Post Y (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePostCollDataYGPU27(para, comm, level);
+ exchangePostCollDataYGPU27(para, comm, cudaManager, level);
//printf("end exchange Post Y (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Post Z (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePostCollDataZGPU27(para, comm, level);
+ exchangePostCollDataZGPU27(para, comm, cudaManager, level);
//printf("end exchange Post Z (level: %d, myID: %d) \n", level, para->getMyID());
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
if (para->getDiffOn()==true)
{
- exchangePostCollDataADXGPU27(para, comm, level);
- exchangePostCollDataADYGPU27(para, comm, level);
- exchangePostCollDataADZGPU27(para, comm, level);
+ exchangePostCollDataADXGPU27(para, comm, cudaManager, level);
+ exchangePostCollDataADYGPU27(para, comm, cudaManager, level);
+ exchangePostCollDataADZGPU27(para, comm, cudaManager, level);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -865,21 +865,21 @@ void updateGrid27(Parameter* para, Communicator* comm, std::vector<std::shared_p
//exchangePreCollDataGPU27(para, comm, level);
//3D domain decomposition
//printf("start exchange Pre X (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePreCollDataXGPU27(para, comm, level);
+ exchangePreCollDataXGPU27(para, comm, cudaManager, level);
//printf("end exchange Pre X (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Pre Y (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePreCollDataYGPU27(para, comm, level);
+ exchangePreCollDataYGPU27(para, comm, cudaManager, level);
//printf("end exchange Pre Y (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Pre Z (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePreCollDataZGPU27(para, comm, level);
+ exchangePreCollDataZGPU27(para, comm, cudaManager, level);
//printf("end exchange Pre Z (level: %d, myID: %d) \n", level, para->getMyID());
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
if (para->getDiffOn()==true)
{
- exchangePreCollDataADXGPU27(para, comm, level);
- exchangePreCollDataADYGPU27(para, comm, level);
- exchangePreCollDataADZGPU27(para, comm, level);
+ exchangePreCollDataADXGPU27(para, comm, cudaManager, level);
+ exchangePreCollDataADYGPU27(para, comm, cudaManager, level);
+ exchangePreCollDataADZGPU27(para, comm, cudaManager, level);
}
}
@@ -924,7 +924,7 @@ void updateGrid27(Parameter* para, Communicator* comm, std::vector<std::shared_p
for (int internaltimestep=0;internaltimestep<2;internaltimestep++)
{
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- updateGrid27(para, comm, pm, level+1, max_level, t);
+ updateGrid27(para, comm, cudaManager, pm, level+1, max_level, t);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//if (t>para->getStartTurn()){
// //para->setPhi((para->getPhi()+para->getParD(level)->deltaPhi));
@@ -1428,21 +1428,21 @@ void updateGrid27(Parameter* para, Communicator* comm, std::vector<std::shared_p
//exchangePostCollDataGPU27(para, comm, level);
//3D domain decomposition
//printf("start exchange Post X (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePostCollDataXGPU27(para, comm, level);
+ exchangePostCollDataXGPU27(para, comm, cudaManager, level);
//printf("end exchange Post X (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Post Y (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePostCollDataYGPU27(para, comm, level);
+ exchangePostCollDataYGPU27(para, comm, cudaManager, level);
//printf("end exchange Post Y (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Post Z (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePostCollDataZGPU27(para, comm, level);
+ exchangePostCollDataZGPU27(para, comm, cudaManager, level);
//printf("end exchange Post Z (level: %d, myID: %d) \n", level, para->getMyID());
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
if (para->getDiffOn()==true)
{
- exchangePostCollDataADXGPU27(para, comm, level);
- exchangePostCollDataADYGPU27(para, comm, level);
- exchangePostCollDataADZGPU27(para, comm, level);
+ exchangePostCollDataADXGPU27(para, comm, cudaManager, level);
+ exchangePostCollDataADYGPU27(para, comm, cudaManager, level);
+ exchangePostCollDataADZGPU27(para, comm, cudaManager, level);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1680,21 +1680,21 @@ void updateGrid27(Parameter* para, Communicator* comm, std::vector<std::shared_p
//exchangePreCollDataGPU27(para, comm, level);
//3D domain decomposition
//printf("start exchange Pre X (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePreCollDataXGPU27(para, comm, level);
+ exchangePreCollDataXGPU27(para, comm, cudaManager, level);
//printf("end exchange Pre X (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Pre Y (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePreCollDataYGPU27(para, comm, level);
+ exchangePreCollDataYGPU27(para, comm, cudaManager, level);
//printf("end exchange Pre Y (level: %d, myID: %d) \n", level, para->getMyID());
//printf("start exchange Pre Z (level: %d, myID: %d) \n", level, para->getMyID());
- exchangePreCollDataZGPU27(para, comm, level);
+ exchangePreCollDataZGPU27(para, comm, cudaManager, level);
//printf("end exchange Pre Z (level: %d, myID: %d) \n", level, para->getMyID());
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
if (para->getDiffOn()==true)
{
- exchangePreCollDataADXGPU27(para, comm, level);
- exchangePreCollDataADYGPU27(para, comm, level);
- exchangePreCollDataADZGPU27(para, comm, level);
+ exchangePreCollDataADXGPU27(para, comm, cudaManager, level);
+ exchangePreCollDataADYGPU27(para, comm, cudaManager, level);
+ exchangePreCollDataADZGPU27(para, comm, cudaManager, level);
}
}
//////////////////////////////////////////////////////////////////////////////////
diff --git a/src/VirtualFluids_GPU/Calculation/UpdateGrid27.h b/src/VirtualFluids_GPU/Calculation/UpdateGrid27.h
index cb0bacc7b..e18a0ba54 100644
--- a/src/VirtualFluids_GPU/Calculation/UpdateGrid27.h
+++ b/src/VirtualFluids_GPU/Calculation/UpdateGrid27.h
@@ -4,9 +4,10 @@
#include "LBM/LB.h"
#include "GPU/GPU_Interface.h"
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
#include "Communication/Communicator.h"
#include "Calculation/PorousMedia.h"
-extern "C" void updateGrid27(Parameter* para, Communicator* comm, std::vector<std::shared_ptr<PorousMedia>> pm, int level, int max_level, unsigned int t);
+extern "C" void updateGrid27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, std::vector<std::shared_ptr<PorousMedia>> pm, int level, int max_level, unsigned int t);
#endif
diff --git a/src/VirtualFluids_GPU/Communication/ExchangeData27.cpp b/src/VirtualFluids_GPU/Communication/ExchangeData27.cpp
index c4a711645..881b98f3c 100644
--- a/src/VirtualFluids_GPU/Communication/ExchangeData27.cpp
+++ b/src/VirtualFluids_GPU/Communication/ExchangeData27.cpp
@@ -7,7 +7,7 @@
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// X
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePreCollDataXGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePreCollDataXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -24,7 +24,7 @@ void exchangePreCollDataXGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborXFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborXFsDH(level, i);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -72,7 +72,7 @@ void exchangePreCollDataXGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsX(level, "send")); i++)
{
- para->cudaCopyProcessNeighborXFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborXFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPreDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighborX[i].f[0],
@@ -88,7 +88,7 @@ void exchangePreCollDataXGPU27(Parameter* para, Communicator* comm, int level)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePostCollDataXGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePostCollDataXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -105,7 +105,7 @@ void exchangePostCollDataXGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborXFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborXFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -153,7 +153,7 @@ void exchangePostCollDataXGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsX(level, "send")); i++)
{
- para->cudaCopyProcessNeighborXFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborXFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPostDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighborX[i].f[0],
@@ -176,7 +176,7 @@ void exchangePostCollDataXGPU27(Parameter* para, Communicator* comm, int level)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Y
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePreCollDataYGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePreCollDataYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -193,7 +193,7 @@ void exchangePreCollDataYGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborYFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborYFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -241,7 +241,7 @@ void exchangePreCollDataYGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsY(level, "send")); i++)
{
- para->cudaCopyProcessNeighborYFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborYFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPreDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighborY[i].f[0],
@@ -257,7 +257,7 @@ void exchangePreCollDataYGPU27(Parameter* para, Communicator* comm, int level)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePostCollDataYGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePostCollDataYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -274,7 +274,7 @@ void exchangePostCollDataYGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborYFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborYFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -322,7 +322,7 @@ void exchangePostCollDataYGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsY(level, "send")); i++)
{
- para->cudaCopyProcessNeighborYFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborYFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPostDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighborY[i].f[0],
@@ -345,7 +345,7 @@ void exchangePostCollDataYGPU27(Parameter* para, Communicator* comm, int level)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Z
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePreCollDataZGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePreCollDataZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -362,7 +362,7 @@ void exchangePreCollDataZGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborZFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborZFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -410,7 +410,7 @@ void exchangePreCollDataZGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsZ(level, "send")); i++)
{
- para->cudaCopyProcessNeighborZFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborZFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPreDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighborZ[i].f[0],
@@ -426,7 +426,7 @@ void exchangePreCollDataZGPU27(Parameter* para, Communicator* comm, int level)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePostCollDataZGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePostCollDataZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -443,7 +443,7 @@ void exchangePostCollDataZGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborZFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborZFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -491,7 +491,7 @@ void exchangePostCollDataZGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsZ(level, "send")); i++)
{
- para->cudaCopyProcessNeighborZFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborZFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPostDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighborZ[i].f[0],
@@ -529,7 +529,7 @@ void exchangePostCollDataZGPU27(Parameter* para, Communicator* comm, int level)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//1D domain decomposition
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePreCollDataGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePreCollDataGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighbors(level, "send")); i++)
{
@@ -545,7 +545,7 @@ void exchangePreCollDataGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborFsDH(level, i);
//////////////////////////////////////////////////////////////////////////
comm->exchngDataGPU(para->getParH(level)->sendProcessNeighbor[i].f[0],
para->getParH(level)->sendProcessNeighbor[i].numberOfFs,
@@ -553,7 +553,7 @@ void exchangePreCollDataGPU27(Parameter* para, Communicator* comm, int level)
para->getParH(level)->recvProcessNeighbor[i].numberOfFs,
para->getParH(level)->sendProcessNeighbor[i].rankNeighbor);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPreDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighbor[i].f[0],
@@ -574,7 +574,7 @@ void exchangePreCollDataGPU27(Parameter* para, Communicator* comm, int level)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePostCollDataGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePostCollDataGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighbors(level, "send")); i++)
{
@@ -590,7 +590,7 @@ void exchangePostCollDataGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborFsDH(level, i);
//////////////////////////////////////////////////////////////////////////
comm->exchngDataGPU(para->getParH(level)->sendProcessNeighbor[i].f[0],
para->getParH(level)->sendProcessNeighbor[i].numberOfFs,
@@ -598,7 +598,7 @@ void exchangePostCollDataGPU27(Parameter* para, Communicator* comm, int level)
para->getParH(level)->recvProcessNeighbor[i].numberOfFs,
para->getParH(level)->sendProcessNeighbor[i].rankNeighbor);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPostDev27(para->getParD(level)->d0SP.f[0],
para->getParD(level)->recvProcessNeighbor[i].f[0],
@@ -932,7 +932,7 @@ void exchangePostCollDataGPU27(Parameter* para, Communicator* comm, int level)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// X
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePreCollDataADXGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePreCollDataADXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -949,7 +949,7 @@ void exchangePreCollDataADXGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborADXFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborADXFsDH(level, i);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -997,7 +997,7 @@ void exchangePreCollDataADXGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsX(level, "send")); i++)
{
- para->cudaCopyProcessNeighborADXFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborADXFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPreDev27(para->getParD(level)->d27.f[0],
para->getParD(level)->recvProcessNeighborADX[i].f[0],
@@ -1013,7 +1013,7 @@ void exchangePreCollDataADXGPU27(Parameter* para, Communicator* comm, int level)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePostCollDataADXGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePostCollDataADXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -1030,7 +1030,7 @@ void exchangePostCollDataADXGPU27(Parameter* para, Communicator* comm, int level
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborADXFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborADXFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -1078,7 +1078,7 @@ void exchangePostCollDataADXGPU27(Parameter* para, Communicator* comm, int level
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsX(level, "send")); i++)
{
- para->cudaCopyProcessNeighborADXFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborADXFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPostDev27(para->getParD(level)->d27.f[0],
para->getParD(level)->recvProcessNeighborADX[i].f[0],
@@ -1101,7 +1101,7 @@ void exchangePostCollDataADXGPU27(Parameter* para, Communicator* comm, int level
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Y
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePreCollDataADYGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePreCollDataADYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -1118,7 +1118,7 @@ void exchangePreCollDataADYGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborADYFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborADYFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -1166,7 +1166,7 @@ void exchangePreCollDataADYGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsY(level, "send")); i++)
{
- para->cudaCopyProcessNeighborADYFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborADYFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPreDev27(para->getParD(level)->d27.f[0],
para->getParD(level)->recvProcessNeighborADY[i].f[0],
@@ -1182,7 +1182,7 @@ void exchangePreCollDataADYGPU27(Parameter* para, Communicator* comm, int level)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePostCollDataADYGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePostCollDataADYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -1199,7 +1199,7 @@ void exchangePostCollDataADYGPU27(Parameter* para, Communicator* comm, int level
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborADYFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborADYFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -1247,7 +1247,7 @@ void exchangePostCollDataADYGPU27(Parameter* para, Communicator* comm, int level
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsY(level, "send")); i++)
{
- para->cudaCopyProcessNeighborADYFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborADYFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPostDev27(para->getParD(level)->d27.f[0],
para->getParD(level)->recvProcessNeighborADY[i].f[0],
@@ -1270,7 +1270,7 @@ void exchangePostCollDataADYGPU27(Parameter* para, Communicator* comm, int level
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Z
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePreCollDataADZGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePreCollDataADZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -1287,7 +1287,7 @@ void exchangePreCollDataADZGPU27(Parameter* para, Communicator* comm, int level)
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborADZFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborADZFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -1335,7 +1335,7 @@ void exchangePreCollDataADZGPU27(Parameter* para, Communicator* comm, int level)
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsZ(level, "send")); i++)
{
- para->cudaCopyProcessNeighborADZFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborADZFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPreDev27(para->getParD(level)->d27.f[0],
para->getParD(level)->recvProcessNeighborADZ[i].f[0],
@@ -1351,7 +1351,7 @@ void exchangePreCollDataADZGPU27(Parameter* para, Communicator* comm, int level)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void exchangePostCollDataADZGPU27(Parameter* para, Communicator* comm, int level)
+void exchangePostCollDataADZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Device to Host
@@ -1368,7 +1368,7 @@ void exchangePostCollDataADZGPU27(Parameter* para, Communicator* comm, int level
para->getParD(level)->evenOrOdd,
para->getParD(level)->numberofthreads);
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyProcessNeighborADZFsDH(level, i);
+ cudaManager->cudaCopyProcessNeighborADZFsDH(level, i);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//start non blocking MPI receive
@@ -1416,7 +1416,7 @@ void exchangePostCollDataADZGPU27(Parameter* para, Communicator* comm, int level
//copy Host to Device
for (unsigned int i = 0; i < (unsigned int)(para->getNumberOfProcessNeighborsZ(level, "send")); i++)
{
- para->cudaCopyProcessNeighborADZFsHD(level, i);
+ cudaManager->cudaCopyProcessNeighborADZFsHD(level, i);
//////////////////////////////////////////////////////////////////////////
SetRecvFsPostDev27(para->getParD(level)->d27.f[0],
para->getParD(level)->recvProcessNeighborADZ[i].f[0],
diff --git a/src/VirtualFluids_GPU/Communication/ExchangeData27.h b/src/VirtualFluids_GPU/Communication/ExchangeData27.h
index 26c4de465..a7ddfbdbf 100644
--- a/src/VirtualFluids_GPU/Communication/ExchangeData27.h
+++ b/src/VirtualFluids_GPU/Communication/ExchangeData27.h
@@ -5,27 +5,28 @@
#include "GPU/GPU_Interface.h"
#include "Parameter/Parameter.h"
#include "Communication/Communicator.h"
+#include "GPU/CudaMemoryManager.h"
//////////////////////////////////////////////////////////////////////////
//1D domain decomposition
-extern "C" void exchangePreCollDataGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePostCollDataGPU27(Parameter* para, Communicator* comm, int level);
+extern "C" void exchangePreCollDataGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePostCollDataGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition
-extern "C" void exchangePreCollDataXGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePreCollDataYGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePreCollDataZGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePostCollDataXGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePostCollDataYGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePostCollDataZGPU27(Parameter* para, Communicator* comm, int level);
+extern "C" void exchangePreCollDataXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePreCollDataYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePreCollDataZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePostCollDataXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePostCollDataYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePostCollDataZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
-extern "C" void exchangePreCollDataADXGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePreCollDataADYGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePreCollDataADZGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePostCollDataADXGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePostCollDataADYGPU27(Parameter* para, Communicator* comm, int level);
-extern "C" void exchangePostCollDataADZGPU27(Parameter* para, Communicator* comm, int level);
+extern "C" void exchangePreCollDataADXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePreCollDataADYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePreCollDataADZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePostCollDataADXGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePostCollDataADYGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
+extern "C" void exchangePostCollDataADZGPU27(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager, int level);
//////////////////////////////////////////////////////////////////////////
extern "C" void barrierGPU(Communicator* comm);
//////////////////////////////////////////////////////////////////////////
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp b/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp
index 3d2eae79f..1d8ce7b04 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.cpp
@@ -9,14 +9,14 @@
#include <GPU/CudaMemoryManager.h>
-std::shared_ptr<GridProvider> GridProvider::makeGridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para)
+std::shared_ptr<GridProvider> GridProvider::makeGridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager)
{
- return std::shared_ptr<GridProvider>(new GridGenerator(builder, para));
+ return std::shared_ptr<GridProvider>(new GridGenerator(builder, para, cudaManager));
}
-std::shared_ptr<GridProvider> GridProvider::makeGridReader(bool readBinaryFiles, std::shared_ptr<Parameter> para)
+std::shared_ptr<GridProvider> GridProvider::makeGridReader(bool readBinaryFiles, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager)
{
- return std::shared_ptr<GridProvider>(new GridReader(readBinaryFiles, para));
+ return std::shared_ptr<GridProvider>(new GridReader(readBinaryFiles, para, cudaManager));
}
void GridProvider::setNumberOfNodes(const int numberOfNodes, const int level) const
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.h b/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.h
index 579a43442..e63681d14 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.h
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridProvider.h
@@ -14,8 +14,8 @@ class CudaMemoryManager;
class VF_PUBLIC GridProvider
{
public:
- static std::shared_ptr<GridProvider> makeGridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para);
- static std::shared_ptr<GridProvider> makeGridReader(bool readBinaryFiles, std::shared_ptr<Parameter> para);
+ static std::shared_ptr<GridProvider> makeGridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager);
+ static std::shared_ptr<GridProvider> makeGridReader(bool readBinaryFiles, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager);
virtual void allocArrays_CoordNeighborGeo() = 0;
virtual void allocArrays_BoundaryValues() = 0;
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp
index fc5a10bd2..c73470a0a 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.cpp
@@ -11,10 +11,10 @@
#include <GPU/CudaMemoryManager.h>
#include "OffsetScale.h"
-GridReader::GridReader(bool binaer, std::shared_ptr<Parameter> para)
+GridReader::GridReader(bool binaer, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager)
{
this->para = para;
- this->cudaMemoryManager = CudaMemoryManager::make(para);
+ this->cudaMemoryManager = cudaManager;
this->binaer=binaer;
channelDirections.resize(6);
@@ -80,14 +80,14 @@ void GridReader::allocArrays_CoordNeighborGeo()
///////////////////////////
//F3
- para->cudaAllocF3SP(level);
+ cudaMemoryManager->cudaAllocF3SP(level);
///////////////////////////
if (para->getCalcMedian())
- para->cudaAllocMedianSP(level);
+ cudaMemoryManager->cudaAllocMedianSP(level);
if (para->getCalcParticle() || para->getUseWale())
- para->cudaAllocNeighborWSB(level);
+ cudaMemoryManager->cudaAllocNeighborWSB(level);
if (para->getUseWale())
- para->cudaAllocTurbulentViscosity(level);
+ cudaMemoryManager->cudaAllocTurbulentViscosity(level);
coordX.initalCoords(para->getParH(level)->coordX_SP, level);
coordY.initalCoords(para->getParH(level)->coordY_SP, level);
@@ -170,10 +170,10 @@ void GridReader::allocArrays_OffsetScale()
para->getParD(i)->mem_size_kFC_off = sizeof(real)* para->getParD(i)->K_FC;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//alloc
- para->cudaAllocInterfaceCF(i);
- para->cudaAllocInterfaceFC(i);
- para->cudaAllocInterfaceOffCF(i);
- para->cudaAllocInterfaceOffFC(i);
+ cudaMemoryManager->cudaAllocInterfaceCF(i);
+ cudaMemoryManager->cudaAllocInterfaceFC(i);
+ cudaMemoryManager->cudaAllocInterfaceOffCF(i);
+ cudaMemoryManager->cudaAllocInterfaceOffFC(i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//init
obj_offCF->initArrayOffset(para->getParH(i)->offCF.xOffCF, para->getParH(i)->offCF.yOffCF, para->getParH(i)->offCF.zOffCF, i);
@@ -184,10 +184,10 @@ void GridReader::allocArrays_OffsetScale()
obj_scaleFCF->initScale(para->getParH(i)->intFC.ICellFCF, i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy
- para->cudaCopyInterfaceCF(i);
- para->cudaCopyInterfaceFC(i);
- para->cudaCopyInterfaceOffCF(i);
- para->cudaCopyInterfaceOffFC(i);
+ cudaMemoryManager->cudaCopyInterfaceCF(i);
+ cudaMemoryManager->cudaCopyInterfaceFC(i);
+ cudaMemoryManager->cudaCopyInterfaceOffCF(i);
+ cudaMemoryManager->cudaCopyInterfaceOffFC(i);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
cout << "Gesamtanzahl Knoten CF = " << AnzahlKnotenGesCF << endl;
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.h b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.h
index 8a8810cd5..a1e8a6c7c 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.h
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.h
@@ -27,7 +27,7 @@ private:
std::vector<std::shared_ptr<BoundaryValues> > BC_Values;
public:
- GridReader(bool binaer, std::shared_ptr<Parameter> para);
+ GridReader(bool binaer, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager);
~GridReader();
void allocArrays_CoordNeighborGeo()override;
void allocArrays_BoundaryValues()override;
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
index b666b99b0..d9ffc2642 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
@@ -8,11 +8,11 @@
#include <iostream>
#include "utilities/math/Math.h"
-GridGenerator::GridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para)
+GridGenerator::GridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager)
{
this->builder = builder;
this->para = para;
- this->cudaMemoryManager = CudaMemoryManager::make(para);
+ this->cudaMemoryManager = cudaManager;
}
GridGenerator::~GridGenerator()
@@ -278,10 +278,10 @@ void GridGenerator::allocArrays_OffsetScale()
para->getParD(level)->mem_size_kFC_off = sizeof(real)* para->getParD(level)->K_FC;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//alloc
- para->cudaAllocInterfaceCF(level);
- para->cudaAllocInterfaceFC(level);
- para->cudaAllocInterfaceOffCF(level);
- para->cudaAllocInterfaceOffFC(level);
+ cudaMemoryManager->cudaAllocInterfaceCF(level);
+ cudaMemoryManager->cudaAllocInterfaceFC(level);
+ cudaMemoryManager->cudaAllocInterfaceOffCF(level);
+ cudaMemoryManager->cudaAllocInterfaceOffFC(level);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//init
builder->setOffsetCF(para->getParH(level)->offCF.xOffCF, para->getParH(level)->offCF.yOffCF, para->getParH(level)->offCF.zOffCF, level);
@@ -289,10 +289,10 @@ void GridGenerator::allocArrays_OffsetScale()
builder->getGridInterfaceIndices(para->getParH(level)->intCF.ICellCFC, para->getParH(level)->intCF.ICellCFF, para->getParH(level)->intFC.ICellFCC, para->getParH(level)->intFC.ICellFCF, level);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy
- para->cudaCopyInterfaceCF(level);
- para->cudaCopyInterfaceFC(level);
- para->cudaCopyInterfaceOffCF(level);
- para->cudaCopyInterfaceOffFC(level);
+ cudaMemoryManager->cudaCopyInterfaceCF(level);
+ cudaMemoryManager->cudaCopyInterfaceFC(level);
+ cudaMemoryManager->cudaCopyInterfaceOffCF(level);
+ cudaMemoryManager->cudaCopyInterfaceOffFC(level);
}
}
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h
index 95efb7a09..7ab3ddc68 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h
@@ -22,7 +22,7 @@ private:
std::shared_ptr<GridBuilder> builder;
public:
- VF_PUBLIC GridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para);
+ VF_PUBLIC GridGenerator(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager);
VF_PUBLIC virtual ~GridGenerator();
void allocArrays_CoordNeighborGeo() override;
diff --git a/src/VirtualFluids_GPU/FindQ/DefineBCs.cpp b/src/VirtualFluids_GPU/FindQ/DefineBCs.cpp
index 003c7ef6d..9b2635e2a 100644
--- a/src/VirtualFluids_GPU/FindQ/DefineBCs.cpp
+++ b/src/VirtualFluids_GPU/FindQ/DefineBCs.cpp
@@ -1,18 +1,18 @@
#include "FindQ/DefineBCs.h"
#include "FindQ/FindQ.h"
-void findPressQShip(Parameter* para)
+void findPressQShip(Parameter* para, CudaMemoryManager* cudaManager)
{
//x = begin (0)
findKforQPressX0(para, para->getCoarse());
- para->cudaAllocPressX0(para->getCoarse());
+ cudaManager->cudaAllocPressX0(para->getCoarse());
findQPressX0(para, para->getCoarse());
- para->cudaCopyPressX0(para->getCoarse());
+ cudaManager->cudaCopyPressX0(para->getCoarse());
//x = end (1)
findKforQPressX1(para, para->getCoarse());
- para->cudaAllocPressX1(para->getCoarse());
+ cudaManager->cudaAllocPressX1(para->getCoarse());
findQPressX1(para, para->getCoarse());
- para->cudaCopyPressX1(para->getCoarse());
+ cudaManager->cudaCopyPressX1(para->getCoarse());
//for (int lev = para->getFine(); lev >= para->getCoarse(); lev--)
//{
// findKforQPressX1(para, lev);
@@ -25,7 +25,7 @@ void findPressQShip(Parameter* para)
-void findQ27(Parameter* para)
+void findQ27(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev = para->getFine(); lev >= para->getCoarse(); lev--)
{
@@ -36,7 +36,7 @@ void findQ27(Parameter* para)
para->getParD(lev)->QWall.kQ = para->getParH(lev)->QWall.kQ;
printf("kQ= %d\n", para->getParH(lev)->kQ);
- para->cudaAllocWallBC(lev);
+ cudaManager->cudaAllocWallBC(lev);
findQ(para, lev);
@@ -45,14 +45,14 @@ void findQ27(Parameter* para)
para->getParD(lev)->QWall.kQ = para->getParH(lev)->QWall.kQ;
printf("kQ= %d\n", para->getParH(lev)->kQ);
- para->cudaCopyWallBC(lev);
+ cudaManager->cudaCopyWallBC(lev);
}
}
-void findBC27(Parameter* para)
+void findBC27(Parameter* para, CudaMemoryManager* cudaManager)
{
if ( para->getMyID() == 0)
{
@@ -64,11 +64,11 @@ void findBC27(Parameter* para)
para->getParD(para->getCoarse())->kInflowQ = para->getParH(para->getCoarse())->Qinflow.kQ;
printf("kInflowQ= %d\n", para->getParH(para->getCoarse())->kInflowQ);
- para->cudaAllocVeloBC(0); //level = 0
+ cudaManager->cudaAllocVeloBC(0); //level = 0
findQInflow(para);
- para->cudaCopyVeloBC(0); //level = 0
+ cudaManager->cudaCopyVeloBC(0); //level = 0
}
//...!!!...next if gets a block comment for a simple test...
diff --git a/src/VirtualFluids_GPU/FindQ/DefineBCs.h b/src/VirtualFluids_GPU/FindQ/DefineBCs.h
index 69d2b1818..261c20a8d 100644
--- a/src/VirtualFluids_GPU/FindQ/DefineBCs.h
+++ b/src/VirtualFluids_GPU/FindQ/DefineBCs.h
@@ -4,11 +4,12 @@
#include "LBM/LB.h"
#include "LBM/D3Q27.h"
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
-extern "C" void findQ27(Parameter* para);
+extern "C" void findQ27(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void findBC27(Parameter* para);
+extern "C" void findBC27(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void findPressQShip(Parameter* para);
+extern "C" void findPressQShip(Parameter* para, CudaMemoryManager* cudaManager);
#endif
diff --git a/src/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp b/src/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
index 208db9ccb..6989c8efc 100644
--- a/src/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
+++ b/src/VirtualFluids_GPU/GPU/CudaMemoryManager.cpp
@@ -6,6 +6,32 @@
#include <Parameter/Parameter.h>
+void CudaMemoryManager::cudaAllocFull(int lev)
+{
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->geo ), parameter->getParH(lev)->mem_size_int ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->k ), parameter->getParH(lev)->mem_size_int ));
+}
+void CudaMemoryManager::cudaFreeFull(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->geo ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->k ));
+}
+void CudaMemoryManager::cudaCopyPrint(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vx_SP , parameter->getParD(lev)->vx_SP , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vy_SP , parameter->getParD(lev)->vy_SP , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vz_SP , parameter->getParD(lev)->vz_SP , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->rho_SP , parameter->getParD(lev)->rho_SP , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->press_SP, parameter->getParD(lev)->press_SP, parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaCopyMedianPrint(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vx_SP_Med , parameter->getParD(lev)->vx_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vy_SP_Med , parameter->getParD(lev)->vy_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->vz_SP_Med , parameter->getParD(lev)->vz_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->rho_SP_Med , parameter->getParD(lev)->rho_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->press_SP_Med, parameter->getParD(lev)->press_SP_Med, parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+}
void CudaMemoryManager::cudaAllocCoord(int lev)
{
//Host
@@ -18,7 +44,7 @@ void CudaMemoryManager::cudaAllocCoord(int lev)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->coordZ_SP ), parameter->getParH(lev)->mem_size_real_SP ));
//////////////////////////////////////////////////////////////////////////
double tmp = 3. * (double)parameter->getParH(lev)->mem_size_real_SP;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyCoord(int lev)
{
@@ -68,7 +94,7 @@ void CudaMemoryManager::cudaAllocSP(int lev)
checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->d0SP.f[0] ), (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParD(lev)->mem_size_real_SP));
//////////////////////////////////////////////////////////////////////////
double tmp = 4. * (double)parameter->getParH(lev)->mem_size_int_SP + 5. * (double)parameter->getParH(lev)->mem_size_real_SP + (double)parameter->getD3Qxx() * (double)parameter->getParH(lev)->mem_size_real_SP;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopySP(int lev)
{
@@ -95,6 +121,35 @@ void CudaMemoryManager::cudaFreeSP(int lev)
checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborY_SP));
checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborZ_SP));
}
+void CudaMemoryManager::cudaAllocF3SP(int lev)
+{
+ //Device
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->g6.g[0]), (unsigned long long)6*(unsigned long long)parameter->getParD(lev)->mem_size_real_SP));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)6 * (double)parameter->getParH(lev)->mem_size_real_SP;
+ setMemsizeGPU(tmp, false);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
//Velo
void CudaMemoryManager::cudaAllocVeloBC(int lev)
{
@@ -120,7 +175,7 @@ void CudaMemoryManager::cudaAllocVeloBC(int lev)
//////////////////////////////////////////////////////////////////////////
double tmp = (double)mem_size_inflow_Q_k + 4. * (double)mem_size_inflow_Q_q + (double)parameter->getD3Qxx() * (double)mem_size_inflow_Q_q;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyVeloBC(int lev)
{
@@ -164,7 +219,7 @@ void CudaMemoryManager::cudaAllocOutflowBC(int lev)
//////////////////////////////////////////////////////////////////////////
double tmp = (double)mem_size_outflow_Q_k + 2. * (double)mem_size_outflow_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_outflow_Q_q;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyOutflowBC(int lev)
{
@@ -203,7 +258,7 @@ void CudaMemoryManager::cudaAllocWallBC(int lev)
//////////////////////////////////////////////////////////////////////////
double tmp = (double)mem_size_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyWallBC(int lev)
{
@@ -236,7 +291,7 @@ void CudaMemoryManager::cudaAllocGeomBC(int lev)
//////////////////////////////////////////////////////////////////////////
double tmp = (double)mem_size_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyGeomBC(int lev)
{
@@ -271,7 +326,7 @@ void CudaMemoryManager::cudaAllocPress(int lev)
//////////////////////////////////////////////////////////////////////////
double tmp = 2. * (double)mem_size_Q_k + (double)mem_size_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyPress(int lev)
{
@@ -303,7 +358,7 @@ void CudaMemoryManager::cudaAllocForcing()
checkCudaErrors( cudaMalloc((void**) ¶meter->forcingD, mem_size));
//////////////////////////////////////////////////////////////////////////
double tmp = (real)mem_size;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
}
void CudaMemoryManager::cudaCopyForcingToDevice()
{
@@ -341,7 +396,7 @@ void CudaMemoryManager::cudaAllocProcessNeighborX(int lev, unsigned int processN
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
double tmp = (double)parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->sendProcessNeighborX[processNeighbor].memsizeFs +
(double)parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->recvProcessNeighborX[processNeighbor].memsizeFs;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
//printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
}
void CudaMemoryManager::cudaCopyProcessNeighborXIndex(int lev, unsigned int processNeighbor)
@@ -396,7 +451,7 @@ void CudaMemoryManager::cudaAllocProcessNeighborY(int lev, unsigned int processN
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
double tmp = (double)parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->sendProcessNeighborY[processNeighbor].memsizeFs +
(double)parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->recvProcessNeighborY[processNeighbor].memsizeFs;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
//printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
}
void CudaMemoryManager::cudaCopyProcessNeighborYIndex(int lev, unsigned int processNeighbor)
@@ -451,7 +506,7 @@ void CudaMemoryManager::cudaAllocProcessNeighborZ(int lev, unsigned int processN
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
double tmp = (double)parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->sendProcessNeighborZ[processNeighbor].memsizeFs +
(double)parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].memsizeIndex + (double)parameter->getD3Qxx()*(double)parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].memsizeFs;
- parameter->setMemsizeGPU(tmp, false);
+ setMemsizeGPU(tmp, false);
//printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
}
void CudaMemoryManager::cudaCopyProcessNeighborZIndex(int lev, unsigned int processNeighbor)
@@ -488,12 +543,1822 @@ void CudaMemoryManager::cudaFreeProcessNeighborZ(int lev, unsigned int processNe
checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].index ));
checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborZ[processNeighbor].f[0] ));
}
+void CudaMemoryManager::cudaAllocNeighborWSB(int lev)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->neighborWSB_SP ), parameter->getParH(lev)->mem_size_int_SP ));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->neighborWSB_SP ), parameter->getParD(lev)->mem_size_int_SP ));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)parameter->getParH(lev)->mem_size_int_SP;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyNeighborWSB(int lev)
+{
+ //copy host to device
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->neighborWSB_SP, parameter->getParH(lev)->neighborWSB_SP, parameter->getParH(lev)->mem_size_int_SP , cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeNeighborWSB(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->neighborWSB_SP));
+}
+//turbulent viscosity
+void CudaMemoryManager::cudaAllocTurbulentViscosity(int lev)
+{
+ //Host
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->turbViscosity), parameter->getParH(lev)->mem_size_real_SP));
+ //Debug
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gSij ), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gSDij), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDxvx), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDyvx), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDzvx), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDxvy), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDyvy), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDzvy), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDxvz), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDyvz), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->gDzvz), parameter->getParH(lev)->mem_size_real_SP));
+
+ //Device
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->turbViscosity), parameter->getParD(lev)->mem_size_real_SP));
+ //Debug
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gSij ), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gSDij), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDxvx), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDyvx), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDzvx), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDxvy), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDyvy), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDzvy), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->gDxvz), parameter->getParD(lev)->mem_size_real_SP));
+ 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;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyTurbulentViscosityHD(int lev)
+{
+ //copy host to device
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->turbViscosity, parameter->getParH(lev)->turbViscosity, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ //Debug
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gSij , parameter->getParH(lev)->gSij , parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gSDij, parameter->getParH(lev)->gSDij, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDxvx, parameter->getParH(lev)->gDxvx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDyvx, parameter->getParH(lev)->gDyvx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDzvx, parameter->getParH(lev)->gDzvx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDxvy, parameter->getParH(lev)->gDxvy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDyvy, parameter->getParH(lev)->gDyvy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDzvy, parameter->getParH(lev)->gDzvy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDxvz, parameter->getParH(lev)->gDxvz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDyvz, parameter->getParH(lev)->gDyvz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->gDzvz, parameter->getParH(lev)->gDzvz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyTurbulentViscosityDH(int lev)
+{
+ //copy device to host
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->turbViscosity, parameter->getParD(lev)->turbViscosity, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ //Debug
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gSij , parameter->getParD(lev)->gSij , parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gSDij, parameter->getParD(lev)->gSDij, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDxvx, parameter->getParD(lev)->gDxvx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDyvx, parameter->getParD(lev)->gDyvx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDzvx, parameter->getParD(lev)->gDzvx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDxvy, parameter->getParD(lev)->gDxvy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDyvy, parameter->getParD(lev)->gDyvy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDzvy, parameter->getParD(lev)->gDzvy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDxvz, parameter->getParD(lev)->gDxvz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDyvz, parameter->getParD(lev)->gDyvz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->gDzvz, parameter->getParD(lev)->gDzvz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeTurbulentViscosity(int lev)
+{
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->turbViscosity));
+ //Debug
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gSij ));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gSDij));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDxvx));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDyvx));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDzvx));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDxvy));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDyvy));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDzvy));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDxvz));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDyvz));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->gDzvz));
+}
+//median
+void CudaMemoryManager::cudaAllocMedianSP(int lev)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->rho_SP_Med ), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vx_SP_Med ), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vy_SP_Med ), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->vz_SP_Med ), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->press_SP_Med ), parameter->getParH(lev)->mem_size_real_SP));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->rho_SP_Med ), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vx_SP_Med ), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vy_SP_Med ), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->vz_SP_Med ), parameter->getParD(lev)->mem_size_real_SP));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->press_SP_Med ), parameter->getParD(lev)->mem_size_real_SP));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 5. * (double)parameter->getParH(lev)->mem_size_real_SP;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyMedianSP(int lev)
+{
+ //copy host to device
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->rho_SP_Med , parameter->getParH(lev)->rho_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vx_SP_Med , parameter->getParH(lev)->vx_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vy_SP_Med , parameter->getParH(lev)->vy_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->vz_SP_Med , parameter->getParH(lev)->vz_SP_Med , parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->press_SP_Med, parameter->getParH(lev)->press_SP_Med, parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeMedianSP(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vx_SP_Med ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vy_SP_Med ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->vz_SP_Med ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->rho_SP_Med ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->press_SP_Med));
+}
+void CudaMemoryManager::cudaAllocMedianOut(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));
+}
+void CudaMemoryManager::cudaFreeMedianOut(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));
+}
+//Interface CF
+void CudaMemoryManager::cudaAllocInterfaceCF(int lev)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intCF.ICellCFC), parameter->getParH(lev)->mem_size_kCF ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intCF.ICellCFF), parameter->getParH(lev)->mem_size_kCF ));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intCF.ICellCFC), parameter->getParD(lev)->mem_size_kCF ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intCF.ICellCFF), parameter->getParD(lev)->mem_size_kCF ));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 2. * (double)parameter->getParH(lev)->mem_size_kCF;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyInterfaceCF(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intCF.ICellCFC, parameter->getParH(lev)->intCF.ICellCFC, parameter->getParH(lev)->mem_size_kCF, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intCF.ICellCFF, parameter->getParH(lev)->intCF.ICellCFF, parameter->getParH(lev)->mem_size_kCF, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeInterfaceCF(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intCF.ICellCFC));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intCF.ICellCFF));
+}
+//Interface FC
+void CudaMemoryManager::cudaAllocInterfaceFC(int lev)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intFC.ICellFCF), parameter->getParH(lev)->mem_size_kFC ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->intFC.ICellFCC), parameter->getParH(lev)->mem_size_kFC ));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intFC.ICellFCF), parameter->getParD(lev)->mem_size_kFC ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->intFC.ICellFCC), parameter->getParD(lev)->mem_size_kFC ));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 2. * (double)parameter->getParH(lev)->mem_size_kFC;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyInterfaceFC(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intFC.ICellFCF, parameter->getParH(lev)->intFC.ICellFCF, parameter->getParH(lev)->mem_size_kFC, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->intFC.ICellFCC, parameter->getParH(lev)->intFC.ICellFCC, parameter->getParH(lev)->mem_size_kFC, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeInterfaceFC(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intFC.ICellFCF));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->intFC.ICellFCC));
+}
+//Interface Offset CF
+void CudaMemoryManager::cudaAllocInterfaceOffCF(int lev)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offCF.xOffCF), parameter->getParH(lev)->mem_size_kCF_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offCF.yOffCF), parameter->getParH(lev)->mem_size_kCF_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offCF.zOffCF), parameter->getParH(lev)->mem_size_kCF_off ));
+ getLastCudaError("Allocate host memory");
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offCF.xOffCF), parameter->getParD(lev)->mem_size_kCF_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offCF.yOffCF), parameter->getParD(lev)->mem_size_kCF_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offCF.zOffCF), parameter->getParD(lev)->mem_size_kCF_off ));
+ getLastCudaError("Allocate device memory");
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 3. * (double)parameter->getParH(lev)->mem_size_kCF_off;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyInterfaceOffCF(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offCF.xOffCF, parameter->getParH(lev)->offCF.xOffCF, parameter->getParH(lev)->mem_size_kCF_off, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offCF.yOffCF, parameter->getParH(lev)->offCF.yOffCF, parameter->getParH(lev)->mem_size_kCF_off, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offCF.zOffCF, parameter->getParH(lev)->offCF.zOffCF, parameter->getParH(lev)->mem_size_kCF_off, cudaMemcpyHostToDevice));
+ getLastCudaError("Copy host memory to device");
+}
+void CudaMemoryManager::cudaFreeInterfaceOffCF(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offCF.xOffCF));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offCF.yOffCF));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offCF.zOffCF));
+}
+//Interface Offset FC
+void CudaMemoryManager::cudaAllocInterfaceOffFC(int lev)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offFC.xOffFC), parameter->getParH(lev)->mem_size_kFC_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offFC.yOffFC), parameter->getParH(lev)->mem_size_kFC_off ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->offFC.zOffFC), parameter->getParH(lev)->mem_size_kFC_off ));
+ getLastCudaError("Allocate host memory");
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offFC.xOffFC), parameter->getParD(lev)->mem_size_kFC_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offFC.yOffFC), parameter->getParD(lev)->mem_size_kFC_off ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->offFC.zOffFC), parameter->getParD(lev)->mem_size_kFC_off ));
+ getLastCudaError("Allocate device memory");
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 3. * (double)parameter->getParH(lev)->mem_size_kFC_off;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyInterfaceOffFC(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offFC.xOffFC, parameter->getParH(lev)->offFC.xOffFC, parameter->getParH(lev)->mem_size_kFC_off, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offFC.yOffFC, parameter->getParH(lev)->offFC.yOffFC, parameter->getParH(lev)->mem_size_kFC_off, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->offFC.zOffFC, parameter->getParH(lev)->offFC.zOffFC, parameter->getParH(lev)->mem_size_kFC_off, cudaMemcpyHostToDevice));
+ getLastCudaError("Copy host memory to device");
+}
+void CudaMemoryManager::cudaFreeInterfaceOffFC(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offFC.xOffFC));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offFC.yOffFC));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->offFC.zOffFC));
+}
+
+//Inlet
+void CudaMemoryManager::cudaAllocInlet(int lev)
+{
+ unsigned int mem_size_inlet_Q_k = sizeof(int)*parameter->getParH(lev)->QInlet.kQ;
+ unsigned int mem_size_inlet_Q_q = sizeof(real)*parameter->getParH(lev)->QInlet.kQ;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInlet.q27[0]), parameter->getD3Qxx()*mem_size_inlet_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInlet.k), mem_size_inlet_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInlet.kN), mem_size_inlet_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QInlet.RhoBC), mem_size_inlet_Q_q ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInlet.q27[0]), parameter->getD3Qxx()* mem_size_inlet_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInlet.k), mem_size_inlet_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInlet.kN), mem_size_inlet_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QInlet.RhoBC), mem_size_inlet_Q_q ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 2. * (double)mem_size_inlet_Q_k + (double)mem_size_inlet_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_inlet_Q_q;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyInlet(int lev)
+{
+ unsigned int mem_size_inlet_Q_k = sizeof(int)*parameter->getParH(lev)->QInlet.kQ;
+ unsigned int mem_size_inlet_Q_q = sizeof(real)*parameter->getParH(lev)->QInlet.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInlet.q27[0], parameter->getParH(lev)->QInlet.q27[0], parameter->getD3Qxx()* mem_size_inlet_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInlet.k, parameter->getParH(lev)->QInlet.k, mem_size_inlet_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInlet.kN, parameter->getParH(lev)->QInlet.kN, mem_size_inlet_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInlet.RhoBC, parameter->getParH(lev)->QInlet.RhoBC, mem_size_inlet_Q_q, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeInlet(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInlet.q27[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInlet.k ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInlet.kN ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInlet.RhoBC ));
+}
+//Outlet
+void CudaMemoryManager::cudaAllocOutlet(int lev)
+{
+ unsigned int mem_size_outlet_Q_k = sizeof(int)*parameter->getParH(lev)->QOutlet.kQ;
+ unsigned int mem_size_outlet_Q_q = sizeof(real)*parameter->getParH(lev)->QOutlet.kQ;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutlet.q27[0]), parameter->getD3Qxx()*mem_size_outlet_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutlet.k), mem_size_outlet_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutlet.kN), mem_size_outlet_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QOutlet.RhoBC), mem_size_outlet_Q_q ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutlet.q27[0]), parameter->getD3Qxx()* mem_size_outlet_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutlet.k), mem_size_outlet_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutlet.kN), mem_size_outlet_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QOutlet.RhoBC), mem_size_outlet_Q_q ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 2. * (double)mem_size_outlet_Q_k + (double)mem_size_outlet_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_outlet_Q_q;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyOutlet(int lev)
+{
+ unsigned int mem_size_outlet_Q_k = sizeof(int)*parameter->getParH(lev)->QOutlet.kQ;
+ unsigned int mem_size_outlet_Q_q = sizeof(real)*parameter->getParH(lev)->QOutlet.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutlet.q27[0], parameter->getParH(lev)->QOutlet.q27[0], parameter->getD3Qxx()* mem_size_outlet_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutlet.k, parameter->getParH(lev)->QOutlet.k, mem_size_outlet_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutlet.kN, parameter->getParH(lev)->QOutlet.kN, mem_size_outlet_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutlet.RhoBC, parameter->getParH(lev)->QOutlet.RhoBC, mem_size_outlet_Q_q, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeOutlet(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutlet.q27[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutlet.k ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutlet.kN ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutlet.RhoBC ));
+}
+
+
+
+//Geometrie inkl. Values
+void CudaMemoryManager::cudaAllocGeomValuesBC(int lev)
+{
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QGeom.kQ;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeom.Vx), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeom.Vy), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QGeom.Vz), mem_size_Q_q ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeom.Vx), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeom.Vy), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QGeom.Vz), mem_size_Q_q ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 3. * (double)mem_size_Q_q;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyGeomValuesBC(int lev)
+{
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QGeom.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeom.Vx, parameter->getParH(lev)->QGeom.Vx, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeom.Vy, parameter->getParH(lev)->QGeom.Vy, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeom.Vz, parameter->getParH(lev)->QGeom.Vz, mem_size_Q_q, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeGeomValuesBC(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeom.Vx));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeom.Vy));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeom.Vz));
+}
+//Geometrie inkl. Normale f¸r Slip
+void CudaMemoryManager::cudaAllocGeomNormals(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QGeomNormalX.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QGeomNormalX.kQ;
+
+ //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)->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)->QGeomNormalZ.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
+ 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)->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)->QGeomNormalZ.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
+ 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;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyGeomNormals(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QGeomNormalX.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QGeomNormalX.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeomNormalX.q27[0], parameter->getParH(lev)->QGeomNormalX.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeomNormalX.k, parameter->getParH(lev)->QGeomNormalX.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeomNormalY.q27[0], parameter->getParH(lev)->QGeomNormalY.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeomNormalY.k, parameter->getParH(lev)->QGeomNormalY.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeomNormalZ.q27[0], parameter->getParH(lev)->QGeomNormalZ.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QGeomNormalZ.k, parameter->getParH(lev)->QGeomNormalZ.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeGeomNormals(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeomNormalX.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeomNormalX.k));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeomNormalY.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeomNormalY.k));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeomNormalZ.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QGeomNormalZ.k));
+}
+//Geometrie inkl. Normale f¸r Inflow
+void CudaMemoryManager::cudaAllocInflowNormals(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QInflowNormalX.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QInflowNormalX.kQ;
+
+ //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)->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)->QInflowNormalZ.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
+ 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)->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)->QInflowNormalZ.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
+ 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;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyInflowNormals(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QInflowNormalX.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QInflowNormalX.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInflowNormalX.q27[0], parameter->getParH(lev)->QInflowNormalX.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInflowNormalX.k, parameter->getParH(lev)->QInflowNormalX.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInflowNormalY.q27[0], parameter->getParH(lev)->QInflowNormalY.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInflowNormalY.k, parameter->getParH(lev)->QInflowNormalY.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInflowNormalZ.q27[0], parameter->getParH(lev)->QInflowNormalZ.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QInflowNormalZ.k, parameter->getParH(lev)->QInflowNormalZ.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeInflowNormals(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInflowNormalX.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInflowNormalX.k));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInflowNormalY.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInflowNormalY.k));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInflowNormalZ.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QInflowNormalZ.k));
+}
+//Geometrie inkl. Normale f¸r Outflow
+void CudaMemoryManager::cudaAllocOutflowNormals(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QOutflowNormalX.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QOutflowNormalX.kQ;
+
+ //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)->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)->QOutflowNormalZ.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
+ 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)->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)->QOutflowNormalZ.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
+ 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;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyOutflowNormals(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QOutflowNormalX.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QOutflowNormalX.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutflowNormalX.q27[0], parameter->getParH(lev)->QOutflowNormalX.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutflowNormalX.k, parameter->getParH(lev)->QOutflowNormalX.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutflowNormalY.q27[0], parameter->getParH(lev)->QOutflowNormalY.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutflowNormalY.k, parameter->getParH(lev)->QOutflowNormalY.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutflowNormalZ.q27[0], parameter->getParH(lev)->QOutflowNormalZ.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QOutflowNormalZ.k, parameter->getParH(lev)->QOutflowNormalZ.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeOutflowNormals(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutflowNormalX.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutflowNormalX.k));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutflowNormalY.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutflowNormalY.k));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutflowNormalZ.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QOutflowNormalZ.k));
+}
+//Slip
+void CudaMemoryManager::cudaAllocSlipBC(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QSlip.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QSlip.kQ;
+ //unsigned int mem_size_Q_value = sizeof(long long)*parameter->getParH(lev)->QSlip.kQ; //Geller
+ //unsigned int mem_size_Q_q_read = sizeof(real)*parameter->getParH(lev)->kSlipQread; //Geller
+
+ //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.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 ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size_Q_k + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopySlipBC(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QSlip.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QSlip.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QSlip.q27[0], parameter->getParH(lev)->QSlip.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QSlip.k, parameter->getParH(lev)->QSlip.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeSlipBC(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QSlip.q27[0]));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QSlip.k));
+ //checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QSlip.valueQ));
+ //checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QSlip.qread));
+}
+
+//Test roundoff error
+void CudaMemoryManager::cudaAllocTestRE(int lev, unsigned int size)
+{
+ unsigned int mem_size = sizeof(real)*size;
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kDistTestRE.f[0]), (1+parameter->getD3Qxx())*mem_size));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kDistTestRE.f[0]), (1+parameter->getD3Qxx())*mem_size));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyTestREtoDevice(int lev, unsigned int size)
+{
+ unsigned int mem_size = sizeof(real)*size;
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->kDistTestRE.f[0], parameter->getParH(lev)->kDistTestRE.f[0], (1+parameter->getD3Qxx())*mem_size, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyTestREtoHost(int lev, unsigned int size)
+{
+ unsigned int mem_size = sizeof(real)*size;
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kDistTestRE.f[0], parameter->getParD(lev)->kDistTestRE.f[0], (1+parameter->getD3Qxx())*mem_size, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeTestRE(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kDistTestRE.f[0]));
+}
+//PressX0 = X-inflow
+void CudaMemoryManager::cudaAllocPressX0(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QpressX0.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QpressX0.kQ;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.kN), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.Vx), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.Vy), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.Vz), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.RhoBC), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX0.deltaVz), mem_size_Q_q ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.kN), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.Vx), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.Vy), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.Vz), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.RhoBC), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX0.deltaVz), mem_size_Q_q ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 2. * (double)mem_size_Q_k + 5. * (double)mem_size_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyPressX0(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QpressX0.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QpressX0.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.q27[0], parameter->getParH(lev)->QpressX0.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.k, parameter->getParH(lev)->QpressX0.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.kN, parameter->getParH(lev)->QpressX0.kN, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.Vx, parameter->getParH(lev)->QpressX0.Vx, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.Vy, parameter->getParH(lev)->QpressX0.Vy, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.Vz, parameter->getParH(lev)->QpressX0.Vz, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.RhoBC, parameter->getParH(lev)->QpressX0.RhoBC, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX0.deltaVz, parameter->getParH(lev)->QpressX0.deltaVz, mem_size_Q_q, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreePressX0(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.q27[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.k ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.kN ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.Vx ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.Vy ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.Vz ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.RhoBC ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX0.deltaVz));
+}
+//PressX1 = X-outflow
+void CudaMemoryManager::cudaAllocPressX1(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QpressX1.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QpressX1.kQ;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.q27[0]), parameter->getD3Qxx()*mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.kN), mem_size_Q_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.Vx), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.Vy), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.Vz), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.RhoBC), mem_size_Q_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QpressX1.deltaVz), mem_size_Q_q ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.q27[0]), parameter->getD3Qxx()* mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.k), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.kN), mem_size_Q_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.Vx), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.Vy), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.Vz), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.RhoBC), mem_size_Q_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QpressX1.deltaVz), mem_size_Q_q ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 2. * (double)mem_size_Q_k + 5. * (double)mem_size_Q_q + (double)parameter->getD3Qxx()*(double)mem_size_Q_q;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyPressX1(int lev)
+{
+ unsigned int mem_size_Q_k = sizeof(int)*parameter->getParH(lev)->QpressX1.kQ;
+ unsigned int mem_size_Q_q = sizeof(real)*parameter->getParH(lev)->QpressX1.kQ;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.q27[0], parameter->getParH(lev)->QpressX1.q27[0], parameter->getD3Qxx()* mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.k, parameter->getParH(lev)->QpressX1.k, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.kN, parameter->getParH(lev)->QpressX1.kN, mem_size_Q_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.Vx, parameter->getParH(lev)->QpressX1.Vx, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.Vy, parameter->getParH(lev)->QpressX1.Vy, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.Vz, parameter->getParH(lev)->QpressX1.Vz, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.RhoBC, parameter->getParH(lev)->QpressX1.RhoBC, mem_size_Q_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QpressX1.deltaVz, parameter->getParH(lev)->QpressX1.deltaVz, mem_size_Q_q, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreePressX1(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.q27[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.k ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.kN ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.Vx ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.Vy ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.Vz ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.RhoBC ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QpressX1.deltaVz));
+}
+//Propeller Velocity
+void CudaMemoryManager::cudaAllocVeloPropeller(int lev)
+{
+ unsigned int mem_size_Propeller_k = sizeof(int)*parameter->getParH(lev)->QPropeller.kQ;
+ unsigned int mem_size_Propeller_q = sizeof(real)*parameter->getParH(lev)->QPropeller.kQ;
+
+ //Host
+ //checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QPropeller.q27[0]), parameter->getD3Qxx()*mem_size_Propeller_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QPropeller.k), mem_size_Propeller_k ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QPropeller.Vx), mem_size_Propeller_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QPropeller.Vy), mem_size_Propeller_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QPropeller.Vz), mem_size_Propeller_q ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->QPropeller.RhoBC), mem_size_Propeller_q ));
+
+ //Device
+ //checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QPropeller.q27[0]), parameter->getD3Qxx()*mem_size_Propeller_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QPropeller.k), mem_size_Propeller_k ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QPropeller.Vx), mem_size_Propeller_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QPropeller.Vy), mem_size_Propeller_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QPropeller.Vz), mem_size_Propeller_q ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->QPropeller.RhoBC), mem_size_Propeller_q ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size_Propeller_k + 4. * (double)mem_size_Propeller_q;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyVeloPropeller(int lev)
+{
+ unsigned int mem_size_Propeller_k = sizeof(int)*parameter->getParH(lev)->QPropeller.kQ;
+ unsigned int mem_size_Propeller_q = sizeof(real)*parameter->getParH(lev)->QPropeller.kQ;
+
+ //checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QPropeller.q27[0], parameter->getParH(lev)->QPropeller.q27[0], parameter->getD3Qxx()* mem_size_Propeller_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QPropeller.k, parameter->getParH(lev)->QPropeller.k, mem_size_Propeller_k, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QPropeller.Vx, parameter->getParH(lev)->QPropeller.Vx, mem_size_Propeller_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QPropeller.Vy, parameter->getParH(lev)->QPropeller.Vy, mem_size_Propeller_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QPropeller.Vz, parameter->getParH(lev)->QPropeller.Vz, mem_size_Propeller_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->QPropeller.RhoBC, parameter->getParH(lev)->QPropeller.RhoBC, mem_size_Propeller_q, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeVeloPropeller(int lev)
+{
+ //checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QPropeller.q27[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QPropeller.k ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QPropeller.Vx ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QPropeller.Vy ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QPropeller.Vz ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->QPropeller.RhoBC ));
+}
+//Measure Points
+//void CudaMemoryManager::cudaAllocMeasurePoints(int lev, int i)
+//{
+// //Host
+// checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->MP[i].Vx), parameter->getParH(lev)->memSizerealMP ));
+// checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->MP[i].Vy), parameter->getParH(lev)->memSizerealMP ));
+// checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->MP[i].Vz), parameter->getParH(lev)->memSizerealMP ));
+// checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->MP[i].Rho), parameter->getParH(lev)->memSizerealMP ));
+//
+// //Device
+// checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->MP[i].Vx), parameter->getParD(lev)->memSizerealMP ));
+// checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->MP[i].Vy), parameter->getParD(lev)->memSizerealMP ));
+// checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->MP[i].Vz), parameter->getParD(lev)->memSizerealMP ));
+// checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->MP[i].Rho), parameter->getParD(lev)->memSizerealMP ));
+//}
+//void CudaMemoryManager::cudaCopyMeasurePoints(int lev, int i)
+//{
+// checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->MP[i].Vx, parameter->getParH(lev)->MP[i].Vx, parameter->getParH(lev)->memSizerealMP, cudaMemcpyHostToDevice));
+// checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->MP[i].Vy, parameter->getParH(lev)->MP[i].Vy, parameter->getParH(lev)->memSizerealMP, cudaMemcpyHostToDevice));
+// checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->MP[i].Vz, parameter->getParH(lev)->MP[i].Vz, parameter->getParH(lev)->memSizerealMP, cudaMemcpyHostToDevice));
+// checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->MP[i].Rho, parameter->getParH(lev)->MP[i].Rho, parameter->getParH(lev)->memSizerealMP, cudaMemcpyHostToDevice));
+//}
+//void CudaMemoryManager::cudaFreeMeasurePoints(int lev, int i)
+//{
+// checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->MP[i].Vx ));
+// checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->MP[i].Vy ));
+// checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->MP[i].Vz ));
+// checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->MP[i].Rho ));
+//}
+void CudaMemoryManager::cudaAllocMeasurePointsIndex(int lev)
+{
+ //Host
+ 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 ));
+
+ //Device
+ 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 ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)parameter->getParH(lev)->memSizeIntkMP + 4. * (double)parameter->getParH(lev)->memSizerealkMP;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyMeasurePointsIndex(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->kMP, parameter->getParH(lev)->kMP, parameter->getParH(lev)->memSizeIntkMP, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->VxMP, parameter->getParH(lev)->VxMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->VyMP, parameter->getParH(lev)->VyMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->VzMP, parameter->getParH(lev)->VzMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->RhoMP, parameter->getParH(lev)->RhoMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyMeasurePointsToHost(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kMP, parameter->getParD(lev)->kMP, parameter->getParH(lev)->memSizeIntkMP, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->VxMP, parameter->getParD(lev)->VxMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->VyMP, parameter->getParD(lev)->VyMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->VzMP, parameter->getParD(lev)->VzMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->RhoMP, parameter->getParD(lev)->RhoMP, parameter->getParH(lev)->memSizerealkMP, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeMeasurePointsIndex(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kMP));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->VxMP));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->VyMP));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->VzMP));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->RhoMP));
+}
+void CudaMemoryManager::cudaAllocFsForCheckPointAndRestart(int lev)
+{
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->d0SP.f[0] ), (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParH(lev)->mem_size_real_SP));
+}
+void CudaMemoryManager::cudaCopyFsForRestart(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->d0SP.f[0], parameter->getParH(lev)->d0SP.f[0], (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyFsForCheckPoint(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->d0SP.f[0], parameter->getParD(lev)->d0SP.f[0], (unsigned long long)parameter->getD3Qxx()*(unsigned long long)parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeFsForCheckPointAndRestart(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->d0SP.f[0]));
+}
+//DragLift
+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)->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)->DragPostX), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPostY), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->DragPostZ), mem_size ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 6. * (double)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyDragLift(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(double)*numofelem;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragPreX, parameter->getParD(lev)->DragPreX, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragPreY, parameter->getParD(lev)->DragPreY, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragPreZ, parameter->getParD(lev)->DragPreZ, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragPostX, parameter->getParD(lev)->DragPostX, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragPostY, parameter->getParD(lev)->DragPostY, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->DragPostZ, parameter->getParD(lev)->DragPostZ, mem_size, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeDragLift(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragPreX));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragPreY));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragPreZ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragPostX));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragPostY));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->DragPostZ));
+}
+//2ndMoments
+void CudaMemoryManager::cudaAlloc2ndMoments(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxyFromfcNEQ ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kyzFromfcNEQ ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxzFromfcNEQ ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxxMyyFromfcNEQ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->kxxMzzFromfcNEQ), mem_size ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxyFromfcNEQ ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kyzFromfcNEQ ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxzFromfcNEQ ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxxMyyFromfcNEQ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->kxxMzzFromfcNEQ), mem_size ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 5. * (real)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopy2ndMoments(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxyFromfcNEQ , parameter->getParD(lev)->kxyFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kyzFromfcNEQ , parameter->getParD(lev)->kyzFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxzFromfcNEQ , parameter->getParD(lev)->kxzFromfcNEQ , mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxxMyyFromfcNEQ, parameter->getParD(lev)->kxxMyyFromfcNEQ, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->kxxMzzFromfcNEQ, parameter->getParD(lev)->kxxMzzFromfcNEQ, mem_size, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFree2ndMoments(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxyFromfcNEQ ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kyzFromfcNEQ ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxzFromfcNEQ ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxxMyyFromfcNEQ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->kxxMzzFromfcNEQ));
+}
+//3rdMoments
+void CudaMemoryManager::cudaAlloc3rdMoments(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbbb ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMabc ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbac ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbca ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcba ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMacb ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcab ), mem_size ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbbb ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMabc ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbac ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbca ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcba ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMacb ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcab ), mem_size ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 7. * (real)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopy3rdMoments(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbbb, parameter->getParD(lev)->CUMbbb, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMabc, parameter->getParD(lev)->CUMabc, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbac, parameter->getParD(lev)->CUMbac, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbca, parameter->getParD(lev)->CUMbca, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcba, parameter->getParD(lev)->CUMcba, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMacb, parameter->getParD(lev)->CUMacb, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcab, parameter->getParD(lev)->CUMcab, mem_size, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFree3rdMoments(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbbb ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMabc ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbac ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbca ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcba ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMacb ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcab ));
+}
+//higher order moments
+void CudaMemoryManager::cudaAllocHigherMoments(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcbb ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbcb ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbbc ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcca ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcac ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMacc ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMbcc ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMcbc ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMccb ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->CUMccc ), mem_size ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcbb ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbcb ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbbc ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcca ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcac ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMacc ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMbcc ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMcbc ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMccb ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->CUMccc ), mem_size ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 7. * (real)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyHigherMoments(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcbb, parameter->getParD(lev)->CUMcbb, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbcb, parameter->getParD(lev)->CUMbcb, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbbc, parameter->getParD(lev)->CUMbbc, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcca, parameter->getParD(lev)->CUMcca, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcac, parameter->getParD(lev)->CUMcac, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMacc, parameter->getParD(lev)->CUMacc, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMbcc, parameter->getParD(lev)->CUMbcc, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMcbc, parameter->getParD(lev)->CUMcbc, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMccb, parameter->getParD(lev)->CUMccb, mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->CUMccc, parameter->getParD(lev)->CUMccc, mem_size, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeHigherMoments(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcbb ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbcb ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbbc ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcca ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcac ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMacc ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMbcc ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMcbc ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMccb ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->CUMccc ));
+}
+//Velcities to fit the Forcing
+void CudaMemoryManager::cudaAllocForceVelo(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->VxForce ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->VyForce ), mem_size ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->VzForce ), mem_size ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->VxForce ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->VyForce ), mem_size ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->VzForce ), mem_size ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 3. * (real)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyForceVelo(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->VxForce , parameter->getParD(lev)->VxForce , mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->VyForce , parameter->getParD(lev)->VyForce , mem_size, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->VzForce , parameter->getParD(lev)->VzForce , mem_size, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeForceVelo(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->VxForce ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->VyForce ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->VzForce ));
+}
+//cp Top
+void CudaMemoryManager::cudaAllocCpTop(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpTop;
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpTop;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpPressTop), mem_size_double ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpTopIndex), mem_size_int ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpPressTop), mem_size_double ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpTopIndex), mem_size_int ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size_double + (double)mem_size_int;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyCpTopInit(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpTop;
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpTop;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpPressTop, parameter->getParH(lev)->cpPressTop, mem_size_double, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpTopIndex, parameter->getParH(lev)->cpTopIndex, mem_size_int, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyCpTop(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpTop;
+ //unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpTop;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpPressTop, parameter->getParD(lev)->cpPressTop, mem_size_double, cudaMemcpyDeviceToHost));
+ //checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpTopIndex, parameter->getParD(lev)->cpTopIndex, mem_size_int, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeCpTop(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpPressTop));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpTopIndex));
+}
+//cp Bottom
+void CudaMemoryManager::cudaAllocCpBottom(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom;
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpPressBottom), mem_size_double ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpBottomIndex), mem_size_int ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpPressBottom), mem_size_double ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpBottomIndex), mem_size_int ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size_double + (double)mem_size_int;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyCpBottomInit(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom;
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpPressBottom, parameter->getParH(lev)->cpPressBottom, mem_size_double, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpBottomIndex, parameter->getParH(lev)->cpBottomIndex, mem_size_int, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyCpBottom(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom;
+ //unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpPressBottom, parameter->getParD(lev)->cpPressBottom, mem_size_double, cudaMemcpyDeviceToHost));
+ //checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpBottomIndex, parameter->getParD(lev)->cpBottomIndex, mem_size_int, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeCpBottom(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpPressBottom));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpBottomIndex));
+}
+//cp Bottom 2
+void CudaMemoryManager::cudaAllocCpBottom2(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom2;
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom2;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpPressBottom2), mem_size_double ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->cpBottom2Index), mem_size_int ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpPressBottom2), mem_size_double ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->cpBottom2Index), mem_size_int ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size_double + (double)mem_size_int;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyCpBottom2Init(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom2;
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsCpBottom2;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpPressBottom2, parameter->getParH(lev)->cpPressBottom2, mem_size_double, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->cpBottom2Index, parameter->getParH(lev)->cpBottom2Index, mem_size_int, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyCpBottom2(int lev)
+{
+ unsigned int mem_size_double = sizeof(double) * parameter->getParH(lev)->numberOfPointsCpBottom2;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->cpPressBottom2, parameter->getParD(lev)->cpPressBottom2, mem_size_double, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeCpBottom2(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpPressBottom2));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->cpBottom2Index));
+}
+//////////////////////////////////////////////////////////////////////////
+//particles
+void CudaMemoryManager::cudaAllocParticles(int lev)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.coordXlocal), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.coordYlocal), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.coordZlocal), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.coordXabsolut), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.coordYabsolut), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.coordZabsolut), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.veloX), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.veloY), parameter->getParH(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.veloZ), parameter->getParH(lev)->plp.memSizerealAll ));
+ //checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.randomLocationInit), parameter->getParH(lev)->plp.memSizereal ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.ID), parameter->getParH(lev)->plp.memSizeID ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.cellBaseID), parameter->getParH(lev)->plp.memSizeID ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.timestep), parameter->getParH(lev)->plp.memSizeTimestep ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.stuck), parameter->getParH(lev)->plp.memSizeBool ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->plp.hot), parameter->getParH(lev)->plp.memSizeBoolBC ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.coordXlocal), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.coordYlocal), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.coordZlocal), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.coordXabsolut), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.coordYabsolut), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.coordZabsolut), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.veloX), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.veloY), parameter->getParD(lev)->plp.memSizerealAll ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.veloZ), parameter->getParD(lev)->plp.memSizerealAll ));
+ //checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.randomLocationInit), parameter->getParD(lev)->plp.memSizereal ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.ID), parameter->getParD(lev)->plp.memSizeID ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.cellBaseID), parameter->getParD(lev)->plp.memSizeID ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.timestep), parameter->getParD(lev)->plp.memSizeTimestep ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->plp.stuck), parameter->getParD(lev)->plp.memSizeBool ));
+ 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;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyParticles(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.coordXlocal, parameter->getParD(lev)->plp.coordXlocal, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.coordYlocal, parameter->getParD(lev)->plp.coordYlocal, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.coordZlocal, parameter->getParD(lev)->plp.coordZlocal, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.coordXabsolut, parameter->getParD(lev)->plp.coordXabsolut, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.coordYabsolut, parameter->getParD(lev)->plp.coordYabsolut, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.coordZabsolut, parameter->getParD(lev)->plp.coordZabsolut, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.veloX, parameter->getParD(lev)->plp.veloX, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.veloY, parameter->getParD(lev)->plp.veloY, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.veloZ, parameter->getParD(lev)->plp.veloZ, parameter->getParH(lev)->plp.memSizerealAll, cudaMemcpyDeviceToHost));
+ //checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.randomLocationInit, parameter->getParD(lev)->plp.randomLocationInit, parameter->getParH(lev)->plp.memSizereal, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.ID, parameter->getParD(lev)->plp.ID, parameter->getParH(lev)->plp.memSizeID, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.cellBaseID, parameter->getParD(lev)->plp.cellBaseID, parameter->getParH(lev)->plp.memSizeID, cudaMemcpyDeviceToHost));
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->plp.timestep, parameter->getParD(lev)->plp.timestep, parameter->getParH(lev)->plp.memSizeTimestep, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeParticles(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.coordXlocal) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.coordYlocal) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.coordZlocal) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.coordXabsolut) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.coordYabsolut) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.coordZabsolut) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.veloX) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.veloY) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.veloZ) );
+ //checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.randomLocationInit));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.ID) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.cellBaseID) );
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->plp.timestep) );
+}
+//random values
+void CudaMemoryManager::cudaAllocRandomValues()
+{
+ //Device
+ checkCudaErrors( cudaMalloc((void**)(parameter->getRandomState()), (sizeof(curandState)*parameter->getParD(parameter->getFine())->plp.numberOfParticles) ));
+}
+//////////////////////////////////////////////////////////////////////////
+//porous media
+void CudaMemoryManager::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 CudaMemoryManager::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 CudaMemoryManager::cudaFreePorousMedia(PorousMedia* pm, int lev)
+{
+ checkCudaErrors(cudaFreeHost(pm->getHostNodeIDsPM()));
+}
+//////////////////////////////////////////////////////////////////////////
+//advection diffusion
+void CudaMemoryManager::cudaAllocConc(int lev)
+{
+ //Host
+ 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));
+}
+void CudaMemoryManager::cudaCopyConcDH(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->Conc, parameter->getParD(lev)->Conc, parameter->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaCopyConcHD(int lev)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->Conc, parameter->getParH(lev)->Conc, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeConc(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->Conc));
+}
+//////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocTempFs(int lev)
+{
+ //Device
+ if (parameter->getDiffMod() == 7)
+ {
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->d7.f[0]), parameter->getDiffMod()*parameter->getParH(lev)->mem_size_real_SP));
+ }
+ else if (parameter->getDiffMod() == 27)
+ {
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->d27.f[0]), parameter->getDiffMod()*parameter->getParH(lev)->mem_size_real_SP));
+ }
+}
+//////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocTempPressBC(int lev)
+{
+ unsigned int mem_size_TempPress_k = sizeof(int)*parameter->getParH(lev)->TempPress.kTemp;
+ unsigned int mem_size_TempPress_q = sizeof(real)*parameter->getParH(lev)->TempPress.kTemp;
+
+ // Host Memory
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->TempPress.temp, mem_size_TempPress_q ));
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->TempPress.velo, mem_size_TempPress_q ));
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->TempPress.k, mem_size_TempPress_k ));
+
+ // Device Memory
+ 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));
+
+}
+void CudaMemoryManager::cudaCopyTempPressBCHD(int lev)
+{
+ unsigned int mem_size_TempPress_k = sizeof(int)*parameter->getParH(lev)->TempPress.kTemp;
+ unsigned int mem_size_TempPress_q = sizeof(real)*parameter->getParH(lev)->TempPress.kTemp;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->TempPress.temp, parameter->getParH(lev)->TempPress.temp, mem_size_TempPress_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->TempPress.velo, parameter->getParH(lev)->TempPress.velo, mem_size_TempPress_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->TempPress.k, parameter->getParH(lev)->TempPress.k, mem_size_TempPress_k, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeTempPressBC(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->TempPress.temp));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->TempPress.velo));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->TempPress.k ));
+}
+//////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocTempVeloBC(int lev)
+{
+ unsigned int mem_size_TempVel_k = sizeof(int)*parameter->getParH(lev)->TempVel.kTemp;
+ unsigned int mem_size_TempVel_q = sizeof(real)*parameter->getParH(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**) ¶meter->getParH(lev)->TempVel.temp, mem_size_TempVel_q ));
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->TempVel.tempPulse, mem_size_TempVel_q ));
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->TempVel.velo, mem_size_TempVel_q ));
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->TempVel.k, mem_size_TempVel_k ));
+
+ // Device Memory
+ checkCudaErrors( cudaMalloc((void**) ¶meter->getParD(lev)->TempVel.temp, mem_size_TempVel_q));
+ 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));
+}
+void CudaMemoryManager::cudaCopyTempVeloBCHD(int lev)
+{
+ unsigned int mem_size_TempVel_k = sizeof(int)*parameter->getParH(lev)->TempVel.kTemp;
+ unsigned int mem_size_TempVel_q = sizeof(real)*parameter->getParH(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(parameter->getParD(lev)->TempVel.temp, parameter->getParH(lev)->TempVel.temp, mem_size_TempVel_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->TempVel.tempPulse, parameter->getParH(lev)->TempVel.tempPulse, mem_size_TempVel_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->TempVel.velo, parameter->getParH(lev)->TempVel.velo, mem_size_TempVel_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->TempVel.k, parameter->getParH(lev)->TempVel.k, mem_size_TempVel_k, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeTempVeloBC(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->TempVel.temp ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->TempVel.tempPulse));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->TempVel.velo ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->TempVel.k ));
+}
+//////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocTempNoSlipBC(int lev)
+{
+ unsigned int mem_size_Temp_k = sizeof(int)*parameter->getParH(lev)->Temp.kTemp;
+ unsigned int mem_size_Temp_q = sizeof(real)*parameter->getParH(lev)->Temp.kTemp;
+
+ // Host Memory
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->Temp.temp, mem_size_Temp_q ));
+ checkCudaErrors( cudaMallocHost((void**) ¶meter->getParH(lev)->Temp.k, mem_size_Temp_k ));
+
+ // 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));
+
+}
+void CudaMemoryManager::cudaCopyTempNoSlipBCHD(int lev)
+{
+ unsigned int mem_size_Temp_k = sizeof(int)*parameter->getParH(lev)->Temp.kTemp;
+ unsigned int mem_size_Temp_q = sizeof(real)*parameter->getParH(lev)->Temp.kTemp;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->Temp.temp, parameter->getParH(lev)->Temp.temp, mem_size_Temp_q, cudaMemcpyHostToDevice));
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->Temp.k, parameter->getParH(lev)->Temp.k, mem_size_Temp_k, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeTempNoSlipBC(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->Temp.temp));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->Temp.k ));
+}
+//PlaneConc
+void CudaMemoryManager::cudaAllocPlaneConcIn(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->ConcPlaneIn), mem_size ));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->ConcPlaneIn), mem_size ));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyPlaneConcIn(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->ConcPlaneIn, parameter->getParD(lev)->ConcPlaneIn, mem_size, cudaMemcpyDeviceToHost));
+}
+//////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocPlaneConcOut1(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->ConcPlaneOut1), mem_size ));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->ConcPlaneOut1), mem_size ));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyPlaneConcOut1(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->ConcPlaneOut1, parameter->getParD(lev)->ConcPlaneOut1, mem_size, cudaMemcpyDeviceToHost));
+}
+//////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocPlaneConcOut2(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->ConcPlaneOut2), mem_size ));
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->ConcPlaneOut2), mem_size ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyPlaneConcOut2(int lev, int numofelem)
+{
+ unsigned int mem_size = sizeof(real)*numofelem;
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->ConcPlaneOut2, parameter->getParD(lev)->ConcPlaneOut2, mem_size, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreePlaneConc(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->ConcPlaneIn));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->ConcPlaneOut1));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->ConcPlaneOut2));
+}
+//////////////////////////////////////////////////////////////////////////
+//concentration file
+void CudaMemoryManager::cudaAllocConcFile(int lev)
+{
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsConc;
+
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->concIndex), mem_size_int ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->concIndex), mem_size_int ));
+
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = (double)mem_size_int;
+ setMemsizeGPU(tmp, false);
+}
+void CudaMemoryManager::cudaCopyConcFile(int lev)
+{
+ unsigned int mem_size_int = sizeof(unsigned int) * parameter->getParH(lev)->numberOfPointsConc;
+
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->concIndex, parameter->getParH(lev)->concIndex, mem_size_int, cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaFreeConcFile(int lev)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->concIndex));
+}
+//////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////
+//Process Neighbors
+//1D domain decomposition
+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].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].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].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].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;
+ setMemsizeGPU(tmp, false);
+ //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
+}
+void CudaMemoryManager::cudaCopyProcessNeighborIndex(int lev, unsigned int processNeighbor)
+{
+ //copy send Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+ //copy recv Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborFsHD(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].f[0],
+ parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].f[0],
+ parameter->getD3Qxx() * parameter->getParD(lev)->recvProcessNeighbor[processNeighbor].memsizeFs,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborFsDH(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].f[0],
+ parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].f[0],
+ parameter->getD3Qxx() * parameter->getParD(lev)->sendProcessNeighbor[processNeighbor].memsizeFs,
+ cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeProcessNeighbor(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighbor[processNeighbor].f[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighbor[processNeighbor].f[0] ));
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// 3D domain decomposition convection diffusion
+// X /////////////////////////////////////////////////////////////////////////////
+void CudaMemoryManager::cudaAllocProcessNeighborADX(int lev, unsigned int processNeighbor)
+{
+ //Host
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].index ), parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].memsizeFs ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].index ), parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMallocHost((void**) &(parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].memsizeFs ));
+
+ //Device
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADX[processNeighbor].index ), parameter->getParD(lev)->sendProcessNeighborADX[processNeighbor].memsizeIndex ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->sendProcessNeighborADX[processNeighbor].f[0] ), parameter->getDiffMod() * parameter->getParD(lev)->sendProcessNeighborADX[processNeighbor].memsizeFs ));
+ checkCudaErrors( cudaMalloc((void**) &(parameter->getParD(lev)->recvProcessNeighborADX[processNeighbor].index ), parameter->getParD(lev)->recvProcessNeighborADX[processNeighbor].memsizeIndex ));
+ 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;
+ setMemsizeGPU(tmp, false);
+ //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADXIndex(int lev, unsigned int processNeighbor)
+{
+ //copy send Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->sendProcessNeighborADX[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+ //copy recv Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighborADX[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADXFsHD(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighborADX[processNeighbor].f[0],
+ parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].f[0],
+ parameter->getDiffMod() * parameter->getParD(lev)->recvProcessNeighborADX[processNeighbor].memsizeFs,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADXFsDH(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].f[0],
+ parameter->getParD(lev)->sendProcessNeighborADX[processNeighbor].f[0],
+ parameter->getDiffMod() * parameter->getParD(lev)->sendProcessNeighborADX[processNeighbor].memsizeFs,
+ cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeProcessNeighborADX(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighborADX[processNeighbor].f[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborADX[processNeighbor].f[0] ));
+}
+// Y /////////////////////////////////////////////////////////////////////////////
+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].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].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].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].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;
+ setMemsizeGPU(tmp, false);
+ //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADYIndex(int lev, unsigned int processNeighbor)
+{
+ //copy send Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+ //copy recv Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADYFsHD(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].f[0],
+ parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].f[0],
+ parameter->getDiffMod() * parameter->getParD(lev)->recvProcessNeighborADY[processNeighbor].memsizeFs,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADYFsDH(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].f[0],
+ parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].f[0],
+ parameter->getDiffMod() * parameter->getParD(lev)->sendProcessNeighborADY[processNeighbor].memsizeFs,
+ cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeProcessNeighborADY(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighborADY[processNeighbor].f[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborADY[processNeighbor].f[0] ));
+}
+// Z /////////////////////////////////////////////////////////////////////////////
+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].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].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].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].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;
+ setMemsizeGPU(tmp, false);
+ //printf("memsize GPU for neighbors %f \n",tmp/1000000.0);
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADZIndex(int lev, unsigned int processNeighbor)
+{
+ //copy send Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].index,
+ parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+ //copy recv Index
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].index,
+ parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].memsizeIndex,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADZFsHD(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].f[0],
+ parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].f[0],
+ parameter->getDiffMod() * parameter->getParD(lev)->recvProcessNeighborADZ[processNeighbor].memsizeFs,
+ cudaMemcpyHostToDevice));
+}
+void CudaMemoryManager::cudaCopyProcessNeighborADZFsDH(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaMemcpy(parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].f[0],
+ parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].f[0],
+ parameter->getDiffMod() * parameter->getParD(lev)->sendProcessNeighborADZ[processNeighbor].memsizeFs,
+ cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaFreeProcessNeighborADZ(int lev, unsigned int processNeighbor)
+{
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->sendProcessNeighborADZ[processNeighbor].f[0] ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].index ));
+ checkCudaErrors( cudaFreeHost(parameter->getParH(lev)->recvProcessNeighborADZ[processNeighbor].f[0] ));
+}
+void CudaMemoryManager::cudaAlloc2ndOrderDerivitivesIsoTest(int lev)
+{
+ //Host
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->dxxUx), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->dyyUy), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMallocHost((void**) &(parameter->getParH(lev)->dzzUz), parameter->getParH(lev)->mem_size_real_SP));
+ //Device (spinning ship)
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->dxxUx), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->dyyUy), parameter->getParH(lev)->mem_size_real_SP));
+ checkCudaErrors(cudaMalloc((void**) &(parameter->getParD(lev)->dzzUz), parameter->getParH(lev)->mem_size_real_SP));
+ //////////////////////////////////////////////////////////////////////////
+ double tmp = 3. * (double)parameter->getParH(lev)->mem_size_real_SP;
+ setMemsizeGPU(tmp, false);
+ //printf("Coord = %f MB",tmp/1000000.);
+}
+void CudaMemoryManager::cudaCopy2ndOrderDerivitivesIsoTestDH(int lev)
+{
+ //copy device to host
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->dxxUx, parameter->getParD(lev)->dxxUx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->dyyUy, parameter->getParD(lev)->dyyUy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+ checkCudaErrors(cudaMemcpy(parameter->getParH(lev)->dzzUz, parameter->getParD(lev)->dzzUz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyDeviceToHost));
+}
+void CudaMemoryManager::cudaCopy2ndOrderDerivitivesIsoTestHD(int lev)
+{
+ //copy host to device
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->dxxUx, parameter->getParH(lev)->dxxUx, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->dyyUy, parameter->getParH(lev)->dyyUy, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+ checkCudaErrors(cudaMemcpy(parameter->getParD(lev)->dzzUz, parameter->getParH(lev)->dzzUz, parameter->getParH(lev)->mem_size_real_SP, cudaMemcpyHostToDevice));
+
+}
+void CudaMemoryManager::cudaFree2ndOrderDerivitivesIsoTest(int lev)
+{
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->dxxUx));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->dyyUy));
+ checkCudaErrors(cudaFreeHost(parameter->getParH(lev)->dzzUz));
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
std::shared_ptr<CudaMemoryManager> CudaMemoryManager::make(std::shared_ptr<Parameter> parameter)
{
return std::shared_ptr<CudaMemoryManager>(new CudaMemoryManager(parameter));
}
+void CudaMemoryManager::setMemsizeGPU(double admem, bool reset)
+{
+ if (reset == true)
+ {
+ this->memsizeGPU = 0.;
+ }
+ else
+ {
+ this->memsizeGPU += admem;
+ }
+}
+
+double CudaMemoryManager::getMemsizeGPU()
+{
+ return memsizeGPU;
+}
+
CudaMemoryManager::CudaMemoryManager(std::shared_ptr<Parameter> parameter)
{
this->parameter = parameter;
diff --git a/src/VirtualFluids_GPU/GPU/CudaMemoryManager.h b/src/VirtualFluids_GPU/GPU/CudaMemoryManager.h
index 09af493b3..d1f599ca1 100644
--- a/src/VirtualFluids_GPU/GPU/CudaMemoryManager.h
+++ b/src/VirtualFluids_GPU/GPU/CudaMemoryManager.h
@@ -11,12 +11,25 @@
#include <cuda_runtime.h>
#include <helper_cuda.h>
+#include <curand.h>
+#include <curand_kernel.h>
+
class Parameter;
+class PorousMedia;
-class CudaMemoryManager
+class VF_PUBLIC CudaMemoryManager
{
public:
static std::shared_ptr<CudaMemoryManager> make(std::shared_ptr<Parameter> parameter);
+
+ void setMemsizeGPU(double admem, bool reset);
+ double getMemsizeGPU();
+
+ void cudaAllocFull(int lev);
+ void cudaFreeFull(int lev);
+
+ void cudaCopyPrint(int lev);
+ void cudaCopyMedianPrint(int lev);
void cudaAllocCoord(int lev);
void cudaCopyCoord(int lev);
@@ -27,13 +40,17 @@ public:
void cudaAllocSP(int lev);
void cudaCopySP(int lev);
void cudaFreeSP(int lev);
+
+ void cudaAllocF3SP(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);
@@ -72,6 +89,208 @@ public:
void cudaFreeProcessNeighborZ(int lev, unsigned int processNeighbor);
//////////////////////////////////////////////////////////////////////////
+ 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 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 cudaAllocSlipBC(int lev);
+ void cudaCopySlipBC(int lev);
+ void cudaFreeSlipBC(int lev);
+
+ void cudaAllocGeomValuesBC(int lev);
+ void cudaCopyGeomValuesBC(int lev);
+ void cudaFreeGeomValuesBC(int lev);
+
+ 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 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 cudaFreeConcFile(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 cudaAlloc2ndOrderDerivitivesIsoTest(int lev);
+ void cudaCopy2ndOrderDerivitivesIsoTestDH(int lev);
+ void cudaCopy2ndOrderDerivitivesIsoTestHD(int lev);
+ void cudaFree2ndOrderDerivitivesIsoTest(int lev);
+
+
+ void cudaAllocParticles(int lev);
+ void cudaCopyParticles(int lev);
+ void cudaFreeParticles(int lev);
+
+ void cudaAllocRandomValues();
+
+ void cudaAllocPorousMedia(PorousMedia* pm, int lev);
+ void cudaCopyPorousMedia(PorousMedia* pm, int lev);
+ void cudaFreePorousMedia(PorousMedia* pm, int lev);
+
+ 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);
+
+ 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);
+
+ 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);
+
+
+
+
+
+
+
+
//
//private:
// int coarse, fine, maxlevel;
@@ -86,8 +305,7 @@ private:
CudaMemoryManager(const CudaMemoryManager&);
std::shared_ptr<Parameter> parameter;
+ double memsizeGPU;
};
-
#endif
-
diff --git a/src/VirtualFluids_GPU/Init/DefineGrid.cpp b/src/VirtualFluids_GPU/Init/DefineGrid.cpp
index 5f9eb5af6..ef718cd29 100644
--- a/src/VirtualFluids_GPU/Init/DefineGrid.cpp
+++ b/src/VirtualFluids_GPU/Init/DefineGrid.cpp
@@ -6,14 +6,14 @@
#include <helper_cuda.h>
////////////////////////////////////////////////////////////////////////////////
-void defineGrid(Parameter* para, Communicator* comm)
+void defineGrid(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager)
{
for (int lev=para->getFine(); lev >= para->getCoarse(); lev--)
{
///////////////////////////////////////////////////////////////////////////////////////////////////
// Allocate Host Memory
///////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaAllocFull(lev);
+ cudaManager->cudaAllocFull(lev);
///////////////////////////////////////////////////////////////////////////////////////////////////
if (para->getDiffOn()==true)
{
@@ -372,9 +372,9 @@ void defineGrid(Parameter* para, Communicator* comm)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
para->setSizeMatSparse(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaAllocSP(lev);
+ cudaManager->cudaAllocSP(lev);
//F3
- para->cudaAllocF3SP(lev);
+ cudaManager->cudaAllocF3SP(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Buffer
//sbuf_t.setSize(27,para->getParH(0)->sizePlaneST);
@@ -384,27 +384,27 @@ void defineGrid(Parameter* para, Communicator* comm)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (para->getDiffOn()==true)
{
- para->cudaAllocConc(lev);
+ cudaManager->cudaAllocConc(lev);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
para->fillSparse(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaCopySP(lev);
+ cudaManager->cudaCopySP(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (para->getDiffOn()==true)
{
std::cout << "Maikes Thermo-Stuff...\n" ;
- initTemperatur(para, lev);//thermostuff(lev);
+ initTemperatur(para, cudaManager, lev);//thermostuff(lev);
std::cout << "done.\n";
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if ( lev < para->getFine() && para->getMaxLevel()>=1)
{
//////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaAllocInterfaceCF(lev);
- para->cudaAllocInterfaceFC(lev);
- para->cudaAllocInterfaceOffCF(lev);
- para->cudaAllocInterfaceOffFC(lev);
+ cudaManager->cudaAllocInterfaceCF(lev);
+ cudaManager->cudaAllocInterfaceFC(lev);
+ cudaManager->cudaAllocInterfaceOffCF(lev);
+ cudaManager->cudaAllocInterfaceOffFC(lev);
//////////////////////////////////////////////////////////////////////////////////////////////////////
//Find Interpolation Interface
//////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -429,10 +429,10 @@ void defineGrid(Parameter* para, Communicator* comm)
// para->getParH(lev)->offCF.zOffCF[test] = -para->getParH(lev)->offCF.zOffCF[test];
//}
//////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaCopyInterfaceCF(lev);
- para->cudaCopyInterfaceFC(lev);
- para->cudaCopyInterfaceOffCF(lev);
- para->cudaCopyInterfaceOffFC(lev);
+ cudaManager->cudaCopyInterfaceCF(lev);
+ cudaManager->cudaCopyInterfaceFC(lev);
+ cudaManager->cudaCopyInterfaceOffCF(lev);
+ cudaManager->cudaCopyInterfaceOffFC(lev);
//////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
diff --git a/src/VirtualFluids_GPU/Init/DefineGrid.h b/src/VirtualFluids_GPU/Init/DefineGrid.h
index 34e59bc70..3b8d18adf 100644
--- a/src/VirtualFluids_GPU/Init/DefineGrid.h
+++ b/src/VirtualFluids_GPU/Init/DefineGrid.h
@@ -4,7 +4,8 @@
#include "LBM/LB.h"
#include "Parameter/Parameter.h"
#include "Communication/Communicator.h"
+#include "GPU/CudaMemoryManager.h"
-extern "C" void defineGrid(Parameter* para, Communicator* comm);
+extern "C" void defineGrid(Parameter* para, Communicator* comm, CudaMemoryManager* cudaManager);
#endif
diff --git a/src/VirtualFluids_GPU/Init/InitLattice.cpp b/src/VirtualFluids_GPU/Init/InitLattice.cpp
index 65e3ebf19..c5969ba6e 100644
--- a/src/VirtualFluids_GPU/Init/InitLattice.cpp
+++ b/src/VirtualFluids_GPU/Init/InitLattice.cpp
@@ -6,9 +6,10 @@
#include "GPU/GPU_Interface.h"
#include "Temperature/FindTemperature.h"
#include "PreProcessor/PreProcessor.h"
+#include "GPU/CudaMemoryManager.h"
////////////////////////////////////////////////////////////////////////////////
-void initLattice(SPtr<Parameter> para, SPtr<PreProcessor> preProcessor)
+void initLattice(SPtr<Parameter> para, SPtr<PreProcessor> preProcessor, SPtr<CudaMemoryManager> cudaManager)
{
for (int lev=para->getFine(); lev >= para->getCoarse(); lev--)
{
@@ -69,7 +70,7 @@ void initLattice(SPtr<Parameter> para, SPtr<PreProcessor> preProcessor)
if (para->getDiffOn()==true){
//malloc
//printf("vor cudaAllocConc\n");
- para->cudaAllocConc(lev);
+ cudaManager->cudaAllocConc(lev);
//define init conc/temp
//printf("vor Schleife\n");
for (unsigned int i = 0; i < para->getParH(lev)->size_Mat_SP; i++)
@@ -78,7 +79,7 @@ void initLattice(SPtr<Parameter> para, SPtr<PreProcessor> preProcessor)
}
//malloc and init fs
//printf("vor initTemperatur\n");
- initTemperatur(para.get(), lev);
+ initTemperatur(para.get(), cudaManager.get(), lev);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
diff --git a/src/VirtualFluids_GPU/Init/InitLattice.h b/src/VirtualFluids_GPU/Init/InitLattice.h
index d65485d99..d536c1528 100644
--- a/src/VirtualFluids_GPU/Init/InitLattice.h
+++ b/src/VirtualFluids_GPU/Init/InitLattice.h
@@ -5,7 +5,8 @@
class Parameter;
class PreProcessor;
+class CudaMemoryManager;
-void initLattice(SPtr<Parameter> para, SPtr<PreProcessor> preProcessor);
+void initLattice(SPtr<Parameter> para, SPtr<PreProcessor> preProcessor, SPtr<CudaMemoryManager> cudaManager);
#endif
diff --git a/src/VirtualFluids_GPU/Init/VfReader.cpp b/src/VirtualFluids_GPU/Init/VfReader.cpp
index 189ae2c1b..89d214186 100644
--- a/src/VirtualFluids_GPU/Init/VfReader.cpp
+++ b/src/VirtualFluids_GPU/Init/VfReader.cpp
@@ -1,13 +1,15 @@
#include "Init/VfReader.h"
+#include "GPU/CudaMemoryManager.h"
+
////////////////////////////////////////////////////////////////////////////////
-void readVFkFull(Parameter* para, const std::string geometryFile)
+void readVFkFull(Parameter* para, CudaMemoryManager* cudaManager, const std::string geometryFile)
{
kFullReader::readFileForAlloc(geometryFile, para);
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaAllocFull(lev);
+ cudaManager->cudaAllocFull(lev);
//////////////////////////////////////////////////////////////////////////
for(unsigned int ix3=0; ix3<para->getParH(lev)->nz; ix3++)
{
@@ -58,14 +60,14 @@ void readVFgeoFull(Parameter* para, const std::string geometryFile)
////////////////////////////////////////////////////////////////////////////////
-void readVecSP(Parameter* para)
+void readVecSP(Parameter* para, CudaMemoryManager* cudaManager)
{
PositionReader::readFileForAlloc(para->getgeoVec(), para);
//alloc
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaAllocSP(lev);
+ cudaManager->cudaAllocSP(lev);
}
//geoSP
@@ -94,7 +96,7 @@ void readVecSP(Parameter* para)
para->getParH(lev)->vz_SP_Med[u] = 0.0f;
para->getParH(lev)->press_SP_Med[u] = 0.0f;
}
- para->cudaCopySP(lev);
+ cudaManager->cudaCopySP(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -102,14 +104,14 @@ void readVecSP(Parameter* para)
////////////////////////////////////////////////////////////////////////////////
-void readInterfaceCF(Parameter* para)
+void readInterfaceCF(Parameter* para, CudaMemoryManager* cudaManager)
{
PositionReader::readFileInterfaceForAlloc(para->getscaleCFC(), "CF", para);
//alloc
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaAllocInterfaceCF(lev);
+ cudaManager->cudaAllocInterfaceCF(lev);
}
//Scale Coarse to Fine - Coarse
@@ -120,7 +122,7 @@ void readInterfaceCF(Parameter* para)
//Copy Host -> Device
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaCopyInterfaceCF(lev);
+ cudaManager->cudaCopyInterfaceCF(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -128,14 +130,14 @@ void readInterfaceCF(Parameter* para)
////////////////////////////////////////////////////////////////////////////////
-void readInterfaceFC(Parameter* para)
+void readInterfaceFC(Parameter* para, CudaMemoryManager* cudaManager)
{
PositionReader::readFileInterfaceForAlloc(para->getscaleFCC(), "FC", para);
//alloc
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaAllocInterfaceFC(lev);
+ cudaManager->cudaAllocInterfaceFC(lev);
}
//Scale Fine to Coarse - Coarse
@@ -146,7 +148,7 @@ void readInterfaceFC(Parameter* para)
//Copy Host -> Device
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaCopyInterfaceFC(lev);
+ cudaManager->cudaCopyInterfaceFC(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -154,20 +156,20 @@ void readInterfaceFC(Parameter* para)
////////////////////////////////////////////////////////////////////////////////
-void readInterfaceOffCF(Parameter* para, const std::string geometryFile)
+void readInterfaceOffCF(Parameter* para, CudaMemoryManager* cudaManager, const std::string geometryFile)
{
PositionReader::readFileInterfaceOffsetForAlloc(geometryFile, "CF", para);
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaAllocInterfaceOffCF(lev);
+ cudaManager->cudaAllocInterfaceOffCF(lev);
}
PositionReader::readFileInterfaceOffset(geometryFile, "CF", para);
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaCopyInterfaceOffCF(lev);
+ cudaManager->cudaCopyInterfaceOffCF(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -175,20 +177,20 @@ void readInterfaceOffCF(Parameter* para, const std::string geometryFile)
////////////////////////////////////////////////////////////////////////////////
-void readInterfaceOffFC(Parameter* para, const std::string geometryFile)
+void readInterfaceOffFC(Parameter* para, CudaMemoryManager* cudaManager, const std::string geometryFile)
{
PositionReader::readFileInterfaceOffsetForAlloc(geometryFile, "FC", para);
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaAllocInterfaceOffFC(lev);
+ cudaManager->cudaAllocInterfaceOffFC(lev);
}
PositionReader::readFileInterfaceOffset(geometryFile, "FC", para);
for (int lev = 0; lev < para->getMaxLevel(); lev++)
{
- para->cudaCopyInterfaceOffFC(lev);
+ cudaManager->cudaCopyInterfaceOffFC(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -196,14 +198,14 @@ void readInterfaceOffFC(Parameter* para, const std::string geometryFile)
////////////////////////////////////////////////////////////////////////////////
-void readNoSlipBc(Parameter* para)
+void readNoSlipBc(Parameter* para, CudaMemoryManager* cudaManager)
{
PositionReader::readFileNoSlipBcForAlloc(para->getnoSlipBcPos(), para);
PositionReader::readFileNoSlipBcQreadForAlloc(para->getnoSlipBcQs(), para);
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaAllocWallBC(lev);
+ cudaManager->cudaAllocWallBC(lev);
}
PositionReader::readFileNoSlipBcPos(para->getnoSlipBcPos(), para);
@@ -214,7 +216,7 @@ void readNoSlipBc(Parameter* para)
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaCopyWallBC(lev);
+ cudaManager->cudaCopyWallBC(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -222,14 +224,14 @@ void readNoSlipBc(Parameter* para)
////////////////////////////////////////////////////////////////////////////////
-void readSlipBc(Parameter* para)
+void readSlipBc(Parameter* para, CudaMemoryManager* cudaManager)
{
PositionReader::readFileSlipBcForAlloc(para->getslipBcPos(), para);
PositionReader::readFileSlipBcQreadForAlloc(para->getslipBcQs(), para);
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaAllocSlipBC(lev);
+ cudaManager->cudaAllocSlipBC(lev);
}
PositionReader::readFileSlipBcPos(para->getslipBcPos(), para);
@@ -240,7 +242,7 @@ void readSlipBc(Parameter* para)
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaCopySlipBC(lev);
+ cudaManager->cudaCopySlipBC(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -248,14 +250,14 @@ void readSlipBc(Parameter* para)
////////////////////////////////////////////////////////////////////////////////
-void readPressBc(Parameter* para)
+void readPressBc(Parameter* para, CudaMemoryManager* cudaManager)
{
PositionReader::readFilePressBcForAlloc(para->getpressBcPos(), para);
PositionReader::readFilePressBcQreadForAlloc(para->getpressBcQs(), para);
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaAllocPress(lev);
+ cudaManager->cudaAllocPress(lev);
}
//only Coarse
//para->cudaAllocPress(para->getCoarse());
@@ -268,7 +270,7 @@ void readPressBc(Parameter* para)
for (int lev = 0; lev <= para->getMaxLevel(); lev++)
{
- para->cudaCopyPress(lev);
+ cudaManager->cudaCopyPress(lev);
}
//only Coarse
//para->cudaCopyPress(para->getCoarse());
@@ -278,23 +280,23 @@ void readPressBc(Parameter* para)
////////////////////////////////////////////////////////////////////////////////
-void readPropellerCylinder(Parameter* para)
+void readPropellerCylinder(Parameter* para, CudaMemoryManager* cudaManager)
{
PositionReader::readFilePropellerCylinderForAlloc(para);
- para->cudaAllocVeloPropeller(para->getFine());
+ cudaManager->cudaAllocVeloPropeller(para->getFine());
PositionReader::readFilePropellerCylinder(para);
//PositionReader::definePropellerQs(para);
- para->cudaCopyVeloPropeller(para->getFine());
+ cudaManager->cudaCopyVeloPropeller(para->getFine());
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
-void readMeasurePoints(Parameter* para)
+void readMeasurePoints(Parameter* para, CudaMemoryManager* cudaManager)
{
//read measure points from file
PositionReader::readMeasurePoints(para);
@@ -317,7 +319,7 @@ void readMeasurePoints(Parameter* para)
printf("Level: %d, numberOfValuesMP: %d, memSizeIntkMP: %d, memSizerealkMP: %d\n",lev,para->getParH(lev)->numberOfValuesMP,para->getParH(lev)->memSizeIntkMP, para->getParD(lev)->memSizerealkMP);
- para->cudaAllocMeasurePointsIndex(lev);
+ cudaManager->cudaAllocMeasurePointsIndex(lev);
//loop over all measure points per level
for(int index = 0; index < (int)para->getParH(lev)->MP.size(); index++)
@@ -336,7 +338,7 @@ void readMeasurePoints(Parameter* para)
}
//copy indices-arrays
- para->cudaCopyMeasurePointsIndex(lev);
+ cudaManager->cudaCopyMeasurePointsIndex(lev);
}
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/VirtualFluids_GPU/Init/VfReader.h b/src/VirtualFluids_GPU/Init/VfReader.h
index fe05e04a2..614c269d3 100644
--- a/src/VirtualFluids_GPU/Init/VfReader.h
+++ b/src/VirtualFluids_GPU/Init/VfReader.h
@@ -9,28 +9,30 @@
#include <iostream>
-extern "C" void readVFkFull(Parameter* para, const std::string geometryFile);
+class CudaMemoryManager;
+
+extern "C" void readVFkFull(Parameter* para, CudaMemoryManager* cudaManager, const std::string geometryFile);
extern "C" void readVFgeoFull(Parameter* para, const std::string geometryFile);
-extern "C" void readVecSP(Parameter* para);
+extern "C" void readVecSP(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void readInterfaceCF(Parameter* para);
+extern "C" void readInterfaceCF(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void readInterfaceFC(Parameter* para);
+extern "C" void readInterfaceFC(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void readInterfaceOffCF(Parameter* para, const std::string geometryFile);
+extern "C" void readInterfaceOffCF(Parameter* para, CudaMemoryManager* cudaManager, const std::string geometryFile);
-extern "C" void readInterfaceOffFC(Parameter* para, const std::string geometryFile);
+extern "C" void readInterfaceOffFC(Parameter* para, CudaMemoryManager* cudaManager, const std::string geometryFile);
-extern "C" void readNoSlipBc(Parameter* para);
+extern "C" void readNoSlipBc(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void readSlipBc(Parameter* para);
+extern "C" void readSlipBc(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void readPressBc(Parameter* para);
+extern "C" void readPressBc(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void readPropellerCylinder(Parameter* para);
+extern "C" void readPropellerCylinder(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void readMeasurePoints(Parameter* para);
+extern "C" void readMeasurePoints(Parameter* para, CudaMemoryManager* cudaManager);
#endif
diff --git a/src/VirtualFluids_GPU/LBM/Simulation.cpp b/src/VirtualFluids_GPU/LBM/Simulation.cpp
index 5f80e7b7d..6337455b8 100644
--- a/src/VirtualFluids_GPU/LBM/Simulation.cpp
+++ b/src/VirtualFluids_GPU/LBM/Simulation.cpp
@@ -76,10 +76,11 @@ void Simulation::setFactories(std::shared_ptr<KernelFactory> kernelFactory, std:
}
-void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std::shared_ptr<DataWriter> dataWriter)
+void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std::shared_ptr<DataWriter> dataWriter, std::shared_ptr<CudaMemoryManager> cudaManager)
{
this->dataWriter = dataWriter;
this->gridProvider = gridProvider;
+ this->cudaManager = cudaManager;
gridProvider->initalGridInformations();
comm = Communicator::getInstanz();
this->para = para;
@@ -130,7 +131,7 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
//////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
- para->setMemsizeGPU(0, true);
+ cudaManager->setMemsizeGPU(0, true);
//////////////////////////////////////////////////////////////////////////
gridProvider->allocArrays_CoordNeighborGeo();
gridProvider->allocArrays_BoundaryValues();
@@ -143,6 +144,9 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
//////////////////////////////////////////////////////////////////////////
kernels = kernelFactory->makeKernels(para);
+
+ if (para->getDiffOn())
+ adKernels = kernelFactory->makeAdvDifKernels(para);
//////////////////////////////////////////////////////////////////////////
//PreProcessor init
@@ -157,9 +161,9 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
//////////////////////////////////////////////////////////////////////////
if (para->getCalcParticle())
{
- rearrangeGeometry(para.get());
+ rearrangeGeometry(para.get(), cudaManager.get());
//////////////////////////////////////////////////////////////////////////
- allocParticles(para.get());
+ allocParticles(para.get(), cudaManager.get());
//////////////////////////////////////////////////////////////////////////
////CUDA random number generation
//para->cudaAllocRandomValues();
@@ -193,21 +197,21 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
//////////////////////////////////////////////////////////////////////////
//Allocate Memory for Plane Conc Calculation
//////////////////////////////////////////////////////////////////////////
- if (para->getDiffOn()) allocPlaneConc(para.get());
+ if (para->getDiffOn()) allocPlaneConc(para.get(), cudaManager.get());
//////////////////////////////////////////////////////////////////////////
//Median
//////////////////////////////////////////////////////////////////////////
- if (para->getCalcMedian()) allocMedian(para.get());
+ if (para->getCalcMedian()) allocMedian(para.get(), cudaManager.get());
//////////////////////////////////////////////////////////////////////////
//allocate memory and initialize 2nd, 3rd and higher order moments
//////////////////////////////////////////////////////////////////////////
- if (para->getCalc2ndOrderMoments()){ alloc2ndMoments(para.get()); init2ndMoments(para.get()); }
- if (para->getCalc3rdOrderMoments()){ alloc3rdMoments(para.get()); init3rdMoments(para.get()); }
- if (para->getCalcHighOrderMoments()){ allocHigherOrderMoments(para.get()); initHigherOrderMoments(para.get()); }
+ if (para->getCalc2ndOrderMoments()){ alloc2ndMoments(para.get(), cudaManager.get()); init2ndMoments(para.get()); }
+ if (para->getCalc3rdOrderMoments()){ alloc3rdMoments(para.get(), cudaManager.get()); init3rdMoments(para.get()); }
+ if (para->getCalcHighOrderMoments()){ allocHigherOrderMoments(para.get(), cudaManager.get()); initHigherOrderMoments(para.get()); }
//////////////////////////////////////////////////////////////////////////
@@ -216,7 +220,7 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
if (para->getUseMeasurePoints())
{
output << "read measure points...";
- readMeasurePoints(para.get());
+ readMeasurePoints(para.get(), cudaManager.get());
output << "done.\n";
}
@@ -255,7 +259,7 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
//output << "done.\n";
output << "init lattice..." ;
- initLattice(para, preProcessor);
+ initLattice(para, preProcessor, cudaManager);
output << "done.\n";
//output << "set geo for Q...\n" ;
@@ -301,7 +305,7 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
output << "Alloc Memory for CheckPoint / Restart...";
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaAllocFsForCheckPointAndRestart(lev);
+ cudaManager->cudaAllocFsForCheckPointAndRestart(lev);
}
output << "done.\n";
}
@@ -320,7 +324,7 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
//////////////////////////////////////////////////////////////////////////
- para->cudaCopyFsForRestart(lev);
+ cudaManager->cudaCopyFsForRestart(lev);
//////////////////////////////////////////////////////////////////////////
//macroscopic values
CalcMacSP27(para->getParD(lev)->vx_SP,
@@ -348,13 +352,13 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
//Print Init
//////////////////////////////////////////////////////////////////////////
output << "Print files Init...";
- dataWriter->writeInit(para);
+ dataWriter->writeInit(para, cudaManager);
if (para->getCalcParticle())
- copyAndPrintParticles(para.get(), 0, true);
+ copyAndPrintParticles(para.get(), cudaManager.get(), 0, true);
output << "done.\n";
//////////////////////////////////////////////////////////////////////////
- output << "used Device Memory: " << para->getMemsizeGPU() / 1000000.0 << " MB\n";
+ output << "used Device Memory: " << cudaManager->getMemsizeGPU() / 1000000.0 << " MB\n";
//////////////////////////////////////////////////////////////////////////
@@ -418,7 +422,7 @@ void Simulation::run()
getLastCudaError("before starting a kernel we get an execution failed");
if (para->getMaxLevel()>=1)
{
- updateGrid27(para.get(), comm, pm, 1, para->getMaxLevel(), t);
+ updateGrid27(para.get(), comm, cudaManager.get(), pm, 1, para->getMaxLevel(), t);
}
////////////////////////////////////////////////////////////////////////////////
// Collision and Propagation
@@ -687,21 +691,21 @@ void Simulation::run()
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition
//output << "start exchange Post X (level 0) \n";
- exchangePostCollDataXGPU27(para.get(), comm, 0);
+ exchangePostCollDataXGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "end exchange Post X (level 0) \n";
//output << "start exchange Post Y (level 0) \n";
- exchangePostCollDataYGPU27(para.get(), comm, 0);
+ exchangePostCollDataYGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "end exchange Post Y (level 0) \n";
//output << "start exchange Post Z (level 0) \n";
- exchangePostCollDataZGPU27(para.get(), comm, 0);
+ exchangePostCollDataZGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "end exchange Post Z (level 0) \n";
////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
if (para->getDiffOn()==true)
{
- exchangePostCollDataADXGPU27(para.get(), comm, 0);
- exchangePostCollDataADYGPU27(para.get(), comm, 0);
- exchangePostCollDataADZGPU27(para.get(), comm, 0);
+ exchangePostCollDataADXGPU27(para.get(), comm, cudaManager.get(), 0);
+ exchangePostCollDataADYGPU27(para.get(), comm, cudaManager.get(), 0);
+ exchangePostCollDataADZGPU27(para.get(), comm, cudaManager.get(), 0);
}
}
////////////////////////////////////////////////////////////////////////////////
@@ -1414,21 +1418,21 @@ void Simulation::run()
//exchangePreCollDataGPU27(para, comm, 0);
//3D domain decomposition
//output << "start exchange Pre X (level 0) \n";
- exchangePreCollDataXGPU27(para.get(), comm, 0);
+ exchangePreCollDataXGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "end exchange Pre X (level 0) \n";
//output << "start exchange Pre Y (level 0) \n";
- exchangePreCollDataYGPU27(para.get(), comm, 0);
+ exchangePreCollDataYGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "end exchange Pre Y (level 0) \n";
//output << "start exchange Pre Z (level 0) \n";
- exchangePreCollDataZGPU27(para.get(), comm, 0);
+ exchangePreCollDataZGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "end exchange Pre Z (level 0) \n";
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
if (para->getDiffOn()==true)
{
- exchangePreCollDataADXGPU27(para.get(), comm, 0);
- exchangePreCollDataADYGPU27(para.get(), comm, 0);
- exchangePreCollDataADZGPU27(para.get(), comm, 0);
+ exchangePreCollDataADXGPU27(para.get(), comm, cudaManager.get(), 0);
+ exchangePreCollDataADYGPU27(para.get(), comm, cudaManager.get(), 0);
+ exchangePreCollDataADZGPU27(para.get(), comm, cudaManager.get(), 0);
}
}
//////////////////////////////////////////////////////////////////////////
@@ -1704,7 +1708,7 @@ void Simulation::run()
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaCopyFsForCheckPoint(lev);
+ cudaManager->cudaCopyFsForCheckPoint(lev);
}
output << "Dateien fuer CheckPoint schreiben t=" << t << "...";
@@ -1752,7 +1756,7 @@ void Simulation::run()
{
for (int lev = para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaCopyMeasurePointsToHost(lev);
+ cudaManager->cudaCopyMeasurePointsToHost(lev);
para->copyMeasurePointsArrayToVector(lev);
output << "\n Write MeasurePoints at level = " << lev << " and timestep = " << t << "\n";
for (int j = 0; j < (int)para->getParH(lev)->MP.size(); j++)
@@ -1812,7 +1816,7 @@ void Simulation::run()
//////////////////////////////////////////////////////////////////////////////////
////Calculation of concentration at the plane
//////////////////////////////////////////////////////////////////////////////////
- calcPlaneConc(para.get(), 0);
+ calcPlaneConc(para.get(), cudaManager.get(), 0);
}
//////////////////////////////////////////////////////////////////////////////////
@@ -1868,21 +1872,21 @@ void Simulation::run()
//exchangePreCollDataGPU27(para, comm, 0);
//3D domain decomposition
//output << "(print) start exchange Pre X (level 0) \n";
- exchangePreCollDataXGPU27(para.get(), comm, 0);
+ exchangePreCollDataXGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "(print) end exchange Pre X (level 0) \n";
//output << "(print) start exchange Pre Y (level 0) \n";
- exchangePreCollDataYGPU27(para.get(), comm, 0);
+ exchangePreCollDataYGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "(print) end exchange Pre Y (level 0) \n";
//output << "(print) start exchange Pre Z (level 0) \n";
- exchangePreCollDataZGPU27(para.get(), comm, 0);
+ exchangePreCollDataZGPU27(para.get(), comm, cudaManager.get(), 0);
//output << "(print) end exchange Pre Z (level 0) \n";
//////////////////////////////////////////////////////////////////////////
//3D domain decomposition convection diffusion
if (para->getDiffOn()==true)
{
- exchangePreCollDataADXGPU27(para.get(), comm, 0);
- exchangePreCollDataADYGPU27(para.get(), comm, 0);
- exchangePreCollDataADZGPU27(para.get(), comm, 0);
+ exchangePreCollDataADXGPU27(para.get(), comm, cudaManager.get(), 0);
+ exchangePreCollDataADYGPU27(para.get(), comm, cudaManager.get(), 0);
+ exchangePreCollDataADZGPU27(para.get(), comm, cudaManager.get(), 0);
}
}
//////////////////////////////////////////////////////////////////////////
@@ -1994,10 +1998,10 @@ void Simulation::run()
//}
- para->cudaCopyPrint(lev);
+ cudaManager->cudaCopyPrint(lev);
if (para->getCalcMedian())
{
- para->cudaCopyMedianPrint(lev);
+ cudaManager->cudaCopyMedianPrint(lev);
}
@@ -2031,7 +2035,7 @@ void Simulation::run()
getLastCudaError("CalcMacTh27 execution failed");
}
- para->cudaCopyConcDH(lev);
+ cudaManager->cudaCopyConcDH(lev);
//cudaMemoryCopy(para->getParH(lev)->Conc, para->getParD(lev)->Conc, para->getParH(lev)->mem_size_real_SP , cudaMemcpyDeviceToHost);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2111,9 +2115,9 @@ void Simulation::run()
////////////////////////////////////////////////////////////////////////
//calculate 2nd, 3rd and higher order moments
////////////////////////////////////////////////////////////////////////
- if (para->getCalc2ndOrderMoments()) calc2ndMoments(para.get());
- if (para->getCalc3rdOrderMoments()) calc3rdMoments(para.get());
- if (para->getCalcHighOrderMoments()) calcHigherOrderMoments(para.get());
+ if (para->getCalc2ndOrderMoments()) calc2ndMoments(para.get(), cudaManager.get());
+ if (para->getCalc3rdOrderMoments()) calc3rdMoments(para.get(), cudaManager.get());
+ if (para->getCalcHighOrderMoments()) calcHigherOrderMoments(para.get(), cudaManager.get());
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
@@ -2135,7 +2139,7 @@ void Simulation::run()
////////////////////////////////////////////////////////////////////////
//printDragLift(para, t);
////////////////////////////////////////////////////////////////////////
- if (para->getCalcParticle()) copyAndPrintParticles(para.get(), t, false);
+ if (para->getCalcParticle()) copyAndPrintParticles(para.get(), cudaManager.get(), t, false);
////////////////////////////////////////////////////////////////////////
output << "done.\n";
////////////////////////////////////////////////////////////////////////
@@ -2184,7 +2188,7 @@ void Simulation::run()
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
- if (para->getDiffOn()==true) printPlaneConc(para.get());
+ if (para->getDiffOn()==true) printPlaneConc(para.get(), cudaManager.get());
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -2341,10 +2345,10 @@ void Simulation::definePMarea(std::shared_ptr<PorousMedia> pMedia)
}
output << "definePMarea....cuda copy SP \n";
- para->cudaCopySP(level);
+ cudaManager->cudaCopySP(level);
pMedia->setSizePM(counter);
output << "definePMarea....cuda alloc PM \n";
- para->cudaAllocPorousMedia(pMedia.get(), level);
+ cudaManager->cudaAllocPorousMedia(pMedia.get(), level);
unsigned int *tpmArrayIDs = pMedia->getHostNodeIDsPM();
output << "definePMarea....copy vector to array \n";
@@ -2355,7 +2359,7 @@ void Simulation::definePMarea(std::shared_ptr<PorousMedia> pMedia)
pMedia->setHostNodeIDsPM(tpmArrayIDs);
output << "definePMarea....cuda copy PM \n";
- para->cudaCopyPorousMedia(pMedia.get(), level);
+ cudaManager->cudaCopyPorousMedia(pMedia.get(), level);
}
void Simulation::free()
@@ -2364,11 +2368,11 @@ void Simulation::free()
for (int lev = para->getCoarse(); lev <= para->getFine(); lev++)
{
//para->cudaFreeFull(lev);
- para->cudaFreeCoord(lev);
- para->cudaFreeSP(lev);
+ cudaManager->cudaFreeCoord(lev);
+ cudaManager->cudaFreeSP(lev);
if (para->getCalcMedian())
{
- para->cudaFreeMedianSP(lev);
+ cudaManager->cudaFreeMedianSP(lev);
}
//para->cudaFreeVeloBC(lev);
//para->cudaFreeWallBC(lev);
@@ -2382,10 +2386,10 @@ void Simulation::free()
{
for (int lev = para->getCoarse(); lev < para->getFine(); lev++)
{
- para->cudaFreeInterfaceCF(lev);
- para->cudaFreeInterfaceFC(lev);
- para->cudaFreeInterfaceOffCF(lev);
- para->cudaFreeInterfaceOffFC(lev);
+ cudaManager->cudaFreeInterfaceCF(lev);
+ cudaManager->cudaFreeInterfaceFC(lev);
+ cudaManager->cudaFreeInterfaceOffCF(lev);
+ cudaManager->cudaFreeInterfaceOffFC(lev);
//para->cudaFreePressX1(lev);
}
}
@@ -2421,7 +2425,7 @@ void Simulation::free()
{
for (int lev = para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaFree2ndMoments(lev);
+ cudaManager->cudaFree2ndMoments(lev);
}
}
//////////////////////////////////////////////////////////////////////////
@@ -2430,7 +2434,7 @@ void Simulation::free()
{
for (int lev = para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaFree3rdMoments(lev);
+ cudaManager->cudaFree3rdMoments(lev);
}
}
//////////////////////////////////////////////////////////////////////////
@@ -2439,7 +2443,7 @@ void Simulation::free()
{
for (int lev = para->getCoarse(); lev <= para->getFine(); lev++)
{
- para->cudaFreeHigherMoments(lev);
+ cudaManager->cudaFreeHigherMoments(lev);
}
}
//////////////////////////////////////////////////////////////////////////
@@ -2468,17 +2472,17 @@ void Simulation::free()
//////////////////////////////////////////////////////////////////////////
for (unsigned int i = 0; i < para->getNumberOfProcessNeighborsX(lev, "send"); i++)
{
- para->cudaFreeProcessNeighborX(lev, i);
+ cudaManager->cudaFreeProcessNeighborX(lev, i);
}
//////////////////////////////////////////////////////////////////////////
for (unsigned int i = 0; i < para->getNumberOfProcessNeighborsY(lev, "send"); i++)
{
- para->cudaFreeProcessNeighborY(lev, i);
+ cudaManager->cudaFreeProcessNeighborY(lev, i);
}
//////////////////////////////////////////////////////////////////////////
for (unsigned int i = 0; i < para->getNumberOfProcessNeighborsZ(lev, "send"); i++)
{
- para->cudaFreeProcessNeighborZ(lev, i);
+ cudaManager->cudaFreeProcessNeighborZ(lev, i);
}
}
}
@@ -2487,7 +2491,7 @@ void Simulation::free()
if (para->getIsGeoNormal()) {
for (int lev = para->getCoarse(); lev < para->getFine(); lev++)
{
- para->cudaFreeGeomNormals(lev);
+ cudaManager->cudaFreeGeomNormals(lev);
}
}
//////////////////////////////////////////////////////////////////////////
diff --git a/src/VirtualFluids_GPU/LBM/Simulation.h b/src/VirtualFluids_GPU/LBM/Simulation.h
index ad46bd9da..a5dc4987e 100644
--- a/src/VirtualFluids_GPU/LBM/Simulation.h
+++ b/src/VirtualFluids_GPU/LBM/Simulation.h
@@ -12,6 +12,7 @@
#include "LBM/LB.h"
class Communicator;
+class CudaMemoryManager;
class Parameter;
class GridProvider;
class PorousMedia;
@@ -31,7 +32,7 @@ public:
Simulation();
~Simulation();
void run();
- void init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std::shared_ptr<DataWriter> dataWriter);
+ void init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std::shared_ptr<DataWriter> dataWriter, std::shared_ptr<CudaMemoryManager> cudaManager);
void free();
void bulk();
void porousMedia();
@@ -60,6 +61,7 @@ protected:
SPtr<Parameter> para;
SPtr<GridProvider> gridProvider;
SPtr<DataWriter> dataWriter;
+ SPtr<CudaMemoryManager> cudaManager;
std::vector < SPtr< Kernel>> kernels;
std::vector < SPtr< ADKernel>> adKernels;
std::shared_ptr<PreProcessor> preProcessor;
diff --git a/src/VirtualFluids_GPU/Output/DataWriter.h b/src/VirtualFluids_GPU/Output/DataWriter.h
index bd1f996a4..95cd9122b 100644
--- a/src/VirtualFluids_GPU/Output/DataWriter.h
+++ b/src/VirtualFluids_GPU/Output/DataWriter.h
@@ -8,6 +8,7 @@
class Parameter;
+class CudaMemoryManager;
class DataWriter
{
@@ -15,7 +16,7 @@ public:
DataWriter() {}
virtual ~DataWriter() {}
- virtual void writeInit(std::shared_ptr<Parameter> para) = 0;
+ virtual void writeInit(std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager) = 0;
virtual void writeTimestep(std::shared_ptr<Parameter> para, unsigned int t) = 0;
DataWriter(const DataWriter& dataWriter) {}
diff --git a/src/VirtualFluids_GPU/Output/FileWriter.cpp b/src/VirtualFluids_GPU/Output/FileWriter.cpp
index 38bb81103..d3026e497 100644
--- a/src/VirtualFluids_GPU/Output/FileWriter.cpp
+++ b/src/VirtualFluids_GPU/Output/FileWriter.cpp
@@ -8,17 +8,18 @@
#include <utilities/StringUtil/StringUtil.h>
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
#include "LBM/LB.h"
#include "LBM/D3Q27.h"
#include <VirtualFluidsBasics/basics/writer/WbWriterVtkXmlBinary.h>
-void FileWriter::writeInit(std::shared_ptr<Parameter> para)
+void FileWriter::writeInit(std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager)
{
unsigned int timestep = para->getTInit();
for (int level = para->getCoarse(); level <= para->getFine(); level++) {
- para->cudaCopyPrint(level);
+ cudaManager->cudaCopyPrint(level);
writeTimestep(para, timestep, level);
}
diff --git a/src/VirtualFluids_GPU/Output/FileWriter.h b/src/VirtualFluids_GPU/Output/FileWriter.h
index 23d830964..cf14a40d4 100644
--- a/src/VirtualFluids_GPU/Output/FileWriter.h
+++ b/src/VirtualFluids_GPU/Output/FileWriter.h
@@ -8,13 +8,14 @@
#include "DataWriter.h"
class Parameter;
+class CudaMemoryManager;
class FileWriter : public DataWriter
{
public:
VF_PUBLIC FileWriter() {}
- void VF_PUBLIC writeInit(std::shared_ptr<Parameter> para) override;
+ void VF_PUBLIC writeInit(std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager) override;
void VF_PUBLIC writeTimestep(std::shared_ptr<Parameter> para, unsigned int timestep) override;
private:
diff --git a/src/VirtualFluids_GPU/Output/WriteData.cpp b/src/VirtualFluids_GPU/Output/WriteData.cpp
index 98e289cfb..36ad314af 100644
--- a/src/VirtualFluids_GPU/Output/WriteData.cpp
+++ b/src/VirtualFluids_GPU/Output/WriteData.cpp
@@ -12,18 +12,19 @@
#include "Output/MeasurePointWriter.hpp"
#include "Parameter/Parameter.h"
+#include "GPU/CudaMemoryManager.h"
////////////////////////////////////////////////////////////////////////////////
-void writeInit(SPtr<Parameter> para)
+void writeInit(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaManager)
{
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy Data to host
- para->cudaCopyPrint(lev);
- if (para->getCalcMedian()) para->cudaCopyMedianPrint(lev);
- if (para->getUseWale()) para->cudaCopyTurbulentViscosityDH(lev);
+ cudaManager->cudaCopyPrint(lev);
+ if (para->getCalcMedian()) cudaManager->cudaCopyMedianPrint(lev);
+ if (para->getUseWale()) cudaManager->cudaCopyTurbulentViscosityDH(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const unsigned int numberOfParts = para->getParH(lev)->size_Mat_SP / para->getlimitOfNodesForVTK() + 1;
std::vector<std::string> fname;
@@ -187,13 +188,13 @@ void writeInit(SPtr<Parameter> para)
////////////////////////////////////////////////////////////////////////////////
-void writeTimestep(Parameter* para, unsigned int t)
+void writeTimestep(Parameter* para, CudaMemoryManager* cudaManager, unsigned int t)
{
////////////////////////////////////////////////////////////////////////////////
for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- if (para->getUseWale()) para->cudaCopyTurbulentViscosityDH(lev);
+ if (para->getUseWale()) cudaManager->cudaCopyTurbulentViscosityDH(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const unsigned int numberOfParts = para->getParH(lev)->size_Mat_SP / para->getlimitOfNodesForVTK() + 1;
std::vector<std::string> fname;
diff --git a/src/VirtualFluids_GPU/Output/WriteData.h b/src/VirtualFluids_GPU/Output/WriteData.h
index d0b29e46f..5d7b28c2a 100644
--- a/src/VirtualFluids_GPU/Output/WriteData.h
+++ b/src/VirtualFluids_GPU/Output/WriteData.h
@@ -4,9 +4,10 @@
#include <core/PointerDefinitions.h>
class Parameter;
+class CudaMemoryManager;
-void writeInit(SPtr<Parameter> para);
-void writeTimestep(Parameter* para, unsigned int t);
+void writeInit(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaManager);
+void writeTimestep(Parameter* para, CudaMemoryManager* cudaManager, unsigned int t);
void writeParticle(Parameter* para, unsigned int t);
#endif
diff --git a/src/VirtualFluids_GPU/Parameter/Parameter.cpp b/src/VirtualFluids_GPU/Parameter/Parameter.cpp
index 4d13f6faf..46d438cbd 100644
--- a/src/VirtualFluids_GPU/Parameter/Parameter.cpp
+++ b/src/VirtualFluids_GPU/Parameter/Parameter.cpp
@@ -415,2313 +415,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));
-}
-//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));
-}
-//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 für 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 für 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 für 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));
-}
-void Parameter::cudaCopyConcDH(int lev)
-{
- 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));
- }
-}
-//////////////////////////////////////////////////////////////////////////
-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));
-}
-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));
-
-}
-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;
-
- //Host
- checkCudaErrors( cudaMallocHost((void**) &(parH[lev]->concIndex), mem_size_int ));
-
- //Device
- checkCudaErrors( cudaMalloc((void**) &(parD[lev]->concIndex), mem_size_int ));
-
- //////////////////////////////////////////////////////////////////////////
- double tmp = (double)mem_size_int;
- setMemsizeGPU(tmp, false);
-}
-void Parameter::cudaCopyConcFile(int lev)
-{
- unsigned int mem_size_int = sizeof(unsigned int) * parH[lev]->numberOfPointsConc;
-
- checkCudaErrors( cudaMemcpy(parD[lev]->concIndex, parH[lev]->concIndex, mem_size_int, cudaMemcpyHostToDevice));
-}
-void Parameter::cudaFreeConcFile(int lev)
-{
- checkCudaErrors( cudaFreeHost(parH[lev]->concIndex));
-}
-//////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////
-//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] ));
-}
-void Parameter::cudaAlloc2ndOrderDerivitivesIsoTest(int lev)
-{
- //Host
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->dxxUx), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->dyyUy), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMallocHost((void**) &(parH[lev]->dzzUz), parH[lev]->mem_size_real_SP));
- //Device (spinning ship)
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->dxxUx), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->dyyUy), parH[lev]->mem_size_real_SP));
- checkCudaErrors(cudaMalloc((void**) &(parD[lev]->dzzUz), 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::cudaCopy2ndOrderDerivitivesIsoTestDH(int lev)
-{
- //copy device to host
- checkCudaErrors(cudaMemcpy(parH[lev]->dxxUx, parD[lev]->dxxUx, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->dyyUy, parD[lev]->dyyUy, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
- checkCudaErrors(cudaMemcpy(parH[lev]->dzzUz, parD[lev]->dzzUz, parH[lev]->mem_size_real_SP, cudaMemcpyDeviceToHost));
-}
-void Parameter::cudaCopy2ndOrderDerivitivesIsoTestHD(int lev)
-{
- //copy host to device
- checkCudaErrors(cudaMemcpy(parD[lev]->dxxUx, parH[lev]->dxxUx, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->dyyUy, parH[lev]->dyyUy, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
- checkCudaErrors(cudaMemcpy(parD[lev]->dzzUz, parH[lev]->dzzUz, parH[lev]->mem_size_real_SP, cudaMemcpyHostToDevice));
-
-}
-void Parameter::cudaFree2ndOrderDerivitivesIsoTest(int lev)
-{
- checkCudaErrors(cudaFreeHost(parH[lev]->dxxUx));
- checkCudaErrors(cudaFreeHost(parH[lev]->dyyUy));
- checkCudaErrors(cudaFreeHost(parH[lev]->dzzUz));
-
-}
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//set-methods
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Parameter::setForcing(real forcingX, real forcingY, real forcingZ)
{
this->hostForcing[0] = forcingX;
@@ -3381,17 +1074,6 @@ void Parameter::setCalcHighOrderMoments(bool isHighOrderMoments)
{
ic.isHighOrderMoments = isHighOrderMoments;
}
-void Parameter::setMemsizeGPU(double admem, bool reset)
-{
- if (reset == true)
- {
- this->memsizeGPU = 0.;
- }
- else
- {
- this->memsizeGPU += admem;
- }
-}
//1D domain decomposition
void Parameter::setPossNeighborFiles(std::vector<std::string> possNeighborFiles, std::string sor)
{
@@ -4318,10 +2000,6 @@ unsigned int Parameter::getTimestepForMP()
{
return ic.timeStepForMP;
}
-double Parameter::getMemsizeGPU()
-{
- return this->memsizeGPU;
-}
//1D domain decomposition
std::vector<std::string> Parameter::getPossNeighborFiles(std::string sor)
{
diff --git a/src/VirtualFluids_GPU/Parameter/Parameter.h b/src/VirtualFluids_GPU/Parameter/Parameter.h
index 8834d87b1..822f2f23c 100644
--- a/src/VirtualFluids_GPU/Parameter/Parameter.h
+++ b/src/VirtualFluids_GPU/Parameter/Parameter.h
@@ -17,7 +17,7 @@
#include "core/PointerDefinitions.h"
#include "VirtualFluidsDefinitions.h"
-#include "Kernel//Utilities/KernelType.h"
+#include "Kernel/Utilities/KernelType.h"
//struct
struct ParameterStruct{
@@ -291,270 +291,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 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 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 cudaFreeConcFile(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();
-
- void cudaAlloc2ndOrderDerivitivesIsoTest(int lev);
- void cudaCopy2ndOrderDerivitivesIsoTestDH(int lev);
- void cudaCopy2ndOrderDerivitivesIsoTestHD(int lev);
- void cudaFree2ndOrderDerivitivesIsoTest(int lev);
-
- //////////////////////////////////////////////////////////////////////////
- //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
@@ -711,7 +447,7 @@ public:
void setCalc2ndOrderMoments(bool is2ndOrderMoments);
void setCalc3rdOrderMoments(bool is3rdOrderMoments);
void setCalcHighOrderMoments(bool isHighOrderMoments);
- void setMemsizeGPU(double admem, bool reset);
+
//1D domain decomposition
void setPossNeighborFiles(std::vector<std::string> possNeighborFiles, std::string sor);
void setNumberOfProcessNeighbors(unsigned int numberOfProcessNeighbors, int level, std::string sor);
@@ -916,7 +652,6 @@ public:
bool getUseMeasurePoints();
bool getUseWale();
bool getSimulatePorousMedia();
- double getMemsizeGPU();
//1D domain decomposition
std::vector<std::string> getPossNeighborFiles(std::string sor);
unsigned int getNumberOfProcessNeighbors(int level, std::string sor);
@@ -968,7 +703,7 @@ private:
int factor_gridNZ;
int D3Qxx;
InitCondition ic;
- double memsizeGPU;
+
unsigned int limitOfNodesForVTK;
unsigned int outputCount;
diff --git a/src/VirtualFluids_GPU/Particles/Particles.cpp b/src/VirtualFluids_GPU/Particles/Particles.cpp
index 8e82b5258..75c894c4b 100644
--- a/src/VirtualFluids_GPU/Particles/Particles.cpp
+++ b/src/VirtualFluids_GPU/Particles/Particles.cpp
@@ -16,7 +16,7 @@
using namespace std;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void allocParticles(Parameter* para)
+void allocParticles(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev = para->getParticleBasicLevel(); lev <= para->getFine(); lev++)
{
@@ -44,7 +44,7 @@ void allocParticles(Parameter* para)
para->getParD(lev)->plp.memSizeBoolBC = para->getParH(lev)->plp.memSizeBoolBC;
//////////////////////////////////////////////////////////////////////////
//alloc particles
- para->cudaAllocParticles(lev);
+ cudaManager->cudaAllocParticles(lev);
//////////////////////////////////////////////////////////////////////////
}
}
@@ -346,7 +346,7 @@ void propagateParticles(Parameter* para, unsigned int t)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void copyAndPrintParticles(Parameter* para, unsigned int t, bool isInit)
+void copyAndPrintParticles(Parameter* para, CudaMemoryManager* cudaManager, unsigned int t, bool isInit)
{
//cout << endl << " t " << t << endl;
@@ -362,7 +362,7 @@ void copyAndPrintParticles(Parameter* para, unsigned int t, bool isInit)
{
//////////////////////////////////////////////////////////////////////////
//copy particles from device to host
- para->cudaCopyParticles(lev);
+ cudaManager->cudaCopyParticles(lev);
//////////////////////////////////////////////////////////////////////////
////test output
//int maximumT = para->getParH(lev)->plp.numberOfParticles * para->getParH(lev)->plp.numberOfTimestepsParticles;
@@ -447,7 +447,7 @@ void copyAndPrintParticles(Parameter* para, unsigned int t, bool isInit)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void rearrangeGeometry(Parameter* para)
+void rearrangeGeometry(Parameter* para, CudaMemoryManager* cudaManager)
{
for (int lev = para->getCoarse(); lev <= para->getFine(); lev++)
{
@@ -474,7 +474,7 @@ void rearrangeGeometry(Parameter* para)
}
//////////////////////////////////////////////////////////////////////////
//copy geometry nodes to the device
- para->cudaCopySP(lev);
+ cudaManager->cudaCopySP(lev);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/VirtualFluids_GPU/Particles/Particles.h b/src/VirtualFluids_GPU/Particles/Particles.h
index 14ae56f76..4dcea815a 100644
--- a/src/VirtualFluids_GPU/Particles/Particles.h
+++ b/src/VirtualFluids_GPU/Particles/Particles.h
@@ -3,15 +3,16 @@
#include "LBM/LB.h"
#include "GPU/GPU_Interface.h"
+#include "GPU/CudaMemoryManager.h"
#include "Utilities/StringUtil.hpp"
#include "Parameter/Parameter.h"
//extern "C" void calcDragLift(Parameter* para, int lev);
-extern "C" void allocParticles(Parameter* para);
+extern "C" void allocParticles(Parameter* para, CudaMemoryManager* cudaManager);
extern "C" void initParticles(Parameter* para);
extern "C" void propagateParticles(Parameter* para, unsigned int t);
-extern "C" void copyAndPrintParticles(Parameter* para, unsigned int t, bool isInit);
+extern "C" void copyAndPrintParticles(Parameter* para, CudaMemoryManager* cudaManager, unsigned int t, bool isInit);
-extern "C" void rearrangeGeometry(Parameter* para);
+extern "C" void rearrangeGeometry(Parameter* para, CudaMemoryManager* cudaManager);
#endif
diff --git a/src/VirtualFluids_GPU/Temperature/FindTemperature.cpp b/src/VirtualFluids_GPU/Temperature/FindTemperature.cpp
index 254c3ee8e..10f148ef2 100644
--- a/src/VirtualFluids_GPU/Temperature/FindTemperature.cpp
+++ b/src/VirtualFluids_GPU/Temperature/FindTemperature.cpp
@@ -2,19 +2,21 @@
#include <cuda_runtime.h>
#include <helper_cuda.h>
-void initTemperatur(Parameter* para, int lev)
+#include "GPU/CudaMemoryManager.h"
+
+void initTemperatur(Parameter* para, CudaMemoryManager* cudaManager, int lev)
{
printf("innerhalb initTemperatur\n");
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// alloc F's
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- para->cudaAllocTempFs(lev);
+ cudaManager->cudaAllocTempFs(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//printf("nach cudaAllocTempFs\n");
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy host to device
- para->cudaCopyConcHD(lev);
+ cudaManager->cudaCopyConcHD(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//printf("nach cudaCopyConcHD\n");
@@ -83,7 +85,7 @@ void initTemperatur(Parameter* para, int lev)
//printf("vor cudaCopyConcDH\n");
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//copy device to host
- para->cudaCopyConcDH(lev);
+ cudaManager->cudaCopyConcDH(lev);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -95,15 +97,15 @@ void initTemperatur(Parameter* para, int lev)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void findTempSim(Parameter* para)
+void findTempSim(Parameter* para, CudaMemoryManager* cudaManager)
{
findKforTemp(para);
- para->cudaAllocTempNoSlipBC(para->getCoarse());
+ cudaManager->cudaAllocTempNoSlipBC(para->getCoarse());
findTemp(para);
- para->cudaCopyTempNoSlipBCHD(para->getCoarse());
+ cudaManager->cudaCopyTempNoSlipBCHD(para->getCoarse());
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -114,15 +116,15 @@ void findTempSim(Parameter* para)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void findTempVelSim(Parameter* para)
+void findTempVelSim(Parameter* para, CudaMemoryManager* cudaManager)
{
findKforTempVel(para);
- para->cudaAllocTempVeloBC(para->getCoarse());
+ cudaManager->cudaAllocTempVeloBC(para->getCoarse());
findTempVel(para);
- para->cudaCopyTempVeloBCHD(para->getCoarse());
+ cudaManager->cudaCopyTempVeloBCHD(para->getCoarse());
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -133,14 +135,14 @@ void findTempVelSim(Parameter* para)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void findTempPressSim(Parameter* para)
+void findTempPressSim(Parameter* para, CudaMemoryManager* cudaManager)
{
findKforTempPress(para);
- para->cudaAllocTempPressBC(para->getCoarse());
+ cudaManager->cudaAllocTempPressBC(para->getCoarse());
findTempPress(para);
- para->cudaCopyTempPressBCHD(para->getCoarse());
+ cudaManager->cudaCopyTempPressBCHD(para->getCoarse());
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/VirtualFluids_GPU/Temperature/FindTemperature.h b/src/VirtualFluids_GPU/Temperature/FindTemperature.h
index afb571d9f..4520e157d 100644
--- a/src/VirtualFluids_GPU/Temperature/FindTemperature.h
+++ b/src/VirtualFluids_GPU/Temperature/FindTemperature.h
@@ -6,12 +6,14 @@
#include "Parameter/Parameter.h"
#include "Temperature/FindQTemp.h"
-extern "C" void initTemperatur(Parameter* para, int lev);
+class CudaMemoryManager;
-extern "C" void findTempSim(Parameter* para);
+extern "C" void initTemperatur(Parameter* para, CudaMemoryManager* cudaManager, int lev);
+
+extern "C" void findTempSim(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void findTempVelSim(Parameter* para);
+extern "C" void findTempVelSim(Parameter* para, CudaMemoryManager* cudaManager);
-extern "C" void findTempPressSim(Parameter* para);
+extern "C" void findTempPressSim(Parameter* para, CudaMemoryManager* cudaManager);
#endif
diff --git a/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.cpp b/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.cpp
index f0dc74913..5a779e0c9 100644
--- a/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.cpp
+++ b/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.cpp
@@ -2,10 +2,13 @@
#include "VirtualFluids_GPU/Output/FileWriter.h"
#include "VirtualFluids_GPU/Parameter/Parameter.h"
+#include "VirtualFluids_GPU/GPU/CudaMemoryManager.h"
#include "VirtualFluids_GPU/Output/FileWriter.h"
#include "Utilities/Structs/VectorWriterInformationStruct.h"
+#include "GPU/CudaMemoryManager.h"
+
ToVectorWriter::ToVectorWriter(std::shared_ptr<VectorWriterInformationStruct> vectorWriterInfo, unsigned int timeStepLength)
{
this->startTimeVectorWriter = vectorWriterInfo->startTimeVectorWriter;
@@ -17,10 +20,14 @@ ToVectorWriter::ToVectorWriter(std::shared_ptr<VectorWriterInformationStruct> ve
this->timeStepLength = timeStepLength;
}
-void ToVectorWriter::writeInit(std::shared_ptr<Parameter> para)
+void ToVectorWriter::writeInit(std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager)
{
- if (startTimeVectorWriter == 0)
+ if (startTimeVectorWriter == 0) {
+ for (int level = para->getCoarse(); level <= para->getFine(); level++)
+ cudaManager->cudaCopyPrint(level);
writeTimestep(para, 0);
+ }
+
if (writeVTKFiles && startTimeVTKWriter == 0)
vtkFileWriter->writeTimestep(para, 0);
}
@@ -29,12 +36,8 @@ void ToVectorWriter::writeTimestep(std::shared_ptr<Parameter> para, unsigned int
{
if (startTimeVectorWriter <= t)
{
- for (int level = para->getCoarse(); level <= para->getFine(); level++)
- {
- if(t==0)
- para->cudaCopyPrint(level);
+ for (int level = para->getCoarse(); level <= para->getFine(); level++)
writeTimestep(para, t, level);
- }
}
if (writeVTKFiles && startTimeVTKWriter < t)
vtkFileWriter->writeTimestep(para, t);
diff --git a/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.h b/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.h
index 2e05defda..43f0ae86e 100644
--- a/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.h
+++ b/targets/tests/NumericalTests/Utilities/DataWriter/ToVectorWriter.h
@@ -10,7 +10,7 @@ struct VectorWriterInformationStruct;
class ToVectorWriter : public DataWriter
{
public:
- void writeInit(std::shared_ptr<Parameter> para);
+ void writeInit(std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager);
void writeTimestep(std::shared_ptr<Parameter> para, unsigned int t);
protected:
diff --git a/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp b/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp
index a3f36f3c8..83ab9630f 100644
--- a/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp
+++ b/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.cpp
@@ -8,9 +8,9 @@
#include <math.h>
-std::shared_ptr<NumericalTestGridReader> NumericalTestGridReader::getNewInstance(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition)
+std::shared_ptr<NumericalTestGridReader> NumericalTestGridReader::getNewInstance(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<CudaMemoryManager> cudaManager)
{
- return std::shared_ptr<NumericalTestGridReader>(new NumericalTestGridReader(para, initialCondition));
+ return std::shared_ptr<NumericalTestGridReader>(new NumericalTestGridReader(para, initialCondition, cudaManager));
}
void NumericalTestGridReader::setInitalNodeValues(const int numberOfNodes, const int level) const
@@ -25,7 +25,7 @@ void NumericalTestGridReader::setInitalNodeValues(const int numberOfNodes, const
}
}
-NumericalTestGridReader::NumericalTestGridReader(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition) : GridReader(true, para), initialCondition(initialCondition)
+NumericalTestGridReader::NumericalTestGridReader(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<CudaMemoryManager> cudaManager) : GridReader(true, para, cudaManager), initialCondition(initialCondition)
{
}
\ No newline at end of file
diff --git a/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h b/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h
index d3d9d5f41..b766e4bab 100644
--- a/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h
+++ b/targets/tests/NumericalTests/Utilities/NumericalTestGridReader/NumericalTestGridReader.h
@@ -10,13 +10,13 @@ class InitialCondition;
class NumericalTestGridReader : public GridReader
{
public:
- static std::shared_ptr<NumericalTestGridReader> getNewInstance(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition);
+ static std::shared_ptr<NumericalTestGridReader> getNewInstance(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<CudaMemoryManager> cudaManager);
protected:
void setInitalNodeValues(const int numberOfNodes, const int level) const;
private:
- NumericalTestGridReader(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition);
+ NumericalTestGridReader(std::shared_ptr<Parameter> para, std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<CudaMemoryManager> cudaManager);
std::shared_ptr<InitialCondition> initialCondition;
diff --git a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.cpp b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.cpp
index 7dc3a7979..35b0369f9 100644
--- a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.cpp
+++ b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.cpp
@@ -12,7 +12,7 @@ void VirtualFluidSimulationImp::run()
numericalTestSuite->makeSimulationHeadOutput();
Simulation sim;
sim.setFactories(kernelFactory, preProcessorFactory);
- sim.init(para, grid, dataWriter);
+ sim.init(para, grid, dataWriter, cudaManager);
timeTracking->setSimulationStartTime();
sim.run();
@@ -28,6 +28,11 @@ void VirtualFluidSimulationImp::setParameter(std::shared_ptr<Parameter> para)
this->para = para;
}
+void VirtualFluidSimulationImp::setCudaMemoryManager(std::shared_ptr<CudaMemoryManager> cudaManager)
+{
+ this->cudaManager = cudaManager;
+}
+
void VirtualFluidSimulationImp::setGridProvider(std::shared_ptr<GridProvider> grid)
{
this->grid = grid;
diff --git a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.h b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.h
index b50dcadf6..492459052 100644
--- a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.h
+++ b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.h
@@ -6,6 +6,7 @@
#include <string>
#include <memory>
+class CudaMemoryManager;
class InitialCondition;
class DataWriter;
class Parameter;
@@ -25,6 +26,7 @@ public:
static std::shared_ptr<VirtualFluidSimulationImp> getNewInstance();
void setParameter(std::shared_ptr<Parameter> para);
+ void setCudaMemoryManager(std::shared_ptr<CudaMemoryManager> cudaManager);
void setGridProvider(std::shared_ptr<GridProvider> grid);
void setDataWriter(std::shared_ptr<DataWriter> dataWriter);
void setNumericalTestSuite(std::shared_ptr<NumericalTestSuite> numericalTestSuite);
@@ -38,6 +40,7 @@ protected:
private:
std::shared_ptr<Parameter> para;
+ std::shared_ptr<CudaMemoryManager> cudaManager;
std::shared_ptr<InitialCondition> initialCondition;
std::shared_ptr<GridProvider> grid;
std::shared_ptr<DataWriter> dataWriter;
diff --git a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.cpp b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.cpp
index 0933fbd22..aab629f63 100644
--- a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.cpp
+++ b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.cpp
@@ -7,6 +7,7 @@
#include "Utilities/SimulationParameter/SimulationParameter.h"
#include "Utilities/VirtualFluidSimulation/VirtualFluidSimulationImp.h"
+#include "VirtualFluids_GPU/GPU/CudaMemoryManager.h"
#include "VirtualFluids_GPU/Parameter/Parameter.h"
#include "VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.h"
#include "VirtualFluids_GPU/PreProcessor/PreProcessorFactory/PreProcessorFactoryImp.h"
@@ -110,12 +111,18 @@ std::shared_ptr<Parameter> VirtualFluidSimulationFactoryImp::makeParameter(std::
return para;
}
-std::shared_ptr<NumericalTestGridReader> VirtualFluidSimulationFactoryImp::makeGridReader(std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<Parameter> para)
+std::shared_ptr<NumericalTestGridReader> VirtualFluidSimulationFactoryImp::makeGridReader(std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager)
{
- std::shared_ptr<NumericalTestGridReader> grid = NumericalTestGridReader::getNewInstance(para, initialCondition);
+ std::shared_ptr<NumericalTestGridReader> grid = NumericalTestGridReader::getNewInstance(para, initialCondition, cudaManager);
return grid;
}
+std::shared_ptr<CudaMemoryManager> VirtualFluidSimulationFactoryImp::makeCudaMemoryManager(std::shared_ptr<Parameter> para)
+{
+ std::shared_ptr<CudaMemoryManager> cudaManager = CudaMemoryManager::make(para);
+ return cudaManager;
+}
+
void VirtualFluidSimulationFactoryImp::initInitialConditions(std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<Parameter> para)
{
initialCondition->setParameter(para);
@@ -135,8 +142,11 @@ std::vector<std::shared_ptr<VirtualFluidSimulation> > VirtualFluidSimulationFact
vfSim->setParameter(para);
testSim.at(i)->setParameter(para);
+ std::shared_ptr<CudaMemoryManager> cudaManager = makeCudaMemoryManager(para);
+ vfSim->setCudaMemoryManager(cudaManager);
+
initInitialConditions(testSim.at(i)->getInitialCondition(), para);
- std::shared_ptr<NumericalTestGridReader> grid = makeGridReader(testSim.at(i)->getInitialCondition(), para);
+ std::shared_ptr<NumericalTestGridReader> grid = makeGridReader(testSim.at(i)->getInitialCondition(), para, cudaManager);
vfSim->setGridProvider(grid);
vfSim->setDataWriter(testSim.at(i)->getDataWriter());
diff --git a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.h b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.h
index 58a28d90f..07e6b6ebb 100644
--- a/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.h
+++ b/targets/tests/NumericalTests/Utilities/VirtualFluidSimulationFactory/VirtualFluidSimulationFactoryImp.h
@@ -3,6 +3,7 @@
#include "VirtualFluidSimulationFactory.h"
+class CudaMemoryManager;
class NumericalTestGridReader;
class InitialCondition;
class Parameter;
@@ -18,7 +19,8 @@ protected:
VirtualFluidSimulationFactoryImp();
std::shared_ptr<Parameter> makeParameter(std::shared_ptr<SimulationParameter> simPara);
- std::shared_ptr<NumericalTestGridReader> makeGridReader(std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<Parameter> para);
+ std::shared_ptr<NumericalTestGridReader> makeGridReader(std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaManager);
+ std::shared_ptr<CudaMemoryManager> makeCudaMemoryManager(std::shared_ptr<Parameter> para);
void initInitialConditions(std::shared_ptr<InitialCondition> initialCondition, std::shared_ptr<Parameter> para);
private:
--
GitLab