docs: update installation and model documentation, add oxidation examples

Author: FilipovicLado

docs/assets/examples/finOxidation.png

@@ -11,11 +11,27 @@ nav_order: 2
 
 ![]({% link assets/images/ViennaPS_framework.png %})
 
-ViennaPS is part of the ViennaTools ecosystem and depends on several lightweight, header-only ViennaTools libraries. During configuration, CMake will fetch them automatically as part of the ViennaPS build. **No separate installation step is required for these dependencies**:
+ViennaPS is part of the ViennaTools ecosystem and depends on several
+ViennaTools libraries. During configuration, CMake will fetch them
+automatically as part of the ViennaPS build. **No separate installation step is
+required for these dependencies**:
 
 ## [ViennaLS](https://github.com/ViennaTools/ViennaLS)
 
-Handles topography simulation using an efficient level-set implementation based on a hierarchical run-length encoded (HRLE) data structure. ViennaLS also integrates the Visualization Toolkit (VTK) for geometry import/export, enabling processed geometries to be saved in the VTK format and visualized using ParaView.
+Provides the level-set algorithms used for topography evolution, geometry
+operations, and surface/volume mesh generation. ViennaLS also provides the
+physics solver stack used by the ViennaPS thermal oxidation model, including
+the coupled oxidant diffusion, viscous oxide-flow, stress/pressure, and nitride
+mask-deformation solves needed for LOCOS and trench oxidation simulations.
+
+ViennaLS integrates the Visualization Toolkit (VTK) for geometry import/export,
+enabling processed geometries and solver fields to be written in VTK formats
+and visualized with tools such as ParaView.
+
+## [ViennaHRLE](https://github.com/ViennaTools/ViennaHRLE)
+
+Provides the hierarchical run-length encoded data structure used by ViennaLS to
+store sparse level-set grids efficiently.
 
 <!-- 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. -->
 
@@ -37,4 +53,4 @@ Furthermore, pseudo-particles have the capability to undergo reflection from the
 
 ## [ViennaCore](https://github.com/ViennaTools/ViennaCore)
 
-A utility library that provides common functionalities such as logging, vector operations, and other shared methods essential for all sub-libraries.
+A utility library that provides common functionalities such as logging, vector operations, and other shared methods essential for all sub-libraries.

docs/assets/examples/locos.png

@@ -48,6 +48,7 @@ Individual examples can also be build by calling `make` in their respective buil
 | **Ion Beam Etching**<br/>[![]({% link assets/examples/IBE.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/ionBeamEtching) | **Selective Epitaxy**<br/>[![]({% link assets/examples/epitaxy.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/selectiveEpitaxy) |
 | **Sputter Deposition**<br/>[![]({% link assets/examples/sputterDepo.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/sputterDeposition) | **Stack Etching**<br/>[![]({% link assets/examples/stackEtching.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/stackEtching) |
 | **TEOS Trench Deposition**<br/>[![]({% link assets/examples/TEOS.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/TEOSTrenchDeposition) | **Trench Deposition**<br/>[![]({% link assets/examples/trenchDepo.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/trenchDeposition) |
+| **Fin Oxidation**<br/>[![]({% link assets/examples/finOxidation.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/finOxidation) | **LOCOS Oxidation**<br/>[![]({% link assets/examples/locos.png %})](https://github.com/ViennaTools/ViennaPS/tree/master/examples/locosOxidation) |
 
 More Examples:
 * [Custom Example Process](https://github.com/ViennaTools/ViennaPS/tree/master/examples/exampleProcess)
@@ -58,5 +59,7 @@ More Examples:
 * [Fin Oxidation](https://github.com/ViennaTools/ViennaPS/tree/master/examples/finOxidation)
 * [Trench Oxidation](https://github.com/ViennaTools/ViennaPS/tree/master/examples/trenchOxidation)
 * [LOCOS Oxidation](https://github.com/ViennaTools/ViennaPS/tree/master/examples/locosOxidation)
+* [Neutral Transport Cylinder](https://github.com/ViennaTools/ViennaPS/tree/master/examples/neutralTransportCylinder)
+* [Surface Diffusion](https://github.com/ViennaTools/ViennaPS/tree/master/examples/surfaceDiffusion)
 * [SiGe Selective Etching](https://github.com/ViennaTools/ViennaPS/tree/master/examples/SiGeSelectiveEtching)
 * [Trench Deposition Geometric](https://github.com/ViennaTools/ViennaPS/tree/master/examples/trenchDepositionGeometric)

docs/deps/index.md

@@ -17,55 +17,98 @@ Process Simulation Library
 
 ---
 
-ViennaPS is a header-only C++ library for topography simulation in microelectronic fabrication processes. It models the evolution of 2D and 3D surfaces during etching, deposition, and related steps, combining advanced level-set methods for surface evolution with Monte Carlo ray tracing for flux calculation. This allows accurate, feature-scale simulation of complex fabrication geometries.
+ViennaPS is a header-only C++ library for process and topography simulation in
+microelectronic fabrication. It models the evolution of 2D and 3D surfaces
+during etching, deposition, oxidation, and related steps, combining advanced
+level-set methods for surface evolution with Monte Carlo ray tracing for flux
+calculation and physics-based solvers for coupled processes.
 
-ViennaPS supports both physical process models and fast emulation approaches, enabling flexible and efficient development of semiconductor processes. It can be easily integrated into existing C++ projects and also provides Python bindings for use in Python-based workflows. The library is actively developed and continuously improved to address the needs of process and topography simulation in microelectronics.
+ViennaPS supports both physics-based process models and fast emulation
+approaches, enabling flexible and efficient development of semiconductor
+processes. It can be integrated into existing C++ projects and also provides
+Python bindings for Python-based workflows.
 
 {: .note }
 > ViennaPS is under heavy development and improved daily. If you do have suggestions or find bugs, please let us know on [GitHub][ViennaPS issues] or contact us directly at [viennatools@iue.tuwien.ac.at](mailto:viennatools@iue.tuwien.ac.at)!
 
-This documentation is your guide to using and getting the most out of our process simulation library. Whether you're a researcher looking to improve your simulation workflows or an engineer working to optimize fabrication processes, this library offers a flexible and powerful platform to support your work.
-
-Inside, you'll find clear explanations, practical examples, and recommended workflows to help you use the library effectively. Our goal is to give you the knowledge and tools needed to accurately simulate a wide range of fabrication processes, enabling better insights, informed decisions, and innovation in the field.
+This documentation is your guide to installing ViennaPS, building C++ and
+Python workflows, selecting process models, and running the provided examples.
 
 ---
 
-> ⚙️ **ViennaPS v4.0.0 Released — Major Framework Update**
->
-> This release introduces a complete rework of the process framework, unified Python bindings, and extended GPU and material support.
-
-## What's New
-
-### Core framework
-- Modular **flux engine** with new options: `AUTO` (default), `CPU_DISK`, `GPU_DISK`, `GPU_LINE`, `GPU_TRIANGLE`.
-- `AUTO` automatically selects CPU or GPU based on build and model support.
-- **AtomicLayerProcess** removed; ALD handled by standard `Process()`.
-- New parameter structs:
-  - `AtomicLayerProcessParameters`
-  - `CoverageParameters`
-  - `RayTracingParameters`
-  - `AdvectionParameters`
-- All parameter structs now use a single `setParameters()` function.
-
-### Python interface
-- Unified package: `viennaps` replaces `viennaps2d` and `viennaps3d`.
-- Dimension modules available under `viennaps.d2` and `viennaps.d3`.
-- Default dimension is 2D; can be changed via `viennaps.setDimension()`.
-
-### Models and simulation
-- Extended **material list** with common semiconductor materials.
-- **Fluorocarbon model** now supports arbitrary material combinations.
-- Fixed issue where **underlying materials** were not etched in geometric models.
-
-### I/O and utilities
-- Updated `saveSurfaceMesh()`:
-  - Removed `addMaterialIds`
-  - Added `addInterfaces` to export all material interfaces.
-- Improved extrusion and slicing functions.
-
-### Build system
-- GPU builds now **auto-download OptiX headers** if missing.
-- Updated CI, OpenMP handling, and dependencies.
+## Quick Start
+
+Install the Python package from PyPI:
+
+```bash
+pip install ViennaPS
+```
+
+Then import it in Python:
+
+```python
+import viennaps as vps
+```
+
+By default, ViennaPS operates in 2D. Use `vps.setDimension(3)` for 3D
+workflows.
+
+For C++ projects, ViennaPS is usually consumed with
+[CPM.cmake](https://github.com/cpm-cmake/CPM.cmake):
+
+```cmake
+CPMAddPackage("gh:viennatools/viennaps@4.6.1")
+target_link_libraries(${PROJECT_NAME} PUBLIC ViennaTools::ViennaPS)
+```
+
+See [Installing the Library]({% link inst/index.md %}) for full installation
+instructions.
+
+## Dependencies
+
+ViennaPS is part of the ViennaTools ecosystem. During CMake configuration, the
+required ViennaTools libraries are fetched automatically:
+
+* [ViennaCore](https://github.com/ViennaTools/ViennaCore)
+* [ViennaLS](https://github.com/ViennaTools/ViennaLS)
+* [ViennaHRLE](https://github.com/ViennaTools/ViennaHRLE)
+* [ViennaRay](https://github.com/ViennaTools/ViennaRay)
+* [ViennaCS](https://github.com/ViennaTools/ViennaCS)
+
+The main external dependencies are:
+
+* [VTK](https://vtk.org/) 9.0.0 or newer
+* [Embree](https://www.embree.org/) 4.0.0 or newer
+
+CMake checks for these dependencies during configuration. If they are not
+available, they can be built from source as part of the build. To prefer local
+installations, pass their prefixes through `VIENNAPS_LOOKUP_DIRS` or
+`CMAKE_PREFIX_PATH`.
+
+## Supported Platforms
+
+ViennaPS supports Linux, macOS, and Windows with a C++20 compiler and OpenMP
+support.
+
+## GPU Acceleration
+
+ViennaPS supports experimental GPU acceleration for ray tracing and for the
+diffusion solver in the physics-based oxidation model. GPU builds require a
+CUDA-capable system. See [Installing the GPU Module]({% link inst/gpu.md %})
+for details.
+
+## Tests
+
+ViennaPS uses CTest. To build and run the regular test suite:
+
+```bash
+git clone https://github.com/ViennaTools/ViennaPS.git
+cd ViennaPS
+
+cmake -B build -DVIENNAPS_BUILD_TESTS=ON
+cmake --build build
+ctest -E "Benchmark|Performance" --test-dir build
+```
 
 ---
 
@@ -89,8 +132,9 @@ Contact us via: [viennatools@iue.tuwien.ac.at](mailto:viennatools@iue.tuwien.ac.
 
 ## License 
 
-ViennaPS is licensed under the [MIT License](https://github.com/ViennaTools/ViennaPS/blob/master/LICENSE).
+Versions older than 4.3.0 were released under the MIT License. Starting with
+version 4.3.0, ViennaPS is licensed under the
+[GPL-3.0 License](https://github.com/ViennaTools/ViennaPS/blob/master/LICENSE).
 
 [ViennaPS repo]: https://github.com/ViennaTools/ViennaPS
 [ViennaPS issues]: https://github.com/ViennaTools/ViennaPS/issues
-

docs/examples/index.md

@@ -5,7 +5,7 @@ parent: Installing the Library
 nav_order: 1
 ---
 
-# Installing the GPU Module 
+# Installing the GPU Module
 {: .fs-9 .fw-500 }
 
 ---
@@ -24,56 +24,56 @@ The GPU ray tracing module is implemented using [**OptiX 8.0**](https://develope
 
 ## Python Bindings Installation
 
-For a convenient setup, a helper script is provided. It builds **ViennaPS** and **ViennaLS** with GPU support directly from source inside the `ViennaTools` folder.
+The Python package can be built with GPU support using helper scripts in
+`python/scripts`. GPU support enables GPU ray tracing in ViennaPS and the GPU
+BiCGSTAB solver used by the oxidation model.
 
-Run:
+### Existing ViennaPS Checkout
+
+Use `install_ViennaPS.py` when working from a ViennaPS checkout. It creates or
+reuses a virtual environment, installs a compatible local ViennaLS build, and
+then installs ViennaPS from the selected checkout.
 
 ```sh
-wget https://raw.githubusercontent.com/ViennaTools/ViennaPS/refs/tags/v4.2.1/python/scripts/install_ViennaTools.py && python3 install_ViennaTools.py
+python python/scripts/install_ViennaPS.py
 ```
 
-The script performs the following steps:
+When working from existing local ViennaPS and ViennaLS checkouts, pass the
+ViennaLS source directory explicitly:
 
-* Creates a virtual environment (`.venv`) in the `ViennaTools` directory.
-* Builds and installs **ViennaLS** and **ViennaPS** with GPU support enabled.
-* Installs required system dependencies (**VTK**, **Embree**).
+```sh
+python python/scripts/install_ViennaPS.py --viennals-dir ../ViennaLS
+```
 
-> **Note:** Installing system dependencies requires `sudo` privileges.
+Use `--no-gpu` for a CPU-only local build.
 
----
+### Fresh ViennaTools Setup
 
-There are two installation scripts available in the `python/scripts` directory, with different compatibility and functionality:
-
-### 1. `install_ViennaPS.py` 
-
-- **Compatibility:** All Linux distributions and Windows 
-- **Functionality:**  
-   - Builds and installs **ViennaPS** locally
-   - Checks for an existing local build of **ViennaLS**
-   - Checks for OptiX installation, downloads if not found
-- **Limitations:**  
-   - Assumes you have already installed dependencies like VTK and embree manually. Otherwise, they will be built from source, which can take a long time.
-
-### 2. `install_ViennaTools.py`
-
-- **Compatibility:** 
-  - Linux: Ubuntu 22.04+, Debian 11+, Fedora 35+, Rocky Linux 8+, AlmaLinux 8+, Arch Linux, Manjaro, openSUSE Leap 15.3+, openSUSE Tumbleweed
-  - macOS: macOS 12+ (Monterey and later) with Homebrew (only CPU support, no GPU)
-- **Prerequisites**:
-  - For Linux:
-    - `sudo` privileges for installing system packages
-    - Git
-    - Python 3.8+
-
-  - For macOS:
-    - [Homebrew](https://brew.sh/) package manager
-    - Xcode Command Line Tools (will be installed automatically if missing)
-    - Git (usually comes with Xcode Command Line Tools)
-    - Python 3.8+
-- **Functionality:**  
-  - Installs all required dependencies: `VTK`, `embree`, and others using `apt`  
-  - Builds and installs **ViennaLS** and **ViennaPS** in a local folder named `ViennaTools`  
-  - Suitable for a fresh installation on Ubuntu systems  
+Use `install_ViennaTools.py` for a broader fresh setup. It creates a
+`ViennaTools` directory, installs supported system dependencies, clones
+ViennaLS and ViennaPS, creates a virtual environment, and builds both Python
+packages.
+
+From a ViennaPS checkout:
+
+```sh
+python python/scripts/install_ViennaTools.py
+```
+
+Or download the script directly from a tagged release:
+
+```sh
+wget https://raw.githubusercontent.com/ViennaTools/ViennaPS/refs/tags/v4.6.1/python/scripts/install_ViennaTools.py
+python3 install_ViennaTools.py
+```
+
+GPU support is enabled by default on Linux when CUDA is available. Use
+`--no-gpu` for a CPU-only setup. On macOS, GPU support is disabled because
+NVIDIA CUDA/OptiX is not available.
+
+{: .note }
+Installing system dependencies with `install_ViennaTools.py` may require
+administrator privileges on Linux.
 
 ## CMake Configuration
 
@@ -100,11 +100,11 @@ include("cmake/cpm.cmake") # Include CPM.cmake (get from: https://github.com/cpm
 
 CPMFindPackage(
   NAME ViennaPS
-  VERSION 4.2.1
+  VERSION 4.6.1
   GIT_REPOSITORY "https://github.com/ViennaTools/ViennaPS"
   OPTIONS "VIENNAPS_USE_GPU ON")
 
 # Link against ViennaPS
 add_executable(example_gpu main.cpp)
-target_link_libraries(example_gpu PRIVATE ViennaPS)
+target_link_libraries(example_gpu PRIVATE ViennaTools::ViennaPS)
 ```