ViennaLS forms the foundation of the process simulator, applying the level-set surface representation concepts for topography simulations. This module not only stores the level-set surface but also encompasses essential algorithms for geometry initialization, level-set value manipulation based on a velocity field, surface feature analysis, and seamless conversion of the level-set representation to other commonly employed material representations in device simulators.
ViennaPS relies on ViennaRay, a top-down Monte Carlo flux calculation library, to carry out essential flux calculations. This library is built upon Intel®’s ray tracing kernel, Embree. Crafted with a focus on efficiency and high-performance ray tracing, ViennaRay ensures a seamless user experience through its straightforward and user-friendly interface.
In the top-down Monte Carlo approach, a large number of pseudo-particles are launched from a source plane situated above the surface, and their points of impact on the surface are determined. These pseudo-particles are initialized with a uniform initial position on the source plane and an initial direction that follows a power-cosine distribution. Each pseudo-particle carries a specific payload, representing a fraction of the total source flux. Upon reaching the surface, the current payload of the pseudo-particle contributes to the flux at that particular surface location.
Furthermore, pseudo-particles have the capability to undergo reflection from the surface. The payload of a pseudo-particle undergoes reduction by the sticking coefficient during reflection. As a result, a pseudo-particle is tracked until its payload falls below a certain threshold or until it exits the simulation domain. This tracking mechanism provides a comprehensive understanding of the particle dynamics during its interaction with the sample surface.
ViennaLS forms the foundation of the process simulator, applying the level-set surface representation concepts for topography simulations. This module not only stores the level-set surface but also encompasses essential algorithms for geometry initialization, level-set value manipulation based on a velocity field, surface feature analysis, and seamless conversion of the level-set representation to other commonly employed material representations in device simulators.
ViennaPS relies on ViennaRay, a top-down Monte Carlo flux calculation library, to carry out essential flux calculations. This library is built upon Intel®’s ray tracing kernel, Embree. Crafted with a focus on efficiency and high-performance ray tracing, ViennaRay ensures a seamless user experience through its straightforward and user-friendly interface.
In the top-down Monte Carlo approach, a large number of pseudo-particles are launched from a source plane situated above the surface, and their points of impact on the surface are determined. These pseudo-particles are initialized with a uniform initial position on the source plane and an initial direction that follows a power-cosine distribution. Each pseudo-particle carries a specific payload, representing a fraction of the total source flux. Upon reaching the surface, the current payload of the pseudo-particle contributes to the flux at that particular surface location.
Furthermore, pseudo-particles have the capability to undergo reflection from the surface. The payload of a pseudo-particle undergoes reduction by the sticking coefficient during reflection. As a result, a pseudo-particle is tracked until its payload falls below a certain threshold or until it exits the simulation domain. This tracking mechanism provides a comprehensive understanding of the particle dynamics during its interaction with the sample surface.
diff --git a/docs/_site/domain/functions.html b/docs/_site/domain/functions.html
index 99b8f9f3..68d77ed8 100644
--- a/docs/_site/domain/functions.html
+++ b/docs/_site/domain/functions.html
@@ -1,13 +1,23 @@
- Member Functions | ViennaPS DocumentationSkip to main content
voiddeepCopy(SmartPointer<Domain>passedDomain)
-voidinsertNextLevelSet(SmartPointer<viennals::Domain<NumericType,D>>passedLevelSet,boolwrapLowerLevelSet=true)
-voidinsertNextLevelSetAsMaterial(SmartPointer<viennals::Domain<NumericType,D>>passedLevelSet,constMaterialmaterial,
- boolwrapLowerLevelSet=true)
+ Member Functions | ViennaPS DocumentationSkip to main content
In our simulation framework, the essential hub for all geometry details is the Domain class. This class is like a smart keeper of information, holding everything about the materials in the simulation domain. It uses level sets to show surfaces and material interfaces with great detail and organizes data in a cell-based structure for the underlying volumes. Depending on the specific process, it can use one or both of these methods. This flexibility ensures that the simulation can handle different processes accurately and efficiently.
If specified, each Level-Set in the Domain class is assigned a specific material, which can be used in a process to implement material-specific rates or similar. The following materials are currently available in the Material enum:
Material
Numeric Value
Description
None
-1
Undefined Material
Mask
0
Mask Material
Si
1
Silicon
SiO2
2
Silicon Dioxide
Si3N4
3
Silicon Nitride
SiN
4
Silicon Nitride
SiON
5
Silicon Oxynitride
SiC
6
Silicon Carbide
SiGe
7
Silicon Germanium
PolySi
8
Polysilicon
GaN
9
Gallium Nitride
W
10
Tungsten
Al2O3
11
Aluminum Oxide
HfO2
12
Hafnium Oxide
TiN
13
Titanium Nitride
Cu
14
Copper
Polymer
15
Polymer
Dielectric
16
Dielectric Material
Metal
17
Metal
Air
18
Air
GAS
19
Gas
Example:
C++
automaterial=Material::Si;
+ Material Mapping | ViennaPS DocumentationSkip to main content
If specified, each Level-Set in the Domain class is assigned a specific material, which can be used in a process to implement material-specific rates or similar. The following materials are currently available in the Material enum:
Material
Numeric Value
Description
None
-1
Undefined Material
Mask
0
Mask Material
Si
1
Silicon
SiO2
2
Silicon Dioxide
Si3N4
3
Silicon Nitride
SiN
4
Silicon Nitride
SiON
5
Silicon Oxynitride
SiC
6
Silicon Carbide
SiGe
7
Silicon Germanium
PolySi
8
Polysilicon
GaN
9
Gallium Nitride
W
10
Tungsten
Al2O3
11
Aluminum Oxide
HfO2
12
Hafnium Oxide
TiN
13
Titanium Nitride
Cu
14
Copper
Polymer
15
Polymer
Dielectric
16
Dielectric Material
Metal
17
Metal
Air
18
Air
GAS
19
Gas
Example:
C++
automaterial=Material::Si;
Python
material=vps.Material.Si;
diff --git a/docs/_site/domain/surface.html b/docs/_site/domain/surface.html
index 5fff6cf0..1eda21bd 100644
--- a/docs/_site/domain/surface.html
+++ b/docs/_site/domain/surface.html
@@ -1 +1 @@
- Surface and Material Interfaces | ViennaPS DocumentationSkip to main content
The surface, as well as the material interfaces, are described implicitly by a level set (LS) function $\phi(\vec{x})$ which is defined at every point $\vec{x}$ in space. This function is obtained using signed distance transforms, describing the surface $S$ as the zero LS:
\[S = \{\vec{x}\!: \, \phi(\vec{x}) = 0 \}.\]
If the domain contains multiple LSs, the top LS wraps the entire structure and therefore represents the surface, while all other LS functions just describe material interfaces. Formally, the different material regions can be described by ${M}$ LS functions satisfying
Here $\Phi_M$ describes the entire structure $\mathcal{M}$, and the other LS functions correspond to material interfaces.
When inserting a new LS into the domain, an automatic wrapping process ensues. This process involves enveloping all existing Level-Sets through a Boolean operation, specifically a union with the topmost LS. It’s worth noting, though, that this default behavior is not obligatory. In instances where a specialized domain structure is desired, users have the option to circumvent this automatic wrapping mechanism.
The surface, as well as the material interfaces, are described implicitly by a level set (LS) function $\phi(\vec{x})$ which is defined at every point $\vec{x}$ in space. This function is obtained using signed distance transforms, describing the surface $S$ as the zero LS:
\[S = \{\vec{x}\!: \, \phi(\vec{x}) = 0 \}.\]
If the domain contains multiple LSs, the top LS wraps the entire structure and therefore represents the surface, while all other LS functions just describe material interfaces. Formally, the different material regions can be described by ${M}$ LS functions satisfying
Here $\Phi_M$ describes the entire structure $\mathcal{M}$, and the other LS functions correspond to material interfaces.
When inserting a new LS into the domain, an automatic wrapping process ensues. This process involves enveloping all existing Level-Sets through a Boolean operation, specifically a union with the topmost LS. It’s worth noting, though, that this default behavior is not obligatory. In instances where a specialized domain structure is desired, users have the option to circumvent this automatic wrapping mechanism.
diff --git a/docs/_site/domain/volume.html b/docs/_site/domain/volume.html
index a803a898..12cace11 100644
--- a/docs/_site/domain/volume.html
+++ b/docs/_site/domain/volume.html
@@ -1,4 +1,4 @@
- Volume | ViennaPS DocumentationSkip to main content
A Cell-Set (CS) is used to store and track volume information in the domain. The CS is stored over the whole simulation domain, above and/or below the surface described by the Level-Set. It uses the same grid as the Level-Set, such that each Level-Set grid point acts as the corner of the cells around the point. To determine which material region a cell lies in, the LS values at the cell corner of the material interface are inspected. If the sum of the values is negative the cell belongs to the underlying material, otherwise it represents the material on the other side of the interface.
To find a cell in which an arbitrary point in space resides, a bounding volume hierarchy (BVH) is built on top of the CS. This allows for fast access to random cells in the CS. Additionally, cell-neighbor relations are established when setting up the CS. This allows for quick access to neighbor cells.
How to use the Cell-Set
To generate the CS from your domain, use the function:
autodomain=SmartPointer<Domain<NumericType,D>>::New()
+ Volume | ViennaPS DocumentationSkip to main content
A Cell-Set (CS) is used to store and track volume information in the domain. The CS is stored over the whole simulation domain, above and/or below the surface described by the Level-Set. It uses the same grid as the Level-Set, such that each Level-Set grid point acts as the corner of the cells around the point. To determine which material region a cell lies in, the LS values at the cell corner of the material interface are inspected. If the sum of the values is negative the cell belongs to the underlying material, otherwise it represents the material on the other side of the interface.
To find a cell in which an arbitrary point in space resides, a bounding volume hierarchy (BVH) is built on top of the CS. This allows for fast access to random cells in the CS. Additionally, cell-neighbor relations are established when setting up the CS. This allows for quick access to neighbor cells.
How to use the Cell-Set
To generate the CS from your domain, use the function:
autodomain=SmartPointer<Domain<NumericType,D>>::New()...// Add level-sets to domain...
diff --git a/docs/_site/examples/index.html b/docs/_site/examples/index.html
index 9ea0a32a..234ec3b1 100644
--- a/docs/_site/examples/index.html
+++ b/docs/_site/examples/index.html
@@ -1,4 +1,4 @@
- Examples | ViennaPS DocumentationSkip to main content
ViennaPS is encapsulated within the viennaps namespace. This design choice ensures that all classes, functions, and utilities within the library are organized under a single namespace, providing a clean and structured interface for users. When working with ViennaPS, it is essential to include the viennaps namespace in your code to access the library’s functionality. In this documentation, the namespace is omitted for brevity, but it should be included in your code.
Numeric Types
ViennaPS supports the utilization of either float or double as the underlying numeric type. While float might offer slightly higher performance in some cases, it is generally recommended to use double in your simulation due to its enhanced precision.
It’s essential to note that the choice of numeric type is a static (compile-time) parameter in every ViennaPS class and function. Once a numeric type is selected for a particular simulation, it is not possible to switch to a different numeric type within the program.
Additionally, for users working with Python bindings, it’s important to be aware that the Python interface always uses double as the numeric type.
Switching between 2D and 3D mode
ViennaPS provides the flexibility for users to choose between 2D and 3D modes during compile time. The dimensionality is specified as a second template (static) parameter, and most classes and functions in ViennaPS adhere to this structure. It’s important to note that 2D and 3D classes cannot be mixed within the same simulation, and the choice of dimensionality is fixed at compile time.
For users who need to transition from a 2D to a 3D simulation, ViennaPS offers the Extrude utility. This utility enables the extrusion of a 2D domain to 3D, providing a seamless way to extend simulations across different dimensions.
Using Smart Pointers
In ViennaPS, smart pointers are utilized to pass domains, models, and other essential objects to processes and utility functions. To facilitate this, the library includes a custom class named SmartPointer, serving as a shared pointer implementation. This design choice ensures efficient memory management and enables seamless interaction between different components within the simulation framework.
Example:
// Creating a new domain
+ General Notes | ViennaPS DocumentationSkip to main content
ViennaPS is encapsulated within the viennaps namespace. This design choice ensures that all classes, functions, and utilities within the library are organized under a single namespace, providing a clean and structured interface for users. When working with ViennaPS, it is essential to include the viennaps namespace in your code to access the library’s functionality. In this documentation, the namespace is omitted for brevity, but it should be included in your code.
Numeric Types
ViennaPS supports the utilization of either float or double as the underlying numeric type. While float might offer slightly higher performance in some cases, it is generally recommended to use double in your simulation due to its enhanced precision.
It’s essential to note that the choice of numeric type is a static (compile-time) parameter in every ViennaPS class and function. Once a numeric type is selected for a particular simulation, it is not possible to switch to a different numeric type within the program.
Additionally, for users working with Python bindings, it’s important to be aware that the Python interface always uses double as the numeric type.
Switching between 2D and 3D mode
ViennaPS provides the flexibility for users to choose between 2D and 3D modes during compile time. The dimensionality is specified as a second template (static) parameter, and most classes and functions in ViennaPS adhere to this structure. It’s important to note that 2D and 3D classes cannot be mixed within the same simulation, and the choice of dimensionality is fixed at compile time.
For users who need to transition from a 2D to a 3D simulation, ViennaPS offers the Extrude utility. This utility enables the extrusion of a 2D domain to 3D, providing a seamless way to extend simulations across different dimensions.
Using Smart Pointers
In ViennaPS, smart pointers are utilized to pass domains, models, and other essential objects to processes and utility functions. To facilitate this, the library includes a custom class named SmartPointer, serving as a shared pointer implementation. This design choice ensures efficient memory management and enables seamless interaction between different components within the simulation framework.
Example:
// Creating a new domainautodomain=psSmartPointer<psDomain<NumericType,D>>::New();// Using a pre-built model
diff --git a/docs/_site/geo/basic/fin.html b/docs/_site/geo/basic/fin.html
index e5c5c1a2..95fb56c4 100644
--- a/docs/_site/geo/basic/fin.html
+++ b/docs/_site/geo/basic/fin.html
@@ -1,5 +1,17 @@
- Fin Geometry | ViennaPS DocumentationSkip to main content
The MakeFin class generates a fin geometry extending in the z (3D) or y (2D) direction, centered at the origin with specified dimensions in the x and y directions. The fin may incorporate periodic boundaries in the x and y directions (limited to 3D). Users can define the width and height of the fin, and it can function as a mask, with the specified material exclusively applied to the bottom of the fin, while the upper portion adopts the mask material.
The MakeHole class generates a hole geometry in the z direction, which, in 2D mode, corresponds to a trench geometry. Positioned at the origin, the hole is centered, with the total extent defined in the x and y directions. The normal direction for the hole creation is in the positive z direction in 3D and the positive y direction in 2D. Users can specify the hole’s radius, depth, and opt for tapering with a designated angle. The hole configuration may include periodic boundaries in both the x and y directions. Additionally, the hole can serve as a mask, with the specified material only applied to the bottom of the hole, while the remainder adopts the mask material.
Specifies the type of domain for the hole geometry.
SmartPointer<Domain<NumericType, D>>
gridDelta
Represents the grid spacing or resolution used in the simulation.
NumericType
xExtent
Defines the extent of the hole geometry in the x-direction.
NumericType
yExtent
Specifies the extent of the hole geometry in the y-direction.
NumericType
holeRadius
Sets the radius of the hole.
NumericType
holeDepth
Determines the depth of the hole.
NumericType
taperAngle
(Optional) Specifies the angle of tapering for the hole geometry in degrees. Default is set to 0.
NumericType
baseHeight
(Optional) Sets the base height of the hole. Default is set to 0.
NumericType
periodicBoundary
(Optional) If set to true, enables periodic boundaries in both x and y directions. Default is set to false.
bool
makeMask
(Optional) If set to true, allows the hole to function as a mask, with specified material applied only to the bottom. Default is set to false.
bool
material
(Optional) Specifies the material used for the hole. Default is set to Material::None.
Material
holeShape
(Optional) Specifies whether a full, half or quarter hole should be created. Half and quarter holes with reflective boundary conditions can simulate the full dynamics of a hole with less computational cost. Default is set to HoleShape::Full.
HoleShape
Example usage:
C++
// namespace viennaps
+
Parameter
Type
Description
Applicable Constructor
domain
psDomainType
The simulation domain.
Both
holeRadius
NumericType
Radius of the hole.
Both
holeDepth
NumericType
Depth of the hole.
Both
holeTaperAngle
NumericType
Taper angle of the hole (default: 0.).
Both
maskHeight
NumericType
Height of the masking layer (default: 0.).
First constructor only
maskTaperAngle
NumericType
Taper angle of the masking layer (default: 0.).
First constructor only
shape
HoleShape
Shape of the hole (default: HoleShape::Full).
Both
material
Material
Material of the hole (default: Material::Si).
Both
maskMaterial
Material
Material of the mask (default: Material::Mask).
First constructor only
gridDelta
NumericType
Grid spacing in the simulation domain.
Second constructor only
xExtent
NumericType
Extent of the domain in the x-direction.
Second constructor only
yExtent
NumericType
Extent of the domain in the y-direction.
Second constructor only
taperAngle
NumericType
Alternative name for holeTaperAngle in the second constructor (default: 0.).
Second constructor only
baseHeight
NumericType
Height at which the hole starts (default: 0.).
Second constructor only
periodicBoundary
bool
If true, enables periodic boundary conditions (default: false).
Second constructor only
makeMask
bool
If true, the mask is created instead of the hole, setting holeDepth to 0 (default: false).
Second constructor only
Note:
The first constructor requires that the domain is already configured.
The second constructor sets up a new simulation domain with gridDelta, xExtent, and yExtent.
If makeMask is true, the hole is not created, and only the masking layer is applied.
Example usage:
C++
// namespace viennaps
+
+// with DomainSetup configured (v3.3.0)
+autodomain=SmartPointer<Domain<NumericType,D>>::New(0.5,10.,10.,BoundaryType::REFLECTIVE_BOUNDARY);
+MakeHole<NumericType,D>(domain,5.0,5.0,10.,0.,0.,HoleShape::Quarter,Material::Si,Material::Mask)
+ .apply();
+
+// without DomainSetupautodomain=SmartPointer<Domain<NumericType,D>>::New();MakeHole<NumericType,D>(domain,0.5,10.0,10.0,2.5,5.0,10.,0.,false,false,Material::Si).apply();
-
ViennaPS provides a set of functions to effortlessly create basic geometries, facilitating quick testing of models or serving as the groundwork for your process simulation configuration. The various available geometries are outlined below:
ViennaPS provides a set of functions to effortlessly create basic geometries, facilitating quick testing of models or serving as the groundwork for your process simulation configuration. The various available geometries are outlined below:
The MakePlane class offers a straightforward approach to generate a plane as a level-set within your domain. This utility is useful for crafting substrates with any material. You have the flexibility to append the plane to an existing geometry or create a new one. In 3D, the plane is generated with a normal direction in the positive z direction, while in 2D, it is oriented in the positive y direction. The plane is centered around the origin, with the total specified extent and height. Additionally, you can opt for a periodic boundary in the x and y directions.
Depending on the specific constructor invoked for the plane-builder, the behavior varies: the domain may be cleared, and a new plane inserted, or the plane can be added to the existing geometry in the domain. A detailed description of the parameters follows:
Parameter
Description
Type
domain
The Domain object passed in a smart pointer.
SmartPointer<Domain<NumericType, D>>
gridDelta
Represents the grid spacing or resolution used in the simulation.
NumericType
xExtent
Defines the extent of the plane geometry in the x-direction.
NumericType
yExtent
Defines the extent of the plane geometry in the y-direction.
NumericType
height
Sets the position of the plane in y(2D)/z(3D) direction.
NumericType
periodicBoundary
(Optional) If set to true, enables periodic boundaries in both x and y directions. Default is set to false.
bool
material
(Optional) Specifies the material used for the plane. Default is set to Material::None.
Depending on the specific constructor invoked for the plane-builder, the behavior varies: the domain may be cleared, and a new plane inserted, or the plane can be added to the existing geometry in the domain. A detailed description of the parameters follows:
Parameter
Type
Description
Applicable Constructor
domain
psDomainType
The simulation domain.
Both
baseHeight
NumericType
Height at which the plane is placed (default: 0.).
Both
material
Material
Material of the plane (default: Material::Si).
Both
addToExisting
bool
If true, the plane is added to an existing geometry instead of creating a new one (default: false).
First constructor only
gridDelta
NumericType
Grid spacing in the simulation domain.
Second constructor only
xExtent
NumericType
Extent of the domain in the x-direction.
Second constructor only
yExtent
NumericType
Extent of the domain in the y-direction.
Second constructor only
periodicBoundary
bool
If true, enables periodic boundary conditions (default: false).
Second constructor only
Note:
The first constructor requires that the domain is already configured and allows adding a plane to an existing geometry.
The second constructor creates a new geometry and sets up the domain using gridDelta, xExtent, and yExtent.
The MakeStack generates a stack of alternating SiO2/Si3N4 layers featuring an optionally etched hole (3D) or trench (2D) at the center. The stack emerges in the positive z direction (3D) or y direction (2D) and is centered around the origin, with its x/y extent specified. Users have the flexibility to introduce periodic boundaries in the x and y directions. Additionally, the stack can incorporate a top mask with a central hole of a specified radius or a trench with a designated width. This versatile functionality enables users to create diverse and customized structures for simulation scenarios.
The MakeTrench class is used to generate a new trench geometry extending in the z (3D) or y (2D) direction, centrally positioned at the origin with the total extent specified in the x and y directions. The trench configuration may include periodic boundaries in both the x and y directions. Users have the flexibility to define the trench’s width, depth, and incorporate tapering with a designated angle. Moreover, the trench can serve as a mask, applying the specified material exclusively to the bottom while the remaining portion adopts the mask material.
ViennaPS offers the capability to create custom geometries using tools from the ViennaLS library. The viennals::MakeGeometry function provides functionality for constructing basic geometric shapes like boxes, spheres, or cylinders. Moreover, shapes can be formed by creating a convex hull over a point cloud or by explicitly defining points and elements of a structure. Subsequently, boolean operations such as union, intersect, and relative complement can be applied to merge these basic shapes into a customized geometry. This flexible approach enables users to create complex geometries tailored to their specific simulation requirements. Some examples are provided below:
ViennaPS offers the capability to create custom geometries using tools from the ViennaLS library. The viennals::MakeGeometry function provides functionality for constructing basic geometric shapes like boxes, spheres, or cylinders. Moreover, shapes can be formed by creating a convex hull over a point cloud or by explicitly defining points and elements of a structure. Subsequently, boolean operations such as union, intersect, and relative complement can be applied to merge these basic shapes into a customized geometry. This flexible approach enables users to create complex geometries tailored to their specific simulation requirements.
diff --git a/docs/_site/geo/gdsimport.html b/docs/_site/geo/gdsimport.html
index 57c21aae..a13cd0dd 100644
--- a/docs/_site/geo/gdsimport.html
+++ b/docs/_site/geo/gdsimport.html
@@ -1,4 +1,4 @@
- GDS File Import | ViennaPS DocumentationSkip to main content
ViennaPS provides a convenient feature allowing users to import geometries directly from GDSII mask files. It’s important to note that ViennaPS focuses on handling simple geometry information extracted from GDSII files, without supporting additional data that might be stored within the GDSII format.
To parse a GDSII file using ViennaPS, follow these steps:
Create a ps::GDSGeometry Object: Initialize a ps::GDSGeometry object, specifying the desired grid spacing, boundary conditions, and additional padding (optional).
automask=ps::SmartPointer<ps::GDSGeometry<NumericType,D>>::New();
+ GDS File Import | ViennaPS DocumentationSkip to main content
ViennaPS provides a convenient feature allowing users to import geometries directly from GDSII mask files. It’s important to note that ViennaPS focuses on handling simple geometry information extracted from GDSII files, without supporting additional data that might be stored within the GDSII format.
To parse a GDSII file using ViennaPS, follow these steps:
Create a ps::GDSGeometry Object: Initialize a ps::GDSGeometry object, specifying the desired grid spacing, boundary conditions, and additional padding (optional).
automask=ps::SmartPointer<ps::GDSGeometry<NumericType,D>>::New();mask->setGridDelta(gridDelta);mask->setBoundaryConditions(boundaryConds);mask->setBoundaryPadding(xPad,yPad);
diff --git a/docs/_site/geo/index.html b/docs/_site/geo/index.html
index 034d5be2..6df8ab9c 100644
--- a/docs/_site/geo/index.html
+++ b/docs/_site/geo/index.html
@@ -1 +1 @@
- Creating a Geometry | ViennaPS DocumentationSkip to main content
Create intricate geometries using the versatile tools offered by ViennaLS or generate a basic geometry using of the provided geometry builders. Alternatively, you can import a geometry from a GDSII mask file.
Create custom geometries using the versatile tools offered by ViennaLS or generate a basic geometry (plane, hole, trench, fin, stack) using one of the provided geometry builders. Alternatively, you can import a geometry from a GDSII mask file.
ViennaPS is a header-only C++ process simulation library, which includes surface and volume representations, a ray tracer, and physical models for the simulation of microelectronic fabrication processes. This library seamlessly integrates advanced level-set functionalities with top-down Monte Carlo flux calculations, powered by state-of-the-art ray tracing techniques. This combination brings a new level of accuracy and efficiency to process simulations, empowering engineers and researchers to model complex systems.
ViennaPS is under heavy development and improved daily. If you do have suggestions or find bugs, please let us know on GitHub or contact us directly at viennatools@iue.tuwien.ac.at!
This documentation serves as your comprehensive guide to understanding, implementing, and harnessing the capabilities of our process simulation library. Whether you are a seasoned researcher seeking to refine your simulations or an engineer aiming to optimize real-world processes, this library provides a versatile and robust platform to meet your diverse needs.
Throughout this documentation, you will find detailed explanations, practical examples, and best practices to effectively utilize the library. We aim to empower users with the knowledge and tools necessary to simulate a wide range of processes accurately and efficiently, making informed decisions and driving innovation in the field.
ViennaPS is a header-only C++ process simulation library, which includes surface and volume representations, a ray tracer, and physical models for the simulation of microelectronic fabrication processes. This library seamlessly integrates advanced level-set functionalities with top-down Monte Carlo flux calculations, powered by state-of-the-art ray tracing techniques. This combination brings a new level of accuracy and efficiency to process simulations, empowering engineers and researchers to model complex systems.
ViennaPS is under heavy development and improved daily. If you do have suggestions or find bugs, please let us know on GitHub or contact us directly at viennatools@iue.tuwien.ac.at!
This documentation serves as your comprehensive guide to understanding, implementing, and harnessing the capabilities of our process simulation library. Whether you are a seasoned researcher seeking to refine your simulations or an engineer aiming to optimize real-world processes, this library provides a versatile and robust platform to meet your diverse needs.
Throughout this documentation, you will find detailed explanations, practical examples, and best practices to effectively utilize the library. We aim to empower users with the knowledge and tools necessary to simulate a wide range of processes accurately and efficiently, making informed decisions and driving innovation in the field.
ViennaLS uses VTK as dependency which can be installed beforehand to save some time when building the dependencies. On Linux based systems, it can be installed using the package manager: sudo apt install libvtk9.1 libvtk9-dev. On macOS, one can use Homebrew to install it: brew install vtk.
ViennaRay uses Embree as dependency which can be installed beforehand to save some time when building the dependencies. On Linux based systems, it can be installed using the package manager: sudo apt install libembree-dev. If you are using an Ubuntu version older than 24, the installed package will be Embree version 3, and you must additionally pass VIENNARAY_EMBREE_VERSION=3 to the CMake options, e.g., cmake -B build -G Ninja -D VIENNARAY_EMBREE_VERSION=3 On macOS, you can install Embree using Homebrew with the command: brew install embree.
The CMake configuration automatically checks if the dependencies are installed. If CMake is unable to find them, the dependencies will be built from source with the buildDependencies target. Notably, ViennaPS operates as a header-only library, eliminating the need for a formal installation process. Nonetheless, we advise following the outlined procedure to neatly organize and relocate all header files to a designated directory:
git clone https://github.com/ViennaTools/ViennaPS.git
+ Installing the Library | ViennaPS DocumentationSkip to main content
ViennaLS uses VTK as dependency which can be installed beforehand to save some time when building the dependencies. On Linux based systems, it can be installed using the package manager: sudo apt install libvtk9.1 libvtk9-dev. On macOS, one can use Homebrew to install it: brew install vtk.
ViennaRay uses Embree as dependency which can be installed beforehand to save some time when building the dependencies. On Linux based systems, it can be installed using the package manager: sudo apt install libembree-dev. If you are using an Ubuntu version older than 24, the installed package will be Embree version 3, and you must additionally pass VIENNARAY_EMBREE_VERSION=3 to the CMake options, e.g., cmake -B build -G Ninja -D VIENNARAY_EMBREE_VERSION=3 On macOS, you can install Embree using Homebrew with the command: brew install embree.
The CMake configuration automatically checks if the dependencies are installed. If CMake is unable to find them, the dependencies will be built from source with the buildDependencies target. Notably, ViennaPS operates as a header-only library, eliminating the need for a formal installation process. Nonetheless, we advise following the outlined procedure to neatly organize and relocate all header files to a designated directory:
git clone https://github.com/ViennaTools/ViennaPS.git
cd ViennaPS
cmake -B build -G Ninja && cmake --build build
diff --git a/docs/_site/misc/extrusion.html b/docs/_site/misc/extrusion.html
index fbeb42e9..b37b95b1 100644
--- a/docs/_site/misc/extrusion.html
+++ b/docs/_site/misc/extrusion.html
@@ -1,4 +1,4 @@
- Geometry Extrusion | ViennaPS DocumentationSkip to main content
Extrude a 2D domain into 3D, allowing users to define the extrusion direction and extent. Additionally, users have the flexibility to specify the boundary conditions for the extruded domain.
Example usage:
C++
ps::Extrude<double>(domain2D,domain3D,
+ Geometry Extrusion | ViennaPS DocumentationSkip to main content
Extrude a 2D domain into 3D, allowing users to define the extrusion direction and extent. Additionally, users have the flexibility to specify the boundary conditions for the extruded domain.
Example usage:
C++
ps::Extrude<double>(domain2D,domain3D,{0.,1.},// min and max extent in the extruded dim2,// extrude in z-direction{viennals::BoundaryConditionEnum::REFLECTIVE,
diff --git a/docs/_site/misc/index.html b/docs/_site/misc/index.html
index da153691..1f5b62f4 100644
--- a/docs/_site/misc/index.html
+++ b/docs/_site/misc/index.html
@@ -1 +1 @@
- Miscellaneous | ViennaPS DocumentationSkip to main content
With this class, the user is able to planarize the domain at a specified cutoff position. The planarization process involves subtracting a plane from all materials within the domain using a boolean operation.
Example usage:
C++
ps::Planarize<double,3>(domain,0./*cut off height in z-direction*/).apply();
Python
vps.Planarize(geometry=domain,cutoffHeight=0.).apply()
diff --git a/docs/_site/misc/pointData.html b/docs/_site/misc/pointData.html
index c9adc07b..d18d92aa 100644
--- a/docs/_site/misc/pointData.html
+++ b/docs/_site/misc/pointData.html
@@ -1 +1 @@
- Point Data | ViennaPS DocumentationSkip to main content
