paraview visit

Why use VisIt?

Download Now

What's new?

New blog articles, visit 3.4.1 release.

By Elaine Jiang

Description

VisIt is an open source, scientific visualization tool. VisIt can automatically generate animations on data with timestamps, and manipulate data with a variety of operators and filters. VisIt is visualize most scientific data formats due to its customizable plugin architecture.

VisIt was originally developed by the Department of Energy (DOE) Advanced Simulation and Computing Initiative (ASCI) to visualize and analyze the results of terascale simulations. Because of it’s applicability beyond visualizing terascale data, VisIt is now a licensed open source product.

Official Resources

Official Documentation: VisIt User Manual

User Support: visitusers.org is a wiki that contains up to date information about VisIt

Installation Guide: VisIt Basic Getting Started Guide

Usable Environments

Accessibility: The estimated time for someone to create a simple data visualization in VR

Beginner: No coding or graphics experience | 10 min

Intermediate: Some coding or graphics experience | 10 min

Advanced: Both coding and graphics experience | 10 min

Expert: A lot of experience with computer graphics | 10 min

Power: The engine's power - i.e. how much one can do with this

High: Intended for developers with years of graphics experience

Usage: Evaluation of software's use for the following purposes

Scientific visualization - main use for ParaView

Recommended System Requirements

Compatible with Unix, Windows, and Mac

Software Performance

Data visualization summary, powerful gui.

Overview: Not a big learning curve for beginner users, and automatically creates time-based animations from data sets that contain multiple time steps

Keyframe Animation Capability

Overview: Has a keyframe animation capability that allows users to create sophisticated animation.

Distributed Parallel Computation

Overview: Employs a distributed and parallel architecture in order to handle extremely large data sets interactively

Support for Multiple Mesh Types

Overview: Supports multiple mesh types including two- and three-dimensional point, rectilinear, curvilinear and unstructured

Extensible with Plugins

Overview: Extensible with dynamically loaded plugins

Final Thoughts

(By Elaine)

Very similar to ParaView; default visualizations are different -- VisIt's default visualizations have axis, labels, legends, while ParaView's default visualizations are more basic (just the model)

In VisIt you can have multiple active windows at once so you can render different models at once. In ParaView you have one active window

In both ParaView and VisIt, users can make animations of the model. Both software have underlying VTK code.

Official Tutorial master page

http://visitusers.org/index.php?title=VisIt_Tutorial

VisIt: About VisIt. 2018, Laurence Livermore National Security, LLC. https://wci.llnl.gov/simulation/computer-codes/visit/

• kitware.com

Tutorials and Webinars

ParaView Self-directed Tutorial This introductory and comprehensive tutorial teaches ParaView through examples that cover basic usage and advanced topics. 

ParaView Classroom Tutorials These tutorial sets were created as instructor-led courses at Sandia National Laboratories for beginners and advanced users.

ParaView Classroom Tutorials Video A companion to the ParaView Classroom Tutorials by Sandia National Labs and Los Alamos National Laboratory, this video is a live version of the tutorials listed above. 

Additional Tutorials

Mike Bailey, from Oregon State University’s computer science department, has developed a ParaView Page with exercises for new ParaView users.

Professional Training

Kitware offers professional ParaView training courses for individuals and groups. You can request a custom training quote or register for an upcoming scheduled course.

• ParaView Developer’s Course
• ParaView User Training

Advanced rendering of scientific data using ray-tracing in ParaView

Presented on: February 29, 2024 Presenter: Thomas Galland & Lucas Givord

This webinar will be focused on using ray tracing rendering capabilities of ParaView in order to obtain stunning visuals of your scientific datasets. Come and discover the integration of Intel OSPray and the new material editor that will be available in the 5.12 release of ParaView. During this up to 30 minutes session, you will be able to follow our explanations and hands-on demonstrations. You will also be able to interact with the presenter via the chat to ask questions or precisions.

Immersive ParaView: AR/VR/XR Exploration with ParaView

Presented on: January 16, 2024 Instructors: Mathieu Westphal & Thomas Galland

This webinar will happen in early January and be focused on AR (Augmented Reality) , VR (Virtual Reality) and XR (eXtended Reality) tools within ParaView in order to perform immersive data exploration.

Basic ElectroMagnetics Post-processing with ParaView

Presented on: September 23, 2023 Instructors: Julien Fausty & Mathieu Westphal

In this 30 minute webinar, you will learn the first steps to explore and visualize data from electro-magnetics simulations that can be performed in COMSOL, Elmer FEM, FEniCS or MEEP to name only a few. Explore and reduce your data, visualize electric and magnetic vector fields in different representations, compute new variables, plot and compare data and learn many tricks to enhance your productivity with ParaView! Data generated by Lukas Henkel on Elmer FEM in the context of the design of an open source laptop.

Basic CFD Post-processing with ParaView

Presented on: March 15, 2023 Instructors: François Mazen & Mathieu Westphal In this webinar, you will learn the first steps to explore and visualize data from computational fluid dynamics simulations (CFD) like OpenFOAM, StarCCM+, Code Saturne or Fluent. Explore and reduce your data, visualize scalar fields and vector fields, compute new variables, plot and compare data and learn many tricks to enhance your productivity with ParaView!

Spitfire Data Provided by IT4Innovation ( blender.it4i.cz/ )

Leverage the Power of your GPU

Presented on: November 9, 2022 Instructors: Timothée Chabat & François Mazen Scientific visualization relies on a number of post processes and visualization techniques in order to make a meaningful interpretation of the data, such as glyphs or iso-surfaces. While most of the time these processes happen on the CPU it is actually possible to use the GPU directly to explore your data. Come and discover how to use these capabilities in ParaView through this Kitware’s webinar!

Animate Your Scientific Data Analysis with ParaView

Presented on: June 29, 2022 Instructors: Nicolas Vuaille & Mathieu Westphal This webinar will teach you how to use ParaView’s Animation module to create videos communicating your scientific results.

ParaView First Steps

Presented on: May 3, 2022 Instructors: Charles Gueunet & Mathieu Westphal This webinar focuses on the first steps of using ParaView, specifically opening a file, adding a simple filter, and saving the results.

How to SLAM with LidarView

Presented on: April 9, 2021 Instructors: Nicolas Cadart and Bastien Jacquet This webinar focuses on how to run Simultaneous Localization and Mapping (SLAM) using only LiDAR data with LidarView.

Feature-based Clustering with TTK in ParaView

Presented on: March 9, 2021 Instructor: Charles Gueunet Using the Topology ToolKit plugin in ParaView, we demonstrate how to classify images using clustering methods relying on a persistent homology-based descriptor for topological data analysis in this webinar.

Kitware ParaView Streamlines Webinar

Presented on: November 24, 2020 Instructor: Mathieu Westphal This webinar focuses on creating streamlined visualizations in ParaView using steady and unsteady simulation results.

Usage of Python in ParaView

Presented on: September 23, 2020 Instructor: Mathieu Westphal An introductory webinar for Python usage in ParaView.

ParaView 5.8 Webinar: Rendering Techniques

Presented on: March 10, 2020 Instructor: Michael Migliore This webinar focuses on the new rendering techniques in ParaView, specifically physically based rendering, raytracing, and advanced GPU-based rendering techniques.

Large Scale Visualization with ParaView

Presented on: September 25, 2017 Instructor: Dan Lipsa Presented at the Argonne Training Program on Extreme-Scale Computing 2017.

ParaView Catalyst: Leverage In situ Analysis with VTK and ParaView

Presented on: September 26, 2013 Instructor: Andy Bauer This webinar highlights the benefits of ParaView Catalyst and how to leverage them for your own simulations.

Professional ParaView Training

Still need help? Kitware offers professional ParaView training courses for individuals and groups. You can request a custom training quote or register for an upcoming scheduled course. 

ParaView and VisIt at TACC

ParaView is an open-source, multi-platform data analysis and visualization application. ParaView users can quickly build visualizations to analyze their data using qualitative and quantitative techniques. The data exploration can be done interactively in 3D or programmatically using ParaView’s batch processing capabilities.

ParaView was developed to analyze extremely large datasets using distributed memory computing resources. It can be run on supercomputers to analyze datasets of petascale size as well as on laptops for smaller data, has become an integral tool in many national laboratories, universities and industry, and has won several awards related to high performance computation.

ParaView is currently installed on TACC’s Stampede2 and Frontera resources.

Table 1. ParaView Modules per TACC Resource

Running paraview gui on a compute-node desktop.

First, use the TACC Analysis Portal to allocate one (or more) compute nodes and run a desktop: https://tap.tacc.utexas.edu/jobs/ You can choose to use either VNC or DCV to provide the desktop.

Select your desired options, and press Submit. Eventually the job will run, allocate the specified nodes and tasks, and provide a means to connect to it in a separate browser tab. There you will see a desktop. In the terminal window on that desktop:

c442-001$ module load {module list}

And the Paraview GUI will appear on the desktop.

We do not use GPUs to run Paraview on either Stampede2 or Lonestar6. swr is a wrapper that enables Paraview to take advantage of Intel’s many-core OpenSWR rendering library. The -p 1 arguments inform OpenSWR that paraview is running serially and should have access to all available cores for rendering.

Running ParaView In Parallel

To run Paraview in parallel, you must first start your VNC or DCV desktop with more than one tasks, running on one or more nodes. This is easily done on the TACC vis portal:

Then start Paraview as above. Once the GUI appears, File->connect… opens the Choose Server Configuration dialog. The auto configuration will cause Paraview to launch a parallel server using one server process on each task allocated above. In this case the available cores will be meted out to the server processes based on the number of tasks running on each node.

Notes on Paraview in Parallel

Note that running Paraview with an excessive number of nodes and/or processes is often detrimental to overall performance.

There are several issues to understand. First, there's limited bandwidth into each node; having lots of processors trying to load data in parallel through one data path causes all sorts of congestion. Generally, I've found that 4-6 processes per node maximizes the bandwidth onto the node; beyond this, total bandwidth falls off and way beyond this (which 48 processes/node is) it can sure look like its hung. In one user’s case, 2 nodes 8 processes loads the data in about a second whereas one node, one process loads in 3-4 seconds or so. The difference rises with the size of the datasets.

Second, lots of processes will only help in one aspect of the overall problem: geometry processing. But, again, it’s not without overhead. PV relies on spatial decomposition for parallel processing. In order to get the right answer at inter-partition boundaries, it must maintain 'ghost zones' - regions of actual overlap between the partitions. When the data is partitioned into lots of little chunks, as it is in our user’s case, the portion of overlap rises, causing it to do significantly more work.

Next, when the data is distributed, a final image is created by having each process render its local data, then compositing (with depth) to resolve a single image that’s correct with respect to all the data. This adds quite a significant overhead to the rendering process, which is engaged whenever you move the viewpoint - which in interactive use happens way more often than, say, computing a new isosurface.

Finally, in most cases our large-scale systems (Stampede2, Lonestar6 and Frontera) do not use GPUs for rendering. Instead, we use a software rendering library which is optimized to run on lots of cores and to use the full SIMD architecture of each. When there are lots of processes on each node, the number of cores available to each for rendering is small. Even if we did use GPUs, though, again - lots of processors per node would cause contention for the GPU resources and would still require compositing.

While we wish there was a magic way to optimize Paraview in parallel, there's not. The best balance depends on the amount of data being read, the amount of geometry processing required, and the number of rendered frames per timestep that will be needed. We generally advise users that the big win of running Paraview in parallel is that you get the aggregate bandwidth into memory and the aggregate total memory. A useful rule of thumb is to use enough nodes to acquire maybe 4x the in-memory size of the input data, and hope that the high-water mark (remember, as you pass your data through PV filters, the intermediate data all increases Paraview's total memory footprint) and then allocate no more than 4-8 processes per node.

Running ParaView In Batch Mode

Paraview can also be run in batch mode, generally from an idev session or launched using a job script and sbatch. In this case you use Paraview through Python; Paraview includes the pvbatch executable to do so. The only difference in the required module stack is that you load the paraview-osmesa module rather than paraview so that it can run without a connection to a desktop.

To run pvbatch serially or in parallel using idev, start a idev session:

TACC Stampede2 System

Provisioned on 24-May-2017 at 11:49

c455-003 knl $ module load impi qt5 swr oneapi_rk paraview-osmesa

At that compute-node prompt you can run pvbatch and give it your Python script. As an example, if your Python script is tt.y containing:

Then you can run it:

c455-003 knl $ ibrun swr pvbatch tt.py

TACC: Starting up job 9553190

TACC: Starting parallel tasks...

…ignore messages…

TACC: Shutdown complete. Exiting.

The scary looking text that emerges can be ignored.

This will create a file named ‘tt.png’ containing an image of a sphere:

Notes from the Vis Team

While one can write one’s own Paraview/Python script by hand, it is often convenient to create a visualization using the Paraview GUI then run it in batch mode. To do so, save your Paraview state as a Python script, then modify the script (by hand) to write images or save data as required. For more information see https://www.paraview.org/Wiki/ParaView/Python_Scripting

You can also modify this script to, for example, take command line arguments to vary input and output file names etc. It is also convenient to modify this script to iterate through datasets.

Parallel VisIt is an Open Source, interactive, scalable, visualization, animation and analysis tool. Users can quickly generate visualizations, animate them through time, manipulate them with a variety of operators and mathematical expressions, and save the resulting images and animations for presentations. VisIt contains a rich set of visualization features to enable users to view a wide variety of data including scalar and vector fields defined on two- and three-dimensional (2D and 3D) structured, adaptive and unstructured meshes. Owing to its customizable plugin design, VisIt is capable of visualizing data from over 120 different scientific data formats.

VisIt is installed on TACC’s Frontera, Stampede2, and Lonestar6 resources. The environment required to run VisIt on each of these resources is slightly different. The user will use the module command to load the required environment for VisIt.

Table 2. VisIt Modules per TACC Resource

*Environment managed by VisIt module

**Default VisIt version on resource

The table above summarizes the version of VisIt installed and the modules required to run it on each TACC resource. All the modules listed for a particular resource must be loaded for VisIt to run correctly. The VisIt module itself manages loading and unloading of certain dependencies on certain resources. Modules that are automatically loaded by the VisIt module are marked with an * in Table 2. There is no need to explicitly load modules managed by VisIt.

Starting the VisIt user interface on TACC resources is very similar to starting Paraview. The user should follow the procedure for starting a remote desktop described in the Paraview documentation above .

Once a remote desktop is running the user will start the VisIt user interface by typing commands into a shell window on that desktop. The commands required are summarized in the table below. The column labeled “Load Modules” contains commands required to load the environment on the particular resource. The column labeled “Run VisIt” contains the command required to launch the user interface. In both columns the text “c442-001$” is simply the command prompt in the shell window.

Table 3. Running VisIt

Consider starting VisIt on Stampede2 as an example. The user should load the intel, impi, and visit modules as indicated by the commands in the Table 3. In addition the user should set the GALLIUM_DRIVER to a value of swr (export GALLIUM_DRIVER=swr). Once that is done the user types the visit command at the command prompt as shown in Table 3. The user interface should appear on the desktop.

It is beyond the scope of this document to describe how to utilize VisIt for analysis once it is started. There is a great deal of online information available on that topic. The user is directed to The VisIt Github Page , VisIt User Guide , and Getting Data Into VisIt for more information on using VisIt. We do provide the following notes related to specifics of using VisIt on TACC resources.

• The module load command will load the most recent version of a module if no version number is specified.
• Loading the compiler family (intel, gcc) will modify the currently loaded mpi family as necessary.
• Launching VisIt on Frontera requires the use of the swr prepend. The argument -p n specifies the number of mpi tasks (n=1 in this case) per node that VisIt will use. This flag is used by the software renderer to determine the number of threads used by the swr software renderer. The number of rendering cores = cores per node / n.
• The total number of mpi ranks used by VisIt is determined by the characteristics of the resource requested when the remote desktop was started. VisIt will start a parallel engine consisting of n total mpi ranks distributed across N nodes where the values of N and n correspond to the number of nodes and procs requested by the remote desktop startup procedure.
• The parallel analysis engine is launched after the user selects a plot type and presses the draw button. At that time VisIt will present the user with a dialog with controls to select either a parallel or serial engine. Parallel is default. There are also controls in that dialog to select the number of Nodes and processes. These values have no effect. Changing the number of nodes in the dialog will not change the number of nodes in the analysis due to the fact that the resource is allocated during startup of the remote desktop.
• VisIt can be used in batch mode via a python interpreter. See the scripting section of the VisIt User Guide for more information.

Preparing Data for Parallel Visit

VisIt reads nearly 150 data formats . Except in some limited circumstances (particle or rectilinear meshes in ADIOS, basic netCDF, Pixie, OpenPMD and a few other formats), VisIt piggy-backs its parallel processing off of whatever static parallel decomposition is used by the data producer. This means that VisIt expects the data to be explicitly partitioned into independent subsets (typically distributed over multiple files) at the time of input. Additionally, VisIt supports a metadata file (with a .visit extension) that lists multiple data files of any supported format that hold subsets of a larger logical dataset. VisIt also supports a “brick of values (bov)” format which supports a simple specification for the static decomposition to use to load data defined on rectilinear meshes. For more information on importing data into VisIt, see Getting Data Into VisIt .

To get answers to questions about using Paraview or VisIt on TACC resources please create a support ticket with TACC consulting via the TACC User Portal .

VisItBridge

• Copy SSH clone URL [email protected]:paraview/visitbridge.git
• Copy HTTPS clone URL https://gitlab.kitware.com/paraview/visitbridge.git

error message any HELP !!!!!

https://idownvotedbecau.se/imageofanexception/

Hi Mathieu, I am trying to use Paraview for output visualization from Nek5000. so after some modifications in the script on Nek5000 I can’t visualize the results after generating the metadata file, am on online visualization he shows me the following message ( 178.090s) [paraview ]vtkAvtSTMDFileFormatAlg:555 ERR| vtkVisItNek5000Reader (0x63d69e0): VisIt Exception caught. thank you for your help !

Looks like you are using Visit. You may want to ask on a Visit forum.

ok i will . thank you .

Actually, it looks like @laylafoura is using ParaView. It’s just that the Nek5000 reader is part of the bridge to VisIt readers. I don’t think the VisIt forum will be able to answer a problem with using the Nek5000 reader in ParaView.

I don’t know anything about the Nek5000 reader. It might be helpful if you can provide an example file that is not working.

Indeed, I read too fast.

@laylafoura : Could you try with the latest binary version of ParaView downloaded from here : https://www.paraview.org/download/

Best Scientific 3D Visualization Libraries

This posts reviews the best four open-source libraries for three-dimensional scientific visualization, ranging from massive standalone applications to interactive tools which can be user from within Python or Julia.

Scientific visualization of large 3D datasets is a complex task for which specialized software libraries have been developed for quite some time.

Unlike other areas of CAD or CAE, 3D visualization software has mostly been open-source since the beginning. In particular, all libraries reviewed in this post offer permissive licenses which allow commercial use.

Importantly, there are two kinds of tools we can rely on.

On one hand, we have large standalone applications like Paraview or VisIt , which are very powerful but can have a step learning curve. With these tools there are few to no limitations on what can be accomplished, including visualizations of extremely massive datasets using sophisticated algorithms. While these tools offer support for scripting, the most usual workflow is to use them to open a file for post-processing.

On the other hand, there are smaller software projects more strongly associated with programming languages such as Python or Julia, which focus on easy and seamless use from within the language. As such, these tools can be easier to use, but have more limitations on the sizes of the datasets that can be managed, fewer built-in algorithms and supported data formats.

ParaView, developed by Kitware in alliance with Los Alamos and Sandia National Labs, among other partners, is perhaps the most well-known scientific visualization software suite. ParaView relies on the Visualization Tool Kit (VTK), also developed by Kitware, to provide the visualization building blocks, and the data processing model.

It is best suited for post-processing data arising from large numerical simulations. For this, it supports the most complex visualizations of massive datasets via distributed processing.

Paraview includes a graphical user interface and a Python shell. A related tool, ParaViewWeb , can be used to build interactive scientific visualization applications inside Web browsers.

Importantly, there is an open discourse forum to ask for help.

Image by Los Alamos National Laboratory.

Paraview Website .

Official Documentation

The VisIt software suite, developed at the Lawrence Livermore National Laboratory (LLNL), was first released in 2002, and offers a powerful suite of visualization functionalities, including parallel processing, support for multiple scientific data formats, and Python scripting.

As with Paraview, VisIt also leverages VTK for the basic building blocks, as well as Python scripting. At the same time, specific efforts have been made in parallelization to extremely massive scales, incorporating support of non-standard data models. In particular, one of the salient points of VisIt is that it supports a very large number of input file formats (see reference ).

VisIt Website

Documentation at visitusers.org

Also based on VTK, MayaVi is a Python library for 3D visualization. It focuses on the creation of visualization scenes directly from Python, offering easy and seamless integration with other scientific libraries in the Python ecosystem.

One of the downsides is that it can be slow for very large datasets, as in particular it doesn’t support distributed processing.

Example from Mayavi documentation

MayaVi website

Makie is a relatively new project, based entirely on the Julia programming language. It can be used for simple 2D plots as well as complex 3D visualizations.

While it is not a standalone application, it contains the basic building blocks to create stunning 3D visualizations. Given that it is based on Julia, once precompiled it can be quite fast as well.

It can read any file format supported by Julia, and a custom script will be required to visualize the data.

Example from BeautifulMakie

Makie Website

Linux / amd64

ParaView is a powerful open-source data analysis and visualization tool that has been containerized for easy deployment. Equipped with advanced features such as NVIDIA IndeX and OptiX, it enables efficient analysis and visualization of large and complex datasets by utilizing parallel processing and distributed computing techniques. NVIDIA OptiX gives ParaView the power to render physically accurate lighting and material, enabling users to create high-quality visualizations, while the integration of NVIDIA IndeX allows for improved data indexing and querying, further enhancing the analysis capabilities of the application.

System requirements

Before running the NGC ParaView container please ensure your system meets the following requirements.

• nvidia-docker
• Singularity >= 3.1
• Pascal(sm60)
• Volta (sm70)
• Ampere (sm80)
• Hopper (sm90)
• >= r450 (>=.80.02)

The following examples demonstrate using the NGC ParaView container to render wavelet source using the latest ParaView image.

Running ParaView Server

To start the ParaView Server on one node with GPUs enabled, you can use the following command in the terminal:

To connect to the ParaView server using the command line, use the following command:

Note: Load all the plugins you plan to use on your local client before connecting to a server.

Using the OptiX Pathtracing Backend on ParaView Server

To enable the NVIDIA OptiX pathtracing backend and test it with some synthetic data, follow these steps:

• In the Properties window (lower-left by default, enabled in the View menu if it is missing), go to the View section > Ray Traced Rendering subsection and check Enable Ray Tracing .
• In the Ray Traced Rendering subsection, go to the Backend drop down menu and select OptiX pathtracer .
• Go to the Sources menu > Data Objects > Wavelet , then Properties > Apply .
• Right-click the Wavelet source and select Add Filter > Common > Contour , then Properties > Apply .
• You should now see a ray traced Wavelet source with proper illumination and shadows. Try enabling/disabling ray tracing a few times for comparison.

Running ParaViewWeb

The Visualizer Web application allows for a ParaView-like experience within a web browser. This is made possible through the ParaViewWeb library, which contains all the necessary components for building the user interface and facilitating data access via WebSocket connectivity to a ParaView server. The Visualizer application connects all of these components in a meaningful way.

Note: If you aren't using the latest ParaView image, be sure to update the directories in the command above.

Using the NVIDIA IndeX plugin on ParaViewWeb

To verify that IndeX is functioning properly, follow these steps to render a generated volume using the NVIDIA IndeX renderer:

• Create a Wavelet by clicking on the + sign and selecting Wavelet .
• Select the scalar(p1)RTData option by clicking on the droplet dropdown menu and choosing it (be sure to deselect Solid color ).
• Select the NVIDIA IndeX renderer by clicking on the eye dropdown menu and selecting it.
• Once NVIDIA IndeX initializes, the volume should be visible.
• Q: When creating a Wavelet, ParaView crashes with the following error:

If you're receiving this message, it means that the NVIDIA IndeX plugin has been loaded on the remote server but not locally. To resolve this issue, be sure to load the plugin on both the remote and local sides as specified above.

Suggested Reading

ParaView Superbuild Repository

Download ParaView

ParaView User's Guide