Add oxidation solver with coupled diffusion, deformation, and GPU acceleration

.github/workflows/build.yml

@@ -33,7 +33,7 @@ jobs:
     container: ${{ matrix.container }}
 
     env:
-      VCPKG_COMMIT: c3867e714dd3a51c272826eea77267876517ed99
+      VCPKG_COMMIT: 72d876b20f06129a1b1e0db80c7075fe3e419d7c
       VCPKG_DEFAULT_BINARY_CACHE: ${{ github.workspace }}/.vcpkg-bincache
 
     name: "🧪 Test on ${{ matrix.os }} (⚙️: ${{ matrix.config }}, 💿: ${{ matrix.container || matrix.os }})"

.github/workflows/python.yml

@@ -30,7 +30,7 @@ jobs:
     container: ${{ matrix.container }}
 
     env:
-      VCPKG_COMMIT: c3867e714dd3a51c272826eea77267876517ed99
+      VCPKG_COMMIT: 72d876b20f06129a1b1e0db80c7075fe3e419d7c
       VCPKG_DEFAULT_BINARY_CACHE: ${{ github.workspace }}/.vcpkg-bincache
 
     name: "🐍 Test Bindings on ${{ matrix.os }}"
@@ -126,6 +126,10 @@ jobs:
 
     name: "🐍 Package Bindings on ${{ matrix.os }}"
 
+    env:
+      VCPKG_COMMIT: 72d876b20f06129a1b1e0db80c7075fe3e419d7c
+      VCPKG_DEFAULT_BINARY_CACHE: ${{ github.workspace }}/.vcpkg-bincache
+
     steps:
       - name: 📥 Checkout
         uses: actions/checkout@v4
@@ -138,10 +142,40 @@ jobs:
       - name: 🛞 CIBuildWheel
         run: pip install cibuildwheel==3.4.0 --break-system-packages
 
+      - name: 🖥️ Setup vcpkg (Windows)
+        shell: pwsh
+        if: ${{ matrix.os == 'windows-latest' }}
+        run: |
+          Remove-Item Env:VCPKG_ROOT -ErrorAction SilentlyContinue
+
+          git clone https://github.com/microsoft/vcpkg.git
+          git -C vcpkg checkout $env:VCPKG_COMMIT
+          & .\vcpkg\bootstrap-vcpkg.bat
+
+          "VCPKG_ROOT=$($env:GITHUB_WORKSPACE)\vcpkg" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+          New-Item -ItemType Directory -Force -Path "${{ env.VCPKG_DEFAULT_BINARY_CACHE }}"
+
+      - name: 🦥 Cache vcpkg binary (Windows)
+        if: ${{ matrix.os == 'windows-latest' }}
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.VCPKG_DEFAULT_BINARY_CACHE }}
+          key: vcpkg-${{ matrix.os }}-Release-${{ env.VCPKG_COMMIT }}
+
+      - name: 🛠️ Build VTK (Windows)
+        if: ${{ matrix.os == 'windows-latest' }}
+        shell: pwsh
+        run: |
+          ./vcpkg/vcpkg install --triplet x64-windows
+
       - name: 🛠️ Package Config (Windows)
         if: ${{ matrix.os == 'windows-latest' }}
+        shell: pwsh
         run: |
-          sed -i 's/\(DVIENNALS_BUILD_PYTHON=ON"\)/\1,"-DVIENNALS_PACKAGE_PYTHON=ON","-DVIENNALS_IS_CI=ON"/g' pyproject.toml
+          $toolchain = "${{ github.workspace }}/vcpkg/scripts/buildsystems/vcpkg.cmake".Replace('\', '/')
+          sed -i 's/\(DVIENNALS_BUILD_PYTHON=ON"\)/\1,"-DVIENNALS_IS_CI=ON"/g' pyproject.toml
+          "CIBW_CONFIG_SETTINGS=cmake.define.CMAKE_TOOLCHAIN_FILE=$toolchain cmake.define.VCPKG_TARGET_TRIPLET=x64-windows" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
           type pyproject.toml
 
       - name: 🛠️ Package Config (MacOs)

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 project(
   ViennaLS
   LANGUAGES CXX
-  VERSION 5.7.3)
+  VERSION 5.8.0)
 
 # --------------------------------------------------------------------------------------------------------
 # Library options
@@ -11,6 +11,8 @@ project(
 option(VIENNALS_USE_VTK "Build with VTK file support" ON)
 option(VIENNALS_VTK_RENDERING "Build with VTK rendering support" ON)
 
+option(VIENNALS_USE_GPU "Enable GPU-accelerated BiCGSTAB linear solver via CUDA" OFF)
+
 option(VIENNALS_PRECOMPILE_HEADERS "Build template specialisations for shorter compile times" OFF)
 option(VIENNALS_STATIC_BUILD "Build dependencies as static libraries" OFF)
 option(VIENNALS_ENABLE_SANITIZER "Enable Sanitizers" OFF)
@@ -90,6 +92,72 @@ if(MSVC)
   target_compile_definitions(${PROJECT_NAME} INTERFACE _USE_MATH_DEFINES=1)
 endif()
 
+# --------------------------------------------------------------------------------------------------------
+# GPU support (CUDA Runtime, no OptiX)
+# --------------------------------------------------------------------------------------------------------
+
+if(VIENNALS_USE_GPU)
+  enable_language(CUDA)
+  get_filename_component(_VIENNALS_CUDA_COMPILER_REAL "${CMAKE_CUDA_COMPILER}" REALPATH)
+  get_filename_component(_VIENNALS_CUDA_COMPILER_BIN "${_VIENNALS_CUDA_COMPILER_REAL}" DIRECTORY)
+  get_filename_component(_VIENNALS_CUDA_COMPILER_ROOT "${_VIENNALS_CUDA_COMPILER_BIN}" DIRECTORY)
+  if(CMAKE_CUDA_COMPILER AND NOT DEFINED CUDAToolkit_ROOT)
+    set(CUDAToolkit_ROOT
+        "${_VIENNALS_CUDA_COMPILER_ROOT}"
+        CACHE PATH "CUDA Toolkit root used by ViennaLS")
+  endif()
+  find_package(CUDAToolkit REQUIRED)
+
+  if(CUDAToolkit_NVCC_EXECUTABLE)
+    get_filename_component(_VIENNALS_CUDATOOLKIT_NVCC_REAL "${CUDAToolkit_NVCC_EXECUTABLE}"
+                           REALPATH)
+    if(NOT _VIENNALS_CUDATOOLKIT_NVCC_REAL STREQUAL _VIENNALS_CUDA_COMPILER_REAL)
+      message(
+        FATAL_ERROR
+          "[ViennaLS] CUDA compiler/toolkit mismatch:\n"
+          "  CMAKE_CUDA_COMPILER=${CMAKE_CUDA_COMPILER}\n"
+          "  CUDAToolkit_NVCC_EXECUTABLE=${CUDAToolkit_NVCC_EXECUTABLE}\n"
+          "Use a fresh build directory or pass -DCUDAToolkit_ROOT=${_VIENNALS_CUDA_COMPILER_ROOT} "
+          "so CUDAToolkit matches the selected CUDA compiler.")
+    endif()
+  endif()
+
+  # Compile the CUDA kernels into a small static library so that consuming
+  # .cpp files (compiled by g++) never see __global__ / <<< >>> syntax.
+  add_library(ViennaLS_GPU STATIC ${PROJECT_SOURCE_DIR}/gpu/lsOxidationBiCGSTABKernels.cu)
+
+  target_compile_definitions(ViennaLS_GPU PRIVATE VIENNALS_GPU_BICGSTAB=1)
+
+  target_include_directories(ViennaLS_GPU PRIVATE ${PROJECT_SOURCE_DIR}/include/viennals
+                                                  ${CUDAToolkit_INCLUDE_DIRS})
+
+  set_target_properties(ViennaLS_GPU PROPERTIES CUDA_SEPARABLE_COMPILATION OFF
+                                                POSITION_INDEPENDENT_CODE ON)
+
+  target_link_libraries(ViennaLS_GPU PUBLIC CUDA::cudart CUDA::cusparse)
+
+  if(UNIX AND NOT APPLE)
+    foreach(_VIENNALS_CUDA_TARGET CUDA::cudart CUDA::cusparse)
+      get_target_property(_VIENNALS_CUDA_LIBRARY ${_VIENNALS_CUDA_TARGET} IMPORTED_LOCATION)
+      if(_VIENNALS_CUDA_LIBRARY)
+        get_filename_component(_VIENNALS_CUDA_LIBRARY_DIR "${_VIENNALS_CUDA_LIBRARY}" DIRECTORY)
+        target_link_options(ViennaLS_GPU INTERFACE
+                            "$<BUILD_INTERFACE:LINKER:-rpath,${_VIENNALS_CUDA_LIBRARY_DIR}>")
+      endif()
+    endforeach()
+  endif()
+
+  # Expose the define and the GPU library to downstream targets.
+  # BUILD_INTERFACE limits the ViennaLS_GPU dependency to the build tree so it
+  # is never exported to the install tree (avoiding the "not in export set" error
+  # from packageProject when ViennaLS_GPU is a non-installed local target).
+  target_compile_definitions(${PROJECT_NAME} INTERFACE VIENNALS_GPU_BICGSTAB=1)
+  target_link_libraries(${PROJECT_NAME} INTERFACE $<BUILD_INTERFACE:ViennaLS_GPU>)
+  target_include_directories(${PROJECT_NAME} INTERFACE ${CUDAToolkit_INCLUDE_DIRS})
+
+  message(STATUS "[ViennaLS] GPU BiCGSTAB solver enabled (CUDA ${CUDAToolkit_VERSION})")
+endif()
+
 # --------------------------------------------------------------------------------------------------------
 # Include directories
 # --------------------------------------------------------------------------------------------------------
@@ -128,6 +196,9 @@ CPMFindPackage(
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaHRLE"
   EXCLUDE_FROM_ALL ${VIENNALS_BUILD_PYTHON})
 
+# # Use local ViennaHRLE with interior point support
+# add_subdirectory(../ViennaHRLE ViennaHRLE.build)
+
 target_link_libraries(${PROJECT_NAME} INTERFACE ViennaHRLE ViennaCore)
 
 if(VIENNALS_USE_VTK AND VIENNALS_VTK_PYTHON_LIBS)

README.md

@@ -9,7 +9,15 @@
 
 </div>
 
-ViennaLS is a header-only C++ level set library developed for high performance topography simulations. The main design goals are simplicity and efficiency, tailored towards scientific simulations. ViennaLS can also be used for visualisation applications, although this is not the main design target.
+ViennaLS is a header-only C++ level set library for high-performance topography and semiconductor process simulations. The main design goals are efficiency and simplicity, tailored towards scientific process simulation.
+
+## Capabilities
+
+- **Level-set equation solver**: Solves ∂φ/∂t + v|∇φ| = 0 to advect interfaces under arbitrary velocity fields; spatial schemes: Engquist-Osher (1st/2nd order), Lax-Friedrichs (global/local, 1st/2nd order), WENO (3rd/5th order); temporal schemes: Forward Euler, Runge-Kutta 2nd/3rd order; CFL-limited time stepping
+- **Level-set operations**: Boolean operations, geometric advection, curvature calculation, normal vectors calculation, visibility calculation, feature detection, 2D<->3D extrusion/slicing, mesh export (VTP/VTU via VTK)
+- **Comparison & analysis**: Chamfer distance (bidirectional surface-to-surface, forward/backward/RMS/max), narrow-band SDF difference, sparse-field SDF difference, volume/area difference, critical dimension extraction
+- **Thermal oxidation**: Coupled Deal-Grove diffusion + Stokes flow oxide mechanics (Maxwell viscoelasticity, SIMPLE pressure-velocity coupling); LOCOS mode adds biharmonic Si₃N₄ mask bending with two-way traction coupling. See [`docs/OxidationSolver.md`](docs/OxidationSolver.md)
+- **GPU acceleration**: Optional CUDA BiCGSTAB back-end for the oxidation diffusion and mechanics linear solves (requires `VIENNALS_USE_GPU=ON`)
 
 > [!NOTE]  
 > ViennaLS is under heavy development and improved daily. If you do have suggestions or find bugs, please let us know!
@@ -32,7 +40,7 @@ Bug reports and suggestions should be filed on GitHub.
 
 ## Releases
 
-Releases are tagged on the maser branch and available in the [releases section](https://github.com/ViennaTools/ViennaLS/releases).
+Releases are tagged on the master branch and available in the [releases section](https://github.com/ViennaTools/ViennaLS/releases).
 
 ## Building
 
@@ -107,6 +115,19 @@ cd ViennaLS
 pip install .
 ```
 
+To build the Python package with **GPU** support for the oxidation diffusion and mechanics solvers, use the install script in the `python/scripts` folder:
+
+```bash
+git clone https://github.com/ViennaTools/ViennaLS.git
+cd ViennaLS
+
+python3 -m venv .venv          # create virtual environment (optional, but recommended)
+source .venv/bin/activate      # activate virtual environment
+python python/scripts/install_ViennaLS.py
+```
+
+A CUDA 12+ toolkit and a driver compatible with your GPU must be installed on your system. On Linux, a GCC version compatible with the CUDA toolkit is also required. Pass `--no-gpu` to build without GPU support using the same script and venv workflow.
+
 ## Using the Python package
 
 The ViennaLS Python package can be used by importing it in your Python scripts:
@@ -154,7 +175,7 @@ We recommend using [CPM.cmake](https://github.com/cpm-cmake/CPM.cmake) to consum
 
 * Installation with CPM
   ```cmake
-  CPMAddPackage("gh:viennatools/viennals@5.7.3")
+  CPMAddPackage("gh:viennatools/viennals@5.8.0")
   ```
 
 * With a local installation

THIRD_PARTY_LICENSES.md

@@ -35,5 +35,3 @@ This file lists third-party libraries used by ViennaLS and their respective lice
 **Note:** Used only when building Python bindings.
 
 ---
-
-

cmake/cpm.cmake

@@ -16,8 +16,10 @@ endif()
 # Expand relative path. This is important if the provided path contains a tilde (~)
 get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
 
-file(DOWNLOAD
-     https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
-     ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM})
+if(NOT EXISTS ${CPM_DOWNLOAD_LOCATION})
+  file(DOWNLOAD
+       https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
+       ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM})
+endif()
 
 include(${CPM_DOWNLOAD_LOCATION})