4.4 Visualizing results

Among the postprocessors that can be selected in the input parameter file (see Sections 4.1 and ??) are some that can produce files in a format that can later be used to generate a graphical visualization of the solution variables $u,p$ and $T$ at select time steps, or of quantities derived from these variables (for the latter, see Section 6.3.9).

By default, the files that are generated are in VTU format, i.e., the XML-based, compressed format defined by the VTK library, see http://public.kitware.com/VTK/. This file format has become a broadly accepted pseudo-standard that many visualization program support, including two of the visualization programs used most widely in computational science: Visit (see https://visit.llnl.gov/) and ParaView (see http://www.paraview.org/). The VTU format has a number of advantages beyond being widely distributed:

• It allows for compression, keeping files relatively small even for sizeable computations.
• It is a structured XML format, allowing other programs to read it without too much trouble.
• It has a degree of support for parallel computations where every processor would only write that part of the data to a file that this processor in fact owns, avoiding the need to communicate all data to a single processor that then generates a single file. This requires a master file for each time step that then contains a reference to the individual files that together make up the output of a single time step. Unfortunately, there doesn’t appear to be a standard for these master records; however, both ParaView and Visit have defined a format that each of these programs understand and that requires placing a file with ending .pvtu or .visit into the same directory as the output files from each processor. Section 4.1 gives an example of what can be found in the output directory.

4.4.1 Visualization the graphical output using Visit

In the following, let us discuss the process of visualizing a 2d computation using Visit. The steps necessary for other visualization programs will obviously differ but are, in principle, similar.

To this end, let us consider a simulation of convection in a box-shaped, 2d region (see the “cookbooks” section, Section 5, and in particular Section 5.2.1 for the input file for this particular model). We can run the program with 4 processors using

Letting the program run for a while will result in several output files as discussed in Section 4.1 above.

In order to visualize one time step, follow these steps:¹⁴

(a)

(b)

(c)

Figure 3: Main window of Visit, illustrating the different steps of adding content to a visualization.

(a)

(b)

Figure 4: Display window of Visit, showing a single plot and one where different data is overlaid.

• Selecting input files: As mentioned above, in parallel computations we usually generate one output file per processor in each time step for which visualization data is produced (see, however, Section 4.4.3). To tell Visit which files together make up one time step, ASPECT creates a output/solution/solution-XXXXX.visit file in the output directory. To open it, start Visit, click on the “Open” button in the “Sources” area of its main window (see Fig. 3(a)) and select the file you want. Alternatively, you can also select files using the “File $>$ Open” menu item, or hit the corresponding keyboard short-cut. After adding an input source, the “Sources” area of the main window should list the selected file name. More easily, you can also just open output/solution.visit which references all output files for all time steps. If you open this, Visit will display a slider that allows you to select which time step you want to visualize, along with forward, backward, and play buttons that allow you to move between time steps.
• Selecting what to plot: ASPECT outputs all sorts of quantities that characterize the solution, such as temperature, pressure, velocity, and many others on demand (see Section ??). Once an input file has been opened, you will want to add graphical representations of some of this data to the still empty canvas. To this end, click on the “Add” button of the “Plots” area. The resulting menu provides a number of different kinds of plots. The most important for our purpose are: (i) “Pseudocolor” allows the visualization of a scalar field (e.g., temperature, pressure, density) by using a color field. (ii) “Vector” displays a vector-valued field (e.g., velocity) using arrows. (iii) “Mesh” displays the mesh. The “Contour”, “Streamline” and “Volume” options are also frequently useful, in particular in 3d.

  Let us choose the “Pseudocolor” item and select the temperature field as the quantity to plot. Your main window should now look as shown in Fig. 3(b). Then hit the “Draw” button to make Visit generate data for the selected plots. This will yield a picture such as shown in Fig. 4(a) in the display window of Visit.

• Overlaying data: Visit can overlay multiple plots in the same view. To this end, add another plot to the view using again the “Add” button to obtain the menu of possible plots, then the “Draw” button to actually draw things. For example, if we add velocity vectors and the mesh, the main window looks as in Fig. 3(c) and the main view as in Fig. 4(b).
• Adjusting how data is displayed: Without going into too much detail, if you double click onto the name of a plot in the “Plots” window, you get a dialog in which many of the properties of this plot can be adjusted. Further details can be changed by using “Operators” on a plot.
• Making the output prettier: As can be seen in Fig. 4, Visit by default puts a lot of clutter around the figure – the name of the user, the name of the input file, color bars, axes labels and ticks, etc. This may be useful to explore data in the beginning but does not yield good pictures for presentations or publications. To reduce the amount of information displayed, go to the “Controls $>$ Annotations” menu item to get a dialog in which all of these displays can be selectively switched on and off.
• Saving figures: To save a visualization into a file that can then be included into presentations and publications, go to the menu item “File $>$ Save window”. This will create successively numbered files in the directory from which Visit was started each time a view is saved. Things like the format used for these files can be chosen using the “File $>$ Set save options” menu item. We have found that one can often get better looking pictures by selecting the “Screenshot” method in this dialog.

More information on all of these topics can be found in the Visit documentation, see https://visit.llnl.gov/. We have also recorded video lectures demonstrating this process interactively at http://www.youtube.com/watch?v=3ChnUxqtt08 for Visit, and at http://www.youtube.com/watch?v=w-_65jufR-_bc for Paraview.

4.4.2 Visualizing statistical data

In addition to the graphical output discussed above, ASPECT produces a statistics file that collects information produced during each time step. For the remainder of this section, let us assume that we have run ASPECT with the input file discussed in Section 5.2.1, simulating convection in a box. After running ASPECT, you will find a file called statistics in the output directory that, at the time of writing this, looked like this: This file has a structure that looks (at the time of writing this section) like this:

In other words, it first lists what the individual columns mean with a hash mark at the beginning of the line and then has one line for each time step in which the individual columns list what has been explained above.¹⁵

This file is easy to visualize. For example, one can import it as a whitespace separated file into a spreadsheet such as Microsoft Excel or OpenOffice/LibreOffice Calc and then generate graphs of one column against another. Or, maybe simpler, there is a multitude of simple graphing programs that do not need the overhead of a full fledged spreadsheet engine and simply plot graphs. One that is particularly simple to use and available on every major platform is Gnuplot. It is extensively documented at http://www.gnuplot.info/.

Gnuplot is a command line program in which you enter commands that plot data or modify the way data is plotted. When you call it, you will first get a screen that looks like this:

At the prompt on the last line, you can then enter commands. Given the description of the individual columns given above, let us first try to plot the heat flux through boundary 2 (the bottom boundary of the box), i.e., column 19, as a function of time (column 2). This can be achieved using the following command:

The left panel of Fig. 5 shows what Gnuplot will display in its output window. There are many things one can configure in these plots (see the Gnuplot manual referenced above). For example, let us assume that we want to add labels to the $x$- and $y$-axes, use not just points but lines and points for the curves, restrict the time axis to the range $\left[0,0.2\right]$ and the heat flux axis to $\left[-10:10\right]$, plot not only the flux through the bottom but also through the top boundary (column 20) and finally add a key to the figure, then the following commands achieve this:

If a line gets too long, you can continue it by ending it in a backslash as above. This is rarely used on the command line but useful when writing the commands above into a script file, see below. We have done it here to get the entire command into the width of the page.

For those who are lazy, Gnuplot allows to abbreviate things in many different ways. For example, one can abbreviate most commands. Furthermore, one does not need to repeat the name of an input file if it is the same as the previous one in a plot command. Thus, instead of the commands above, the following abbreviated form would have achieved the same effect:

This is of course unreadable at first but becomes useful once you become more familiar with the commands offered by this program.

Once you have gotten the commands that create the plot you want right, you probably want to save it into a file. Gnuplot can write output in many different formats. For inclusion in publications, either eps or png are the most common. In the latter case, the commands to achieve this are

The last command will simply generate the same plot again but this time into the given file. The result is a graphics file similar to the one shown in Fig. 8 on page 147.

What makes Gnuplot so useful is that it doesn’t just allow entering all these commands at the prompt. Rather, one can write them all into a file, say plot-heatflux.gnuplot, and then, on the command line, call

to generate the heatflux.png file. This comes in handy if one wants to create the same plot for multiple simulations while playing with parameters of the physical setup. It is also a very useful tool if one wants to generate the same kind of plot again later with a different data set, for example when a reviewer requested additional computations to be made for a paper or if one realizes that one has forgotten or misspelled an axis label in a plot.¹⁶

Gnuplot has many many more features we have not even touched upon. For example, it is equally happy to produce three-dimensional graphics, and it also has statistics modules that can do things like curve fits, statistical regression, and many more operations on the data you provide in the columns of an input file. We will not try to cover them here but instead refer to the manual at http://www.gnuplot.info/. You can also get a good amount of information by typing help at the prompt, or a command like help plot to get help on the plot command.

4.4.3 Large data issues for parallel computations

Among the challenges in visualizing the results of parallel computations is dealing with the large amount of data. The first bottleneck this presents is during run-time when ASPECT wants to write the visualization data of a time step to disk. Using the compressed VTU format, ASPECT generates on the order of 10 bytes of output for each degree of freedom in 2d and more in 3d; thus, output of a single time step can run into the range of gigabytes that somehow have to get from compute nodes to disk. This stresses both the cluster interconnect as well as the data storage array.

There are essentially two strategies supported by ASPECT for this scenario:

• If your cluster has a fast interconnect, for example Infiniband, and if your cluster has a fast, distributed file system, then ASPECT can produce output files that are already located in the correct output directory (see the options in Section ??) on the global file system. ASPECT uses MPI I/O calls to this end, ensuring that the local machines do not have to access these files using slow NFS-mounted global file systems.
• If your cluster has a slow interconnect, e.g., if it is simply a collection of machines connected via Ethernet, then writing data to a central file server may block the rest of the program for a while. On the other hand, if your machines have fast local storage for temporary file systems, then ASPECT can write data first into such a file and then move it in the background to its final destination while already continuing computations. To select this mode, set the appropriate variables discussed in Section ??. Note, however, that this scheme only makes sense if every machine on which MPI processes run has fast local disk space for temporary storage.