AdvectionDiffusion to ADKernelManager

src/gpu/VirtualFluids_GPU/AdvectionDiffusion/AdvectionDiffusion.cpp → src/gpu/VirtualFluids_GPU/AdvectionDiffusion/ADKernelManager.cpp

@@ -30,13 +30,13 @@
 //! \ingroup AdvectionDiffusion
 //! \author Martin Schoenherr
 //=======================================================================================
-#include "AdvectionDiffusion/AdvectionDiffusion.h"
+#include "AdvectionDiffusion/ADKernelManager.h"
 #include "GPU/CudaMemoryManager.h"
 #include "GPU/GPU_Interface.h"
 #include "Parameter/Parameter.h"
 
 ////////////////////////////////////////////////////////////////////////////////
-void initAD(SPtr<Parameter> para)
+void ADKernelManager::initAD()
 {
     //////////////////////////////////////////////////////////////////////////
     // calculation of omega for diffusivity
@@ -87,7 +87,7 @@ void initAD(SPtr<Parameter> para)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void setInitialNodeValuesAD(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager)
+void ADKernelManager::setInitialNodeValuesAD(SPtr<CudaMemoryManager> cudaMemoryManager)
 {
     for (uint j = 1; j <= para->getParH()->numberOfNodes; j++) {
         const real coordX = para->getParH()->coordinateX[j];
@@ -110,7 +110,7 @@ void setInitialNodeValuesAD(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMe
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void runADcollisionKernel(SPtr<Parameter> para)
+void ADKernelManager::runADcollisionKernel()
 {
     FactorizedCentralMomentsAdvectionDiffusionDeviceKernel(
         para->getParD()->numberofthreads,
@@ -126,7 +126,7 @@ void runADcollisionKernel(SPtr<Parameter> para)
         para->getParD()->isEvenTimestep);
 }
 
-void runADslipBCKernel(){
+void ADKernelManager::runADslipBCKernel(){
     if (para->getParD()->numberOfSlipBCnodes > 1) {
         ADSlipVelDevComp(
             para->getParD()->numberofthreads,
@@ -149,7 +149,7 @@ void runADslipBCKernel(){
 
 
 ////////////////////////////////////////////////////////////////////////////////
-void printAD(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager)
+void ADKernelManager::printAD(SPtr<CudaMemoryManager> cudaMemoryManager)
 {
     CalcConcentration27(
         para->getParD()->numberofthreads,
@@ -164,3 +164,14 @@ void printAD(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager)
 
     cudaMemoryManager->cudaCopyConcentrationDeviceToHost();
 }
+
+SPtr<ADKernelManager> ADKernelManager::make(SPtr<Parameter> parameter){
+    return SPtr<ADKernelManager>(new ADKernelManager(parameter));
+}
+
+ADKernelManager::ADKernelManager(SPtr<Parameter> parameter): para(parameter){}
+
+ADKernelManager::ADKernelManager(const ADKernelManager&)
+{
+
+}
\ No newline at end of file

src/gpu/VirtualFluids_GPU/AdvectionDiffusion/AdvectionDiffusion.h → src/gpu/VirtualFluids_GPU/AdvectionDiffusion/ADKernelManager.h

@@ -40,22 +40,48 @@
 class Parameter;
 class CudaMemoryManager;
 
+//! \class ADKernelManager
+//! \brief manage the advection diffusion kernel calls
+class ADKernelManager{
+
+public:
+
+//! \brief makes an object of ADKernelManager
+//! \param para shared pointer to instance of class Parameter
+static SPtr<ADKernelManager> make(SPtr<Parameter> parameter);
+
 //! \brief initialize the Advection Diffusion distributions
 //! \param para instance of class Parameter
-void initAD(SPtr<Parameter> para);
+void initAD();
 
 //! \brief set initial concentration values at all nodes
 //! \param para instance of class Parameter
 //! \param cudaManager instance of class CudaMemoryManager
-void setInitialNodeValuesAD(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager);
+void setInitialNodeValuesAD(SPtr<CudaMemoryManager> cudaMemoryManager);
 
 //! \brief calculate the state of the next time step of the Advection Diffusion distributions
 //! \param para instance of class Parameter
-void calcAD(SPtr<Parameter> para);
+void runADcollisionKernel();
+
+//! \brief calls the device function of the slip boundary condition for advection diffusion
+void runADslipBCKernel();
 
 //! \brief copy the concentration from device to host and writes VTK file with concentration
 //! \param para instance of class Parameter
 //! \param cudaManager instance of class CudaMemoryManager
-void printAD(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager);
+void printAD(SPtr<CudaMemoryManager> cudaMemoryManager);
+
+
+private:
+    //! Class constructor
+    //! \param parameter shared pointer to instance of class Parameter
+    ADKernelManager(SPtr<Parameter> parameter);
+    //! Class copy constructor
+    //! \param ADKernelManager is a reference to ADKernelManager object
+    ADKernelManager(const ADKernelManager&);
+
+    //! \property para is a shared pointer to an object of Parameter
+    SPtr<Parameter> para;
+};
 
 #endif

src/gpu/VirtualFluids_GPU/Init/InitLattice.cpp

@@ -33,10 +33,10 @@
 #include "Init/InitLattice.h"
 #include "Parameter/Parameter.h"
 #include "GPU/GPU_Interface.h"
-#include "AdvectionDiffusion/AdvectionDiffusion.h"
+#include "AdvectionDiffusion/ADKernelManager.h"
 
 ////////////////////////////////////////////////////////////////////////////////
-void initLattice(SPtr<Parameter> para)
+void initLattice(SPtr<Parameter> para, ADKernelManager* adKernelManager)
 {
 	//////////////////////////////////////////////////////////////////////////
 	para->getParD()->isEvenTimestep = true;
@@ -89,6 +89,5 @@ void initLattice(SPtr<Parameter> para)
 
 	//////////////////////////////////////////////////////////////////////////
     if (para->getIsADcalculationOn())
-        initAD(para);
-
+        adKernelManager->initAD();
 }

src/gpu/VirtualFluids_GPU/Init/InitLattice.h

@@ -37,9 +37,10 @@
 
 //! \brief Class forwarding for Parameter
 class Parameter;
+class ADKernelManager;
 
 //! \brief initialize the LBM lattice
 //! \param para instance of classParameter
-void initLattice(SPtr<Parameter> para);
+void initLattice(SPtr<Parameter> para, ADKernelManager* adKernelManager);
 
 #endif

src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp

@@ -31,9 +31,9 @@
 //! \author Martin Schoenherr
 //=======================================================================================
 #include "Simulation.h"
-#include "AdvectionDiffusion/AdvectionDiffusion.h"
 #include "DataStructureInitializer/GridProvider.h"
 #include "GPU/CudaKernelManager.h"
+#include "AdvectionDiffusion/ADKernelManager.h"
 #include "GPU/CudaMemoryManager.h"
 #include "GPU/devCheck.h"
 #include "Init/InitLattice.h"
@@ -50,7 +50,9 @@
 #include <stdio.h>
 //////////////////////////////////////////////////////////////////////////
 
-Simulation::Simulation() {}
+Simulation::Simulation() {
+    this->adKernelManager = ADKernelManager::make(para);
+}
 
 Simulation::~Simulation() {}
 
@@ -100,19 +102,19 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, SPt
         para->getParD()->diffusivity = para->getParH()->diffusivity;
         cudaMemoryManager->cudaAllocConcentrationDistributions();
         cudaMemoryManager->cudaAllocConcentration();
-        setInitialNodeValuesAD(para, cudaMemoryManager);
+        adKernelManager->setInitialNodeValuesAD(cudaMemoryManager);
     }
 
     //////////////////////////////////////////////////////////////////////////
     // initialize the grid
     output << "init lattice...";
-    initLattice(para);
+    initLattice(para, adKernelManager.get());
     output << "done.\n";
 
     //////////////////////////////////////////////////////////////////////////
     // print initialized grid
     output << "Print files Init...";
-    dataWriter->writeInit(para, cudaMemoryManager, cudaKernelManager);
+    dataWriter->writeInit(para, cudaMemoryManager, cudaKernelManager, adKernelManager.get());
     output << "done.\n";
 
     //////////////////////////////////////////////////////////////////////////
@@ -135,8 +137,10 @@ void Simulation::run()
     for (timestep = para->getTimestepStart(); timestep <= para->getTimestepEnd(); timestep++) {
         ////////////////////////////////////////////////////////////////////////////////
         // Advection Diffusion calculation ... Advection first -> fluid second
-        if (para->getIsADcalculationOn())
-            calcAD(para);
+        if (para->getIsADcalculationOn()){
+            adKernelManager->runADcollisionKernel();
+            adKernelManager->runADslipBCKernel();
+        }
 
         ////////////////////////////////////////////////////////////////////////////////
         // LBM Kernel
@@ -169,7 +173,7 @@ void Simulation::run()
             // IO
             if (para->getPrintFiles()) {
                 output << "File IO for t=" << timestep << "...";
-                dataWriter->writeTimestep(para, cudaMemoryManager, cudaKernelManager, timestep);
+                dataWriter->writeTimestep(para, cudaMemoryManager, cudaKernelManager, adKernelManager.get(), timestep);
                 output << "done.\n";
             }
             timer->start();

src/gpu/VirtualFluids_GPU/LBM/Simulation.h

@@ -40,6 +40,7 @@
 //! \brief Class forwarding for CudaMemoryManager, Parameter, GridProvider and DataWriter
 class CudaMemoryManager;
 class CudaKernelManager;
+class ADKernelManager;
 class Parameter;
 class GridProvider;
 class DataWriter;
@@ -76,5 +77,7 @@ protected:
     SPtr<CudaMemoryManager> cudaMemoryManager;
     //! \property cudaKernelManager is a shared pointer to an object of CudaKernelManager
     SPtr<CudaKernelManager> cudaKernelManager;
+    //! \property adKernelManager is a shared pointer to an object of ADKernelManager
+    std::shared_ptr<ADKernelManager> adKernelManager;
 };
 #endif

src/gpu/VirtualFluids_GPU/Output/DataWriter.h

@@ -41,6 +41,7 @@
 class Parameter;
 class CudaMemoryManager;
 class CudaKernelManager;
+class ADKernelManager;
 
 //! \class FileWriter
 //! \brief manages the VTK output
@@ -59,7 +60,8 @@ public:
     virtual void VIRTUALFLUIDS_GPU_EXPORT writeInit(
 		SPtr<Parameter> para, 
 		SPtr<CudaMemoryManager> cudaMemoryManager, 
-		SPtr<CudaKernelManager> cudaKernelManager) = 0;
+		SPtr<CudaKernelManager> cudaKernelManager,
+		ADKernelManager* ADKernelManager) = 0;
 	//! \brief write time step to VTK file(s)
 	//! \param para instance of classParameter
     //! \param cudaMemoryManager instance of class CudaMemoryManager
@@ -68,7 +70,8 @@ public:
 	virtual void VIRTUALFLUIDS_GPU_EXPORT writeTimestep(
 		SPtr<Parameter> para, 
 		SPtr<CudaMemoryManager> cudaMemoryManager, 
-		SPtr<CudaKernelManager> cudaKernelManager, 
+		SPtr<CudaKernelManager> cudaKernelManager,
+		ADKernelManager* ADKernelManager, 
 		uint timestep) = 0;
 };
 #endif

src/gpu/VirtualFluids_GPU/Output/FileWriter.cpp

@@ -34,19 +34,19 @@
 #include "GPU/CudaMemoryManager.h"
 #include "Parameter/Parameter.h"
 #include "basics/writer/WbWriterVtkXmlBinary.h"
-#include "AdvectionDiffusion/AdvectionDiffusion.h"
+#include "AdvectionDiffusion/ADKernelManager.h"
 #include "GPU/CudaKernelManager.h"
 
-void FileWriter::writeInit(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager, SPtr<CudaKernelManager> cudaKernelManager)
+void FileWriter::writeInit(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager, SPtr<CudaKernelManager> cudaKernelManager, ADKernelManager* adKernelManager)
 {
     uint timestep = 0;
-    writeTimestep(para, cudaMemoryManager, cudaKernelManager, timestep);
+    writeTimestep(para, cudaMemoryManager, cudaKernelManager, adKernelManager, timestep);
 }
 
-void FileWriter::writeTimestep(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager, SPtr<CudaKernelManager> cudaKernelManager, uint timestep)
+void FileWriter::writeTimestep(SPtr<Parameter> para, SPtr<CudaMemoryManager> cudaMemoryManager, SPtr<CudaKernelManager> cudaKernelManager, ADKernelManager* adKernelManager, uint timestep)
 {
     if (para->getIsADcalculationOn())
-        printAD(para, cudaMemoryManager);
+        adKernelManager->printAD(cudaMemoryManager);
 
     cudaKernelManager->calculateMacroscopicValues(para);
     cudaMemoryManager->cudaCopyDataToHost();

src/gpu/VirtualFluids_GPU/Output/FileWriter.h

@@ -42,48 +42,51 @@
 class Parameter;
 class CudaMemoryManager;
 class CudaKernelManager;
+class ADKernelManager;
 
 //! \class FileWriter derived class of DataWriter
 //! \brief manages the VTK output
 class FileWriter : public DataWriter
 {
 public:
-	//! Class default constructor
-	VIRTUALFLUIDS_GPU_EXPORT FileWriter() {}
-	//! Class destructor
-	VIRTUALFLUIDS_GPU_EXPORT ~FileWriter() {}
+    //! Class default constructor
+    VIRTUALFLUIDS_GPU_EXPORT FileWriter() {}
+    //! Class destructor
+    VIRTUALFLUIDS_GPU_EXPORT ~FileWriter() {}
 
-	//! \brief write the initialization step to VTK file(s)
-	//! \param para instance of classParameter
-	//! \param cudaMemoryManager instance of class CudaMemoryManager
+    //! \brief write the initialization step to VTK file(s)
+    //! \param para instance of classParameter
+    //! \param cudaMemoryManager instance of class CudaMemoryManager
     //! \param cudaKernelManager instance of class CudaKernelManager
     void VIRTUALFLUIDS_GPU_EXPORT writeInit(
-		SPtr<Parameter> para, 
-		SPtr<CudaMemoryManager> cudaMemoryManager, 
-		SPtr<CudaKernelManager> cudaKernelManager) override;
-	//! \brief write time step to VTK file(s)
-	//! \param para instance of classParameter
+        SPtr<Parameter> para, 
+        SPtr<CudaMemoryManager> cudaMemoryManager, 
+        SPtr<CudaKernelManager> cudaKernelManager,
+        ADKernelManager* adKernelManager) override;
+    //! \brief write time step to VTK file(s)
+    //! \param para instance of classParameter
     //! \param cudaMemoryManager instance of class CudaMemoryManager
     //! \param cudaKernelManager instance of class CudaKernelManager
     //! \param timestep of the simulation
-	void VIRTUALFLUIDS_GPU_EXPORT writeTimestep(
-		SPtr<Parameter> para, 
-		SPtr<CudaMemoryManager> cudaMemoryManager, 
-		SPtr<CudaKernelManager> cudaKernelManager, 
-		uint timestep) override;
+    void VIRTUALFLUIDS_GPU_EXPORT writeTimestep(
+        SPtr<Parameter> para,
+        SPtr<CudaMemoryManager> cudaMemoryManager,
+        SPtr<CudaKernelManager> cudaKernelManager,
+        ADKernelManager* adKernelManager,
+        uint timestep) override;
 
 private:
-	//! \brief write binary VTK file as unstructured grid
-	//! \param para instance of classParameter
-	//! \param fname vector of strings with path and prefix of written files
-	void VIRTUALFLUIDS_GPU_EXPORT writeUnstrucuredGridLT(SPtr<Parameter> para, std::vector<std::string >& fname);
+    //! \brief write binary VTK file as unstructured grid
+    //! \param para instance of classParameter
+    //! \param fname vector of strings with path and prefix of written files
+    void VIRTUALFLUIDS_GPU_EXPORT writeUnstrucuredGridLT(SPtr<Parameter> para, std::vector<std::string >& fname);
     //! \brief write binary VTK file as unstructured grid with concentration of Advection Diffusion component
     //! \param para instance of classParameter
     //! \param fname vector of strings with path and prefix of written files
     void VIRTUALFLUIDS_GPU_EXPORT writeUnstrucuredGridAD(SPtr<Parameter> para, std::vector<std::string> &fname);
     //! \brief checks for periodic cells
-	//! \param para instance of classParameter
-	//! \param number 2, 1, 3 and 5 are the possible periodic neighbors
-	bool VIRTUALFLUIDS_GPU_EXPORT isPeriodicCell(SPtr<Parameter> para, uint number2, uint number1, uint number3, uint number5);
+    //! \param para instance of classParameter
+    //! \param number 2, 1, 3 and 5 are the possible periodic neighbors
+    bool VIRTUALFLUIDS_GPU_EXPORT isPeriodicCell(SPtr<Parameter> para, uint number2, uint number1, uint number3, uint number5);
 };
 #endif
\ No newline at end of file