Warp SimData

Warp SimData is a Warp-native Python library for processing simulation data. Scientific data comes in many shapes and forms. While popular standardized data models exist, simulation codes, time and again, produce data in custom formats tailored to their specific needs. This creates a dilemma when writing data processing algorithms: either invest significant effort converting data to a standardized model, or write bespoke implementations for each custom format. Both approaches are time-consuming and error-prone. This project explores whether we can avoid this trade-off altogether by providing a flexible framework that works seamlessly across different data models.

Disclaimer: Warp SimData is not part of the warp-lang package, and it is not maintained by the NVIDIA Warp core team. It is a Warp ecosystem library. Issues, releases, roadmap, and support are managed by the maintainers of this repository.

Background

Warp SimData grew out of Kit-CAE, where we developed Warp-based algorithms for simulation data processing. That work was largely intended to showcase how NVIDIA Warp could accelerate CAE operations and how those capabilities could be integrated into Omniverse workflows.

The algorithms are potentially useful beyond Kit-CAE, so we split them into this standalone project. This makes it possible to use, evaluate, and develop them without adopting the Kit and Omniverse application stack.

Warp SimData now serves both as a practical example of using Warp for simulation data processing and as an experimental framework for applying algorithms across heterogeneous data models. It explores whether operators can share a consistent implementation while model-specific access is supplied through lightweight interfaces, avoiding unnecessary data conversion and copying.

Installation

Requirements

• Python 3.10 or newer
• warp-lang 1.12.0 or newer
• NumPy 1.20.0 or newer
• An NVIDIA CUDA-capable GPU and compatible driver for CUDA execution; CPU execution is also supported
• Git LFS when cloning the full source tree and its test data

From Source

git clone https://github.com/NVIDIA/warp-simdata.git
cd warp-simdata
pip install .

For Developers

# Setup virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install in editable mode with test dependencies
pip install -e .[test]

# Or install with all development tools (linting, formatting, type checking)
pip install -e .[dev]

# Run all tests
pytest tests/

See INSTALL.md for detailed installation instructions.

Testing

Quick Start

# After installing with test dependencies (pip install -e .[test])
pytest tests/

Common Commands

# Run tests on CPU only (filter by device parameter)
pytest tests/ -k "[cpu]"

# Run tests on GPU only (requires CUDA)
pytest tests/ -k "[cuda]"

# Run fast tests (skip slow/VTK)
pytest tests/ -m "not slow and not vtk"

# Run with coverage report
pytest tests/ --cov=warp_simdata --cov-report=html

# Run specific operator tests
pytest tests/test_bounds.py
pytest tests/test_centroid.py

# Run in parallel (faster)
pytest tests/ -n auto

# Verbose output with full tracebacks
pytest tests/ -vv

Optional visualization filters can also be loaded from a source checkout in ParaView; see the ParaView extension instructions.

Basics

Warp SimData is based on NVIDIA Warp. Similar to Warp, Warp SimData has two sets of APIs: one intended to be used at the Python Scope and run inside the CPython interpreter, and second intended to be used at the Kernel Scope which, while still written in Python, get JIT compiled to CUDA or C++ to execute on target devices like CPU or CUDA compute.

CPU performance note: Warp currently processes kernel work sequentially when a CPU device is the target. CPU execution is supported, but workloads designed for parallel execution may be significantly slower than expected. CPU use cases should become more practical when Warp supports parallelizing kernel launches across CPU cores.

Python scope APIs are intended for users and developers who want to use Warp SimData for specific data processing tasks. Kernel scope APIs are for those developers who want to introduce new data models to Warp SimData or develop operators for data processing in Warp SimData.

API Reference:

• Python Scope Reference - Complete guide for using Warp SimData operators and datasets
• Kernel Scope Reference - Guide for developing data models and operators
• Element Faces Operator - Boundary classification, CPU/CUDA implementations, memory model, and limitations
• Iso-Surface Operator - Single/batched interfaces, implementation, supported topology, and open work
• Plane Slice Operator - Plane batching, exact preselection design, field transfer, and performance
• OpenUSD Reference - Using warp_simdata.usd to convert OpenUSD scientific dataset prims into Warp SimData datasets and fields
• Changelog - Notable changes grouped by release

Common operators include bounds, element bounds/sizes, centroids, probing, voxelization, advection, streamlines, element_faces, and iso_surface. element_faces extracts volumetric faces as a surface mesh and can compact only external faces with external_only=True. See the element-faces operator reference for its topology contract, device-specific classification, and resource model. iso_surface extracts a merged triangular surface from a node scalar through any data model that exposes the required neutral topology capabilities. See the operator reference for its contract, implementation, limitations, and maintained open-work list.

import warp_simdata as simdata
from warp_simdata.operators import bounds, iso_surface

result = bounds.compute(dataset)
field = simdata.Field.from_array(values, simdata.AssociationType.NODE)
dataset.add_field("pressure", field)
surface = iso_surface.compute(dataset, "pressure", 0.5)

OpenUSD Integration

The warp_simdata.usd package provides adapters from OpenUSD scientific dataset prims to Warp SimData datasets and fields. This is the recommended path when your data is already represented in USD through scientific schemas such as CGNS and CAE mesh, point-cloud, EnSight, or OpenFOAM marker APIs.

The scientific schemas and native file-format plugins consumed by these adapters are provided by CAE OpenUSD Plugins. Refer to its schema documentation and Conceptual Data Mappings for the authoritative USD contracts.

See the OpenUSD Reference for supported schemas, API details, and usage examples.

import warp_simdata.usd as simusd

dataset = simusd.dataset_from_prim(prim, device="cuda:0")
fields = simusd.list_fields(prim)
pressure = simusd.field_from_prim(prim, "pressure", device="cuda:0")

Contributing

This project is currently not accepting contributions.

Releases

See CHANGELOG.md for notable changes. Release artifacts are published through the repository's Releases page when available. See the versioning and release guide for supported version forms, release branches, and tag conventions.

Governance and Maintainers

Warp SimData is maintained by NVIDIA. See GOVERNANCE.md and MAINTAINERS.md.

Security

Do not report security vulnerabilities through public GitHub issues. Follow the private disclosure process in SECURITY.md.

Support

Warp SimData is an experimental project. See SUPPORT.md for support channels and response expectations.

License

Warp SimData is licensed under the Apache License 2.0. See LICENSE.md and NOTICE.md.