Commandline examples

There are more examples in the pages describing each of the pgkyl commands and functions. For a brief set of examples we here consider the output of a two-stream instability Vlasov-Maxwell simulation.

List outputs

We can list the different kinds of files outputted by the simulation with the listoutputs command

pgkyl list

Notice that we used the abbreviation list instead of listoutputs; this is allowed and whenever convenient we will use abbreviations if the meaning is clear. This writes out a list of the unique filename stems of the files outputted by a simulation.

Obtain file information

Now suppose we wish to know more about one file in particular, say the electron initial condition. We can load the data set and probe it with the info command:

pgkyl two-stream_elc_0.bp info
Set  (default#0)
├─ Time: 0.000000e+00
├─ Frame: 0
├─ Number of components: 8
├─ Number of dimensions: 2
├─ Grid: (uniform)  ├─ Dim 0: Num. cells: 64; Lower: -6.283185e+00; Upper: 6.283185e+00
│  └─ Dim 1: Num. cells: 64; Lower: -6.000000e+00; Upper: 6.000000e+00
├─ Maximum: 3.804653e+00 at (31, 26) component 0
├─ Minimum: -6.239745e-01 at (31, 38) component 2
├─ DG info:
│  ├─ Polynomial Order: 2  └─ Basis Type: serendipity (modal)
├─ Created with Gkeyll:
│  ├─ Changeset: 82231b06678c+
│  └─ Build Date: Feb  7 2021 09:14:06

The output shows (in order):

  • Simulation time of this snapshot.

  • Frame number of this snapshot.

  • Number of degrees of freedom per cell (components). In this case 8 basis functions for the second order 2D Serendipity basis ([Arnold2011], see Modal basis functions for more details).

  • Number of dimensions (in this case 2 because it is a 1x1v simulation, 1D in position and 1D in velocity).

  • The grid resolution and extents.

  • The maximum value of the dataset (in this case largest DG coefficient).

  • The minimum value of the dataset (in this case smallest DG coefficient).

  • The polynomial order and type of basis.

  • The Gkeyll build used to produce this simulation.

Plotting (interpolated data or single coefficients)

In the case of DG data one is most frequently interested in plotting the actual function instead of its expansion (DG) coefficients. To do so we construct finite-volume-like dataset on a uniform mesh with higher resolution using the interpolate command. If we interpolate the same dataset (electron initial condition) as in the previous example and inspect it with info, we get

pgkyl two-stream_elc_0.bp interpolate info
Set  (default#0)
├─ Time: 0.000000e+00
├─ Frame: 0
├─ Number of components: 1
├─ Number of dimensions: 2
├─ Grid: (uniform)  ├─ Dim 0: Num. cells: 192; Lower: -6.283185e+00; Upper: 6.283185e+00
│  └─ Dim 1: Num. cells: 192; Lower: -6.000000e+00; Upper: 6.000000e+00
├─ Maximum: 1.970512e+00 at (96, 79)
├─ Minimum: -1.177877e-08 at (94, 60)
├─ DG info:
│  ├─ Polynomial Order: 2  └─ Basis Type: serendipity (modal)
├─ Created with Gkeyll:
│  ├─ Changeset: 82231b06678c+
│  └─ Build Date: Feb  7 2021 09:14:06

Note that now there is only one degree of freedom (component) per cell but there are 3X more cells; we have interpolated the function onto a finer mesh.

We can then plot the distribution function evaluated on this finer mesh with the plot command

pgkyl two-stream_elc_0.bp interp plot

Note the allowed abbreviation of interpolate to interp. This command produces the figure below:


In some cases one may also be interested in plotting single expansion coefficients. The most common use is to, for example, plot the cell-averaged value (which is the zeroth coefficient times a constant). We can select specific coefficients in all cells with the select and the -c flag. So, to plot the cell averaged electron distribution function (times a factor) we would use

pgkyl two-stream_elc_0.bp select -c0 plot

Which produces the figure below. Notice how the values are slightly different and the resolution is coarser than in the previous plot of interpolated data.


Plot data slices

The select command introduced in the previous example can also be used with the --z flag in order to select a data slice which we may subsequently plot. In the two stream instability example, the electron initial condition is clearly independent of position, so we can plot as a function of velocity space at \(x=-2.0\) with

pgkyl two-stream_elc_0.bp interp select --z0 -2. plot

producing the following plot


Postgkyl is currently limited to 1D and 2D plots, so in order to visualize datasets that have more than 3 dimensions one may need to select several slices at once. You can do that with multiple --z flags. For example, if we have a 2x2v simulation producing four-dimensional distribution functions, we can select a slice at \(v_x=0.\) and \(v_y=1.\) with --z2 0. --z3 1..

Create animations

Another useful operation is to load multiple datasets consisting of consecutive frames in a time-dependent simulation, plot them and stitch them together into a movie. This can be accomplished by the animate command. We first load all the frames containing the electron momentum densities in time (i.e. elc_M1i), then interpolate them onto a finer mesh, and put together all the frames with the animate command:

pgkyl "two-stream_elc_M1i_[0-9]*.bp" interp animate -x 'x' -y 'Momentum'

Here we are also using the -x and -y flags to the animate command in order to place labels in the figure. The product is the movie given below:

Of course, one can use command chaining to slice higher dimensional data prior to calling the animate command. For example, creating an animation of the distribution function along velocity-space at \(x=0\) would be accomplished with

pgkyl "two-stream_elc_[0-9]*.bp" interp sel --z0 0. animate

Here we have used the abbreviations interp and sel in favor of interpolate and select, respectively. Such command produces this animation:

Averaging and integrating

A common diagnostic need is to perform averages and integrations over a dimension or over time. In general averages can be performed either by using the ev command with the avg operation, or using the integrate and later dividing by the corresponding space/time segment (with the ev command).

We use the final electron distribution function (frame 100) as an example. Let’s first plot it in phase-space to get a sense of it:

pgkyl two-stream_elc_100.bp interp pl

Suppose we wish to average over the central region \(x\in[-2,2]\) where a velocity-space ‘hole’ forms. We can plot such \(x\) integral as follows

pgkyl two-stream_elc_100.bp interp sel --z0 -2.:2. ev 'f[0] 0 avg' pl

As mentioned above, we can also do this with the integrate command. We accomplish that with

pgkyl two-stream_elc_100.bp interp sel --z0 -2.:2. integrate 0 ev 'f[0] 4. /' pl

Another useful application of ev (with avg) and integrate is to average or integrate quantities over time. Consider the evolution of the electron distribution function along velocity space at \(x=0\) in the previous example. The action starts after the 60th frame approximately, so if we wish to time-average the distribution function at \(x=0\) we could use the ev command as follows:

pgkyl "two-stream_elc_[0-9]*.bp" activate -i '59:' interp sel --z0 0. collect ev 'f[0] 0 avg' pl

A different way to accomplish the same time average over frames 59-100 and dividing by the corresponding time period (\(\tau=50-29.5018=20.4982\)):

pgkyl "two-stream_elc_[0-9]*.bp" activate -i '59:' interp sel --z0 0. collect integrate 0 ev 'f[0] 20.4982 /' pl

To break this last approach down, the command does the following (in order):

  • Load all frames of the electron distribution function.

  • Activate only frames 59-100.

  • Interpolate each frame onto a finer mesh and slice at \(x=0\).

  • Collect all the slices into a single dataset. This produces a 2D dataset with time along the 0th dimension and velocity-space along the 1st dimension.

  • Use the integrate command to integrate along the 0th dimension (time).

  • Use ev to divide the time-integrated quantity by the appropriate time window.

  • Plot.

The product of either of these comands is shown below:


Plot differences between datasets

It is common to have to evaluate the difference between two datasets. These could be two frames from the same simulation, or two datasets from different simulations. There are also various ways to discern differences, and below we show how to plot them in a single figure or how to plot their actual difference.

Suppose we wish to see how the electron distribution function has changed along \(x\) between \(t=0\) (0th frame) and \(t=50\) (100th frame) at \(v_x=0\). We can plot both of these datasets as follows

pgkyl two-stream_elc_0.bp two-stream_elc_100.bp interp sel --z1 0. plot -f0 -x '$x$' -y '$f_e(x,v_x=0)$'

where we have specified the figure with -f0 so they are both plotted together, and we have used -x and -y to place labels. The plot produced is


Another alternative is to compute the actual difference of the two data sets with ev:

pgkyl two-stream_elc_0.bp two-stream_elc_100.bp interp sel --z1 0. ev 'f[1] f[0] -' pl

Note that these operations also work with 2D datasets. So we could’ve have taken the whole distribution function in phase space at \(t=0,50\), subtracted them and plot them with

pgkyl two-stream_elc_0.bp two-stream_elc_100.bp interp ev 'f[1] f[0] -' plot --diverging

which thanks to the --diverging flag, produces the following image:


Saving plots/animations to a file

Any of the figures above can be saved to a file by appending either --save, or --saveas followed by the desired filename. For example the diverging 2D colorplot in the previous section can be saved to a file with

pgkyl two-stream_elc_0.bp two-stream_elc_100.bp interp ev 'f[1] f[0] -' plot --diverging --saveas 'two-stream_elc_fr0m100.png'

Fileformats supported depend on matplotlib, but likely include .png, .pdf and .eps.

The animate command is also capable of saving animations to a file. It requires an ffmpeg installation, and once that is available we can create an animation described earlier as

pgkyl "two-stream_elc_[0-9]*.bp" interp sel --z0 0. animate --saveas 'two-stream_elc_z0eq0p0.mp4'

Extracting input file

In our commitment to reproducibility, Gkeyll output files store the Lua input file used to produce that data. This input file can be extracted using the extractinput command, as follows

pgkyl two-stream_elc_0.bp extractinput

By default, this commands simply prints the input file to screen. However, this could be easily piped into a new file with

pgkyl two-stream_elc_0.bp extractinput > newInputFile.lua



Arnold, D. N. and Awanou, G. “The serendipity family of finite elements.” Foundations of Computational Mathematics 11.3 (2011): 337-344.