Add emulation examples and coverage convergence warning (#141)

* Check number of coverage iterations and add warning

* Add emulation example

* Add emulation FinFET example

* Add nanowire example

* Fix nanowire example

* Domain bounds setup and small fixes

* small adjustment in nanowire example

Author: tobre1

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 project(
   ViennaPS
   LANGUAGES CXX C
-  VERSION 3.5.1)
+  VERSION 3.5.2)
 
 # --------------------------------------------------------------------------------------------------------
 # Library switches
@@ -96,7 +96,7 @@ include("cmake/cpm.cmake")
 
 CPMAddPackage(
   NAME ViennaCore
-  VERSION 1.4.3
+  VERSION 1.4.4
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaCore"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON}
   OPTIONS "VIENNACORE_USE_GPU ${VIENNAPS_USE_GPU}" "VIENNACORE_FORCE_GPU ${VIENNAPS_FORCE_GPU}")
@@ -115,7 +115,7 @@ CPMFindPackage(
 
 CPMFindPackage(
   NAME ViennaLS
-  VERSION 4.3.2
+  VERSION 4.3.3
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaLS"
   EXCLUDE_FROM_ALL ${VIENNAPS_BUILD_PYTHON})
 

README.md

@@ -115,7 +115,7 @@ We recommend using [CPM.cmake](https://github.com/cpm-cmake/CPM.cmake) to consum
 
 * Installation with CPM
   ```cmake
-  CPMAddPackage("gh:viennatools/viennaps@3.5.1")
+  CPMAddPackage("gh:viennatools/viennaps@3.5.2")
   ```
 
 * With a local installation

examples/atomicLayerDeposition/atomicLayerDeposition.py

@@ -1,49 +1,66 @@
 import viennaps2d as vps
-import viennals2d as vls  
+import viennals2d as vls
 
 
 params = vps.ReadConfigFile("config.txt")
 geometry = vps.Domain()
 
 # Create the geometry
-boundaryCons = [vls.BoundaryConditionEnum.REFLECTIVE_BOUNDARY, vls.BoundaryConditionEnum.INFINITE_BOUNDARY]
+boundaryCons = [
+    vls.BoundaryConditionEnum.REFLECTIVE_BOUNDARY,
+    vls.BoundaryConditionEnum.INFINITE_BOUNDARY,
+]
 gridDelta = params["gridDelta"]
-bounds = [0., 
-          params["openingWidth"] / 2. + params["xPad"] + params["gapLength"], 
-          -gridDelta,
-          params["openingDepth"] + params["gapHeight"] + gridDelta]
+bounds = [
+    0.0,
+    params["openingWidth"] / 2.0 + params["xPad"] + params["gapLength"],
+    -gridDelta,
+    params["openingDepth"] + params["gapHeight"] + gridDelta,
+]
 
 substrate = vls.Domain(bounds, boundaryCons, gridDelta)
-normal = [0., 1.]
-origin = [0., params["openingDepth"] + params["gapHeight"]]
+normal = [0.0, 1.0]
+origin = [0.0, params["openingDepth"] + params["gapHeight"]]
 vls.MakeGeometry(substrate, vls.Plane(origin, normal)).apply()
 
 geometry.insertNextLevelSetAsMaterial(substrate, vps.Material.Si)
 
 vertBox = vls.Domain(bounds, boundaryCons, gridDelta)
-minPoint = [-gridDelta, 0.]
-maxPoint = [params["openingWidth"] / 2., params["gapHeight"] + params["openingDepth"] + gridDelta]
+minPoint = [-gridDelta, 0.0]
+maxPoint = [
+    params["openingWidth"] / 2.0,
+    params["gapHeight"] + params["openingDepth"] + gridDelta,
+]
 vls.MakeGeometry(vertBox, vls.Box(minPoint, maxPoint)).apply()
 
 geometry.applyBooleanOperation(vertBox, vls.BooleanOperationEnum.RELATIVE_COMPLEMENT)
 
 horiBox = vls.Domain(bounds, boundaryCons, gridDelta)
-minPoint = [params["openingWidth"] / 2. - gridDelta, 0.]
-maxPoint = [params["openingWidth"] / 2. + params["gapLength"], params["gapHeight"]]
+minPoint = [params["openingWidth"] / 2.0 - gridDelta, 0.0]
+maxPoint = [params["openingWidth"] / 2.0 + params["gapLength"], params["gapHeight"]]
 vls.MakeGeometry(horiBox, vls.Box(minPoint, maxPoint)).apply()
 geometry.applyBooleanOperation(horiBox, vls.BooleanOperationEnum.RELATIVE_COMPLEMENT)
 
 geometry.saveVolumeMesh("SingleParticleALD_initial.vtu")
 
 geometry.duplicateTopLevelSet(vps.Material.Al2O3)
 
-gasMFP = vps.constants.gasMeanFreePath(params["pressure"], params["temperature"], params["diameter"])
+gasMFP = vps.constants.gasMeanFreePath(
+    params["pressure"], params["temperature"], params["diameter"]
+)
 print("Mean free path: ", gasMFP, " um")
 
-model = vps.SingleParticleALD(params["stickingProbability"], params["numCycles"],
-                                params["growthPerCycle"], params["totalCycles"],
-                                params["coverageTimeStep"], params["evFlux"],
-                                params["inFlux"], params["s0"], gasMFP)
+model = vps.SingleParticleALD(
+    params["stickingProbability"],
+    params["numCycles"],
+    params["growthPerCycle"],
+    params["totalCycles"],
+    params["coverageTimeStep"],
+    params["evFlux"],
+    params["inFlux"],
+    params["s0"],
+    gasMFP,
+)
 
 ALP = vps.AtomicLayerProcess(geometry, model)
 ALP.setCoverageTimeStep(params["coverageTimeStep"])
@@ -57,4 +74,4 @@
 #   MeasureProfile<NumericType, D>(domain, params.get("gapHeight") / 2.)
 #       .save(params.get<std::string>("outputFile"));
 
-geometry.saveVolumeMesh("SingleParticleALD_final.vtu")
+geometry.saveVolumeMesh("SingleParticleALD_final.vtu")

examples/emulation/CMakeLists.txt

@@ -0,0 +1,6 @@
+project(Emulation LANGUAGES CXX)
+
+add_executable(FinFET "FinFET.cpp")
+target_link_libraries(FinFET PRIVATE ViennaPS)
+
+viennacore_setup_bat(FinFET ${VIENNAPS_ARTIFACTS_DIRECTORY})