Optix debug logging update, TEOS PECVD GPU model (#188)

* Added removeMaterial info when removing top LS layer

* Added WENO 5th order advection scheme

* Reverted back to install script, with ViennaLS default version 5.2.1

* Add option to enable adaptive time stepping during advection

* Use new ViennaRay functions

* TEOS PECVD GPU model

* Refactor GPU include setup

* Remove old benchmark files

* Bump ViennaRay

* Fix tests

---------

Co-authored-by: filipovic <filipovic@iue.tuwien.ac.at>

Author: tobre1

CMakeLists.txt

@@ -101,7 +101,7 @@ include("cmake/cpm.cmake")
 
 CPMAddPackage(
   NAME ViennaCore
-  VERSION 1.7.4
+  VERSION 1.8.0
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaCore"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON}
   OPTIONS "VIENNACORE_USE_GPU ${VIENNAPS_USE_GPU}")
@@ -113,7 +113,7 @@ CPMAddPackage(
 
 CPMFindPackage(
   NAME ViennaRay
-  VERSION 3.9.0
+  VERSION 3.9.1
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaRay"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON}
   OPTIONS "VIENNARAY_USE_GPU ${VIENNAPS_USE_GPU}")
@@ -177,8 +177,6 @@ endif()
 if(VIENNAPS_USE_GPU AND VIENNACORE_PTX_DIR)
   message(STATUS "[ViennaPS] Enabled GPU Support")
   add_subdirectory(gpu)
-  target_include_directories(${PROJECT_NAME}
-                             INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/gpu/include>)
 else()
   message(STATUS "[ViennaPS] Disabled GPU Support")
   set(VIENNAPS_USE_GPU OFF)

cmake/ViennaPSUtils.cmake

@@ -1,6 +1,6 @@
 function(viennaps_add_executable target_name source_file)
   if(VIENNAPS_USE_GPU)
-    add_gpu_executable(${target_name} _unused_target_var ${source_file})
+    add_gpu_executable(${target_name} ${source_file})
   else()
     add_executable(${target_name} ${source_file})
     target_link_libraries(${target_name} PRIVATE ViennaPS)

cmake/generate_ptx.cmake

@@ -8,7 +8,7 @@ function(generate_pipeline target_name generated_files_output)
   cuda_include_directories(${OptiX_INCLUDE_DIR} ${CUDA_INCLUDE_DIRS})
 
   # Include ViennaRay headers which are used in pipelines
-  cuda_include_directories(${VIENNARAY_GPU_INCLUDE} ${VIENNAPS_GPU_INCLUDE})
+  cuda_include_directories(${VIENNARAY_GPU_INCLUDE})
   cuda_include_directories(${ViennaPS_SOURCE_DIR}/include/viennaps)
   cuda_include_directories(${ViennaCore_SOURCE_DIR}/include/viennacore)
   add_compile_definitions(VIENNACORE_COMPILE_GPU)
@@ -55,7 +55,7 @@ function(generate_kernel target_name generated_files_output)
 
   cuda_include_directories(${OptiX_INCLUDE_DIR} ${CUDA_INCLUDE_DIRS})
   cuda_include_directories(${ViennaCore_SOURCE_DIR}/include/viennacore)
-  cuda_include_directories(${VIENNARAY_GPU_INCLUDE} ${VIENNAPS_GPU_INCLUDE})
+  cuda_include_directories(${VIENNARAY_GPU_INCLUDE})
   add_compile_definitions(VIENNACORE_COMPILE_GPU)
   if(VIENNARAY_GPU_DOUBLE_PRECISION)
     add_compile_definitions(VIENNARAY_GPU_DOUBLE_PRECISION)
@@ -76,11 +76,8 @@ function(generate_kernel target_name generated_files_output)
 endfunction()
 
 # In CMake, functions have their own scope, whereas macros use the scope of the caller.
-function(add_GPU_executable target_name_base target_name_var)
+function(add_GPU_executable target_name_base)
   set(target_name ${target_name_base})
-  set(${target_name_var}
-      ${target_name}
-      PARENT_SCOPE)
 
   # Separate the sources from the CMake and CUDA options fed to the macro.  This code
   # comes from the CUDA_COMPILE_PTX macro found in FindCUDA.cmake.  We are copying the
@@ -102,7 +99,7 @@ function(add_GPU_executable target_name_base target_name_var)
   cuda_include_directories(${OptiX_INCLUDE_DIR} ${CUDA_INCLUDE_DIRS})
 
   # Include ViennaRay headers which are used in pipelines
-  cuda_include_directories(${VIENNARAY_GPU_INCLUDE} ${VIENNAPS_GPU_INCLUDE})
+  cuda_include_directories(${VIENNARAY_GPU_INCLUDE})
   cuda_include_directories(${ViennaPS_SOURCE_DIR}/include/viennaps)
   cuda_include_directories(${ViennaCore_SOURCE_DIR}/include/viennacore)
   add_compile_definitions(VIENNACORE_COMPILE_GPU)
@@ -125,7 +122,7 @@ function(add_GPU_executable target_name_base target_name_var)
   list(APPEND cu_optix_source_files ${VIENNARAY_PIPELINE_DIR}/GeneralPipelineDisk.cu)
   list(APPEND cu_optix_source_files ${VIENNARAY_PIPELINE_DIR}/GeneralPipelineTriangle.cu)
   list(APPEND cu_optix_source_files ${VIENNARAY_PIPELINE_DIR}/GeneralPipelineLine.cu)
-  list(APPEND cu_optix_source_files ${VIENNAPS_GPU_INCLUDE}/models/CallableWrapper.cu)
+  list(APPEND cu_optix_source_files ${VIENNAPS_GPU_MODELS}/CallableWrapper.cu)
 
   # Wrap OptiX pipeline files.
   if(VIENNAPS_GENERATE_OPTIXIR)
@@ -156,8 +153,7 @@ function(add_GPU_executable target_name_base target_name_var)
   # the cmake_options parsed out of the arguments.
   message(STATUS "Adding GPU target: ${target_name}")
   add_executable(${target_name} ${source_files} ${generated_files} ${cmake_options})
-  target_include_directories(${target_name} PRIVATE ${VIENNARAY_GPU_INCLUDE}
-                                                    ${VIENNAPS_GPU_INCLUDE})
+  target_include_directories(${target_name} PRIVATE ${VIENNARAY_GPU_INCLUDE})
   target_link_libraries(${target_name} PRIVATE ViennaPS)
   target_compile_definitions(${target_name}
                              PRIVATE VIENNACORE_KERNELS_PATH_DEFINE=${VIENNACORE_PTX_DIR})

gpu/CMakeLists.txt

@@ -19,9 +19,9 @@ else()
 endif()
 
 #### Set variables
-set(VIENNAPS_GPU_INCLUDE
-    "${PROJECT_SOURCE_DIR}/include"
-    CACHE STRING "Includes for ViennaPS GPU processing.")
+set(VIENNAPS_GPU_MODELS
+    "${PROJECT_SOURCE_DIR}/models"
+    CACHE STRING "ModelsViennaPS GPU process models.")
 set(VIENNAPS_CUDA_KERNELS
     ""
     CACHE STRING "ViennaPS CUDA kernel source files.")

gpu/benchmark/CMakeLists.txt

@@ -2,19 +2,15 @@ project(ViennaPS-GPU_Benchmark)
 
 add_custom_target(ViennaPS-GPU_Benchmark ALL)
 
-add_gpu_executable(GPU_Benchmark target_name ${CMAKE_CURRENT_SOURCE_DIR}/GPU_Benchmark.cpp)
+add_gpu_executable(GPU_Benchmark ${CMAKE_CURRENT_SOURCE_DIR}/GPU_Benchmark.cpp)
 add_dependencies(ViennaPS-GPU_Benchmark GPU_Benchmark)
 
 add_executable(CPU_Benchmark ${CMAKE_CURRENT_SOURCE_DIR}/CPU_Benchmark.cpp)
 target_link_libraries(CPU_Benchmark ViennaPS)
 add_dependencies(ViennaPS-GPU_Benchmark CPU_Benchmark)
 
-add_executable(CPU_Benchmark_single ${CMAKE_CURRENT_SOURCE_DIR}/CPU_Benchmark_single.cpp)
-target_link_libraries(CPU_Benchmark_single ViennaPS)
-add_dependencies(ViennaPS-GPU_Benchmark CPU_Benchmark_single)
-
-add_gpu_executable(holeComparison target_name ${CMAKE_CURRENT_SOURCE_DIR}/holeCompare.cpp)
+add_gpu_executable(holeComparison ${CMAKE_CURRENT_SOURCE_DIR}/holeCompare.cpp)
 add_dependencies(ViennaPS-GPU_Benchmark holeComparison)
 
-add_gpu_executable(holeComparisonGrid target_name ${CMAKE_CURRENT_SOURCE_DIR}/holeCompareGrid.cpp)
+add_gpu_executable(holeComparisonGrid ${CMAKE_CURRENT_SOURCE_DIR}/holeCompareGrid.cpp)
 add_dependencies(ViennaPS-GPU_Benchmark holeComparisonGrid)

gpu/benchmark/CPU_Benchmark.cpp

@@ -186,9 +186,9 @@ int main() {
           tracer.normalizeFlux(fluxResult);
           fluxResultVec.push_back(std::move(fluxResult));
         }
-        ElementToPointData<NumericType, float, viennaray::gpu::ResultType>(
-            fluxResultVec, pointData, particles, elementKdTree, diskMesh,
-            surfMesh, domain->getGridDelta() * 2.0f)
+        ElementToPointData<NumericType, float, float>(
+            IndexMap(particles), fluxResultVec, pointData, elementKdTree,
+            diskMesh, surfMesh, domain->getGridDelta() * 2.0f)
             .apply();
         auto velocities = SmartPointer<std::vector<NumericType>>::New(
             std::move(*pointData->getScalarData(fluxLabel)));

gpu/benchmark/CPU_Benchmark_single.cpp

@@ -111,8 +111,8 @@ int main() {
         auto pointData = viennals::PointData<NumericType>::New();
         tracer.normalizeResults();
         // tracer.downloadResults();
-        gpu::ElementToPointData<NumericType, float, viennaray::gpu::ResultType>(
-            tracer.getResults(), pointData, tracer.getParticles(),
+        ElementToPointData<NumericType, float, viennaray::gpu::ResultType>(
+            IndexMap(tracer.getParticles()), tracer.getResults(), pointData,
             elementKdTree, diskMesh, surfMesh, domain->getGridDelta() * 2.0f)
             .apply();
         auto velocities = SmartPointer<std::vector<NumericType>>::New(