zum Inhalt springen

ExaBrick Framework for High-Performance AMR Rendering with Ray Tracing on GPUs

Motivation

ExaBrick is our under-development middleware to visualize large structured AMR data sets on GPUs. ExaBrick is a joint project by researchers from NVIDIA, the University of Utah, and the University of Cologne. Current development snapshots are available on github: https://github.com/owl-project/owlExaBrick.

The problem we're solving with ExaBrick is that different structured AMR simulation formats have different outputs, and the hierarchies are often not suitable for rendering. This is a huge problem, as tools like ParaView or VisIt build acceleration data structures based on the original hierarchy of cells and use that for cell location during rendering. In contrast to that, ExaBrick is based on a data structure that is taylored for rendering on the GPU with smooth reconstruction at level boundaries.

The ExaBrick Data Structure

The following figure just gives a glimpse of the complexity of the cells of the original hierarchy, and how we organize same-level cells into bricks that can be efficiently rendered on the GPU. This is particularly difficult with cell-centered data; our data structure allows for smooth reconstruction across level boundaries.

ExaBrick tackles this complexity by completely dropping the original hierarchy as, e.g., proposed in prior work by Kähler and Abel, and then building a spatial hierarchy that is more suitable for rendering, processing each "brick" one after another with a parallel ray tracer. The problem with this approach is that reconstruction at level boundaries is ill-supported. The ExaBrick data structure solves this problem by defining the spatial hierarchy not over actual bricks, but over brick support overlap regions that bound the spatial regions where the 1st order reconstruction filters overlap.

By building on the OptiX 7 Wrappers Library (OWL), our data structure utilizes NVIDIA's RTX ray tracing hardware extensions for ray traversal. That way, we support effects such as ambient occlusion, but can also efficiently use the data structure to point-sample AMR cells, e.g., in order to integrate velocities for streamline computation.

Features

ExaBrick comes with a prototypical viewer application and tools to convert from various input formats to our internal format. The following is a non-exhaustive list of features supported by the framework:

  • Direct volume and implicit isosurface rendering with high-quality reconstruction kernels.
  • Volumetric clipping.
  • Hardware acceleration through NVIDIA's RTX ray tracing hardware extensions.
  • Support for triangle geometry; integrates with volume rendering and iso surfaces (e.g., iso surfaces can cast ambient shadows onto triangle geometry and vice versa ).
  • Support for various input formats.
  • Multi-field rendering with a (theoretically) unlimited number of channels.
  • Derived fields and field masks (experimental).
  • Contour planes (experimental).
  • Streamline computation and rendering on the GPU (experimental).

Example Visualizations

Molecular cloud astrophysics simulation, data set courtesy Daniel Seifried from the Theoretical Astrophysics Group, University of Cologne. The visualization demonstrates direct volume rendering of a huge, 8K astrophysics simulation.

Data set courtesy Jamie Law-Smith and Enrico Ramirez-Ruiz from the Dept. of Astronomy & Astrophysics, University of California Santa Cruz (UCSC). The visualization demonstrates the use of contour planes, direct volume rendering, and streamlines that are visualized using ray traced ambient occlusion resulting in soft shadows to provide additional depth cues.

Several time steps from the same simulation, but with multiple fields visualized at once; we use the energy field as an "index volume" to steer the rendering of the density field: where the energy field is above zero, we plot the density field with purple/orange/yellowish colors, whereas, when the energy field is below zero, we plot it in greyish colors in those regions.

LANL Deep water impact data set (SciVis contest 2018, data availabe from: https://sciviscontest2018.org/); the visualization is particularly demanding because of the fine detail around the plume of the meteor impacting the ocean surface and can be significantly improved with our ExaBrick data structure.

Future Work

ExaBrick is ongoing work; the framework serves as a middleware and will eventually be integrated into commonly used visualization tools like ParaView or VisIt. The data structure underlying the framework is also currently optimized for single timestep visualizations; in particular, building the ExaBrick data structure is not interactive. AMR simulations are however often time-varying, so we're currently investigating directions to make the construction process more interactive without sacrificing too much rendering performance.

Publications Related to this Project

  • J. A. P. Law-Smith, R. W. Everson, E. Ramirez-Ruiz, S. E. de Mink, L. A. C. van Son, Y. Götberg, S. Zellmann, A. Vigna-Gómez, M. Renzo, S. Wu, S. L. Schrøder, R. J. Foley, T. Hutchinson-Smith (2020),
    "Successful Common Envelope Ejection and Binary Neutron Star Formation in 3D Hydrodynamics".
    Preprint on arXiv.org, submitted to The Astrophysical Journal Letters.
    Link
     
  • I. Wald, S. Zellmann, W. Usher, N. Morrical, U. Lang, V. Pascucci (2020),
    "Ray Tracing Structured AMR Data Using ExaBricks".
    IEEE Visualization (VIS 2020) / IEEE Transactions on Visualization and Computer Graphics (TVCG).
    PDF Link

Downloads / Source Code

https://github.com/owl-project/owlExaBrick

People Involved

Ingo Wald (NVIDIA), Will Usher, Nate Morrical, Valerio Pascucci (SCI Institute, University of Utah), Stefan Zellmann, Ulrich Lang (University of Cologne)

Contact Person @UoC

Stefan Zellmann