From 1d55591d018131810f791f66891802d8ae260926 Mon Sep 17 00:00:00 2001
From: "LEGOLAS\\lenz" <lenz@irmb.tu-bs.de>
Date: Thu, 27 Jun 2019 08:48:05 +0200
Subject: [PATCH] introduces an interface for Core/Timer to improve granularity
 and erase problem with definition of zero as constant and as symbol in
 <chrono>

---
 src/Core/Timer/TimerImp.cpp                   |  26 +++
 src/Core/Timer/TimerImp.h                     |  33 ++++
 src/GksGpu/Analyzer/CupsAnalyzer.cpp          |  10 +-
 src/GksGpu/Analyzer/CupsAnalyzer.h            |   4 +-
 .../TriangularMesh/TriangularMesh.cu          |   6 +-
 .../TriangularMesh/TriangularMeshStrategy.cpp |   8 +-
 .../GridGpuStrategy/GridGpuStrategy.cpp       |   8 +-
 .../SimulationFileWriter.cpp                  |   5 +-
 src/core/Timer/Timer.cpp                      |  32 +--
 src/core/Timer/Timer.h                        |  20 +-
 .../GKS/DrivenCavity3D/DrivenCavity3D.cpp     |   3 +-
 targets/apps/LBM/DrivenCavity/CMakeLists.txt  |  11 +-
 .../apps/LBM/DrivenCavity/DrivenCavity.cpp    | 184 ++++++++++++------
 .../LBM/DrivenCavity/configDrivenCavity.txt   |   6 +-
 14 files changed, 226 insertions(+), 130 deletions(-)
 create mode 100644 src/Core/Timer/TimerImp.cpp
 create mode 100644 src/Core/Timer/TimerImp.h

diff --git a/src/Core/Timer/TimerImp.cpp b/src/Core/Timer/TimerImp.cpp
new file mode 100644
index 000000000..4fc234a29
--- /dev/null
+++ b/src/Core/Timer/TimerImp.cpp
@@ -0,0 +1,26 @@
+#include "TimerImp.h"
+
+TimerImp::TimerImp()
+{
+    
+}
+
+void TimerImp::start()
+{
+    this->startTime = std::chrono::high_resolution_clock::now();
+}
+
+void TimerImp::end()
+{
+    this->endTime = std::chrono::high_resolution_clock::now();
+}
+
+real TimerImp::getTimeInSeconds() const
+{
+    return std::chrono::duration_cast<std::chrono::microseconds>( endTime - startTime ).count() / 1000000.0;
+}
+
+real TimerImp::getCurrentRuntimeInSeconds() const
+{
+    return std::chrono::duration_cast<std::chrono::microseconds>( std::chrono::high_resolution_clock::now() - startTime ).count() / 1000000.0;
+}
diff --git a/src/Core/Timer/TimerImp.h b/src/Core/Timer/TimerImp.h
new file mode 100644
index 000000000..f7d37fd6a
--- /dev/null
+++ b/src/Core/Timer/TimerImp.h
@@ -0,0 +1,33 @@
+#ifndef TIMER_IMP_H
+#define TIMER_IMP_H
+
+#include "Timer.h"
+
+#include <chrono>
+
+#include "VirtualFluidsDefinitions.h"
+
+#include "DataTypes.h"
+
+
+class VF_PUBLIC TimerImp : public Timer
+{
+public:
+
+    typedef std::chrono::high_resolution_clock::time_point timePoint;
+
+    TimerImp();
+
+    void start() override;
+    void end() override;
+
+    real getTimeInSeconds() const override;
+    real getCurrentRuntimeInSeconds() const override;
+
+private:
+    timePoint startTime;
+    timePoint endTime;
+};
+
+#endif
+
diff --git a/src/GksGpu/Analyzer/CupsAnalyzer.cpp b/src/GksGpu/Analyzer/CupsAnalyzer.cpp
index 18ecff98f..24d6ee53c 100644
--- a/src/GksGpu/Analyzer/CupsAnalyzer.cpp
+++ b/src/GksGpu/Analyzer/CupsAnalyzer.cpp
@@ -31,20 +31,20 @@ CupsAnalyzer::CupsAnalyzer(SPtr<DataBase> dataBase,
 void CupsAnalyzer::start()
 {
     this->counter = 0;
-    this->timer.start();
-    this->timerRestart.start();
+    this->timer->start();
+    this->timerRestart->start();
 }
 
 void CupsAnalyzer::restart()
 {
     this->counter = 0;
-    this->timerRestart.start();
+    this->timerRestart->start();
 }
 
 void CupsAnalyzer::run( uint iter, real dt )
 {
-    real currentRuntime             = this->timer.getCurrentRuntimeInSeconds();
-    real currentRuntimeSinceRestart = this->timerRestart.getCurrentRuntimeInSeconds();
+    real currentRuntime             = this->timer->getCurrentRuntimeInSeconds();
+    real currentRuntimeSinceRestart = this->timerRestart->getCurrentRuntimeInSeconds();
 
     this->counter++;
 
diff --git a/src/GksGpu/Analyzer/CupsAnalyzer.h b/src/GksGpu/Analyzer/CupsAnalyzer.h
index ee162ac61..3fe5ae3f1 100644
--- a/src/GksGpu/Analyzer/CupsAnalyzer.h
+++ b/src/GksGpu/Analyzer/CupsAnalyzer.h
@@ -14,8 +14,8 @@ struct DataBase;
 class VF_PUBLIC CupsAnalyzer
 {
 private:
-    Timer timer;
-    Timer timerRestart;
+    SPtr<Timer> timer;
+    SPtr<Timer> timerRestart;
 
     bool outputPerTime;
 
diff --git a/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu b/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
index 429cd0b44..acce19b71 100644
--- a/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
+++ b/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
@@ -68,14 +68,14 @@ void TriangularMesh::findNeighbors()
 {
 	*logging::out << logging::Logger::INFO_INTERMEDIATE << "start finding neighbors ...\n";
 
-    Timer t = Timer::makeStart();
+    auto t = Timer::makeStart();
 
 	TriangleNeighborFinder finder(triangles, size);
 	finder.fillWithNeighborAngles(this);
 
-    t.end();
+    t->end();
 
-    *logging::out << logging::Logger::INFO_INTERMEDIATE << "time finding neighbors: " << t.getTimeInSeconds() << "s\n";
+    *logging::out << logging::Logger::INFO_INTERMEDIATE << "time finding neighbors: " << t->getTimeInSeconds() << "s\n";
 }
 
 void TriangularMesh::setTriangles(std::vector<Triangle> triangles)
diff --git a/src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.cpp b/src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.cpp
index 1b3ae3da9..b24c6c9fb 100644
--- a/src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.cpp
+++ b/src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.cpp
@@ -27,9 +27,7 @@ void PointInObjectDiscretizationStrategy::doDiscretize(TriangularMesh* triangula
     // trigger the GbTriFaceMesh3D to generate a kd-tree
     triangularMesh->getGbTriFaceMesh3D()->isPointInGbObject3D(0.0, 0.0, 0.0);
 
-    Timer timer;
-
-    timer.start();
+    auto timer = Timer::makeStart();
 
     real outputTime = 60.0;
     
@@ -46,9 +44,9 @@ void PointInObjectDiscretizationStrategy::doDiscretize(TriangularMesh* triangula
         //else
         //    grid->setNodeTo(i, OuterType);
 
-        if( timer.getCurrentRuntimeInSeconds() > outputTime ){
+        if( timer->getCurrentRuntimeInSeconds() > outputTime ){
             *logging::out << logging::Logger::INFO_INTERMEDIATE << "    " << index << "/" << grid->getSize() <<" nodes tested!\n";
-            timer.start();
+            timer->start();
         }
     }
 
diff --git a/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp b/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
index f9ab568cf..1f872414c 100644
--- a/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
+++ b/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
@@ -297,7 +297,7 @@ void GridGpuStrategy::allocMatrixIndicesOnGPU(SPtr<GridImp> grid)
 void GridGpuStrategy::allocAndCopyTrianglesToGPU(TriangularMesh &geom)
 {
     *logging::out << logging::Logger::INFO_INTERMEDIATE << "start copying triangles ...\n";
-    clock_t begin = clock();
+    //clock_t begin = clock();
     int size_in_bytes_triangles = sizeof(Triangle)*geom.size;
     real sizeInMB = size_in_bytes_triangles / (1024.f*1024.f);
 
@@ -308,9 +308,9 @@ void GridGpuStrategy::allocAndCopyTrianglesToGPU(TriangularMesh &geom)
     CudaSafeCall(cudaMemcpy(triangles_d, geom.triangles, size_in_bytes_triangles, cudaMemcpyHostToDevice));
     geom.triangles = triangles_d;
     CudaCheckError();
-    clock_t end = clock();
-    real time = real(end - begin) / CLOCKS_PER_SEC;
-    *logging::out << logging::Logger::INFO_INTERMEDIATE << "time copying triangles: " << time << "s\n";
+    //clock_t end = clock();
+    //real time = real(end - begin) / CLOCKS_PER_SEC;
+    //*logging::out << logging::Logger::INFO_INTERMEDIATE << "time copying triangles: " << time << "s\n";
     *logging::out << logging::Logger::INFO_INTERMEDIATE << "...copying triangles finish!\n\n";
 }
 
diff --git a/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp b/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp
index 7443e3047..925661071 100644
--- a/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp
+++ b/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp
@@ -27,12 +27,11 @@ void SimulationFileWriter::write(std::string folder, SPtr<GridBuilder> builder,
     SimulationFileWriter::folder = folder;
 
     *logging::out << logging::Logger::INFO_INTERMEDIATE << "Start writing simulation files to " << folder << ":\n";
-    Timer timer;
-    timer.start();
+    auto timer = Timer::makeStart();
 
     write(builder, format);
 
-    *logging::out << logging::Logger::INFO_INTERMEDIATE << "    Time writing files: " << timer.getCurrentRuntimeInSeconds() << " sec\n";
+    *logging::out << logging::Logger::INFO_INTERMEDIATE << "    Time writing files: " << timer->getCurrentRuntimeInSeconds() << " sec\n";
     *logging::out << logging::Logger::INFO_INTERMEDIATE << "Done writing simulation Files!\n";
 }
 
diff --git a/src/core/Timer/Timer.cpp b/src/core/Timer/Timer.cpp
index a5d6f8708..9ca58ed19 100644
--- a/src/core/Timer/Timer.cpp
+++ b/src/core/Timer/Timer.cpp
@@ -1,33 +1,11 @@
 #include "Timer.h"
+#include "TimerImp.h"
 
-Timer::Timer()
-{
-    
-}
+#include <memory>
 
-Timer Timer::makeStart()
+SPtr<Timer> Timer::makeStart()
 {
-    Timer t;
-    t.start();
+    SPtr<Timer> t = std::make_shared<TimerImp>();
+    t->start();
     return t;
 }
-
-void Timer::start()
-{
-    this->startTime = std::chrono::high_resolution_clock::now();
-}
-
-void Timer::end()
-{
-    this->endTime = std::chrono::high_resolution_clock::now();
-}
-
-real Timer::getTimeInSeconds() const
-{
-    return std::chrono::duration_cast<std::chrono::microseconds>( endTime - startTime ).count() / 1000000.0;
-}
-
-real Timer::getCurrentRuntimeInSeconds() const
-{
-    return std::chrono::duration_cast<std::chrono::microseconds>( std::chrono::high_resolution_clock::now() - startTime ).count() / 1000000.0;
-}
diff --git a/src/core/Timer/Timer.h b/src/core/Timer/Timer.h
index 8ee72118f..bda096f4b 100644
--- a/src/core/Timer/Timer.h
+++ b/src/core/Timer/Timer.h
@@ -1,30 +1,22 @@
 #ifndef TIMER_H
 #define TIMER_H
 
-#include <chrono>
-
 #include "VirtualFluidsDefinitions.h"
 
 #include "DataTypes.h"
+#include "PointerDefinitions.h"
 
 class VF_PUBLIC Timer
 {
 public:
 
-    typedef std::chrono::high_resolution_clock::time_point timePoint;
-
-    Timer();
-    static Timer makeStart();
-
-    void start();
-    void end();
+    static SPtr<Timer> makeStart();
 
-    real getTimeInSeconds() const;
-    real getCurrentRuntimeInSeconds() const;
+    virtual void start() = 0;
+    virtual void end() = 0;
 
-private:
-    timePoint startTime;
-    timePoint endTime;
+    virtual real getTimeInSeconds() const = 0;
+    virtual real getCurrentRuntimeInSeconds() const = 0;
 };
 
 #endif
diff --git a/targets/apps/GKS/DrivenCavity3D/DrivenCavity3D.cpp b/targets/apps/GKS/DrivenCavity3D/DrivenCavity3D.cpp
index 5ed52e952..2a57b5d8d 100644
--- a/targets/apps/GKS/DrivenCavity3D/DrivenCavity3D.cpp
+++ b/targets/apps/GKS/DrivenCavity3D/DrivenCavity3D.cpp
@@ -242,7 +242,8 @@ void drivenCavity( std::string path, std::string simulationName )
 
 int main( int argc, char* argv[])
 {
-    std::string path( "E:/DrivenCavity/resultsGKS/" );
+    //std::string path( "E:/DrivenCavity/resultsGKS/" );
+    std::string path( "F:/Work/Computations/out/DrivenCavity/" );
     //std::string path( "out/" );
     std::string simulationName ( "DrivenCavity" );
 
diff --git a/targets/apps/LBM/DrivenCavity/CMakeLists.txt b/targets/apps/LBM/DrivenCavity/CMakeLists.txt
index 6ef6241b5..b045a43f1 100644
--- a/targets/apps/LBM/DrivenCavity/CMakeLists.txt
+++ b/targets/apps/LBM/DrivenCavity/CMakeLists.txt
@@ -1,8 +1,15 @@
 setTargetNameToFolderName(${CMAKE_CURRENT_LIST_DIR}) 
 
 set(linkDirectories "")
-set(libsToLink VirtualFluids_GPU GridGenerator)
-set(includeDirectories "${CMAKE_SOURCE_DIR}/src" "${CMAKE_SOURCE_DIR}/src/VirtualFluids_GPU" "${CMAKE_SOURCE_DIR}/src/GridGenerator" "${CMAKE_SOURCE_DIR}/src/VirtualFluidsBasics")
+set(libsToLink Core VirtualFluids_GPU GridGenerator GksMeshAdapter GksVtkAdapter GksGpu)
+set(includeDirectories "${CMAKE_SOURCE_DIR}/src"
+                       "${CMAKE_SOURCE_DIR}/src/Core"
+                       "${CMAKE_SOURCE_DIR}/src/VirtualFluids_GPU" 
+                       "${CMAKE_SOURCE_DIR}/src/GridGenerator" 
+                       "${CMAKE_SOURCE_DIR}/src/VirtualFluidsBasics"
+                       "${CMAKE_SOURCE_DIR}/src/GksMeshAdapter"
+                       "${CMAKE_SOURCE_DIR}/src/GksVtkAdapter"
+                       "${CMAKE_SOURCE_DIR}/src/GksGpu")
 
 #glob files and save in MY_SRCS
 include(CMakePackage.cmake)
diff --git a/targets/apps/LBM/DrivenCavity/DrivenCavity.cpp b/targets/apps/LBM/DrivenCavity/DrivenCavity.cpp
index b918e46c3..66192340c 100644
--- a/targets/apps/LBM/DrivenCavity/DrivenCavity.cpp
+++ b/targets/apps/LBM/DrivenCavity/DrivenCavity.cpp
@@ -1,27 +1,43 @@
-//#define MPI_LOGGING
-
-//Martin Branch
-
-#include <mpi.h>
-#if defined( MPI_LOGGING )
-	#include <mpe.h>
-#endif
 
+#define _USE_MATH_DEFINES
+#include <math.h>
 #include <string>
 #include <sstream>
 #include <iostream>
 #include <stdexcept>
 #include <fstream>
-#define _USE_MATH_DEFINES
-#include <math.h>
+#include <exception>
+#include <memory>
+
+//////////////////////////////////////////////////////////////////////////
 
-//#include "metis.h"
+#include "Core/DataTypes.h"
+#include "Core/PointerDefinitions.h"
 
 #include "Core/LbmOrGks.h"
 #include "Core/Input/Input.h"
 #include "Core/StringUtilities/StringUtil.h"
 #include "Core/Input/ConfigFileReader/ConfigFileReader.h"
 
+#include "Core/VectorTypes.h"
+#include "Core/Logger/Logger.h"
+
+//////////////////////////////////////////////////////////////////////////
+
+//#include "GridGenerator/global.h"
+
+#include "GridGenerator/grid/GridBuilder/LevelGridBuilder.h"
+#include "GridGenerator/grid/GridBuilder/MultipleGridBuilder.h"
+#include "GridGenerator/grid/BoundaryConditions/Side.h"
+#include "GridGenerator/grid/GridFactory.h"
+
+#include "GridGenerator/io/SimulationFileWriter/SimulationFileWriter.h"
+#include "GridGenerator/io/GridVTKWriter/GridVTKWriter.h"
+#include "GridGenerator/io/STLReaderWriter/STLReader.h"
+#include "GridGenerator/io/STLReaderWriter/STLWriter.h"
+
+//////////////////////////////////////////////////////////////////////////
+
 #include "VirtualFluids_GPU/LBM/Simulation.h"
 #include "VirtualFluids_GPU/Communication/Communicator.h"
 #include "VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h"
@@ -30,34 +46,34 @@
 #include "VirtualFluids_GPU/Parameter/Parameter.h"
 #include "VirtualFluids_GPU/Output/FileWriter.h"
 
-#include "global.h"
+#include "VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.h"
+#include "VirtualFluids_GPU/PreProcessor/PreProcessorFactory/PreProcessorFactoryImp.h"
+
+#include "VirtualFluids_GPU/GPU/CudaMemoryManager.h"
 
-#include "geometries/Sphere/Sphere.h"
-#include "geometries/VerticalCylinder/VerticalCylinder.h"
-#include "geometries/Cuboid/Cuboid.h"
-#include "geometries/TriangularMesh/TriangularMesh.h"
-#include "geometries/Conglomerate/Conglomerate.h"
-#include "geometries/TriangularMesh/TriangularMeshStrategy.h"
+//////////////////////////////////////////////////////////////////////////
 
-#include "grid/GridBuilder/LevelGridBuilder.h"
-#include "grid/GridBuilder/MultipleGridBuilder.h"
-#include "grid/BoundaryConditions/Side.h"
-#include "grid/BoundaryConditions/BoundaryCondition.h"
-#include "grid/GridFactory.h"
+#include "GksMeshAdapter/GksMeshAdapter.h"
 
-#include "VirtualFluids_GPU/GPU/CudaMemoryManager.h"
+#include "GksVtkAdapter/VTKInterface.h"
+
+#include "GksGpu/DataBase/DataBase.h"
+#include "GksGpu/Parameters/Parameters.h"
+#include "GksGpu/Initializer/Initializer.h"
 
-#include "io/SimulationFileWriter/SimulationFileWriter.h"
-#include "io/GridVTKWriter/GridVTKWriter.h"
-#include "io/STLReaderWriter/STLReader.h"
-#include "io/STLReaderWriter/STLWriter.h"
+#include "GksGpu/FlowStateData/FlowStateDataConversion.cuh"
 
-#include "utilities/math/Math.h"
-#include "utilities/communication.h"
-#include "utilities/transformator/TransformatorImp.h"
+#include "GksGpu/BoundaryConditions/BoundaryCondition.h"
+#include "GksGpu/BoundaryConditions/IsothermalWall.h"
 
-#include "Kernel/Utilities/KernelFactory/KernelFactoryImp.h"
-#include "PreProcessor/PreProcessorFactory/PreProcessorFactoryImp.h"
+#include "GksGpu/TimeStepping/NestedTimeStep.h"
+
+#include "GksGpu/Analyzer/CupsAnalyzer.h"
+#include "GksGpu/Analyzer/ConvergenceAnalyzer.h"
+
+#include "GksGpu/CudaUtility/CudaUtility.h"
+
+//////////////////////////////////////////////////////////////////////////
 
 void multipleLevel(const std::string& configPath)
 {
@@ -80,6 +96,8 @@ void multipleLevel(const std::string& configPath)
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    LbmOrGks lbmOrGks = LBM;
+
 	const real L = 1.0;
 
     const real Re = 1000;
@@ -93,7 +111,7 @@ void multipleLevel(const std::string& configPath)
 
     const real viscosity = nx * velocity / Re; // LB units
 
-    *logging::out << logging::Logger::INFO_HIGH << "velocity = " << velocity << " s\n";
+    *logging::out << logging::Logger::INFO_HIGH << "velocity  = " << velocity << " s\n";
 
     *logging::out << logging::Logger::INFO_HIGH << "viscosity = " << viscosity << "\n";
 
@@ -108,44 +126,86 @@ void multipleLevel(const std::string& configPath)
 
 	gridBuilder->buildGrids(LBM, false); // buildGrids() has to be called before setting the BCs!!!!
 
-	gridBuilder->setVelocityBoundaryCondition(SideType::PX, 0.0, 0.0, 0.0);
-	gridBuilder->setVelocityBoundaryCondition(SideType::MX, 0.0, 0.0, 0.0);
-	gridBuilder->setVelocityBoundaryCondition(SideType::PY, 0.0, 0.0, 0.0);
-	gridBuilder->setVelocityBoundaryCondition(SideType::MY, 0.0, 0.0, 0.0);
-	gridBuilder->setVelocityBoundaryCondition(SideType::PZ,  vx,  vy, 0.0);
-	gridBuilder->setVelocityBoundaryCondition(SideType::MZ, 0.0, 0.0, 0.0);
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	//////////////////////////////////////////////////////////////////////////
+    if( lbmOrGks == LBM )
+    {
+	    gridBuilder->setVelocityBoundaryCondition(SideType::PX, 0.0, 0.0, 0.0);
+	    gridBuilder->setVelocityBoundaryCondition(SideType::MX, 0.0, 0.0, 0.0);
+	    gridBuilder->setVelocityBoundaryCondition(SideType::PY, 0.0, 0.0, 0.0);
+	    gridBuilder->setVelocityBoundaryCondition(SideType::MY, 0.0, 0.0, 0.0);
+	    gridBuilder->setVelocityBoundaryCondition(SideType::PZ,  vx,  vy, 0.0);
+	    gridBuilder->setVelocityBoundaryCondition(SideType::MZ, 0.0, 0.0, 0.0);
 
-	SPtr<Parameter> para = Parameter::make(configData, comm);
-	//SPtr<Parameter> para = Parameter::make();
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	SPtr<CudaMemoryManager> cudaMemoryManager = CudaMemoryManager::make(para);
+        SPtr<Parameter> para = Parameter::make(configData, comm);
+        //SPtr<Parameter> para = Parameter::make();
 
-	SPtr<GridProvider> gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+        SPtr<CudaMemoryManager> cudaMemoryManager = CudaMemoryManager::make(para);
 
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        SPtr<GridProvider> gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
 
-    para->setVelocity( velocity );
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    para->setViscosity( viscosity );
+        para->setVelocity(velocity);
 
-    para->setVelocityRatio( 1.0 / velocity );
+        para->setViscosity(viscosity);
 
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        para->setVelocityRatio(1.0 / velocity);
+
+        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+        Simulation sim;
+        SPtr<FileWriter> fileWriter = SPtr<FileWriter>(new FileWriter());
+        SPtr<KernelFactoryImp> kernelFactory = KernelFactoryImp::getInstance();
+        SPtr<PreProcessorFactoryImp> preProcessorFactory = PreProcessorFactoryImp::getInstance();
+        sim.setFactories(kernelFactory, preProcessorFactory);
+        sim.init(para, gridGenerator, fileWriter, cudaMemoryManager);
+        sim.run();
+        sim.free();
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    }
+    else
+    {
+        CudaUtility::setCudaDevice(0);
 
-    Simulation sim;
-	SPtr<FileWriter> fileWriter = SPtr<FileWriter>(new FileWriter());
-	SPtr<KernelFactoryImp> kernelFactory = KernelFactoryImp::getInstance();
-	SPtr<PreProcessorFactoryImp> preProcessorFactory = PreProcessorFactoryImp::getInstance();
-	sim.setFactories(kernelFactory, preProcessorFactory);
-    sim.init(para, gridGenerator, fileWriter, cudaMemoryManager);
-    sim.run();
-	sim.free();
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        
+        GksMeshAdapter meshAdapter( gridBuilder );
+
+        meshAdapter.inputGrid();
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+        auto dataBase = std::make_shared<DataBase>( "GPU" );
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+        real lambda = 0.1;
+
+        SPtr<BoundaryCondition> bcLid  = std::make_shared<IsothermalWall>( dataBase, Vec3(  vx, 0.0, 0.0 ), lambda, false );
+        SPtr<BoundaryCondition> bcWall = std::make_shared<IsothermalWall>( dataBase, Vec3( 0.0, 0.0, 0.0 ), lambda, false );
+
+        bcLid->findBoundaryCells ( meshAdapter, true,  [&](Vec3 center){ return center.y > 0.5; } );
+        bcWall->findBoundaryCells( meshAdapter, false, [&](Vec3 center){ return center.y < 0.5; } );
+
+        dataBase->boundaryConditions.push_back( bcLid  );
+        dataBase->boundaryConditions.push_back( bcWall );
+    
+        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    }
 }
 
 int main( int argc, char* argv[])
diff --git a/targets/apps/LBM/DrivenCavity/configDrivenCavity.txt b/targets/apps/LBM/DrivenCavity/configDrivenCavity.txt
index a6793f0b3..16102c7fe 100644
--- a/targets/apps/LBM/DrivenCavity/configDrivenCavity.txt
+++ b/targets/apps/LBM/DrivenCavity/configDrivenCavity.txt
@@ -7,13 +7,15 @@ NumberOfDevices=4
 ##################################################
 #informations for Writing
 ##################################################
-Path="E:/DrivenCavity/results"
+#Path="E:/DrivenCavity/results"
+Path="F:/Work/Computations/out/DrivenCavity/"
 Prefix="DrivenCavity" 
 WriteGrid=true
 ##################################################
 #informations for reading
 ##################################################
-GridPath="E:/DrivenCavity/dummy"
+#GridPath="E:/DrivenCavity/dummy"
+GridPath="F:/Work/Computations/out/DrivenCavity/dummy"
 
 ##################################################
 #number of grid levels
-- 
GitLab