feat: surface diffusion and desorption (#228)

* Initial commit for neutral transport with coverage and 1D surface diffusion

* set geometry to flat wafer with cylinder mask

* Add desorption re-emission for cpu/gpu disk/triangle

* add etching to coverage equation

* Calculate flux from Maxwellian distribution

* remove desorption from Si, leave on mask only

* Improve surface diffusion

* Add CPU triangle option for transmission calculation

* refactor: small fixes in desorption fluxes

* fix: typo

* feat: graph based surface diffusion implementation

* feat: add surface diffusion framework to process framework

* refactor: use existings constants

* feat: surface diffusion of coverage

* feat: surface diffusion in single particle ALD model

* refactor: keep surface diffusion setup in ALP

* Update max number of relections

* refactor: use unmodified CMake setup

* refactor: update benchmarks

* refactor: start seperating desorption flux from normal flux calculation

* refactor: surface flux calculation GPU triangle

* perf: post processing update

* refactor: desorption for CPU triange engine

* refactor: desorption fluxes for disk engines

* feat: purge pulse in ALP strategy

* feat: test purge pulse in ALD model

* feat: python bindings for params

* refactor: replace tracing data with point data

* feat: split purge pulse in multiple time steps

* refactor: ALD parameters

* feat: use mesh helper functions, update purge step

* refactor: flux process strategy, bump version

* chore: bump deps

* chore: format

* fix: let delocate vendor macOS VTK dylibs

* fix: disable VTK rendering on macOS package

* fix: RenderMode include scope and dangling reference warning

* fix: verbose python build

* fix: Windows runtime deps

* fix: windows python dll dependency

* fix: macOS use local ViennaLS build for bindings

---------

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

Author: tobre1

.github/workflows/python.yml

@@ -96,11 +96,22 @@ jobs:
             --config-settings=cmake.define.VCPKG_TARGET_TRIPLET="x64-windows"
           .\venv\Scripts\python -c "import viennaps; print(viennaps.__doc__)"
 
-      - name: 🐍 Build and check Python Module (Other)
-        if: ${{ matrix.os != 'windows-latest' }}
+      - name: 🐍 Build and check Python Module (Linux)
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: |
+          python -m venv venv
+          CMAKE_ARGS=-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF ./venv/bin/pip install . 
+          ./venv/bin/python -c "import viennaps; print(viennaps.__doc__)"
+
+      - name: 🐍 Build and check Python Module (macOS)
+        if: ${{ matrix.os == 'macos-latest' }}
         run: |
           python -m venv venv
-          CMAKE_ARGS=-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF ./venv/bin/pip install .
+          ./venv/bin/python -m pip install --upgrade pip
+          git clone --depth 1 --branch v5.7.3 https://github.com/ViennaTools/ViennaLS.git ViennaLS
+          CMAKE_ARGS=-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF ./venv/bin/pip install ./ViennaLS
+          CMAKE_ARGS=-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF ./venv/bin/pip install . --no-deps
+          SITE_PACKAGES=$(./venv/bin/python -c 'import sysconfig; print(sysconfig.get_paths()["platlib"])')
           ./venv/bin/python -c "import viennaps; print(viennaps.__doc__)"
 
       - name: 📦 Upload Artifact

.gitignore

@@ -1,4 +1,5 @@
 build/
+build-cpu/
 cmake-build*
 .vscode
 .vs

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 project(
   ViennaPS
   LANGUAGES CXX C
-  VERSION 4.4.0)
+  VERSION 4.5.0)
 
 # --------------------------------------------------------------------------------------------------------
 # Include guards
@@ -23,6 +23,7 @@ option(VIENNAPS_PRECOMPILE_HEADERS "Enable precompiled headers" OFF)
 option(VIENNAPS_STATIC_BUILD "Build ViennaPS as static library" OFF)
 option(VIENNAPS_ENABLE_SANITIZER "Enable sanitizers" OFF)
 option(VIENNAPS_ENABLE_CLANG_TIDY "Run clang-tidy during build" OFF)
+option(VIENNAPS_VTK_RENDERING "Enable VTK rendering support" ON)
 
 option(VIENNAPS_USE_GPU "Enable GPU support" OFF)
 
@@ -67,6 +68,10 @@ endif()
 
 if(VIENNAPS_BUILD_PYTHON)
   set(CMAKE_PLATFORM_NO_VERSIONED_SONAME ON)
+
+  if(APPLE)
+    set(VIENNAPS_VTK_RENDERING OFF)
+  endif()
 endif()
 
 if(MSVC)
@@ -106,7 +111,7 @@ include("cmake/cpm.cmake")
 
 CPMAddPackage(
   NAME ViennaCore
-  VERSION 2.1.2
+  VERSION 2.2.1
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaCore"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON}
   OPTIONS "VIENNACORE_USE_GPU ${VIENNAPS_USE_GPU}")
@@ -118,17 +123,18 @@ CPMAddPackage(
 
 CPMAddPackage(
   NAME ViennaRay
-  VERSION 4.1.2
+  VERSION 4.3.1
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaRay"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON}
   OPTIONS "VIENNARAY_USE_GPU ${VIENNAPS_USE_GPU}")
 
 CPMAddPackage(
   NAME ViennaLS
-  VERSION 5.7.1
+  VERSION 5.7.3
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaLS"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON}
-  OPTIONS "VIENNALS_PRECOMPILE_HEADERS ${VIENNAPS_PRECOMPILE_HEADERS}")
+  OPTIONS "VIENNALS_PRECOMPILE_HEADERS ${VIENNAPS_PRECOMPILE_HEADERS}"
+          "VIENNALS_VTK_RENDERING ${VIENNAPS_VTK_RENDERING}")
 
 CPMAddPackage(
   NAME ViennaCS

README.md

@@ -130,7 +130,7 @@ We recommend using [CPM.cmake](https://github.com/cpm-cmake/CPM.cmake) to consum
 
 * Installation with CPM
   ```cmake
-  CPMAddPackage("gh:viennatools/viennaps@4.4.0")
+  CPMAddPackage("gh:viennatools/viennaps@4.5.0")
   ```
 
 * With a local installation
@@ -155,7 +155,7 @@ cmake -B build -DVIENNALS_PRECOMPILE_HEADERS=ON
 
 If ViennaPS was built with shared libraries and you use ViennaPS in your project (see above), CMake will automatically link them to your project.
 
-## GPU Acceleration (Experimental)
+## GPU Acceleration
 
 As of version 3.4.0, ViennaPS supports GPU acceleration for the ray tracing part of the library. This feature is still experimental. Details on how to enable GPU functionality can be found in the [documentation](https://viennatools.github.io/ViennaPS/inst/gpu.html).
 
@@ -286,4 +286,4 @@ http://www.iue.tuwien.ac.at/
 Versions < 4.3.0 were released under MIT License. Starting with version 4.3.0, the project is licensed under GPL-3.0 License. For more details, please refer to the [LICENSE](./LICENSE) file in the base directory of the repository.
 
 Some third-party libraries used by ViennaPS are under their own permissive licenses (BSD, Apache-2.0).  
-See [`THIRD_PARTY_LICENSES.md`](./THIRD_PARTY_LICENSES.md) for details.
+See [`THIRD_PARTY_LICENSES.md`](./THIRD_PARTY_LICENSES.md) for details.

examples/atomicLayerDeposition/atomicLayerDeposition.cpp

@@ -9,25 +9,25 @@
 // #include "constants.hpp"
 #include "geometry.hpp"
 
-namespace ps = viennaps;
+using namespace viennaps;
 
 template <typename T, int D> class MeasureProfile {
   using ResultType = std::pair<std::vector<T>, std::vector<T>>;
 
-  ps::SmartPointer<ps::Domain<T, D>> domain_;
+  SmartPointer<Domain<T, D>> domain_;
   T cutoffHeight_;
 
 public:
-  MeasureProfile(ps::SmartPointer<ps::Domain<T, D>> &domain, T cutoffHeight)
+  MeasureProfile(SmartPointer<Domain<T, D>> &domain, T cutoffHeight)
       : cutoffHeight_(cutoffHeight) {
-    domain_ = ps::SmartPointer<ps::Domain<T, D>>::New();
+    domain_ = SmartPointer<Domain<T, D>>::New();
     domain_->deepCopy(domain);
   }
 
   ResultType get() {
-    ps::Planarize<T, D>(domain_, cutoffHeight_).apply();
+    Planarize<T, D>(domain_, cutoffHeight_).apply();
     auto mesh = viennals::Mesh<T>::New();
-    ps::ToDiskMesh<T, D>(domain_, mesh).apply();
+    ToDiskMesh<T, D>(domain_, mesh).apply();
 
     std::vector<T> height, position;
     height.reserve(mesh->nodes.size());
@@ -57,7 +57,7 @@ int main(int argc, char **argv) {
   omp_set_num_threads(16);
 
   // Parse the parameters
-  ps::util::Parameters params;
+  util::Parameters params;
   if (argc > 1) {
     params.readConfigFile(argv[1]);
   } else {
@@ -70,34 +70,49 @@ int main(int argc, char **argv) {
     }
   }
 
-  auto domain = ps::SmartPointer<ps::Domain<NumericType, D>>::New();
+  auto domain = SmartPointer<Domain<NumericType, D>>::New();
   makeT(domain, params.get("gridDelta"), params.get("openingDepth"),
         params.get("openingWidth"), params.get("gapLength"),
-        params.get("gapHeight"), params.get("xPad"), ps::Material::Si,
+        params.get("gapHeight"), params.get("xPad"), Material::Si,
         params.get("gapWidth"));
 
   domain->saveVolumeMesh("SingleParticleALD_initial");
 
-  domain->duplicateTopLevelSet(ps::Material::Al2O3);
+  domain->duplicateTopLevelSet(Material::Al2O3);
 
-  auto gasMFP = ps::constants::gasMeanFreePath(params.get("pressure"),
-                                               params.get("temperature"),
-                                               params.get("diameter"));
+  auto gasMFP = constants::gasMeanFreePath(params.get("pressure"),
+                                           params.get("temperature"),
+                                           params.get("diameter"));
   std::cout << "Mean free path: " << gasMFP << " um" << std::endl;
 
-  auto model = ps::SmartPointer<ps::SingleParticleALD<NumericType, D>>::New(
-      params.get("stickingProbability"), params.get("numCycles"),
-      params.get("growthPerCycle"), params.get("totalCycles"),
-      params.get("coverageTimeStep"), params.get("evFlux"),
-      params.get("inFlux"), params.get("s0"), gasMFP);
+  const NumericType gpc = params.get<int>("totalCycles") /
+                          params.get<int>("numCycles") *
+                          params.get("growthPerCycle");
 
-  ps::AtomicLayerProcessParameters alpParams;
+  SingleParticleALDParams alpModelParams;
+  alpModelParams.stickingProbability = params.get("stickingProbability");
+  alpModelParams.gasMeanFreePath = gasMFP;
+  alpModelParams.growthPerCycle = gpc;
+  alpModelParams.evaporationFlux = params.get("evFlux");
+  alpModelParams.incomingFlux = params.get("inFlux");
+  alpModelParams.s0 = params.get("s0");
+  alpModelParams.coverageDiffusionCoefficient =
+      params.get("coverageDiffusionCoefficient");
+
+  auto model =
+      SmartPointer<SingleParticleALD<NumericType, D>>::New(alpModelParams);
+
+  AtomicLayerProcessParameters alpParams;
   alpParams.numCycles = params.get<unsigned>("numCycles");
   alpParams.pulseTime = params.get("pulseTime");
   alpParams.coverageTimeStep = params.get("coverageTimeStep");
 
-  ps::Process<NumericType, D> ALP(domain, model);
+  RayTracingParameters rayTracingParams;
+  rayTracingParams.raysPerPoint = params.get<unsigned>("numRaysPerPoint");
+
+  Process<NumericType, D> ALP(domain, model);
   ALP.setParameters(alpParams);
+  ALP.setParameters(rayTracingParams);
   ALP.apply();
 
   MeasureProfile<NumericType, D>(domain, params.get("gapHeight") / 2.)

examples/atomicLayerDeposition/atomicLayerDeposition.py

@@ -45,26 +45,25 @@
 
 geometry.saveSurfaceMesh("SingleParticleALD_initial")
 
-model = ps.SingleParticleProcess(rate=1.0, stickingProbability=1e-4)
-
 geometry.duplicateTopLevelSet(ps.Material.Al2O3)
 
 gasMFP = ps.constants.gasMeanFreePath(
     params["pressure"], params["temperature"], params["diameter"]
 )
 print("Mean free path: ", gasMFP, " um")
 
-model = ps.SingleParticleALD(
-    stickingProbability=params["stickingProbability"],
-    numCycles=int(params["numCycles"]),
-    growthPerCycle=params["growthPerCycle"],
-    totalCycles=int(params["totalCycles"]),
-    coverageTimeStep=params["coverageTimeStep"],
-    evFlux=params["evFlux"],
-    inFlux=params["inFlux"],
-    s0=params["s0"],
-    gasMFP=gasMFP,
-)
+gpc = params["totalCycles"] / params["numCycles"] * params["growthPerCycle"]
+
+params = ps.SingleParticleALDParams()
+params.stickingProbability = params["stickingProbability"]
+params.gasMeanFreePath = gasMFP
+params.growthPerCycle = gpc
+params.evaporationFlux = params["evFlux"]
+params.incomingFlux = params["inFlux"]
+params.s0 = params["s0"]
+params.coverageDiffusionCoefficient = params["coverageDiffusionCoefficient"]
+
+model = ps.SingleParticleALD(params)
 
 alpParams = ps.AtomicLayerProcessParameters()
 alpParams.pulseTime = params["pulseTime"]

examples/atomicLayerDeposition/config.txt

@@ -12,6 +12,7 @@ topSpace = 0.
 
 # Cycles
 pulseTime = 0.1
+purgePulseTime = 0.05
 coverageTimeStep=0.01
 growthPerCycle = 0.000112
 numCycles=10
@@ -26,7 +27,7 @@ mass = 28.02
 # Atomistic
 inFlux = 2e6 # 1e19
 stickingProbability = 5e-5
-evFlux = 0 # 6.5 # 1e19
+evFlux = 2.5 # 1e19
 s0 = 3.36
 
 # Simulation

examples/customParticleDistribution/customParticleDistribution.cpp

@@ -142,18 +142,18 @@ class CustomDistributionParticle final
   void surfaceCollision(NumericType rayWeight, const Vec3D<NumericType> &rayDir,
                         const Vec3D<NumericType> &geomNormal,
                         const unsigned int primID, const int,
-                        viennaray::TracingData<NumericType> &localData,
-                        const viennaray::TracingData<NumericType> *,
-                        RNG &) override {
-    localData.getVectorData(0)[primID] +=
-        std::max(std::sqrt(energy_) - std::sqrt(thresholdEnergy_), 0.);
+                        PointData<NumericType> &localData,
+                        const PointData<NumericType> *, RNG &) override {
+    localData.addToScalarData(
+        0, primID,
+        std::max(std::sqrt(energy_) - std::sqrt(thresholdEnergy_), 0.));
   }
 
   std::pair<NumericType, Vec3D<NumericType>>
   surfaceReflection(NumericType rayWeight, const Vec3D<NumericType> &rayDir,
                     const Vec3D<NumericType> &geomNormal,
                     const unsigned int primID, const int materialId,
-                    const viennaray::TracingData<NumericType> *globalData,
+                    const PointData<NumericType> *globalData,
                     RNG &rngState) override {
 
     NumericType incAngle = std::acos(-DotProduct(rayDir, geomNormal));
@@ -199,7 +199,7 @@ template <typename NumericType>
 class CustomSurfaceModel : public SurfaceModel<NumericType> {
 public:
   SmartPointer<std::vector<NumericType>>
-  calculateVelocities(SmartPointer<viennals::PointData<NumericType>> fluxes,
+  calculateVelocities(SmartPointer<PointData<NumericType>> fluxes,
                       const std::vector<Vec3D<NumericType>> &coordinates,
                       const std::vector<NumericType> &materialIds) override {
     auto velocity =

examples/exampleProcess/particles.hpp

@@ -14,18 +14,18 @@ class Particle
                         const viennaray::Vec3D<NumericType> &rayDir,
                         const viennaray::Vec3D<NumericType> &geomNormal,
                         const unsigned int primID, const int materialId,
-                        viennaray::TracingData<NumericType> &localData,
-                        const viennaray::TracingData<NumericType> *globalData,
+                        viennaray::PointData<NumericType> &localData,
+                        const viennaray::PointData<NumericType> *globalData,
                         viennaray::RNG &rngState) final {
     // collect data for this hit
-    localData.getVectorData(0)[primID] += rayWeight;
+    localData.addToScalarData(0, primID, rayWeight);
   }
   std::pair<NumericType, viennaray::Vec3D<NumericType>>
   surfaceReflection(NumericType rayWeight,
                     const viennaray::Vec3D<NumericType> &rayDir,
                     const viennaray::Vec3D<NumericType> &geomNormal,
                     const unsigned int primId, const int materialId,
-                    const viennaray::TracingData<NumericType> *globalData,
+                    const viennaray::PointData<NumericType> *globalData,
                     viennaray::RNG &rngState) final {
     auto direction =
         viennaray::ReflectionDiffuse<NumericType, D>(geomNormal, rngState);

examples/exampleProcess/surfaceModel.hpp

@@ -11,7 +11,7 @@ class SurfaceModel : public viennaps::SurfaceModel<NumericType> {
   void initializeCoverages(unsigned numGeometryPoints) override {
     std::vector<NumericType> someCoverages(numGeometryPoints, 0);
 
-    coverages = viennals::PointData<NumericType>::New();
+    coverages = viennaps::PointData<NumericType>::New();
     coverages->insertNextScalarData(someCoverages, "coverages");
   }
 
@@ -22,7 +22,7 @@ class SurfaceModel : public viennaps::SurfaceModel<NumericType> {
   }
 
   viennaps::SmartPointer<std::vector<NumericType>> calculateVelocities(
-      viennaps::SmartPointer<viennals::PointData<NumericType>> rates,
+      viennaps::SmartPointer<viennaps::PointData<NumericType>> rates,
       const std::vector<viennaps::Vec3D<NumericType>> &coordinates,
       const std::vector<NumericType> &materialIds) override {
     // use coverages and rates here to calculate the velocity here
@@ -31,7 +31,7 @@ class SurfaceModel : public viennaps::SurfaceModel<NumericType> {
   }
 
   void updateCoverages(
-      viennaps::SmartPointer<viennals::PointData<NumericType>> rates,
+      viennaps::SmartPointer<viennaps::PointData<NumericType>> rates,
       const std::vector<NumericType> &materialIds) override {
     // update coverages
   }