8.1 Post-processing commands

Alias View[expression];

Creates an alias of the expression-th post-processing view.

Note that Alias creates a logical duplicate of the view without actually duplicating the data in memory. This is very useful when you want multiple simultaneous renderings of the same large dataset (usually with different display options), but you cannot afford to store all copies in memory. If what you really want is multiple physical copies of the data, just merge the file containing the post-processing view multiple times.

AliasWithOptions View[expression];

Creates an alias of the expression-th post-processing view and copies all the options of the expression-th view to the new aliased view.

Combine ElementsByViewName;

Combines all the post-processing views having the same name into new views. The combination is done “spatially”, i.e., simply by appending the elements at the end of the new views.

Combine ElementsFromAllViews | Combine Views;

Combines all the post-processing views into a single new view. The combination is done “spatially”, i.e., simply by appending the elements at the end of the new view.

Combine ElementsFromVisibleViews;

Combines all the visible post-processing views into a single new view. The combination is done “spatially”, i.e., simply by appending the elements at the end of the new view.

Combine TimeStepsByViewName | Combine TimeSteps;

Combines the data from all the post-processing views having the same name into new multi-time-step views. The combination is done “temporally”, i.e., as if the data in each view corresponds to a different time instant. The combination will fail if the meshes in all the views are not identical.

Combine TimeStepsFromAllViews;

Combines the data from all the post-processing views into a new multi-time-step view. The combination is done “temporally”, i.e., as if the data in each view corresponds to a different time instant. The combination will fail if the meshes in all the views are not identical.

Combine TimeStepsFromVisibleViews;

Combines the data from all the visible post-processing views into a new multi-time-step view. The combination is done “temporally”, i.e., as if the data in each view corresponds to a different time instant. The combination will fail if the meshes in all the views are not identical.

Delete View[expression];

Deletes (removes) the expression-th post-processing view. Note that post-processing view numbers start at 0.

Delete Empty Views;

Deletes (removes) all the empty post-processing views.

Background Mesh View[expression];

Applies the expression-th post-processing view as the current background mesh. Note that post-processing view numbers start at 0.

Plugin (string) . Run;

Executes the plugin string. The list of default plugins is given in Post-processing plugins.

Plugin (string) . string = expression | char-expression;

Sets an option for a given plugin. See Post-processing plugins, for a list of default plugins and ‘t9.geo’, for some examples.

Save View[expression] char-expression;

Saves the the expression-th post-processing view in a file named char-expression. If the path in char-expression is not absolute, char-expression is appended to the path of the current file.

View "string" { string < ( expression-list ) > { expression-list }; … };

Creates a new post-processing view, named "string". This is an easy and quite powerful way to import post-processing data: all the values are expressions, you can embed datasets directly into your geometrical descriptions (see, e.g., ‘t4.geo’), the data can be easily generated “on-the-fly” (there is no header containing a priori information on the size of the dataset). The syntax is also very permissive, which makes it ideal for testing purposes.

However this “parsed format” is read by Gmsh's script parser, which makes it inefficient if there are many elements in the dataset. Also, there is no connectivity information in parsed views and all the elements are independent (all fields can be discontinuous), so a lot of information can be duplicated. For large datasets, you should thus use the mesh-based post-processing file format described in File formats, or use one of the standard formats like MED.

More explicitly, the syntax for a parsed View is the following

View "string" { type ( list-of-coords ) { list-of-values }; … < TIME { expression-list }; > < INTERPOLATION_SCHEME { val-coef-matrix } { val-exp-matrix } < { geo-coef-matrix } { geo-exp-matrix } > ; > };

where the 47 object types that can be displayed are:

type #list-of-coords #list-of-values -------------------------------------------------------------------- Scalar point SP 3 1 * nb-time-steps Vector point VP 3 3 * nb-time-steps Tensor point TP 3 9 * nb-time-steps Scalar line SL 6 2 * nb-time-steps Vector line VL 6 6 * nb-time-steps Tensor line TL 6 18 * nb-time-steps Scalar triangle ST 9 3 * nb-time-steps Vector triangle VT 9 9 * nb-time-steps Tensor triangle TT 9 27 * nb-time-steps Scalar quadrangle SQ 12 4 * nb-time-steps Vector quadrangle VQ 12 12 * nb-time-steps Tensor quadrangle TQ 12 36 * nb-time-steps Scalar tetrahedron SS 12 4 * nb-time-steps Vector tetrahedron VS 12 12 * nb-time-steps Tensor tetrahedron TS 12 36 * nb-time-steps Scalar hexahedron SH 24 8 * nb-time-steps Vector hexahedron VH 24 24 * nb-time-steps Tensor hexahedron TH 24 72 * nb-time-steps Scalar prism SI 18 6 * nb-time-steps Vector prism VI 18 18 * nb-time-steps Tensor prism TI 18 54 * nb-time-steps Scalar pyramid SY 15 5 * nb-time-steps Vector pyramid VY 15 15 * nb-time-steps Tensor pyramid TY 15 45 * nb-time-steps 2D text T2 3 arbitrary 3D text T3 4 arbitrary

The coordinates are given `by node', i.e.,

• (coord1, coord2, coord3) for a point,
• (coord1-node1, coord2-node1, coord3-node1,
coord1-node2, coord2-node2, coord3-node2) for a line,
• (coord1-node1, coord2-node1, coord3-node1,
coord1-node2, coord2-node2, coord3-node2,
coord1-node3, coord2-node3, coord3-node3) for a triangle,
• etc.

The ordering of the nodes is given in Node ordering.

The values are given by time step, by node and by component, i.e.:

comp1-node1-time1, comp2-node1-time1, comp3-node1-time1, comp1-node2-time1, comp2-node2-time1, comp3-node2-time1, comp1-node3-time1, comp2-node3-time1, comp3-node3-time1, comp1-node1-time2, comp2-node1-time2, comp3-node1-time2, comp1-node2-time2, comp2-node2-time2, comp3-node2-time2, comp1-node3-time2, comp2-node3-time2, comp3-node3-time2, …

For the 2D text objects, the two first expressions in list-of-coords give the X-Y position of the string in screen coordinates, measured from the top-left corner of the window. If the first (respectively second) expression is negative, the position is measured from the right (respectively bottom) edge of the window. If the value of the first (respectively second) expression is larger than 99999, the string is centered horizontally (respectively vertically). If the third expression is equal to zero, the text is aligned bottom-left and displayed using the default font and size. Otherwise, the third expression is converted into an integer whose eight lower bits give the font size, whose eight next bits select the font (the index corresponds to the position in the font menu in the GUI), and whose eight next bits define the text alignment (0=bottom-left, 1=bottom-center, 2=bottom-right, 3=top-left, 4=top-center, 5=top-right, 6=center-left, 7=center-center, 8=center-right).

For the 3D text objects, the three first expressions in list-of-coords give the XYZ position of the string in model (real world) coordinates. The fourth expression has the same meaning as the third expression in 2D text objects.

For both 2D and 3D text objects, the list-of-values can contain an arbitrary number of char-expressions.

The optional TIME list can contain a list of expressions giving the value of the time (or any other variable) for which an evolution was saved.

The optional INTERPOLATION_SCHEME lists can contain the interpolation matrices used for high-order adaptive visualization.

Let us assume that the approximation of the view's value over an element is written as a linear combination of d basis functions f[i], i=0, ..., d-1 (the coefficients being stored in list-of-values). Defining f[i] = Sum(j=0, ..., d-1) F[i][j] p[j], with p[j] = u^P[j][0] v^P[j][1] w^P[j][2] (u, v and w being the coordinates in the element's parameter space), then val-coef-matrix denotes the d x d matrix F and val-exp-matrix denotes the d x 3 matrix P.

In the same way, let us also assume that the coordinates x, y and z of the element are obtained through a geometrical mapping from parameter space as a linear combination of m basis functions g[i], i=0, ..., m-1 (the coefficients being stored in list-of-coords). Defining g[i] = Sum(j=0, ..., m-1) G[i][j] q[j], with q[j] = u^Q[j][0] v^Q[j][1] w^Q[j][2], then val-coef-matrix denotes the m x m matrix G and val-exp-matrix denotes the m x 3 matrix Q.

Here are for example the interpolation matrices for a first order quadrangle:

INTERPOLATION_SCHEME { {1/4,-1/4, 1/4,-1/4}, {1/4, 1/4,-1/4,-1/4}, {1/4, 1/4, 1/4, 1/4}, {1/4,-1/4,-1/4, 1/4} } { {0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0} };