fix: CPU triangle tracing bug and boundary interaction

CMakeLists.txt

@@ -118,7 +118,7 @@ CPMAddPackage(
 
 CPMAddPackage(
   NAME ViennaRay
-  VERSION 4.1.1
+  VERSION 4.1.2
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaRay"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON}
   OPTIONS "VIENNARAY_USE_GPU ${VIENNAPS_USE_GPU}")

tests/fluxEngineBenchmarks/CMakeLists.txt

@@ -0,0 +1,6 @@
+project(fluxEngineBenchmarks LANGUAGES CXX)
+
+viennaps_add_executable(plasmaEtchingBenchmark "plasmaEtching.cpp")
+viennaps_add_executable(spDepositionBenchmark "spDeposition.cpp")
+viennaps_add_executable(spEtchingBenchmark "spEtching.cpp")
+viennaps_add_executable(ibeEtchingBenchmark "ibeEtching.cpp")

tests/fluxEngineBenchmarks/ibeEtching.cpp

@@ -0,0 +1,57 @@
+#include <geometries/psMakeTrench.hpp>
+#include <models/psIonBeamEtching.hpp>
+
+#include <process/psProcess.hpp>
+#include <psUtil.hpp>
+
+using namespace viennaps;
+
+int main(int argc, char *argv[]) {
+  using NumericType = double;
+  constexpr int D = 2;
+
+  Logger::setLogLevel(LogLevel::WARNING);
+
+  auto run = [&](FluxEngineType fluxEngine) {
+    auto geometry = Domain<NumericType, D>::New(
+        0.09, 10.0, BoundaryType::REFLECTIVE_BOUNDARY);
+    MakeTrench<NumericType, D>(geometry, 5.0, 0.0, 0.0, 2.0).apply();
+
+    IBEParameters<NumericType> ibeParams;
+    ibeParams.exponent = 100;
+    ibeParams.thetaRMin = 89.;
+    ibeParams.thetaRMax = 90.;
+
+    // ibeParams.meanEnergy = 100;
+    // ibeParams.sigmaEnergy = 10;
+    // ibeParams.thresholdEnergy = 10;
+
+    ibeParams.planeWaferRate = 1.0;
+
+    // ibeParams.cos4Yield.isDefined = true;
+    // ibeParams.cos4Yield.a1 = 1.075;
+    // ibeParams.cos4Yield.a2 = -1.55;
+    // ibeParams.cos4Yield.a3 = 0.65;
+
+    auto model = SmartPointer<IonBeamEtching<NumericType, D>>::New(
+        ibeParams, std::vector<Material>{Material::Mask});
+
+    AdvectionParameters advectionParams;
+    advectionParams.spatialScheme =
+        viennals::SpatialSchemeEnum::LAX_FRIEDRICHS_2ND_ORDER;
+
+    Process<NumericType, D> process(geometry, model);
+    process.setProcessDuration(10);
+    process.setParameters(advectionParams);
+    process.setFluxEngineType(fluxEngine);
+
+    process.apply();
+
+    geometry->saveSurfaceMesh("ibeEtching_" + util::toString(fluxEngine));
+  };
+
+  run(FluxEngineType::GPU_TRIANGLE);
+  run(FluxEngineType::GPU_DISK);
+  run(FluxEngineType::CPU_TRIANGLE);
+  run(FluxEngineType::CPU_DISK);
+}

tests/fluxEngineBenchmarks/plasmaEtching.cpp

@@ -0,0 +1,67 @@
+#include <geometries/psMakeHole.hpp>
+#include <models/psSF6O2Etching.hpp>
+
+#include <process/psProcess.hpp>
+#include <psUtil.hpp>
+
+using namespace viennaps;
+
+int main(int argc, char *argv[]) {
+  using NumericType = double;
+  constexpr int D = 2;
+
+  Logger::setLogLevel(LogLevel::WARNING);
+  // set parameter units
+  units::Length::setUnit("um");
+  units::Time::setUnit("min");
+
+  auto run = [&](FluxEngineType fluxEngine) {
+    // geometry setup
+    auto geometry = Domain<NumericType, D>::New(
+        0.03, 1.0,
+        BoundaryType::REFLECTIVE_BOUNDARY); // gridDelta, xExtent, boundary
+    MakeHole<NumericType, D>(geometry, 0.175,
+                             0.0, // holeDepth
+                             0.0, // holeTaperAngle
+                             1.2, 1.193, HoleShape::QUARTER)
+        .apply();
+
+    // use pre-defined model SF6O2 etching model
+    auto modelParams = SF6O2Etching<NumericType, D>::defaultParameters();
+    modelParams.beta_E[static_cast<int>(Material::Si)] = 1.0;
+    modelParams.beta_E[static_cast<int>(Material::Mask)] = 1.0;
+    modelParams.beta_P[static_cast<int>(Material::Si)] = 1.0;
+    modelParams.beta_P[static_cast<int>(Material::Mask)] = 1.0;
+
+    modelParams.ionFlux = 1.;
+    modelParams.etchantFlux = 4.5e3;
+    modelParams.passivationFlux = 8e2;
+    modelParams.Ions.meanEnergy = 100;
+    modelParams.Ions.sigmaEnergy = 10;
+    modelParams.Ions.exponent = 1000;
+    modelParams.Passivation.A_ie = 2.0;
+    modelParams.Substrate.A_ie = 7;
+    auto model = SmartPointer<SF6O2Etching<NumericType, D>>::New(modelParams);
+
+    CoverageParameters coverageParams;
+    coverageParams.tolerance = 1e-4;
+
+    RayTracingParameters rayTracingParams;
+    rayTracingParams.raysPerPoint = 10000;
+
+    Process<NumericType, D> process(geometry, model);
+    process.setProcessDuration(1.0);
+    process.setParameters(coverageParams);
+    process.setFluxEngineType(fluxEngine);
+    process.setParameters(rayTracingParams);
+
+    process.apply();
+
+    geometry->saveSurfaceMesh("PlasmaEtching_" + util::toString(fluxEngine));
+  };
+
+  run(FluxEngineType::GPU_TRIANGLE);
+  run(FluxEngineType::GPU_DISK);
+  run(FluxEngineType::CPU_TRIANGLE);
+  run(FluxEngineType::CPU_DISK);
+}

tests/fluxEngineBenchmarks/spDeposition.cpp

@@ -0,0 +1,52 @@
+#include <geometries/psMakeTrench.hpp>
+#include <models/psSingleParticleProcess.hpp>
+
+#include <process/psProcess.hpp>
+#include <psUtil.hpp>
+
+using namespace viennaps;
+
+int main(int argc, char *argv[]) {
+  using NumericType = double;
+  constexpr int D = 2;
+
+#ifndef NDEBUG
+  Logger::setLogLevel(LogLevel::INTERMEDIATE);
+//   omp_set_num_threads(1);
+#else
+  Logger::setLogLevel(LogLevel::WARNING);
+#endif
+
+  auto run = [&](FluxEngineType fluxEngine) {
+    auto geometry = Domain<NumericType, D>::New(
+        0.14, 10, BoundaryType::REFLECTIVE_BOUNDARY);
+    MakeTrench<NumericType, D>(geometry, 4.0, 20.0, 0.0, 0.0, 0.0, true)
+        .apply();
+
+    geometry->duplicateTopLevelSet(Material::SiO2);
+
+    auto model =
+        SmartPointer<SingleParticleProcess<NumericType, D>>::New(1.0, 0.01);
+    model->setProcessName(util::toString(fluxEngine));
+
+    RayTracingParameters rayTracingParams;
+    rayTracingParams.raysPerPoint = 10000;
+
+    Process<NumericType, D> process(geometry, model);
+    process.setProcessDuration(5);
+    process.setParameters(rayTracingParams);
+    process.setFluxEngineType(fluxEngine);
+    process.apply();
+    // auto flux = process.calculateFlux();
+    // viennals::VTKWriter<NumericType>(
+    //     flux, "flux_" + util::toString(fluxEngine) + ".vtp")
+    //     .apply();
+
+    geometry->saveSurfaceMesh("spDeposition_" + util::toString(fluxEngine));
+  };
+
+  run(FluxEngineType::GPU_TRIANGLE);
+  run(FluxEngineType::GPU_DISK);
+  run(FluxEngineType::CPU_TRIANGLE);
+  run(FluxEngineType::CPU_DISK);
+}

tests/fluxEngineBenchmarks/spEtching.cpp

@@ -0,0 +1,49 @@
+#include <geometries/psMakeTrench.hpp>
+#include <models/psSingleParticleProcess.hpp>
+
+#include <process/psProcess.hpp>
+#include <psUtil.hpp>
+
+using namespace viennaps;
+
+int main(int argc, char *argv[]) {
+  using NumericType = double;
+  constexpr int D = 2;
+
+#ifndef NDEBUG
+  Logger::setLogLevel(LogLevel::INTERMEDIATE);
+//   omp_set_num_threads(1);
+#else
+  Logger::setLogLevel(LogLevel::WARNING);
+#endif
+
+  auto run = [&](FluxEngineType fluxEngine) {
+    auto geometry = Domain<NumericType, D>::New(
+        0.14, 16, BoundaryType::REFLECTIVE_BOUNDARY);
+    MakeTrench<NumericType, D>(geometry, 4.0, 0.0, 0.0, 1.0, 0.0, true).apply();
+
+    auto model = SmartPointer<SingleParticleProcess<NumericType, D>>::New(
+        -1.0, 0.05, 10.0, Material::Mask);
+    model->setProcessName(util::toString(fluxEngine));
+
+    RayTracingParameters rayTracingParams;
+    rayTracingParams.raysPerPoint = 10000;
+
+    Process<NumericType, D> process(geometry, model);
+    process.setProcessDuration(5);
+    process.setParameters(rayTracingParams);
+    process.setFluxEngineType(fluxEngine);
+    process.apply();
+    // auto flux = process.calculateFlux();
+    // viennals::VTKWriter<NumericType>(
+    //     flux, "flux_" + util::toString(fluxEngine) + ".vtp")
+    //     .apply();
+
+    geometry->saveSurfaceMesh("spEtching_" + util::toString(fluxEngine));
+  };
+
+  run(FluxEngineType::GPU_TRIANGLE);
+  run(FluxEngineType::GPU_DISK);
+  run(FluxEngineType::CPU_TRIANGLE);
+  run(FluxEngineType::CPU_DISK);
+}