feat: mask materials in geometric process models (#223)

* feat: get disk mesh from domain

* fix: Plasma models fix (#221)

* set a default rateFactor in plasma models

* change default sticking in SF6C4F8 model

* refactor: improve MaterialValueMap and update examples (#222)

* feat: add function to insert mask at front of material stack

* feat: directional process rate based

* feat: material value mapping in single particle process rates

* feat: single particle process python bindings updated

* feat: add mapping in IsotropicProcess

* refactor: material mapping, allow custom material registration

* feat: materials on CUDA device code

* fix: plasma etching models

* feat: add material factors in plasma etching model

* test adding custom material to domain

* refactor: use singleton MaterialRegistry

* material registry tests

* refactor: update directional process

* refactor: udpate ion beam etching model

* fix: faraday cage model, update python bindings

* small map refactor

* fix: bug in mask blur GDS

* feat: parallel blur loop

* fix: correct material check function in CSV file process

* refactor: material info

* feat: fix build

* chore: format

* fix: material info requires string for custom values

* feat: MaterialValueMap iterator includes custom values

* feat(MaterialValueMap): get entries by index

* refactor: SelectiveEpitaxy material handling and emulation examples

* refactor: rename header file with MaterialMap

* refactor: CF4O2 model and selective epitaxy

* fix: clean up finFET example

* refactor: MultiParticleProcess uses MaterialValueMap

* fix: check all examples

* format

* refactor: move geometric model logic to strategy

* feat: mask materials in geometric model

* fix: missing header, python stubs

* refactor: use mask materials in emulation examples

---------

Co-authored-by: Roman Kostal <roman.kstl@gmail.com>

Author: tobre1

examples/emulation/FinFET.cpp

@@ -59,8 +59,8 @@ int main() {
     std::cout << "DP-Patterning ..." << std::flush;
     const NumericType etchDepth = 6; // nm
     auto dist = SmartPointer<BoxDistribution<double, D>>::New(
-        std::array<NumericType, D>{-gridDelta, -gridDelta, -etchDepth},
-        domain->getLevelSets().front());
+        std::array<NumericType, D>{-gridDelta, -gridDelta, -etchDepth});
+    dist->addMaskMaterial(Material::Si);
     Process<NumericType, D>(domain, dist).apply();
     std::cout << " done" << std::endl;
   }
@@ -108,8 +108,8 @@ int main() {
   // pattern STI material
   {
     std::cout << "STI Patterning ..." << std::flush;
-    auto dist =
-        IsotropicProcessGeometric::New(-35, domain->getLevelSets().front());
+    auto dist = IsotropicProcessGeometric::New(-35);
+    dist->addMaskMaterial(Material::Si); // protect silicon during etch
     Process<NumericType, D>(domain, dist).apply();
     std::cout << " done" << std::endl;
   }
@@ -155,12 +155,15 @@ int main() {
   // gate patterning
   {
     std::cout << "Dummy Gate Patterning ..." << std::flush;
-    Vec3D<NumericType> direction = {0, 0, 1};
     std::vector<Material> masks = {Material::Mask, Material::Si,
                                    Material::SiO2};
-    auto model = SmartPointer<DirectionalProcess<NumericType, D>>::New(
-        direction, 1.0, 0., masks, false);
-    Process<NumericType, D>(domain, model, 110.).apply();
+    const NumericType etchDepth = 110; // nm
+    auto dist = SmartPointer<BoxDistribution<double, D>>::New(
+        std::array<NumericType, D>{-gridDelta, -gridDelta, -etchDepth});
+    for (const auto &maskMaterial : masks) {
+      dist->addMaskMaterial(maskMaterial);
+    }
+    Process<NumericType, D>(domain, dist).apply();
     std::cout << " done" << std::endl;
   }
   writeSurface(domain);
@@ -182,9 +185,15 @@ int main() {
 
   { // spacer etch
     std::cout << "Spacer Etch ..." << std::flush;
-    auto mask = domain->getLevelSets()[domain->getLevelSets().size() - 2];
+    auto materialsInDomain = domain->getMaterialsInDomain();
+    materialsInDomain.erase(
+        Material::Si3N4);             // protect spacer material during etch
+    const NumericType etchDepth = 50; // nm
     auto dist = SmartPointer<BoxDistribution<double, D>>::New(
-        std::array<NumericType, D>{-gridDelta, -gridDelta, -50}, mask);
+        std::array<NumericType, D>{-gridDelta, -gridDelta, -etchDepth});
+    for (const auto &maskMaterial : materialsInDomain) {
+      dist->addMaskMaterial(maskMaterial);
+    }
     Process<NumericType, D>(domain, dist).apply();
     std::cout << " done" << std::endl;
   }

examples/emulation/FinFET.py

@@ -46,10 +46,9 @@ def writeSurface(domain):
 # DP-Patterning
 print("DP-Patterning ...", end="", flush=True)
 etchDepth = 6.0  # nm
-dist = ps.BoxDistribution(
-    halfAxes=[-gridDelta, -gridDelta, -etchDepth], mask=domain.getLevelSets()[0]
-)
-ps.Process(domain, dist, 0).apply()
+dist = ps.BoxDistribution(halfAxes=[-gridDelta, -gridDelta, -etchDepth])
+dist.addMaskMaterial(ps.Material.Si)
+ps.Process(domain, dist).apply()
 print(" done")
 writeSurface(domain)
 
@@ -87,7 +86,8 @@ def writeSurface(domain):
 
 # pattern STI material
 print("STI Patterning ...", end="", flush=True)
-dist = ps.SphereDistribution(radius=-35, mask=domain.getLevelSets()[0])
+dist = ps.SphereDistribution(radius=-35.0)
+dist.addMaskMaterial(ps.Material.Si)
 ps.Process(domain, dist, 0).apply()
 print(" done")
 writeSurface(domain)
@@ -125,13 +125,9 @@ def writeSurface(domain):
 print("Dummy Gate Patterning ...", end="", flush=True)
 direction = [0.0, 0.0, 1.0]
 masks = [ps.Material.Mask, ps.Material.Si, ps.Material.SiO2]
-model = ps.DirectionalProcess(
-    direction=direction,
-    directionalVelocity=1.0,
-    isotropicVelocity=0.0,
-    maskMaterial=masks,
-    calculateVisibility=False,
-)
+model = ps.BoxDistribution(halfAxes=[-gridDelta, -gridDelta, -110.0])
+for mask in masks:
+    model.addMaskMaterial(mask)
 ps.Process(domain, model, 110.0).apply()
 print(" done")
 writeSurface(domain)
@@ -151,8 +147,11 @@ def writeSurface(domain):
 
 # Spacer Etch
 print("Spacer Etch ...", end="", flush=True)
-ls = domain.getLevelSets()[-2]
-dist = ps.BoxDistribution(halfAxes=[-gridDelta, -gridDelta, -50], mask=ls)
+masks = domain.getMaterialsInDomain()
+masks.remove(ps.Material.Si3N4)
+dist = ps.BoxDistribution(halfAxes=[-gridDelta, -gridDelta, -50])
+for material in masks:
+    dist.addMaskMaterial(material)
 ps.Process(domain, dist, 0).apply()
 print(" done")
 writeSurface(domain)

examples/emulation/stackedNanowire.py

@@ -74,31 +74,31 @@
 # Deposit dummy gate material
 print("Depositing dummy gate material ...")
 domain.duplicateTopLevelSet(ps.Material.PolySi)
-ps.Process(domain, growth, 55.0).apply()
+ps.Process(domain, growth, 85.0).apply()
 
-# CMP at 80nm height
-ps.Planarize(domain, 80.0).apply()
+# CMP at 100nm height
+ps.Planarize(domain, 100.0).apply()
 
 domain.saveSurfaceMesh("StackedNanowire_" + str(n))
 n += 1
 
 # Dummy gate mask addition
 print("Adding dummy gate mask ...")
 mask = ps.ls.Domain(bounds, boundaryConds, gridDelta)
-geo = ps.ls.MakeGeometry(mask, ps.ls.Box([-10, 30, 75], [80, 70, 80]))
+geo = ps.ls.MakeGeometry(mask, ps.ls.Box([-10, 30, 99], [80, 70, 105]))
 geo.setIgnoreBoundaryConditions(True)
 geo.apply()
+domain.insertNextLevelSetAsMaterial(mask, ps.Material.Mask)
+domain.saveSurfaceMesh("StackedNanowire_" + str(n))
+n += 1
 
-ps.ls.BooleanOperation(
-    mask, domain.getLevelSets()[-2], ps.ls.BooleanOperationEnum.UNION
-).apply()
-
-tmpDomain = ps.Domain()
-tmpDomain.insertNextLevelSetAsMaterial(mask, ps.Material.Mask)
-tmpDomain.insertNextLevelSetAsMaterial(domain.getLevelSets()[-1], ps.Material.PolySi)
+masks = domain.getMaterialsInDomain()
+masks.remove(ps.Material.PolySi)
+geometricEtch = ps.BoxDistribution([-gridDelta, -gridDelta, -100])
+for material in masks:
+    geometricEtch.addMaskMaterial(material)
 
-geometricEtch = ps.BoxDistribution([-gridDelta, -gridDelta, -80], mask)
-ps.Process(tmpDomain, geometricEtch, 1.0).apply()
+ps.Process(domain, geometricEtch).apply()
 
 domain.removeMaterial(ps.Material.Mask)
 domain.saveSurfaceMesh("StackedNanowire_" + str(n))
@@ -107,7 +107,7 @@
 # Spacer Deposition
 print("Depositing spacer material ...")
 domain.duplicateTopLevelSet(ps.Material.Si3N4)
-ps.Process(domain, growth, 12.0).apply()
+ps.Process(domain, growth, 10.0).apply()
 domain.saveSurfaceMesh("StackedNanowire_" + str(n))
 n += 1
 

include/viennaps/models/psGeometricDistributionModels.hpp

@@ -25,6 +25,12 @@ class SphereDistribution : public ProcessModelCPU<NumericType, D> {
     this->setProcessName("SphereDistribution");
     this->processMetaData["Radius"] = std::vector<double>{radius};
   }
+
+  void addMaskMaterial(const Material material) {
+    auto geomModel = this->getGeometricModel();
+    assert(geomModel != nullptr);
+    geomModel->addMaskMaterial(material);
+  }
 };
 
 template <typename NumericType, int D>
@@ -46,6 +52,12 @@ class BoxDistribution : public ProcessModelCPU<NumericType, D> {
         static_cast<double>(halfAxes[0]), static_cast<double>(halfAxes[1]),
         static_cast<double>(halfAxes[2])};
   }
+
+  void addMaskMaterial(const Material material) {
+    auto geomModel = this->getGeometricModel();
+    assert(geomModel != nullptr);
+    geomModel->addMaskMaterial(material);
+  }
 };
 
 template <typename NumericType, int D>
@@ -65,6 +77,12 @@ class CustomSphereDistribution : public ProcessModelCPU<NumericType, D> {
     this->setGeometricModel(geomModel);
     this->setProcessName("CustomSphereDistribution");
   }
+
+  void addMaskMaterial(const Material material) {
+    auto geomModel = this->getGeometricModel();
+    assert(geomModel != nullptr);
+    geomModel->addMaskMaterial(material);
+  }
 };
 
 namespace impl {

include/viennaps/process/psGeometricModel.hpp

@@ -2,17 +2,19 @@
 
 #include <lsGeometricAdvect.hpp>
 
-#include "../psDomain.hpp"
+#include "../psPreCompileMacros.hpp"
+
+#include "../materials/psMaterial.hpp"
 
 namespace viennaps {
 
 using namespace viennacore;
 
 VIENNAPS_TEMPLATE_ND(NumericType, D) class GeometricModel {
-  SmartPointer<Domain<NumericType, D>> domain = nullptr;
   SmartPointer<viennals::GeometricAdvectDistribution<NumericType, D>> dist =
       nullptr;
   SmartPointer<viennals::Domain<NumericType, D>> mask = nullptr;
+  std::vector<Material> maskMaterials;
 
 public:
   GeometricModel() = default;
@@ -23,10 +25,6 @@ VIENNAPS_TEMPLATE_ND(NumericType, D) class GeometricModel {
       SmartPointer<viennals::Domain<NumericType, D>> passedMask = nullptr)
       : dist(passedDist), mask(passedMask) {}
 
-  void setDomain(SmartPointer<Domain<NumericType, D>> passedDomain) {
-    domain = passedDomain;
-  }
-
   void setDistribution(
       SmartPointer<viennals::GeometricAdvectDistribution<NumericType, D>>
           passedDist) {
@@ -37,24 +35,17 @@ VIENNAPS_TEMPLATE_ND(NumericType, D) class GeometricModel {
     mask = passedMask;
   }
 
-  void apply() {
-    if (!dist) {
-      VIENNACORE_LOG_ERROR(
-          "No GeometricAdvectDistribution passed to GeometricModel.");
-      return;
-    }
-
-    viennals::GeometricAdvect<NumericType, D>(domain->getLevelSets().back(),
-                                              dist, mask)
-        .apply();
-
-    for (int i = domain->getNumberOfLevelSets() - 1; i >= 0; --i) {
-      viennals::BooleanOperation<NumericType, D>(
-          domain->getLevelSets()[i], domain->getLevelSets().back(),
-          viennals::BooleanOperationEnum::INTERSECT)
-          .apply();
-    }
+  void addMaskMaterial(const Material material) {
+    maskMaterials.push_back(material);
   }
+
+  void setMaskMaterials(const std::vector<Material> &materials) {
+    maskMaterials = materials;
+  }
+
+  auto &getDistribution() const { return dist; }
+  auto &getMask() const { return mask; }
+  auto &getMaskMaterials() const { return maskMaterials; }
 };
 
 } // namespace viennaps

include/viennaps/process/psGeometricProcessStrategy.hpp

@@ -18,8 +18,94 @@ class GeometricProcessStrategy : public ProcessStrategy<NumericType, D> {
     }
 
     auto geometricModel = context.model->getGeometricModel();
-    geometricModel->setDomain(context.domain);
-    geometricModel->apply();
+    assert(geometricModel);
+
+    auto dist = geometricModel->getDistribution();
+    if (!dist) {
+      VIENNACORE_LOG_ERROR(
+          "No GeometricAdvectDistribution passed to GeometricModel.");
+      return ProcessResult::INVALID_INPUT;
+    }
+
+    auto mask = geometricModel->getMask();
+    if (!mask) {
+      // check if mask materials are set, if so create a mask level set from the
+      // domain
+      auto maskMaterials = geometricModel->getMaskMaterials();
+      if (!maskMaterials.empty()) {
+        auto domain = context.domain;
+        auto materialMap = domain->getMaterialMap();
+        if (!materialMap) {
+          VIENNACORE_LOG_ERROR("Domain does not have a material map, cannot "
+                               "create mask level set "
+                               "from mask materials.");
+          return ProcessResult::INVALID_INPUT;
+        }
+
+        auto maskLevelSet = SmartPointer<viennals::Domain<NumericType, D>>::New(
+            domain->getGrid());
+        bool foundMaterial = false;
+
+        auto const &levelSets = domain->getLevelSets();
+        for (auto &material : maskMaterials) {
+          for (int j = 0; j < levelSets.size(); ++j) {
+            if (materialMap->getMaterialAtIdx(j) == material) {
+              auto lsCopy = SmartPointer<viennals::Domain<NumericType, D>>::New(
+                  levelSets[j]);
+
+              // remove all lower level sets that are not mask materials
+              for (int k = j - 1; k >= 0; --k) {
+                if (MaterialMap::isMaterial(materialMap->getMaterialAtIdx(k),
+                                            maskMaterials))
+                  continue;
+
+                viennals::BooleanOperation<NumericType, D>(
+                    lsCopy, levelSets[k],
+                    viennals::BooleanOperationEnum::RELATIVE_COMPLEMENT)
+                    .apply();
+              }
+
+              if (foundMaterial) {
+                // union with mask level set
+                viennals::BooleanOperation<NumericType, D>(
+                    maskLevelSet, lsCopy, viennals::BooleanOperationEnum::UNION)
+                    .apply();
+              } else {
+                maskLevelSet = lsCopy;
+                foundMaterial = true;
+              }
+            }
+          }
+        }
+
+        if (maskLevelSet->getNumberOfPoints() > 0) {
+          mask = maskLevelSet;
+          if (Logger::hasDebug()) {
+            auto dbgMesh = viennals::Mesh<NumericType>::New();
+            viennals::ToMesh<NumericType, D>(mask, dbgMesh).apply();
+            viennals::VTKWriter<NumericType>(dbgMesh, "geometric_mask_debug")
+                .apply();
+          }
+        } else {
+          VIENNACORE_LOG_WARNING(
+              "None of the specified mask materials were found in the domain, "
+              "cannot create mask level set from mask materials.");
+        }
+      }
+    }
+
+    viennals::GeometricAdvect<NumericType, D>(
+        context.domain->getLevelSets().back(), dist, mask)
+        .apply();
+
+    // Intersect all other level sets with the last one to keep them consistent
+    for (int i = context.domain->getNumberOfLevelSets() - 1; i >= 0; --i) {
+      viennals::BooleanOperation<NumericType, D>(
+          context.domain->getLevelSets()[i],
+          context.domain->getLevelSets().back(),
+          viennals::BooleanOperationEnum::INTERSECT)
+          .apply();
+    }
 
     return ProcessResult::SUCCESS;
   }