From f2ba0be8dc8efd4e3ee58292728ebe1b5e5b90fd Mon Sep 17 00:00:00 2001 From: Tobias Reiter <44025882+tobre1@users.noreply.github.com> Date: Thu, 30 Jan 2025 17:02:50 +0100 Subject: [PATCH] Add Faraday cage etching model (#105) * Start implement default FaradayCageEtching model * IBE Python bindings and stubs * Faraday cage etching Python bindings * Implement 2D mode for FC model * Add periodic boundary condition warning --- examples/faradayCageEtching/CMakeLists.txt | 10 + examples/faradayCageEtching/config.txt | 14 + .../faradayCageEtching/faradayCageEtching.cpp | 56 ++++ .../faradayCageEtching/faradayCageEtching.py | 58 ++++ .../viennaps/models/psFaradayCageEtching.hpp | 263 ++++++++++++++++++ include/viennaps/models/psIonBeamEtching.hpp | 39 ++- include/viennaps/psDomain.hpp | 9 + include/viennaps/psProcess.hpp | 7 +- include/viennaps/psProcessModel.hpp | 1 + python/generateStubs.py | 27 ++ python/pyWrap.cpp | 61 ++++ python/stubs/viennaps2d/viennaps2d.pyi | 242 ++++++++-------- python/stubs/viennaps3d/viennaps3d.pyi | 238 ++++++++-------- 13 files changed, 755 insertions(+), 270 deletions(-) create mode 100644 examples/faradayCageEtching/CMakeLists.txt create mode 100644 examples/faradayCageEtching/config.txt create mode 100644 examples/faradayCageEtching/faradayCageEtching.cpp create mode 100644 examples/faradayCageEtching/faradayCageEtching.py create mode 100644 include/viennaps/models/psFaradayCageEtching.hpp create mode 100644 python/generateStubs.py diff --git a/examples/faradayCageEtching/CMakeLists.txt b/examples/faradayCageEtching/CMakeLists.txt new file mode 100644 index 00000000..2c1ecde5 --- /dev/null +++ b/examples/faradayCageEtching/CMakeLists.txt @@ -0,0 +1,10 @@ +project(faradayCageEtching LANGUAGES CXX) + +add_executable(${PROJECT_NAME}.exe "${PROJECT_NAME}.cpp") +target_link_libraries(${PROJECT_NAME}.exe PRIVATE ViennaPS) + +configure_file(faradayCageEtching.py ${CMAKE_CURRENT_BINARY_DIR}/faradayCageEtching.py COPYONLY) +configure_file(config.txt ${CMAKE_CURRENT_BINARY_DIR}/config.txt COPYONLY) + +add_dependencies(ViennaPS_Examples ${PROJECT_NAME}.exe) +viennacore_setup_bat(${PROJECT_NAME}.exe ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}) diff --git a/examples/faradayCageEtching/config.txt b/examples/faradayCageEtching/config.txt new file mode 100644 index 00000000..bd3f133a --- /dev/null +++ b/examples/faradayCageEtching/config.txt @@ -0,0 +1,14 @@ +# Geometry +gridDelta = 0.1 +xExtent = 10.0 +yExtent = 10.0 + +finWidth = 2.0 +maskHeight = 0.5 + +# Cage Setup +tiltAngle = 60.0 +cageAngle = 90.0 + +etchTime = 7.0 +raysPerPoint = 1000 diff --git a/examples/faradayCageEtching/faradayCageEtching.cpp b/examples/faradayCageEtching/faradayCageEtching.cpp new file mode 100644 index 00000000..f62b4a35 --- /dev/null +++ b/examples/faradayCageEtching/faradayCageEtching.cpp @@ -0,0 +1,56 @@ +#include +#include + +#include +#include + +namespace ps = viennaps; + +int main(int argc, char *argv[]) { + using NumericType = double; + constexpr int D = 2; + + ps::Logger::setLogLevel(ps::LogLevel::INTERMEDIATE); + omp_set_num_threads(16); + + // Parse the parameters + ps::utils::Parameters params; + if (argc > 1) { + params.readConfigFile(argv[1]); + } else { + std::cout << "Usage: " << argv[0] << " " << std::endl; + return 1; + } + + // geometry setup + auto geometry = ps::SmartPointer>::New(); + ps::MakeFin(geometry, params.get("gridDelta"), + params.get("xExtent"), params.get("yExtent"), + params.get("finWidth"), params.get("maskHeight"), + 0.0, 0.0, true, true, ps::Material::Si) + .apply(); + + std::vector maskMaterials = {ps::Material::Mask}; + ps::FaradayCageParameters cageParams; + cageParams.ibeParams.tiltAngle = params.get("tiltAngle"); + cageParams.cageAngle = params.get("cageAngle"); + auto model = ps::SmartPointer>::New( + maskMaterials, cageParams); + + // process setup + ps::Process process; + process.setDomain(geometry); + process.setProcessModel(model); + process.setMaxCoverageInitIterations(10); + process.setNumberOfRaysPerPoint(params.get("raysPerPoint")); + process.setProcessDuration(params.get("etchTime")); + + // print initial surface + geometry->saveSurfaceMesh("initial.vtp"); + + // run the process + process.apply(); + + // print final surface + geometry->saveSurfaceMesh("final.vtp"); +} diff --git a/examples/faradayCageEtching/faradayCageEtching.py b/examples/faradayCageEtching/faradayCageEtching.py new file mode 100644 index 00000000..f68d659d --- /dev/null +++ b/examples/faradayCageEtching/faradayCageEtching.py @@ -0,0 +1,58 @@ +from argparse import ArgumentParser + +# parse config file name and simulation dimension +parser = ArgumentParser(prog="faradayCageEtching", description="Run a faraday cage etching process.") +parser.add_argument("-D", "-DIM", dest="dim", type=int, default=2) +parser.add_argument("filename") +args = parser.parse_args() + +# switch between 2D and 3D mode +if args.dim == 2: + print("Running 2D simulation.") + import viennaps2d as vps +else: + print("Running 3D simulation.") + import viennaps3d as vps + +params = vps.ReadConfigFile(args.filename) + +# print intermediate output surfaces during the process +vps.Logger.setLogLevel(vps.LogLevel.INTERMEDIATE) + +# geometry setup, all units in um +geometry = vps.Domain() +vps.MakeFin( + domain=geometry, + gridDelta=params["gridDelta"], + xExtent=params["xExtent"], + yExtent=params["yExtent"], + finWidth=params["finWidth"], + finHeight=params["maskHeight"], + periodicBoundary=True, + makeMask=True, + material=vps.Material.Si, +).apply() + +# use pre-defined model SF6O2 etching model +parameters = vps.FaradayCageParameters() +parameters.cageAngle = params["cageAngle"] +parameters.ibeParams.tiltAngle = params["tiltAngle"] +mask = [vps.Material.Mask] + +model = vps.FaradayCageEtching(mask, parameters) + +# process setup +process = vps.Process() +process.setDomain(geometry) +process.setProcessModel(model) +process.setNumberOfRaysPerPoint(int(params["raysPerPoint"])) +process.setProcessDuration(params["etchTime"]) # seconds + +# print initial surface +geometry.saveSurfaceMesh(filename="initial.vtp", addMaterialIds=True) + +# run the process +process.apply() + +# print final surface +geometry.saveSurfaceMesh(filename="final.vtp", addMaterialIds=True) diff --git a/include/viennaps/models/psFaradayCageEtching.hpp b/include/viennaps/models/psFaradayCageEtching.hpp new file mode 100644 index 00000000..a0151a27 --- /dev/null +++ b/include/viennaps/models/psFaradayCageEtching.hpp @@ -0,0 +1,263 @@ +#pragma once + +#include "psIonBeamEtching.hpp" + +#include "../psMaterials.hpp" +#include "../psProcessModel.hpp" + +#include +#include + +#include +#include + +namespace viennaps { + +using namespace viennacore; + +template struct FaradayCageParameters { + IBEParameters ibeParams; + + NumericType cageAngle = 0; // degree +}; + +namespace impl { + +template +class PeriodicSource : public viennaray::Source { +public: + PeriodicSource(const std::array, 2> &boundingBox, + const NumericType gridDelta, const NumericType tiltAngle, + const NumericType cageAngle, const NumericType cosinePower) + : sourceExtent_{boundingBox[1][0] - boundingBox[0][0], + boundingBox[1][1] - boundingBox[0][1]}, + minPoint_{boundingBox[0][0], boundingBox[0][1]}, + zPos_(boundingBox[1][D - 1] + 2 * gridDelta), gridDelta_(gridDelta), + ee_{2 / (cosinePower + 1)} { + + NumericType cage_x = std::cos(cageAngle * M_PI / 180.); + NumericType cage_y = std::sin(cageAngle * M_PI / 180.); + NumericType cosTilt = std::cos(tiltAngle * M_PI / 180.); + NumericType sinTilt = std::sin(tiltAngle * M_PI / 180.); + + viennaray::Vec3D direction; + direction[0] = -cosTilt * cage_y; + direction[1] = cosTilt * cage_x; + direction[2] = -sinTilt; + if constexpr (D == 2) + std::swap(direction[1], direction[2]); + + if (Logger::getLogLevel() >= 5) { + Logger::getInstance() + .addDebug("FaradayCageEtching: Source direction 1: " + + std::to_string(direction[0]) + " " + + std::to_string(direction[1]) + " " + + std::to_string(direction[2])) + .print(); + } + orthoBasis1_ = rayInternal::getOrthonormalBasis(direction); + + direction[0] = cosTilt * cage_y; + direction[1] = -cosTilt * cage_x; + direction[2] = -sinTilt; + if constexpr (D == 2) + std::swap(direction[1], direction[2]); + + if (Logger::getLogLevel() >= 5) { + Logger::getInstance() + .addDebug("FaradayCageEtching: Source direction 2: " + + std::to_string(direction[0]) + " " + + std::to_string(direction[1]) + " " + + std::to_string(direction[2])) + .print(); + } + orthoBasis2_ = rayInternal::getOrthonormalBasis(direction); + } + + viennaray::Vec2D> + getOriginAndDirection(const size_t idx, + viennaray::RNG &RngState) const override { + std::uniform_real_distribution dist(0., 1.); + + viennaray::Vec3D origin; + origin[0] = minPoint_[0] + sourceExtent_[0] * dist(RngState); + if constexpr (D == 3) + origin[1] = minPoint_[1] + sourceExtent_[1] * dist(RngState); + origin[D - 1] = zPos_; + + viennaray::Vec3D direction; + if (idx % 2 == 0) { + direction = getCustomDirection(RngState, orthoBasis1_); + } else { + direction = getCustomDirection(RngState, orthoBasis2_); + } + rayInternal::Normalize(direction); + + return {origin, direction}; + } + + size_t getNumPoints() const override { + if constexpr (D == 3) + return sourceExtent_[0] * sourceExtent_[1] / (gridDelta_ * gridDelta_); + else + return sourceExtent_[0] / gridDelta_; + } + + NumericType getSourceArea() const override { + if constexpr (D == 3) + return sourceExtent_[0] * sourceExtent_[1]; + else + return sourceExtent_[0]; + } + + void saveSourcePlane() const { + auto mesh = viennals::SmartPointer>::New(); + if constexpr (D == 3) { + std::array point = {minPoint_[0], minPoint_[1], zPos_}; + mesh->insertNextNode(point); + point[0] += sourceExtent_[0]; + mesh->insertNextNode(point); + point[1] += sourceExtent_[1]; + mesh->insertNextNode(point); + point[0] -= sourceExtent_[0]; + mesh->insertNextNode(point); + mesh->insertNextTriangle({0, 1, 2}); + mesh->insertNextTriangle({0, 2, 3}); + } else { + std::array point = {minPoint_[0], zPos_, NumericType(0)}; + mesh->insertNextNode(point); + point[0] += sourceExtent_[0]; + mesh->insertNextNode(point); + mesh->insertNextLine({0, 1}); + } + viennals::VTKWriter(mesh, "sourcePlane_periodic.vtp").apply(); + } + +private: + viennaray::Vec3D getCustomDirection( + viennaray::RNG &rngState, + const std::array, 3> &basis) const { + viennaray::Vec3D direction; + std::uniform_real_distribution uniDist; + + viennaray::Vec3D rndDirection{0., 0., 0.}; + auto r1 = uniDist(rngState); + auto r2 = uniDist(rngState); + + const NumericType tt = std::pow(r2, ee_); + rndDirection[0] = std::sqrt(tt); + rndDirection[1] = std::cos(M_PI * 2. * r1) * std::sqrt(1 - tt); + rndDirection[2] = std::sin(M_PI * 2. * r1) * std::sqrt(1 - tt); + + direction[0] = basis[0][0] * rndDirection[0] + + basis[1][0] * rndDirection[1] + + basis[2][0] * rndDirection[2]; + direction[1] = basis[0][1] * rndDirection[0] + + basis[1][1] * rndDirection[1] + + basis[2][1] * rndDirection[2]; + if constexpr (D == 3) { + direction[2] = basis[0][2] * rndDirection[0] + + basis[1][2] * rndDirection[1] + + basis[2][2] * rndDirection[2]; + } else { + direction[2] = 0.; + Normalize(direction); + } + + return direction; + } + + std::array const sourceExtent_; + std::array const minPoint_; + + NumericType const zPos_; + NumericType const gridDelta_; + const NumericType ee_; + + std::array, 3> orthoBasis1_; + std::array, 3> orthoBasis2_; +}; + +} // namespace impl + +template +class FaradayCageEtching : public ProcessModel { +public: + FaradayCageEtching() = default; + + FaradayCageEtching(const std::vector &maskMaterials) + : maskMaterials_(maskMaterials) {} + + FaradayCageEtching(const std::vector &maskMaterials, + const FaradayCageParameters ¶ms) + : maskMaterials_(maskMaterials), params_(params) {} + + void setMaskMaterials(const std::vector &maskMaterials) { + maskMaterials_ = maskMaterials; + } + + FaradayCageParameters &getParameters() { return params_; } + + void setParameters(const FaradayCageParameters ¶ms) { + params_ = params; + } + + void initialize(SmartPointer> domain, + const NumericType processDuration) override final { + + auto gridDelta = domain->getGrid().getGridDelta(); + auto boundingBox = domain->getBoundingBox(); + auto source = SmartPointer>::New( + boundingBox, gridDelta, params_.ibeParams.tiltAngle, params_.cageAngle, + params_.ibeParams.exponent); + this->setSource(source); + + if (firstInit) + return; + + auto boundaryConditions = domain->getBoundaryConditions(); + if ((D == 3 && + (boundaryConditions[0] != + viennals::BoundaryConditionEnum::PERIODIC_BOUNDARY || + boundaryConditions[1] != + viennals::BoundaryConditionEnum::PERIODIC_BOUNDARY)) || + (D == 2 && boundaryConditions[0] != + viennals::BoundaryConditionEnum::PERIODIC_BOUNDARY)) { + Logger::getInstance() + .addWarning("FaradayCageEtching: Periodic boundary conditions are " + "required for the Faraday Cage Etching process.") + .print(); + } + + // particles + auto particle = + std::make_unique>(params_.ibeParams); + + // surface model + auto surfModel = SmartPointer>::New( + params_.ibeParams, maskMaterials_); + + // velocity field + auto velField = SmartPointer>::New(2); + + if (Logger::getLogLevel() >= 5) + source->saveSourcePlane(); + + this->particles.clear(); + this->setSurfaceModel(surfModel); + this->setVelocityField(velField); + this->insertNextParticleType(particle); + this->setProcessName("FaradayCageEtching"); + + firstInit = true; + } + + void reset() override final { firstInit = false; } + +private: + bool firstInit = false; + std::vector maskMaterials_; + FaradayCageParameters params_; +}; + +} // namespace viennaps diff --git a/include/viennaps/models/psIonBeamEtching.hpp b/include/viennaps/models/psIonBeamEtching.hpp index 45ea4230..8531cda2 100644 --- a/include/viennaps/models/psIonBeamEtching.hpp +++ b/include/viennaps/models/psIonBeamEtching.hpp @@ -18,8 +18,8 @@ template struct IBEParameters { NumericType meanEnergy = 250; // eV NumericType sigmaEnergy = 10; // eV NumericType thresholdEnergy = 20; // eV - NumericType sourcePower = 100; - NumericType n = 10; + NumericType exponent = 100; + NumericType n_l = 10; NumericType inflectAngle = 89; // degree NumericType minAngle = 5; // degree NumericType tiltAngle = 0; // degree @@ -77,7 +77,7 @@ class IBEIon : public viennaray::Particle, NumericType> { public: IBEIon(const IBEParameters ¶ms) : params_(params), normalDist_(params.meanEnergy, params.sigmaEnergy), - A_(1. / (1. + params.n * (M_PI_2 / params.inflectAngle - 1.))), + A_(1. / (1. + params.n_l * (M_PI_2 / params.inflectAngle - 1.))), inflectAngle_(params.inflectAngle * M_PI / 180.), minAngle_(params.minAngle * M_PI / 180.) {} @@ -109,7 +109,7 @@ class IBEIon : public viennaray::Particle, NumericType> { Eref_peak = 1. - (1. - A_) * (M_PI_2 - incAngle) / (M_PI_2 - inflectAngle_); } else { - Eref_peak = A_ * std::pow(incAngle / inflectAngle_, params_.n); + Eref_peak = A_ * std::pow(incAngle / inflectAngle_, params_.n_l); } // Gaussian distribution around the Eref_peak scaled by the particle energy NumericType newEnergy; @@ -137,7 +137,7 @@ class IBEIon : public viennaray::Particle, NumericType> { } NumericType getSourceDistributionPower() const override final { - return params_.sourcePower; + return params_.exponent; } std::vector getLocalDataLabels() const override final { @@ -158,14 +158,14 @@ class IBEIon : public viennaray::Particle, NumericType> { template class IonBeamEtching : public ProcessModel { public: - IonBeamEtching() { - std::vector maskMaterial; - initialize(std::move(maskMaterial)); - } + IonBeamEtching() = default; - IonBeamEtching(std::vector maskMaterial) { - initialize(std::move(maskMaterial)); - } + IonBeamEtching(const std::vector &maskMaterial) + : maskMaterials_(maskMaterial) {} + + IonBeamEtching(const std::vector &maskMaterial, + const IBEParameters ¶ms) + : maskMaterials_(maskMaterial), params_(params) {} IBEParameters &getParameters() { return params_; } @@ -173,25 +173,34 @@ class IonBeamEtching : public ProcessModel { params_ = params; } -private: - void initialize(std::vector &&maskMaterial) { + void initialize(SmartPointer> domain, + const NumericType processDuration) override final { + if (firstInit) + return; + // particles auto particle = std::make_unique>(params_); // surface model auto surfModel = SmartPointer>::New( - params_, maskMaterial); + params_, maskMaterials_); // velocity field auto velField = SmartPointer>::New(2); + this->particles.clear(); this->setSurfaceModel(surfModel); this->setVelocityField(velField); this->insertNextParticleType(particle); this->setProcessName("IonBeamEtching"); + firstInit = true; } + void reset() override final { firstInit = false; } + private: + bool firstInit = false; + std::vector maskMaterials_; IBEParameters params_; }; diff --git a/include/viennaps/psDomain.hpp b/include/viennaps/psDomain.hpp index 6d491323..ed6d9e6a 100644 --- a/include/viennaps/psDomain.hpp +++ b/include/viennaps/psDomain.hpp @@ -262,6 +262,10 @@ template class Domain { // Returns the underlying HRLE grid of the top Level-Set in the domain. auto &getGrid() const { return levelSets_.back()->getGrid(); } + auto getGridDelta() const { + return levelSets_.back()->getGrid().getGridDelta(); + } + // Returns the bounding box of the top Level-Set in the domain. // [min, max][x, y, z] auto getBoundingBox() const { @@ -273,6 +277,11 @@ template class Domain { return boundingBox; } + // Returns the boundary conditions of the domain. + auto getBoundaryConditions() const { + return levelSets_.back()->getGrid().getBoundaryConditions(); + } + void print() const { std::cout << "Process Simulation Domain:" << std::endl; std::cout << "**************************" << std::endl; diff --git a/include/viennaps/psProcess.hpp b/include/viennaps/psProcess.hpp index 9ade26d0..124404b6 100644 --- a/include/viennaps/psProcess.hpp +++ b/include/viennaps/psProcess.hpp @@ -135,6 +135,7 @@ template class Process { } meshConverter.apply(); + model->initialize(domain, 0.); if (model->getSurfaceModel()->getCoverages() != nullptr) { Logger::getInstance() .addWarning( @@ -216,7 +217,6 @@ template class Process { .print(); return; } - const auto name = model->getProcessName().value_or("default"); if (!domain) { Logger::getInstance() @@ -225,6 +225,9 @@ template class Process { return; } + model->initialize(domain, processDuration); + const auto name = model->getProcessName().value_or("default"); + if (model->getGeometricModel()) { model->getGeometricModel()->setDomain(domain); Logger::getInstance().addInfo("Applying geometric model...").print(); @@ -479,6 +482,7 @@ template class Process { #endif // Expand LS based on the integration scheme advectionKernel.prepareLS(); + model->initialize(domain, remainingTime); auto rates = SmartPointer>::New(); meshConverter.apply(); @@ -701,6 +705,7 @@ template class Process { processTimer.totalDuration * 1e-9) .print(); } + model->reset(); } void writeParticleDataLogs(std::string fileName) { diff --git a/include/viennaps/psProcessModel.hpp b/include/viennaps/psProcessModel.hpp index cf334745..89318509 100644 --- a/include/viennaps/psProcessModel.hpp +++ b/include/viennaps/psProcessModel.hpp @@ -38,6 +38,7 @@ template class ProcessModel { virtual void initialize(SmartPointer> domain, const NumericType processDuration) {} + virtual void reset() {} auto &getParticleTypes() { return particles; } auto getSurfaceModel() const { return surfaceModel; } diff --git a/python/generateStubs.py b/python/generateStubs.py new file mode 100644 index 00000000..6e09e2f8 --- /dev/null +++ b/python/generateStubs.py @@ -0,0 +1,27 @@ +import mypy.stubgen as stubgen +import sys +import argparse + + +if __name__ == "__main__": + # parse dim + parser = argparse.ArgumentParser() + parser.add_argument("--dim", type=int, default=2) + args = parser.parse_args() + dim = args.dim + + # Don't create __pycache__ directory + sys.dont_write_bytecode = True + + # Initialize the stubgen parser options + options = stubgen.parse_options( + [ + "-o", + "stubs", + "-p", + "viennaps"+str(dim)+"d", + ] + ) + + # Generate the stubs + stubgen.generate_stubs(options) diff --git a/python/pyWrap.cpp b/python/pyWrap.cpp index 1a0a3e7e..5d243cca 100644 --- a/python/pyWrap.cpp +++ b/python/pyWrap.cpp @@ -50,8 +50,10 @@ // models #include #include +#include #include #include +#include #include #include #include @@ -835,6 +837,55 @@ PYBIND11_MODULE(VIENNAPS_MODULE_NAME, module) { .def("getParameters", &FluorocarbonEtching::getParameters, pybind11::return_value_policy::reference); + // Ion Beam Etching + pybind11::class_>(module, "IBEParameters") + .def(pybind11::init<>()) + .def_readwrite("planeWaferRate", &IBEParameters::planeWaferRate) + .def_readwrite("meanEnergy", &IBEParameters::meanEnergy) + .def_readwrite("sigmaEnergy", &IBEParameters::sigmaEnergy) + .def_readwrite("thresholdEnergy", &IBEParameters::thresholdEnergy) + .def_readwrite("exponent", &IBEParameters::exponent) + .def_readwrite("n_l", &IBEParameters::n_l) + .def_readwrite("inflectAngle", &IBEParameters::inflectAngle) + .def_readwrite("minAngle", &IBEParameters::minAngle) + .def_readwrite("tiltAngle", &IBEParameters::tiltAngle) + .def_readwrite("yieldFunction", &IBEParameters::yieldFunction); + + pybind11::class_, SmartPointer>>( + module, "IonBeamEtching", processModel) + .def(pybind11::init<>()) + .def(pybind11::init(&SmartPointer>::New< + const std::vector &>), + pybind11::arg("maskMaterials")) + .def(pybind11::init( + &SmartPointer>::New< + const std::vector &, const IBEParameters &>), + pybind11::arg("maskMaterials"), pybind11::arg("parameters")) + .def("setParameters", &IonBeamEtching::setParameters) + .def("getParameters", &IonBeamEtching::getParameters, + pybind11::return_value_policy::reference); + + // Faraday Cage Etching + pybind11::class_>(module, "FaradayCageParameters") + .def(pybind11::init<>()) + .def_readwrite("ibeParams", &FaradayCageParameters::ibeParams) + .def_readwrite("cageAngle", &FaradayCageParameters::cageAngle); + + pybind11::class_, + SmartPointer>>( + module, "FaradayCageEtching", processModel) + .def(pybind11::init<>()) + .def(pybind11::init(&SmartPointer>::New< + const std::vector &>), + pybind11::arg("maskMaterials")) + .def(pybind11::init(&SmartPointer>::New< + const std::vector &, + const FaradayCageParameters &>), + pybind11::arg("maskMaterials"), pybind11::arg("parameters")) + .def("setParameters", &FaradayCageEtching::setParameters) + .def("getParameters", &FaradayCageEtching::getParameters, + pybind11::return_value_policy::reference); + // Isotropic Process pybind11::class_, SmartPointer>>( @@ -1223,6 +1274,11 @@ PYBIND11_MODULE(VIENNAPS_MODULE_NAME, module) { .def("getLevelSets", &Domain::getLevelSets) .def("getCellSet", &Domain::getCellSet, "Get the cell set.") .def("getGrid", &Domain::getGrid, "Get the grid") + .def("getGridDelta", &Domain::getGridDelta, "Get the grid delta.") + .def("getBoundingBox", &Domain::getBoundingBox, + "Get the bounding box of the domain.") + .def("getBoundaryConditions", &Domain::getBoundaryConditions, + "Get the boundary conditions of the domain.") .def("print", &Domain::print) .def("saveLevelSetMesh", &Domain::saveLevelSetMesh, pybind11::arg("filename"), pybind11::arg("width") = 1, @@ -1379,6 +1435,11 @@ PYBIND11_MODULE(VIENNAPS_MODULE_NAME, module) { .def("getLevelSets", &Domain::getLevelSets) .def("getCellSet", &Domain::getCellSet, "Get the cell set.") .def("getGrid", &Domain::getGrid, "Get the grid") + .def("getGridDelta", &Domain::getGridDelta, "Get the grid delta.") + .def("getBoundingBox", &Domain::getBoundingBox, + "Get the bounding box of the domain.") + .def("getBoundaryConditions", &Domain::getBoundaryConditions, + "Get the boundary conditions of the domain.") .def("print", &Domain::print) .def("saveLevelSetMesh", &Domain::saveLevelSetMesh, pybind11::arg("filename"), pybind11::arg("width") = 1, diff --git a/python/stubs/viennaps2d/viennaps2d.pyi b/python/stubs/viennaps2d/viennaps2d.pyi index e0bcf891..4d306591 100644 --- a/python/stubs/viennaps2d/viennaps2d.pyi +++ b/python/stubs/viennaps2d/viennaps2d.pyi @@ -1,5 +1,5 @@ from _typeshed import Incomplete -from typing import ClassVar, List, Tuple, overload +from typing import Callable, ClassVar, overload Air: Material Al2O3: Material @@ -44,107 +44,68 @@ class AdvectionCallback: class AnisotropicProcess(ProcessModel): @overload - def __init__(self, materials: List[Tuple[Material, float]]) -> None: ... + def __init__(self, materials: list[tuple[Material, float]]) -> None: ... @overload - def __init__(self, direction100, direction010, rate100: float, rate110: float, rate111: float, rate311: float, materials: List[Tuple[Material, float]]) -> None: ... + def __init__(self, direction100, direction010, rate100: float, rate110: float, rate111: float, rate311: float, materials: list[tuple[Material, float]]) -> None: ... class AtomicLayerProcess: - @overload def __init__(self) -> None: ... - @overload - def __init__(self, domain: Domain) -> None: ... - @overload - def __init__(self, domain: Domain, processModel: ProcessModel) -> None: ... def apply(self) -> None: ... def disableRandomSeeds(self) -> None: ... def enableRandomSeeds(self) -> None: ... def setCoverageTimeStep(self, arg0: float) -> None: ... - def setDesorptionRates(self, arg0: List[float]) -> None: ... - def setDomain(self, arg0: Domain): ... - def setIntegrationScheme(self, arg0: IntegrationSchemeEnum) -> None: ... - def setNumberOfRaysPerPoint(self, arg0: int) -> None: ... + def setDesorptionRates(self, arg0: list[float]) -> None: ... + def setDomain(self, *args, **kwargs): ... + def setIntegrationScheme(self, arg0) -> None: ... def setNumCycles(self, arg0: int) -> None: ... - def setPulseTime(self, arg0: float) -> None: ... + def setNumberOfRaysPerPoint(self, arg0: int) -> None: ... def setProcessModel(self, arg0: ProcessModel) -> None: ... + def setPulseTime(self, arg0: float) -> None: ... def setSourceDirection(self, arg0: rayTraceDirection) -> None: ... class BoxDistribution(ProcessModel): def __init__(self, halfAxes, gridDelta: float) -> None: ... -# class DenseCellSet: -# def __init__(self) -> None: ... -# @overload -# def addFillingFraction(self, arg0: int, arg1: float) -> bool: ... -# @overload -# def addFillingFraction(self, arg0, arg1: float) -> bool: ... -# def addFillingFractionInMaterial(self, arg0, arg1: float, arg2: int) -> bool: ... -# def addScalarData(self, arg0: str, arg1: float) -> None: ... -# def buildNeighborhood(self, arg0: bool) -> None: ... -# def clear(self) -> None: ... -# def getAverageFillingFraction(self, arg0, arg1: float) -> float: ... -# def getBoundingBox(self, *args, **kwargs): ... -# def getCellCenter(self, *args, **kwargs): ... -# def getCellGrid(self, *args, **kwargs): ... -# def getCellSetPosition(self) -> bool: ... -# def getDepth(self) -> float: ... -# def getElement(self, *args, **kwargs): ... -# def getElements(self, *args, **kwargs): ... -# def getFillingFraction(self, arg0) -> float: ... -# def getFillingFractions(self) -> List[float]: ... -# def getGridDelta(self) -> float: ... -# def getIndex(self, arg0) -> int: ... -# def getNeighbors(self, *args, **kwargs): ... -# def getNode(self, *args, **kwargs): ... -# def getNodes(self, *args, **kwargs): ... -# def getNumberOfCells(self) -> int: ... -# def getScalarData(self, arg0: str) -> List[float]: ... -# def getScalarDataLabels(self) -> List[str]: ... -# def getSurface(self, *args, **kwargs): ... -# def readCellSetData(self, arg0: str) -> None: ... -# def setCellSetPosition(self, arg0: bool) -> None: ... -# def setCoverMaterial(self, arg0: Material) -> None: ... -# @overload -# def setFillingFraction(self, arg0: int, arg1: float) -> bool: ... -# @overload -# def setFillingFraction(self, arg0, arg1: float) -> bool: ... -# def setPeriodicBoundary(self, arg0) -> None: ... -# def updateMaterials(self) -> None: ... -# def updateSurface(self) -> None: ... -# def writeCellSetData(self, arg0: str) -> None: ... -# def writeVTU(self, arg0: str) -> None: ... - class DirectionalEtching(ProcessModel): @overload - def __init__(self, direction, directionalVelocity: float = ..., isotropicVelocity: float = ..., maskMaterial: Material = ...) -> None: ... + def __init__(self, direction, directionalVelocity: float, isotropicVelocity: float = ..., maskMaterial: Material = ..., calculateVisibility: bool = ...) -> None: ... + @overload + def __init__(self, direction, directionalVelocity: float, isotropicVelocity: float = ..., maskMaterial: list[Material] = ..., calculateVisibility: bool = ...) -> None: ... @overload - def __init__(self, direction, directionalVelocity: float, isotropicVelocity: float, maskMaterial: List[Material]) -> None: ... + def __init__(self, rateSets: list[RateSet]) -> None: ... + @overload + def __init__(self, rateSet: RateSet) -> None: ... class Domain: def __init__(self) -> None: ... - def applyBooleanOperation(self, arg0: viennals.Domain, arg1: BooleanOperationEnum): ... + def applyBooleanOperation(self, *args, **kwargs): ... def clear(self) -> None: ... + def deepCopy(self, arg0: Domain) -> None: ... def duplicateTopLevelSet(self, arg0: Material) -> None: ... def generateCellSet(self, arg0: float, arg1: Material, arg2: bool) -> None: ... def getCellSet(self, *args, **kwargs): ... def getGrid(self, *args, **kwargs): ... def getLevelSets(self, *args, **kwargs): ... - def getMaterialMap(self) -> MaterialMap: ... + def getMaterialMap(self, *args, **kwargs): ... def insertNextLevelSet(self, *args, **kwargs): ... def insertNextLevelSetAsMaterial(self, *args, **kwargs): ... def print(self) -> None: ... + def removeLevelSet(self, arg0: int, arg1: bool) -> None: ... + def removeMaterial(self, arg0: Material) -> None: ... def removeTopLevelSet(self) -> None: ... def saveLevelSetMesh(self, filename: str, width: int = ...) -> None: ... - def saveLevelSets(self, arg0: str) -> None: ... + def saveLevelSets(self, filename: str) -> None: ... def saveSurfaceMesh(self, filename: str, addMaterialIds: bool = ...) -> None: ... def saveVolumeMesh(self, filename: str) -> None: ... - def setMaterialMap(self, arg0: MaterialMap) -> None: ... + def setMaterialMap(self, arg0) -> None: ... class Domain3D: def __init__(self) -> None: ... def applyBooleanOperation(self, *args, **kwargs): ... def clear(self) -> None: ... + def deepCopy(self, arg0: Domain3D) -> None: ... def duplicateTopLevelSet(self, arg0: Material) -> None: ... - def generateCellSet(self, position: float, coverMaterial: Material, isAboveSurface: bool) -> None: ... + def generateCellSet(self, arg0: float, arg1: Material, arg2: bool) -> None: ... def getCellSet(self, *args, **kwargs): ... def getGrid(self, *args, **kwargs): ... def getLevelSets(self, *args, **kwargs): ... @@ -152,6 +113,8 @@ class Domain3D: def insertNextLevelSet(self, *args, **kwargs): ... def insertNextLevelSetAsMaterial(self, *args, **kwargs): ... def print(self) -> None: ... + def removeLevelSet(self, arg0: int, arg1: bool) -> None: ... + def removeMaterial(self, arg0: Material) -> None: ... def removeTopLevelSet(self) -> None: ... def saveLevelSetMesh(self, filename: str, width: int = ...) -> None: ... def saveLevelSets(self, arg0: str) -> None: ... @@ -171,6 +134,21 @@ class Extrude: def setInputDomain(self, arg0: Domain) -> None: ... def setOutputDomain(self, arg0: Domain3D) -> None: ... +class FaradayCageEtching(ProcessModel): + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material]) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material], parameters: FaradayCageParameters) -> None: ... + def getParameters(self) -> FaradayCageParameters: ... + def setParameters(self, arg0: FaradayCageParameters) -> None: ... + +class FaradayCageParameters: + cageAngle: float + ibeParams: IBEParameters + def __init__(self) -> None: ... + class FluorocarbonEtching(ProcessModel): @overload def __init__(self) -> None: ... @@ -252,11 +230,34 @@ class FluorocarbonParametersSiO2: rho: float def __init__(self) -> None: ... +class IBEParameters: + exponent: float + inflectAngle: float + meanEnergy: float + minAngle: float + n_l: float + planeWaferRate: float + sigmaEnergy: float + thresholdEnergy: float + tiltAngle: float + yieldFunction: Callable[[float], float] + def __init__(self) -> None: ... + +class IonBeamEtching(ProcessModel): + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material]) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material], parameters: IBEParameters) -> None: ... + def getParameters(self) -> IBEParameters: ... + def setParameters(self, arg0: IBEParameters) -> None: ... + class IsotropicProcess(ProcessModel): @overload def __init__(self, rate: float = ..., maskMaterial: Material = ...) -> None: ... @overload - def __init__(self, rate: float, maskMaterial: List[Material]) -> None: ... + def __init__(self, rate: float, maskMaterial: list[Material]) -> None: ... class LogLevel: __members__: ClassVar[dict] = ... # read-only @@ -321,6 +322,7 @@ class MakeTrench: def __init__(self, domain: Domain, gridDelta: float, xExtent: float, yExtent: float, trenchWidth: float, trenchDepth: float, taperingAngle: float = 0.0, baseHeight: float = 0.0, periodicBoundary: bool = False, makeMask: bool = False, material: Material = Undefined) -> None: ... def apply(self) -> None: ... + class Material: __members__: ClassVar[dict] = ... # read-only Air: ClassVar[Material] = ... @@ -358,7 +360,7 @@ class Material: class MaterialMap: def __init__(self) -> None: ... def getMaterialAtIdx(self, arg0: int) -> Material: ... - def getMaterialMap(self) -> lsMaterialMap: ... + def getMaterialMap(self, *args, **kwargs): ... def insertNextMaterial(self, material: Material = ...) -> None: ... @staticmethod def isMaterial(arg0: float, arg1: Material) -> bool: ... @@ -366,24 +368,21 @@ class MaterialMap: def mapToMaterial(arg0: float) -> Material: ... def size(self) -> int: ... -# class MeanFreePath: -# def __init__(self) -> None: ... -# def apply(self) -> None: ... -# def disableSmoothing(self) -> None: ... -# def enableSmoothing(self) -> None: ... -# def setBulkLambda(self, arg0: float) -> None: ... -# def setDomain(self, arg0: Domain) -> None: ... -# def setMaterial(self, arg0: Material) -> None: ... -# def setNumRaysPerCell(self, arg0: float) -> None: ... -# def setReflectionLimit(self, arg0: int) -> None: ... -# def setRngSeed(self, arg0: int) -> None: ... +class MultiParticleProcess(ProcessModel): + def __init__(self) -> None: ... + def addIonParticle(self, sourcePower: float, thetaRMin: float = ..., thetaRMax: float = ..., minAngle: float = ..., B_sp: float = ..., meanEnergy: float = ..., sigmaEnergy: float = ..., thresholdEnergy: float = ..., inflectAngle: float = ..., n: float = ..., label: str = ...) -> None: ... + @overload + def addNeutralParticle(self, stickingProbability: float, label: str = ...) -> None: ... + @overload + def addNeutralParticle(self, materialSticking: dict[Material, float], defaultStickingProbability: float = ..., label: str = ...) -> None: ... + def setRateFunction(self, arg0: Callable[[list[float], Material], float]) -> None: ... class OxideRegrowth(ProcessModel): def __init__(self, nitrideEtchRate: float, oxideEtchRate: float, redepositionRate: float, redepositionThreshold: float, redepositionTimeInt: float, diffusionCoefficient: float, sinkStrength: float, scallopVelocity: float, centerVelocity: float, topHeight: float, centerWidth: float, stabilityFactor: float) -> None: ... class Particle: def __init__(self, *args, **kwargs) -> None: ... - def getLocalDataLabels(self) -> List[str]: ... + def getLocalDataLabels(self) -> list[str]: ... def getSourceDistributionPower(self) -> float: ... def initNew(self, *args, **kwargs): ... def surfaceCollision(self, *args, **kwargs): ... @@ -393,44 +392,30 @@ class Planarize: @overload def __init__(self) -> None: ... @overload - def __init__(self, geometry: Domain, cutoffHeight: float = 0.0) -> None: ... - def setDomain(self, arg0: Domain) -> None: ... - def setCutoffPosition(self, arg0: float) -> None: ... + def __init__(self, geometry: Domain, cutoffHeight: float = ...) -> None: ... def apply(self) -> None: ... - -# class PlasmaDamage(ProcessModel): - # def __init__(self, ionEnergy: float = ..., meanFreePath: float = ..., maskMaterial: Material = ...) -> None: ... - -# class Precursor: -# adsorptionRate: float -# desorptionRate: float -# duration: float -# inFlux: float -# meanThermalVelocity: float -# name: str -# def __init__(self) -> None: ... + def setCutoffPosition(self, arg0: float) -> None: ... + def setDomain(self, arg0: Domain) -> None: ... class Process: - @overload def __init__(self) -> None: ... - @overload - def __init__(self, domain: Domain) -> None: ... - @overload - def __init__(self, domain: Domain, processModel: ProcessModel, duration: float) -> None: ... - def setPrintTimeInterval(self, arg0: float): ... def apply(self) -> None: ... - def calculateFlux(self): ... + def calculateFlux(self, *args, **kwargs): ... + def disableAdvectionVelocityOutput(self) -> None: ... def disableFluxSmoothing(self) -> None: ... - def enableFluxSmoothing(self) -> None: ... def disableRandomSeeds(self) -> None: ... + def enableAdvectionVelocityOutput(self) -> None: ... + def enableFluxSmoothing(self) -> None: ... def enableRandomSeeds(self) -> None: ... def getProcessDuration(self) -> float: ... - def setDomain(self, arg0: Domain): ... - def setIntegrationScheme(self, arg0: IntegrationSchemeEnum) -> None: ... + def setDomain(self, *args, **kwargs): ... + def setIntegrationScheme(self, arg0) -> None: ... def setMaxCoverageInitIterations(self, arg0: int) -> None: ... def setNumberOfRaysPerPoint(self, arg0: int) -> None: ... + def setPrintTimeInterval(self, arg0: float) -> None: ... def setProcessDuration(self, arg0: float) -> None: ... def setProcessModel(self, arg0: ProcessModel) -> None: ... + def setRayTracingDiskRadius(self, arg0: float) -> None: ... def setSourceDirection(self, arg0: rayTraceDirection) -> None: ... def setTimeStepRatio(self, arg0: float) -> None: ... @@ -450,7 +435,7 @@ class ProcessModel: def setPrimaryDirection(self, arg0) -> None: ... def setProcessName(self, arg0: str) -> None: ... def setSurfaceModel(self, arg0) -> None: ... - def setVelocityField(self, arg0) -> None: ... + def setVelocityField(self, *args, **kwargs): ... class ProcessParams: def __init__(self) -> None: ... @@ -461,13 +446,31 @@ class ProcessParams: @overload def getScalarData(self, arg0: str) -> float: ... @overload - def getScalarData(self) -> List[float]: ... + def getScalarData(self) -> list[float]: ... @overload - def getScalarData(self) -> List[float]: ... + def getScalarData(self) -> list[float]: ... def getScalarDataIndex(self, arg0: str) -> int: ... def getScalarDataLabel(self, arg0: int) -> str: ... def insertNextScalar(self, arg0: float, arg1: str) -> None: ... +class RateSet: + calculateVisibility: bool + direction: Incomplete + directionalVelocity: float + isotropicVelocity: float + maskMaterials: list[Material] + def __init__(self, direction=..., directionalVelocity: float = ..., isotropicVelocity: float = ..., maskMaterials: list[Material] = ..., calculateVisibility: bool = ...) -> None: ... + +class SF6Etching(ProcessModel): + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, ionFlux: float, etchantFlux: float, meanIonEnergy: float = ..., sigmaIonEnergy: float = ..., ionExponent: float = ..., etchStopDepth: float = ...) -> None: ... + @overload + def __init__(self, parameters: SF6O2Parameters) -> None: ... + def getParameters(self) -> SF6O2Parameters: ... + def setParameters(self, arg0: SF6O2Parameters) -> None: ... + class SF6O2Etching(ProcessModel): @overload def __init__(self) -> None: ... @@ -525,24 +528,16 @@ class SF6O2ParametersSi: rho: float def __init__(self) -> None: ... -# class SegmentCells: -# @overload -# def __init__(self, arg0: DenseCellSet) -> None: ... -# @overload -# def __init__(self, cellSet: DenseCellSet, cellTypeString: str = ..., bulkMaterial: Material = ...) -> None: ... -# def apply(self) -> None: ... -# def setBulkMaterial(self, arg0: Material) -> None: ... -# def setCellSet(self, arg0: DenseCellSet) -> None: ... -# def setCellTypeString(self, arg0: str) -> None: ... +class SingleParticleALD(ProcessModel): + def __init__(self, stickingProbability: float, numCycles: float, growthPerCycle: float, totalCycles: float, coverageTimeStep: float, evFlux: float, inFlux: float, s0: float, gasMFP: float) -> None: ... class SingleParticleProcess(ProcessModel): @overload - def __init__(self, rate: float = 1.0, stickingProbability: float = 1.0, sourceExponent: float = 1.0, maskMaterial: Material = Undefined) -> None: ... + def __init__(self, rate: float = ..., stickingProbability: float = ..., sourceExponent: float = ..., maskMaterial: Material = ...) -> None: ... @overload - def __init__(self, rate: float, stickingProbability: float, sourceExponent: float, maskMaterials: List[Material]) -> None: ... - -class SingleParticleALD(ProcessModel): - def __init__(self, stickingProbability: float, numCycles: int, growthPerCycle: float, totalCycles: int, coverageTimeStep: float, evFlux: float, inFlux: float, s0: float, gasMFP: float) -> None: ... + def __init__(self, rate: float, stickingProbability: float, sourceExponent: float, maskMaterials: list[Material]) -> None: ... + @overload + def __init__(self, materialRates: dict[Material, float], stickingProbability: float, sourceExponent: float) -> None: ... class SphereDistribution(ProcessModel): def __init__(self, radius: float, gridDelta: float) -> None: ... @@ -550,15 +545,8 @@ class SphereDistribution(ProcessModel): class TEOSDeposition(ProcessModel): def __init__(self, stickingProbabilityP1: float, rateP1: float, orderP1: float, stickingProbabilityP2: float = ..., rateP2: float = ..., orderP2: float = ...) -> None: ... -class Timer: - def __init__(self) -> None: ... - def finish(self) -> None: ... - def reset(self) -> None: ... - def start(self) -> None: ... - @property - def currentDuration(self) -> int: ... - @property - def totalDuration(self) -> int: ... +class TEOSPECVD(ProcessModel): + def __init__(self, stickingProbabilityRadical: float, depositionRateRadical: float, depositionRateIon: float, exponentIon: float, stickingProbabilityIon: float = ..., reactionOrderRadical: float = ..., reactionOrderIon: float = ..., minAngleIon: float = ...) -> None: ... class ToDiskMesh: @overload diff --git a/python/stubs/viennaps3d/viennaps3d.pyi b/python/stubs/viennaps3d/viennaps3d.pyi index 029dc7ca..74237c9f 100644 --- a/python/stubs/viennaps3d/viennaps3d.pyi +++ b/python/stubs/viennaps3d/viennaps3d.pyi @@ -1,6 +1,5 @@ from _typeshed import Incomplete -from typing import ClassVar, List, Tuple, overload, Annotated, FixedSize -# from viennals3d import * +from typing import Callable, ClassVar, overload Air: Material Al2O3: Material @@ -45,100 +44,75 @@ class AdvectionCallback: class AnisotropicProcess(ProcessModel): @overload - def __init__(self, materials: List[Tuple[Material, float]]) -> None: ... + def __init__(self, materials: list[tuple[Material, float]]) -> None: ... @overload - def __init__(self, direction100, direction010, rate100: float, rate110: float, rate111: float, rate311: float, materials: List[Tuple[Material, float]]) -> None: ... + def __init__(self, direction100, direction010, rate100: float, rate110: float, rate111: float, rate311: float, materials: list[tuple[Material, float]]) -> None: ... class AtomicLayerProcess: - @overload def __init__(self) -> None: ... - @overload - def __init__(self, domain: Domain) -> None: ... - @overload - def __init__(self, domain: Domain, processModel: ProcessModel) -> None: ... def apply(self) -> None: ... def disableRandomSeeds(self) -> None: ... def enableRandomSeeds(self) -> None: ... def setCoverageTimeStep(self, arg0: float) -> None: ... - def setDesorptionRates(self, arg0: List[float]) -> None: ... - def setDomain(self, arg0: Domain): ... - def setIntegrationScheme(self, arg0: IntegrationSchemeEnum) -> None: ... - def setNumberOfRaysPerPoint(self, arg0: int) -> None: ... + def setDesorptionRates(self, arg0: list[float]) -> None: ... + def setDomain(self, *args, **kwargs): ... + def setIntegrationScheme(self, arg0) -> None: ... def setNumCycles(self, arg0: int) -> None: ... - def setPulseTime(self, arg0: float) -> None: ... + def setNumberOfRaysPerPoint(self, arg0: int) -> None: ... def setProcessModel(self, arg0: ProcessModel) -> None: ... + def setPulseTime(self, arg0: float) -> None: ... def setSourceDirection(self, arg0: rayTraceDirection) -> None: ... class BoxDistribution(ProcessModel): def __init__(self, halfAxes, gridDelta: float) -> None: ... -# class DenseCellSet: -# def __init__(self) -> None: ... -# @overload -# def addFillingFraction(self, arg0: int, arg1: float) -> bool: ... -# @overload -# def addFillingFraction(self, arg0: Annotated[List[float], FixedSize(3)], arg1: float) -> bool: ... -# def addFillingFractionInMaterial(self, arg: Annotated[List[float], FixedSize(3)], arg1: float, arg2: int) -> bool: ... -# def addScalarData(self, arg0: str, arg1: float) -> None: ... -# def buildNeighborhood(self, arg0: bool) -> None: ... -# def clear(self) -> None: ... -# def getAverageFillingFraction(self, arg0: Annotated[List[float], FixedSize(3)], arg1: float) -> float: ... -# def getBoundingBox(self) -> Annotated[List[Annotated[List[float], FixedSize(3)]], FixedSize(2)]: ... -# def getCellCenter(self, arg0: int) -> Annotated[List[float], FixedSize(3)]: ... -# def getCellGrid(self): ... -# def getCellSetPosition(self) -> bool: ... -# def getDepth(self) -> float: ... -# def getElement(self, arg0: int): ... -# def getElements(self): ... -# def getFillingFraction(self, arg0: Annotated[List[float], FixedSize(3)]) -> float: ... -# def getFillingFractions(self) -> List[float]: ... -# def getGridDelta(self) -> float: ... -# def getIndex(self, arg0: Annotated[List[float], FixedSize(3)]) -> int: ... -# def getNeighbors(self, arg0: int): ... -# def getNode(self, arg0: int): ... -# def getNodes(self) -> List[Annotated[List[float], FixedSize(3)]]: ... -# def getNumberOfCells(self) -> int: ... -# def getScalarData(self, arg0: str) -> List[float]: ... -# def getScalarDataLabels(self) -> List[str]: ... -# def getSurface(self): ... -# def readCellSetData(self, arg0: str) -> None: ... -# def setCellSetPosition(self, arg0: bool) -> None: ... -# def setCoverMaterial(self, arg0: Material) -> None: ... -# @overload -# def setFillingFraction(self, arg0: int, arg1: float) -> bool: ... -# @overload -# def setFillingFraction(self, arg0, arg1: float) -> bool: ... -# def setPeriodicBoundary(self, arg0: Annotated[List[bool], FixedSize(3)]) -> None: ... -# def updateMaterials(self) -> None: ... -# def updateSurface(self) -> None: ... -# def writeCellSetData(self, arg0: str) -> None: ... -# def writeVTU(self, arg0: str) -> None: ... - class DirectionalEtching(ProcessModel): @overload - def __init__(self, direction, directionalVelocity: float = ..., isotropicVelocity: float = ..., maskMaterial: Material = ...) -> None: ... + def __init__(self, direction, directionalVelocity: float, isotropicVelocity: float = ..., maskMaterial: Material = ..., calculateVisibility: bool = ...) -> None: ... @overload - def __init__(self, direction, directionalVelocity: float, isotropicVelocity: float, maskMaterial: List[Material]) -> None: ... + def __init__(self, direction, directionalVelocity: float, isotropicVelocity: float = ..., maskMaterial: list[Material] = ..., calculateVisibility: bool = ...) -> None: ... + @overload + def __init__(self, rateSets: list[RateSet]) -> None: ... + @overload + def __init__(self, rateSet: RateSet) -> None: ... class Domain: def __init__(self) -> None: ... - def applyBooleanOperation(self, arg0: lsDomain, arg1: lsBooleanOperationEnum): ... + def applyBooleanOperation(self, *args, **kwargs): ... def clear(self) -> None: ... + def deepCopy(self, arg0: Domain) -> None: ... def duplicateTopLevelSet(self, arg0: Material) -> None: ... def generateCellSet(self, arg0: float, arg1: Material, arg2: bool) -> None: ... def getCellSet(self, *args, **kwargs): ... def getGrid(self, *args, **kwargs): ... def getLevelSets(self, *args, **kwargs): ... - def getMaterialMap(self) -> MaterialMap: ... + def getMaterialMap(self, *args, **kwargs): ... def insertNextLevelSet(self, *args, **kwargs): ... def insertNextLevelSetAsMaterial(self, *args, **kwargs): ... def print(self) -> None: ... + def removeLevelSet(self, arg0: int, arg1: bool) -> None: ... + def removeMaterial(self, arg0: Material) -> None: ... def removeTopLevelSet(self) -> None: ... def saveLevelSetMesh(self, filename: str, width: int = ...) -> None: ... - def saveLevelSets(self, arg0: str) -> None: ... + def saveLevelSets(self, filename: str) -> None: ... def saveSurfaceMesh(self, filename: str, addMaterialIds: bool = ...) -> None: ... def saveVolumeMesh(self, filename: str) -> None: ... - def setMaterialMap(self, arg0: MaterialMap) -> None: ... + def setMaterialMap(self, arg0) -> None: ... + +class FaradayCageEtching(ProcessModel): + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material]) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material], parameters: FaradayCageParameters) -> None: ... + def getParameters(self) -> FaradayCageParameters: ... + def setParameters(self, arg0: FaradayCageParameters) -> None: ... + +class FaradayCageParameters: + cageAngle: float + ibeParams: IBEParameters + def __init__(self) -> None: ... class FluorocarbonEtching(ProcessModel): @overload @@ -242,11 +216,34 @@ class GDSReader: def setFileName(self, arg0: str) -> None: ... def setGeometry(self, arg0: GDSGeometry) -> None: ... +class IBEParameters: + exponent: float + inflectAngle: float + meanEnergy: float + minAngle: float + n_l: float + planeWaferRate: float + sigmaEnergy: float + thresholdEnergy: float + tiltAngle: float + yieldFunction: Callable[[float], float] + def __init__(self) -> None: ... + +class IonBeamEtching(ProcessModel): + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material]) -> None: ... + @overload + def __init__(self, maskMaterials: list[Material], parameters: IBEParameters) -> None: ... + def getParameters(self) -> IBEParameters: ... + def setParameters(self, arg0: IBEParameters) -> None: ... + class IsotropicProcess(ProcessModel): @overload def __init__(self, rate: float = ..., maskMaterial: Material = ...) -> None: ... @overload - def __init__(self, rate: float, maskMaterial: List[Material]) -> None: ... + def __init__(self, rate: float, maskMaterial: list[Material]) -> None: ... class LogLevel: __members__: ClassVar[dict] = ... # read-only @@ -311,6 +308,7 @@ class MakeTrench: def __init__(self, domain: Domain, gridDelta: float, xExtent: float, yExtent: float, trenchWidth: float, trenchDepth: float, taperingAngle: float = 0.0, baseHeight: float = 0.0, periodicBoundary: bool = False, makeMask: bool = False, material: Material = Undefined) -> None: ... def apply(self) -> None: ... + class Material: __members__: ClassVar[dict] = ... # read-only Air: ClassVar[Material] = ... @@ -348,7 +346,7 @@ class Material: class MaterialMap: def __init__(self) -> None: ... def getMaterialAtIdx(self, arg0: int) -> Material: ... - def getMaterialMap(self) -> lsMaterialMap: ... + def getMaterialMap(self, *args, **kwargs): ... def insertNextMaterial(self, material: Material = ...) -> None: ... @staticmethod def isMaterial(arg0: float, arg1: Material) -> bool: ... @@ -356,24 +354,21 @@ class MaterialMap: def mapToMaterial(arg0: float) -> Material: ... def size(self) -> int: ... -# class MeanFreePath: -# def __init__(self) -> None: ... -# def apply(self) -> None: ... -# def disableSmoothing(self) -> None: ... -# def enableSmoothing(self) -> None: ... -# def setBulkLambda(self, arg0: float) -> None: ... -# def setDomain(self, arg0: Domain) -> None: ... -# def setMaterial(self, arg0: Material) -> None: ... -# def setNumRaysPerCell(self, arg0: float) -> None: ... -# def setReflectionLimit(self, arg0: int) -> None: ... -# def setRngSeed(self, arg0: int) -> None: ... +class MultiParticleProcess(ProcessModel): + def __init__(self) -> None: ... + def addIonParticle(self, sourcePower: float, thetaRMin: float = ..., thetaRMax: float = ..., minAngle: float = ..., B_sp: float = ..., meanEnergy: float = ..., sigmaEnergy: float = ..., thresholdEnergy: float = ..., inflectAngle: float = ..., n: float = ..., label: str = ...) -> None: ... + @overload + def addNeutralParticle(self, stickingProbability: float, label: str = ...) -> None: ... + @overload + def addNeutralParticle(self, materialSticking: dict[Material, float], defaultStickingProbability: float = ..., label: str = ...) -> None: ... + def setRateFunction(self, arg0: Callable[[list[float], Material], float]) -> None: ... class OxideRegrowth(ProcessModel): def __init__(self, nitrideEtchRate: float, oxideEtchRate: float, redepositionRate: float, redepositionThreshold: float, redepositionTimeInt: float, diffusionCoefficient: float, sinkStrength: float, scallopVelocity: float, centerVelocity: float, topHeight: float, centerWidth: float, stabilityFactor: float) -> None: ... class Particle: def __init__(self, *args, **kwargs) -> None: ... - def getLocalDataLabels(self) -> List[str]: ... + def getLocalDataLabels(self) -> list[str]: ... def getSourceDistributionPower(self) -> float: ... def initNew(self, *args, **kwargs): ... def surfaceCollision(self, *args, **kwargs): ... @@ -383,44 +378,30 @@ class Planarize: @overload def __init__(self) -> None: ... @overload - def __init__(self, geometry: Domain, cutoffHeight: float = 0.0) -> None: ... - def setDomain(self, arg0: Domain) -> None: ... - def setCutoffPosition(self, arg0: float) -> None: ... + def __init__(self, geometry: Domain, cutoffHeight: float = ...) -> None: ... def apply(self) -> None: ... - -# class PlasmaDamage(ProcessModel): - # def __init__(self, ionEnergy: float = ..., meanFreePath: float = ..., maskMaterial: Material = ...) -> None: ... - -# class Precursor: -# adsorptionRate: float -# desorptionRate: float -# duration: float -# inFlux: float -# meanThermalVelocity: float -# name: str -# def __init__(self) -> None: ... + def setCutoffPosition(self, arg0: float) -> None: ... + def setDomain(self, arg0: Domain) -> None: ... class Process: - @overload def __init__(self) -> None: ... - @overload - def __init__(self, domain: Domain) -> None: ... - @overload - def __init__(self, domain: Domain, processModel: ProcessModel, duration: float) -> None: ... - def setPrintTimeInterval(self, arg0: float): ... def apply(self) -> None: ... - def calculateFlux(self): ... + def calculateFlux(self, *args, **kwargs): ... + def disableAdvectionVelocityOutput(self) -> None: ... def disableFluxSmoothing(self) -> None: ... - def enableFluxSmoothing(self) -> None: ... def disableRandomSeeds(self) -> None: ... + def enableAdvectionVelocityOutput(self) -> None: ... + def enableFluxSmoothing(self) -> None: ... def enableRandomSeeds(self) -> None: ... def getProcessDuration(self) -> float: ... - def setDomain(self, arg0: Domain): ... - def setIntegrationScheme(self, arg0: lsIntegrationSchemeEnum) -> None: ... + def setDomain(self, *args, **kwargs): ... + def setIntegrationScheme(self, arg0) -> None: ... def setMaxCoverageInitIterations(self, arg0: int) -> None: ... def setNumberOfRaysPerPoint(self, arg0: int) -> None: ... + def setPrintTimeInterval(self, arg0: float) -> None: ... def setProcessDuration(self, arg0: float) -> None: ... def setProcessModel(self, arg0: ProcessModel) -> None: ... + def setRayTracingDiskRadius(self, arg0: float) -> None: ... def setSourceDirection(self, arg0: rayTraceDirection) -> None: ... def setTimeStepRatio(self, arg0: float) -> None: ... @@ -440,7 +421,7 @@ class ProcessModel: def setPrimaryDirection(self, arg0) -> None: ... def setProcessName(self, arg0: str) -> None: ... def setSurfaceModel(self, arg0) -> None: ... - def setVelocityField(self, arg0) -> None: ... + def setVelocityField(self, *args, **kwargs): ... class ProcessParams: def __init__(self) -> None: ... @@ -451,13 +432,31 @@ class ProcessParams: @overload def getScalarData(self, arg0: str) -> float: ... @overload - def getScalarData(self) -> List[float]: ... + def getScalarData(self) -> list[float]: ... @overload - def getScalarData(self) -> List[float]: ... + def getScalarData(self) -> list[float]: ... def getScalarDataIndex(self, arg0: str) -> int: ... def getScalarDataLabel(self, arg0: int) -> str: ... def insertNextScalar(self, arg0: float, arg1: str) -> None: ... +class RateSet: + calculateVisibility: bool + direction: Incomplete + directionalVelocity: float + isotropicVelocity: float + maskMaterials: list[Material] + def __init__(self, direction=..., directionalVelocity: float = ..., isotropicVelocity: float = ..., maskMaterials: list[Material] = ..., calculateVisibility: bool = ...) -> None: ... + +class SF6Etching(ProcessModel): + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, ionFlux: float, etchantFlux: float, meanIonEnergy: float = ..., sigmaIonEnergy: float = ..., ionExponent: float = ..., etchStopDepth: float = ...) -> None: ... + @overload + def __init__(self, parameters: SF6O2Parameters) -> None: ... + def getParameters(self) -> SF6O2Parameters: ... + def setParameters(self, arg0: SF6O2Parameters) -> None: ... + class SF6O2Etching(ProcessModel): @overload def __init__(self) -> None: ... @@ -515,24 +514,16 @@ class SF6O2ParametersSi: rho: float def __init__(self) -> None: ... -# class SegmentCells: -# @overload -# def __init__(self, arg0: DenseCellSet) -> None: ... -# @overload -# def __init__(self, cellSet: DenseCellSet, cellTypeString: str = ..., bulkMaterial: Material = ...) -> None: ... -# def apply(self) -> None: ... -# def setBulkMaterial(self, arg0: Material) -> None: ... -# def setCellSet(self, arg0: DenseCellSet) -> None: ... -# def setCellTypeString(self, arg0: str) -> None: ... +class SingleParticleALD(ProcessModel): + def __init__(self, stickingProbability: float, numCycles: float, growthPerCycle: float, totalCycles: float, coverageTimeStep: float, evFlux: float, inFlux: float, s0: float, gasMFP: float) -> None: ... class SingleParticleProcess(ProcessModel): @overload - def __init__(self, rate: float = 1.0, stickingProbability: float = 1.0, sourceExponent: float = 1.0, maskMaterial: Material = Undefined) -> None: ... + def __init__(self, rate: float = ..., stickingProbability: float = ..., sourceExponent: float = ..., maskMaterial: Material = ...) -> None: ... @overload - def __init__(self, rate: float, stickingProbability: float, sourceExponent: float, maskMaterials: List[Material]) -> None: ... - -class SingleParticleALD(ProcessModel): - def __init__(self, stickingProbability: float, numCycles: int, growthPerCycle: float, totalCycles: int, coverageTimeStep: float, evFlux: float, inFlux: float, s0: float, gasMFP: float) -> None: ... + def __init__(self, rate: float, stickingProbability: float, sourceExponent: float, maskMaterials: list[Material]) -> None: ... + @overload + def __init__(self, materialRates: dict[Material, float], stickingProbability: float, sourceExponent: float) -> None: ... class SphereDistribution(ProcessModel): def __init__(self, radius: float, gridDelta: float) -> None: ... @@ -540,15 +531,8 @@ class SphereDistribution(ProcessModel): class TEOSDeposition(ProcessModel): def __init__(self, stickingProbabilityP1: float, rateP1: float, orderP1: float, stickingProbabilityP2: float = ..., rateP2: float = ..., orderP2: float = ...) -> None: ... -class Timer: - def __init__(self) -> None: ... - def finish(self) -> None: ... - def reset(self) -> None: ... - def start(self) -> None: ... - @property - def currentDuration(self) -> int: ... - @property - def totalDuration(self) -> int: ... +class TEOSPECVD(ProcessModel): + def __init__(self, stickingProbabilityRadical: float, depositionRateRadical: float, depositionRateIon: float, exponentIon: float, stickingProbabilityIon: float = ..., reactionOrderRadical: float = ..., reactionOrderIon: float = ..., minAngleIon: float = ...) -> None: ... class ToDiskMesh: @overload