ViennaPS-4.3.0

ViennaPS 4.3.0 – Release Notes

This release introduces GPU acceleration for the Python package on Linux.

Major Changes

GPU Acceleration in PyPI Linux Package

The Linux PyPI package now includes GPU acceleration support. ViennaPS attempts to load the CUDA driver at runtime. If the CUDA driver is available and a compatible device is detected, simulations automatically run on the GPU.

This allows users to benefit from GPU acceleration without requiring CUDA libraries at installation time. If no suitable CUDA environment is found, ViennaPS falls back to CPU execution.

Notes:

• Currently supported only for the manylinux wheel.
• Not yet supported on Windows or macOS wheels.

License Change

Starting with version 4.3.0, the ViennaPS license has changed from MIT to GNU GPL v3.

Other New Features

• Polynomial Cosine Yield Function
  Added a new yield function option that models angular dependence using a polynomial cosine formulation.

• Hull Mesh Generation
  Introduces a new method for generating hull meshes, improving geometry handling and surface reconstruction workflows.

• CUDA Runtime Loading
  ViennaPS now loads the CUDA driver dynamically at runtime, enabling optional GPU acceleration without requiring static CUDA linkage.

Full Changelog

v4.2.2...v4.3.0

ViennaPS-4.2.2

ViennaPS – Release Notes

This release provides several bug fixes and minor performance improvements across the ray tracing, time integration, and geometry import components

• Fixed a bug in the 2D ray tracing pipeline where the incoming angle of particles at surface intersections was computed incorrectly. This affected all models with angle-dependent yields. The angular evaluation is now correct, leading to slightly different but physically consistent etch/deposition rates in 2D simulations.
• Updated ViennaLS dependency to include recent stability fixes:
  • Corrected adaptive time stepping behavior in the Advect routine.
  • Fixed issues in the RK2 and RK3 time integration schemes to ensure consistent temporal evolution and improved robustness for multi-step process flows.
• Improved performance of the GDS reader

ViennaPS-4.2.1

What's Changed

• fix(python): save exception to a variable that persists
• fix: update examples
• fix: small coding style issues
• perf: avoid unnecessary copies
• refactor: split ElementToPointData into prepare and convert phase
• feat: enable intermediate velocity calculation for RK2/RK3
• feat: enable sanitizer and clang-tidy build

Full Changelog: v4.2.0...v4.2.1

ViennaPS-4.2.0

ViennaPS 4.2.0 — Release Highlights

This release improves GPU robustness, numerical accuracy, and usability.

Fixes

• Fixed GPU memory leaks causing overflows in long simulations.
• GPU simulations are now reproducible with identical RNG seeds.
• Fixed GDS reader segmentation fault related to flipped/rotated cell references.
• Fixed a GPU bug in plasma etching models for specific material configurations.

Refactoring

• Improved CMake installation and export setup.
• GPU builds now tested and supported on Windows.
• Logger now uses lazy string evaluation for better performance.

New Features

• Domain::removeStrayPoints() to remove isolated floating points.
• TEOS PECVD GPU model.
• Rotating ion beam etching (IBE) model.
• Adaptive time stepping for thin-layer accuracy.
• New level-set integration schemes: RK2 and RK3 (Forward Euler remains default).
• Lightweight built-in VTK renderer: Domain::show().

API

• IntegrationScheme renamed to SpatialScheme.
  IntegrationScheme is deprecated and will be removed in a future release.

ViennaPS-4.1.1

What's Changed

New

• Flux engines now support triangle-based geometries in 2D, enabling more consistent behavior between 2D and 3D simulations.

Improvements and Fixes

• Updated ion model utilities and ray-tracing utilities.
• Fixed an issue where consecutive calls to Process.apply() could crash.
• Improved installation script for smoother dependency handling across platforms.
• Fixed Python package build and CI workflow.

Full Changelog: v4.1.0...4.1.1

ViennaPS-4.1.0

New Features

• CPU triangle flux calculation
• More options in MakeTrench

Fixes

• Fixes in psPlasmaEtching and psIonModelUtil
• Correct wrapper and stubs to reflect changes in psReader

Full Changelog: 4.0.1...v4.1.0

ViennaPS-4.0.1

What's Changed

• Remove NumericType template in DomainSetup
• Update GPU model pipelines and IonBeamEtching model
• Add Materials: Au, Cr

Full Changelog: v4.0.0...4.0.1

ViennaPS-4.0.0

ViennaPS v4.0.0 — 2025-10-22

Highlights

• Complete rework of the process framework with modular flux engine design.
• Improved GPU integration across all process types.
• Unified Python bindings: one package viennaps with submodules viennaps.d2 and viennaps.d3.
• Extended material list covering the most common materials in semiconductor fabrication.

Breaking changes

• Python packages viennaps2d and viennaps3d are removed. Use viennaps.
• Default Python dimension is 2D when using top-level viennaps.*.
• Dimension can be changed at runtime with viennaps.setDimension(2 | 3).
• AtomicLayerProcess was removed. ALD and related atomic-layer processes are now handled by the standard Process() class.
• All process parameters must now be set through parameter structs using setParameters().
• saveSurfaceMesh() behavior changed (see below).

New / changed API

Flux engine

Processes now use a configurable flux engine, which defines how particle fluxes are computed.
Available options:

• AUTO (default) — chooses CPU or GPU automatically, depending on build type and model support
• CPU_DISK
• GPU_DISK
• GPU_LINE
• GPU_TRIANGLE

Example:

auto proc = ps::Process(...);
proc.setFluxEngineType(ps::FluxEngineType::AUTO);

import viennaps as vps
p = vps.Process(...)
p.setFluxEngineType(vps.FluxEngineType.AUTO)

Python bindings

• Unified structure:

  import viennaps as vps
  
  dom = vps.Domain()  # default 2D
  
  from viennaps import d3
  dom3 = d3.Domain()  # explicit 3D
  
  vps.setDimension(3)
  dom = vps.Domain()  # now 3D by default

Process parameters

• Parameters are configured via parameter structs and passed using the unified setParameters() function:

  struct AtomicLayerProcessParameters {
    unsigned numCycles = 1;
    double pulseTime = 1.0;
    double coverageTimeStep = 1.0;
    double purgePulseTime = 0.0;
  };
  
  struct CoverageParameters {
    double coverageDeltaThreshold = 0.0;
    unsigned maxIterations = std::numeric_limits<unsigned>::max();
  };

• Example:

  ps::AtomicLayerProcessParameters alp;
  alp.numCycles = 10;
  proc.setParameters(alp);  // same function for all parameter structs

• Applies to:

  • AtomicLayerProcessParameters
  • CoverageParameters
  • RayTracingParameters
  • AdvectionParameters

Domain and mesh output

• saveSurfaceMesh() updated:

  • Removed addMaterialIds option.
  • New option addInterfaces — when enabled, all material interfaces in the domain are exported.

  domain.saveSurfaceMesh("surface.vtp", /*addInterfaces=*/true);

Models and physical updates

• Fluorocarbon model now supports arbitrary material combinations.
  See documentation for the new parameter setup.
• Geometric process models: fixed an issue where underlying materials were not etched correctly.
• Material list extended to include commonly used materials in semiconductor manufacturing (e.g., Si, SiO₂, Si₃N₄, SiGe, W, Al₂O₃, HfO₂, TiN, and more).

Build system and GPU support

• OptiX headers are now downloaded automatically if not found on the system when building with GPU support.
• Standard OpenMP is used on macOS.

Other changes

• Cleaner process metadata management.
• New calculateFlux() entry point in the process path.
• Improved surface mesh generation and point-to-element data mapping.
• Extrusion and slice functions exposed in Python (Extrude, Slice).
• GDS reader fixes and mask blur improvements.

Migration guide

From viennaps2d / viennaps3d to unified viennaps

• Before:

  import viennaps2d as vps
  dom = vps.Domain(...)

• After:

  import viennaps as vps
  dom = vps.Domain(...)

Selecting a flux engine

p.setFluxEngineType(vps.FluxEngineType.AUTO)         # automatic
p.setFluxEngineType(vps.FluxEngineType.CPU_DISK)     # CPU
p.setFluxEngineType(vps.FluxEngineType.GPU_TRIANGLE) # GPU

Process parameters

• Before:

  proc.numCycles = 10;

• After:

  ps::AtomicLayerProcessParameters alp;
  alp.numCycles = 10;
  proc.setParameters(alp);

Surface mesh export

• Before:

  domain.saveSurfaceMesh("surf.vtp", /*addMaterialIds=*/true);

• After:

  domain.saveSurfaceMesh("surf.vtp", /*addInterfaces=*/true);

ViennaPS-3.7.3

This release provides a temporary compatibility update.

Updated dependency to ViennaLS 4.5.0 (instead of the latest version) to ensure compatibility and restore Python import functionality.

Notes:
This is an interim fix. A major update aligning with ViennaPS 4.0.0 and ViennaLS 5.0.0 will follow soon.

ViennaPS-3.7.2

What's Changed

• Parallelize surface rate calculation by @tobre1 in #151
• Use python native enums and improve stub generation by @tobre1 in #152
• ViennaPS title banner by @tobre1 in #153

Full Changelog: v3.7.1...v3.7.2