1.1 Geometry: model entity creation

A model in Gmsh is defined using its Boundary Representation (BRep): a volume is bounded by a set of surfaces, a surface is bounded by a series of curves, and a curve is bounded by two end points. Model entities are topological entities, i.e., they only deal with adjacencies in the model, and are implemented as a set of abstract topological classes. This BRep is extended by the definition of embedded, or internal, model entities: internal points, edges and surfaces can be embedded in volumes; and internal points and curves can be embedded in surfaces.

The geometry of model entities can be provided by different CAD kernels. The two default kernels interfaced by Gmsh are the “Built-in” kernel and the “OpenCASCADE” kernel. Gmsh does not translate the geometrical representation from one kernel to another, or from these kernels to some neutral representation. Instead, Gmsh directly queries the native data for each CAD kernel, which avoids data loss and is crucial for complex models where translations invariably introduce issues linked to slightly different representations.

Gmsh’s scripting language and the Gmsh API allow to parametrize all model entities. The entities can either be built in a “bottom-up” manner (first points, then curves, surfaces and volumes) or in a “Constructive Solid Geometry” fashion (solids on which boolean operations are performed). Both methodologies can also be combined. Finally, groups of model entities (called “physical groups”) can be defined, based on the elementary geometric entities.

1.2 Mesh: finite element mesh generation

A finite element mesh of a model is a tessellation of its geometry by simple geometrical elements of various shapes (in Gmsh: lines, triangles, quadrangles, tetrahedra, prisms, hexahedra and pyramids), arranged in such a way that if two of them intersect, they do so along a face, an edge or a node, and never otherwise. This defines a so-called “conformal” mesh. Gmsh implements several algorithms to generate such meshes automatically. All the meshes produced by Gmsh are considered as “unstructured”, even if they were generated in a “structured” way (e.g., by extrusion). This implies that the mesh elements are completely defined simply by an ordered list of their nodes, and that no predefined ordering relation is assumed between any two elements.

In order to guarantee the conformity of the mesh, mesh generation is performed in a bottom-up flow: curves are discretized first; the mesh of the curves is then used to mesh the surfaces; then the mesh of the surfaces is used to mesh the volumes. In this process, the mesh of an entity is only constrained by the mesh of its boundary, unless entities of lower dimensions are explicitly embedded in entities of higher dimension. For example, in three dimensions, the triangles discretizing a surface will be forced to be faces of tetrahedra in the final 3D mesh only if the surface is part of the boundary of a volume, or if that surface has been explicitly embedded in the volume. This automatically ensures the conformity of the mesh when, for example, two volumes share a common surface. Every meshing step is constrained by a mesh “size field”, which prescribes the desired size of the elements in the mesh. This size field can be uniform, specified by values associated with points in the geometry, or defined by general “fields” (for example related to the distance to some boundary, to a arbitrary scalar field defined on another mesh, etc.): see Specifying mesh element sizes. For each meshing step, all structured mesh directives are executed first, and serve as additional constraints for the unstructured parts.

1.3 Solver: external solver interface

Gmsh implements a ONELAB (http://onelab.info) server to pilot external solvers (called “clients”). The ONELAB interface allows to call such clients and have them share parameters and modeling information. The implementation is based on a client-server model, with a server-side database and local or remote clients communicating in-memory or through TCP/IP sockets. Contrary to most solver interfaces, the ONELAB server has no a priori knowledge about any specifics (input file format, syntax, ...) of the clients. This is made possible by having any simulation preceded by an analysis phase, during which the clients are asked to upload their parameter set to the server. The issues of completeness and consistency of the parameter sets are completely dealt with on the client side: the role of ONELAB is limited to data centralization, modification and re-dispatching.

Examples on how to interface solvers are available in the source distribution (see utils/solvers). A full-featured solver interfaced in this manner is GetDP (https://getdp.info), a general finite elements solver using mixed finite elements.

Using the Gmsh API, Gmsh can also be embedded directly in your own solver, and ONELAB parameters can be used to interactively drive it. Examples on how to embed Gmsh in your solver, and build a custom graphical user interface to control it, are available in demos/api. See in particular custom_gui.py and custom_gui.cpp.

1.4 Post-processing: scalar, vector and tensor field visualization

Gmsh can load and manipulate multiple post-processing scalar, vector or tensor fields along with the geometry and the mesh. Such fields, together with visualization options, are called “post-processing views” (or simply “views”). Scalar views can be represented by iso-curves, iso-surfaces or color maps, while vector views can be represented by three-dimensional arrows or displacement maps. Post-processing functions include section computation, offset, elevation, boundary and component extraction, color map and range modification, animation, vector graphic output, etc. All the post-processing options can be accessed either interactively, through the input script files or through the API. Various operations on the post-processing data can also be performed through plugins (see Post-processing plugins).

1.5 What Gmsh is pretty good at …

Here is a tentative list of what Gmsh does best:

• quickly describe simple and/or “repetitive” geometries with the built-in scripting language, thanks to user-defined macros, loops, conditionals and includes (see User-defined macros, Loops and conditionals, and General commands). For more advanced geometries, using the Gmsh API (see Gmsh API) in the language of your choice (C++, C, Python or Julia) brings even greater flexibility, the only downside being that you need to either compile your code (for C++ and C) or to configure and install an interpreter (Python or Julia) in addition to Gmsh. A binary Software Development Kit (SDK) is distributed on the Gmsh web site to make the process easier;
• parametrize these geometries. Gmsh’s scripting language or the Gmsh API enable all commands and command arguments to depend on previous calculations (see Expressions, Geometry commands, and Gmsh API). Using the OpenCASCADE geometry kernel, Gmsh gives access to all usual constructive solid geometry operations;
• import geometries from other CAD software in standard exchange formats. Gmsh uses OpenCASCADE to import such files, including label and color information from STEP and IGES files;
• generate 1D, 2D and 3D simplicial (i.e., using line segments, triangles and tetrahedra) finite element meshes (see Mesh module), with fine control over the element size (see Specifying mesh element sizes);
• create simple extruded geometries and meshes (see Geometry commands, and Mesh commands), and allow to automatically couple such structured meshes with unstructured ones (using a layer of pyramids in 3D);
• generate high-order (curved) meshes that conform to the CAD model geometry. High-order mesh optimization tools allow to guarantee the validity of such curved meshes;
• interact with external solvers by defining ONELAB parameters, shared between Gmsh and the solvers and easily modifiable in the GUI (see Solver module);
• visualize and export computational results in a great variety of ways. Gmsh can display scalar, vector and tensor datasets, perform various operations on the resulting post-processing views (see Post-processing module), can export plots in many different formats (see General options list), and can generate complex animations (see General tools, and t8: Post-processing and animations);
• run on low end machines and/or machines with no graphical interface. Gmsh can be compiled with or without the GUI (see Compiling the source code), and all versions can be used either interactively or directly from the command line (see Running Gmsh on your system);
• configure your preferred options. Gmsh has a large number of configuration options that can be set interactively using the GUI, scattered inside script files, changed through the API, set in per-user configuration files and specified on the command-line (see Running Gmsh on your system and Options);
• and do all the above on various platforms (Windows, Mac and Unix), for free (see Copying conditions)!

1.6 … and what Gmsh is not so good at

Here are some known weaknesses of Gmsh:

• Gmsh is not a multi-bloc mesh generator: all meshes produced by Gmsh are conforming in the sense of finite element meshes;
• Gmsh’s user interface is only exposing a limited number of the available features, and many aspects of the interface could be enhanced (especially manipulators).
• Your complaints about Gmsh here :-)

If you have the skills and some free time, feel free to join the project: we gladly accept any code contributions (see Information for developers) to remedy the aforementioned (and all other) shortcomings!

1.7 Bug reports

Please file issues on https://gitlab.onelab.info/gmsh/gmsh/issues. Provide as precise a description of the problem as you can, including sample input files that produce the bug. Don’t forget to mention both the version of Gmsh and the version of your operation system (see Command-line options to see how to get this information).

See Frequently asked questions, and the bug tracking system to see which problems we already know about.

2.1 Syntactic rules used in the manual

Here are the rules we tried to follow when writing this reference manual. Note that metasyntactic variable definitions stay valid throughout the manual (and not only in the sections where the definitions appear).

1. Keywords and literal symbols are printed like this.
2. Metasyntactic variables (i.e., text bits that are not part of the syntax, but stand for other text bits) are printed like this.
3. A colon (:) after a metasyntactic variable separates the variable from its definition.
4. Optional rules are enclosed in < > pairs.
5. Multiple choices are separated by |.
6. Three dots (…) indicate a possible (multiple) repetition of the preceding rule.

3.1 Interactive mode

To launch Gmsh in interactive mode, just double-click on the Gmsh icon, or type

> gmsh

at your shell prompt in a terminal. This will open the main Gmsh window, with a tree-like menu on the left, a graphic area on the right, and a status bar at the bottom. (You can detach the tree menu using ‘Window->Attach/Detach Menu’.)

To open the first tutorial file (see Tutorial), select the ‘File->Open’ menu, and choose t1.geo. When using a terminal, you can specify the file name directly on the command line, i.e.:

> gmsh t1.geo

To perform the mesh generation, go to the mesh module (by selecting ‘Mesh’ in the tree) and choose the dimension (‘1D’ will mesh all the curves; ‘2D’ will mesh all the surfaces—as well as all the curves if ‘1D’ was not called before; ‘3D’ will mesh all the volumes—and all the surfaces if ‘2D’ was not called before). To save the resulting mesh in the current mesh format click on ‘Save’, or select the appropriate format and file name with the ‘File->Export’ menu. The default mesh file name is based on the name of the current active model, with an appended extension depending on the mesh format¹.

To create a new geometry or to modify an existing geometry, select ’Geometry’ in the tree. For example, to create a spline, select ‘Elementary entities’, ‘Add’, ‘New’ and ‘Spline’. You will then be asked to select a list of points, and to type e to finish the selection (or q to abort it). Once the interactive command is completed, a text string is automatically added at the end of the current script file. You can edit the script file by hand at any time by pressing the ‘Edit’ button in the ‘Geometry’ menu and then reloading the model by pressing ‘Reload’. For example, it is often faster to define variables and points directly in the script file, and then use the GUI to define the curves, the surfaces and the volumes interactively.

Several files can be loaded simultaneously in Gmsh. When specified on the command line, the first one defines the active model and the others are ‘merged’ into this model. You can merge such files with the ‘File->Merge’ menu. For example, to merge the post-processing views contained in the files view1.pos and view5.msh together with the geometry of the first tutorial t1: Geometry basics, elementary entities, physical groups, you can type the following command:

> gmsh t1.geo view1.pos view5.msh

In the Post-Processing module (select ‘Post-Processing’ in the tree), three items will appear, respectively labeled ‘A scalar map’, ‘Nodal scalar map’ and ‘Element 1 vector’. In this example the views contain several time steps: you can loop through them with the small “remote-control” icons in the status bar. A mouse click on the view name will toggle the visibility of the selected view, while a click on the arrow button on the right will provide access to the view’s options.

Note that all the options specified interactively can also be directly specified in the script files. You can save the current options of the current active model with the ‘File->Save Model Options’. This will create a new option file with the same filename as the active model, but with an extra .opt extension added. The next time you open this model, the associated options will be automatically loaded, too. To save the current options as your default preferences for all future Gmsh sessions, use the ‘File->Save Options As Default’ menu instead. Finally, you can also save the current options in an arbitrary file by choosing the ‘Gmsh options’ format in ‘File->Export’.

For more information about available options (and how to reset them to their default values), see Options. A full list of options with their current values is also available in the ‘Help->Current Options’ menu.

3.2 Non-interactive mode

Gmsh can be run non-interactively in ‘batch’ mode, without GUI². For example, to mesh the first tutorial in batch mode, just type:

> gmsh t1.geo -2

To mesh the same example, but with the background mesh available in the file bgmesh.pos, type:

> gmsh t1.geo -2 -bgm bgmesh.pos

For the list of all command-line options, see Command-line options. In particular, any complicated workflow can be written in a .geo file, and this file can be executed as a script using

> gmsh script.geo -

The script can contain e.g. meshing commands, like Mesh 3;.

3.3 Command-line options

(Related option names, if any, are given between parentheses)

Geometry:

-0 ¶

Output model, then exit

-tol value ¶

Set geometrical tolerance (Geometry.Tolerance)

-match ¶

Match geometries and meshes

Mesh:

-1, -2, -3 ¶

Perform 1D, 2D or 3D mesh generation, then exit

-save ¶

Save mesh, then exit

-o file ¶

Specify output file name

-format string ¶

Select output mesh format: auto, msh1, msh2, msh22, msh3, msh4, msh40, msh41, msh, unv, vtk, wrl, mail, stl, p3d, mesh, bdf, cgns, med, diff, ir3, inp, ply2, celum, su2, x3d, dat, neu, m, key (Mesh.Format)

-bin ¶

Create binary files when possible (Mesh.Binary)

-refine ¶

Perform uniform mesh refinement, then exit

-barycentric_refine ¶

Perform barycentric mesh refinement, then exit

-reclassify angle ¶

Reclassify surface mesh, then exit

-reparam angle ¶

Reparametrize surface mesh, then exit

-part int ¶

Partition after batch mesh generation (Mesh.NbPartitions)

-part_weight [tri,quad,tet,hex,pri,pyr,trih] int ¶

Weight of a triangle/quad/etc. during partitioning (Mesh.Partition[Tri,Quad,...]Weight)

-part_split ¶

Save mesh partitions in separate files (Mesh.PartitionSplitMeshFiles)

-part_[no_]topo ¶

Create the partition topology (Mesh.PartitionCreateTopology)

-part_[no_]ghosts ¶

Create ghost cells (Mesh.PartitionCreateGhostCells)

-part_[no_]physicals ¶

Create physical groups for partitions (Mesh.PartitionCreatePhysicals)

-part_topo_pro ¶

Save the partition topology .pro file (Mesh.PartitionTopologyFile)

-preserve_numbering_msh2 ¶

Preserve element numbering in MSH2 format (Mesh.PreserveNumberingMsh2)

-save_all ¶

Save all elements (Mesh.SaveAll)

-save_parametric ¶

Save nodes with their parametric coordinates (Mesh.SaveParametric)

-save_topology ¶

Save model topology (Mesh.SaveTopology)

-algo string ¶

Select mesh algorithm: auto, meshadapt, del2d, front2d, delquad, pack, initial2d, del3d, front3d, mmg3d, hxt, initial3d (Mesh.Algorithm and Mesh.Algorithm3D)

-smooth int ¶

Set number of mesh smoothing steps (Mesh.Smoothing)

-order int ¶

Set mesh order (Mesh.ElementOrder)

-optimize[_netgen] ¶

Optimize quality of tetrahedral elements (Mesh.Optimize[Netgen])

-optimize_threshold ¶

Optimize tetrahedral elements that have a quality less than a threshold (Mesh.OptimizeThreshold)

-optimize_ho ¶

Optimize high order meshes (Mesh.HighOrderOptimize)

-ho_[min,max,nlayers] ¶

High-order optimization parameters (Mesh.HighOrderThreshold[Min,Max], Mesh.HighOrderNumLayers)

-clscale value ¶

Set mesh element size factor (Mesh.MeshSizeFactor)

-clmin value ¶

Set minimum mesh element size (Mesh.MeshSizeMin)

-clmax value ¶

Set maximum mesh element size (Mesh.MeshSizeMax)

-clextend value ¶

Extend mesh element sizes from boundaries (Mesh.MeshSizeExtendFromBoundary)

-clcurv value ¶

Compute mesh element size from curvature, with value the target number of elements per 2*pi radians (Mesh.MeshSizeFromCurvature)

-aniso_max value ¶

Set maximum anisotropy for bamg (Mesh.AnisoMax)

-smooth_ratio value ¶

Set smoothing ration between mesh sizes at nodes of a same edge for bamg (Mesh.SmoothRatio)

-epslc1d value ¶

Set accuracy of evaluation of mesh size field for 1D mesh (Mesh.LcIntegrationPrecision)

-swapangle value ¶

Set the threshold angle (in degrees) between two adjacent faces below which a swap is allowed (Mesh.AllowSwapAngle)

-rand value ¶

Set random perturbation factor (Mesh.RandomFactor)

-bgm file ¶

Load background mesh from file

-check ¶

Perform various consistency checks on mesh

-ignore_periocity ¶

Ignore periodic boundaries (Mesh.IgnorePeriodicity)

Post-processing:

-link int ¶

Select link mode between views (PostProcessing.Link)

-combine ¶

Combine views having identical names into multi-time-step views

Solver:

-listen string ¶

Always listen to incoming connection requests (Solver.AlwaysListen) on the given socket (uses Solver.SocketName if not specified)

-minterpreter string ¶

Name of Octave interpreter (Solver.OctaveInterpreter)

-pyinterpreter string ¶

Name of Python interpreter (Solver.OctaveInterpreter)

-run ¶

Run ONELAB solver(s)

Display:

-n ¶

Hide all meshes and post-processing views on startup (View.Visible, Mesh.[Points,Lines,SurfaceEdges,...])

-nodb ¶

Disable double buffering (General.DoubleBuffer)

-numsubedges ¶

Set num of subdivisions for high order element display (Mesh.NumSubEdges)

-fontsize int ¶

Specify the font size for the GUI (General.FontSize)

-theme string ¶

Specify FLTK GUI theme (General.FltkTheme)

-display string ¶

Specify display (General.Display)

-camera ¶

Use camera mode view (General.CameraMode)

-stereo ¶

OpenGL quad-buffered stereo rendering (General.Stereo)

-gamepad ¶

Use gamepad controller if available

Other:

-, -parse_and_exit ¶

Parse input files, then exit

-new ¶

Create new model before merge next file

-merge ¶

Merge next files

-open ¶

Open next files

-log filename ¶

Log all messages to filename

-a, -g, -m, -s, -p ¶

Start in automatic, geometry, mesh, solver or post-processing mode (General.InitialModule)

-pid ¶

Print process id on stdout

-watch pattern ¶

Pattern of files to merge as they become available (General.WatchFilePattern)

-bg file ¶

Load background (image or PDF) file (General.BackgroundImageFileName)

-v int ¶

Set verbosity level (General.Verbosity)

-string "string" ¶

Parse command string at startup

-setnumber name value ¶

Set constant or option number name=value

-setstring name value ¶

Set constant or option string name=value

-nopopup ¶

Don’t popup dialog windows in scripts (General.NoPopup)

-noenv ¶

Don’t modify the environment at startup

-nolocale ¶

Don’t modify the locale at startup

-option file ¶

Parse option file at startup

-convert files ¶

Convert files into latest binary formats, then exit

-nt int ¶

Set number of threads (General.NumThreads)

-cpu ¶

Report CPU times for all operations

-version ¶

Show version number

-info ¶

Show detailed version information

-help ¶

Show command line usage

-help_options ¶

Show all options

3.4 Mouse actions

Move

Highlight the entity under the mouse pointer and display its properties / Resize a lasso zoom or a lasso (un)selection

Left button

Rotate / Select an entity / Accept a lasso zoom or a lasso selection

Ctrl+Left button

Start a lasso zoom or a lasso (un)selection

Middle button

Zoom / Unselect an entity / Accept a lasso zoom or a lasso unselection

Ctrl+Middle button

Orthogonalize display

Right button

Pan / Cancel a lasso zoom or a lasso (un)selection / Pop-up menu on post-processing view button

Ctrl+Right button

Reset to default viewpoint

For a 2 button mouse, Middle button = Shift+Left button.

For a 1 button mouse, Middle button = Shift+Left button, Right button = Alt+Left button.

3.5 Keyboard shortcuts

(On Mac Ctrl is replaced by Cmd (the ‘Apple key’) in the shortcuts below.)

Left arrow

Go to previous time step

Right arrow

Go to next time step

Up arrow

Make previous view visible

Down arrow

Make next view visible

0

Reload geometry

Ctrl+0 or 9

Reload full project

1 or F1

Mesh lines

2 or F2

Mesh surfaces

3 or F3

Mesh volumes

Escape

Cancel lasso zoom/selection, toggle mouse selection ON/OFF

e

End/accept selection in geometry creation mode

g

Go to geometry module

m

Go to mesh module

p

Go to post-processing module

q

Abort selection in geometry creation mode

s

Go to solver module

x

Toogle x coordinate freeze in geometry creation mode

y

Toogle y coordinate freeze in geometry creation mode

z

Toogle z coordinate freeze in geometry creation mode

Shift+a

Bring all windows to front

Shift+g

Show geometry options

Shift+m

Show mesh options

Shift+o

Show general options

Shift+p

Show post-processing options

Shift+s

Show solver options

Shift+u

Show post-processing view plugins

Shift+w

Show post-processing view options

Shift+x

Move only along x coordinate in geometry creation mode

Shift+y

Move only along y coordinate in geometry creation mode

Shift+z

Move only along z coordinate in geometry creation mode

Shift+Escape

Enable full mouse selection

Ctrl+d

Attach/detach menu

Ctrl+e

Export project

Ctrl+f

Enter full screen

Ctrl+i

Show statistics window

Ctrl+j

Save model options

Ctrl+l

Show message console

Ctrl+m

Minimize window

Ctrl+n

Create new project file

Ctrl+o

Open project file

Ctrl+q

Quit

Ctrl+r

Rename project file

Ctrl+s

Save mesh in default format

Shift+Ctrl+c

Show clipping plane window

Shift+Ctrl+h

Show current options and workspace window

Shift+Ctrl+j

Save options as default

Shift+Ctrl+m

Show manipulator window

Shift+Ctrl+n

Show option window

Shift+Ctrl+o

Merge file(s)

Shift+Ctrl+r

Open next-to-last opened file

Shift+Ctrl+u

Show plugin window

Shift+Ctrl+v

Show visibility window

Alt+a

Loop through axes modes

Alt+b

Hide/show bounding boxes

Alt+c

Loop through predefined color schemes

Alt+e

Hide/Show element outlines for visible post-pro views

Alt+f

Change redraw mode (fast/full)

Alt+h

Hide/show all post-processing views

Alt+i

Hide/show all post-processing view scales

Alt+l

Hide/show geometry lines

Alt+m

Toggle visibility of all mesh entities

Alt+n

Hide/show all post-processing view annotations

Alt+o

Change projection mode (orthographic/perspective)

Alt+p

Hide/show geometry points

Alt+r

Loop through range modes for visible post-pro views

Alt+s

Hide/show geometry surfaces

Alt+t

Loop through interval modes for visible post-pro views

Alt+v

Hide/show geometry volumes

Alt+w

Enable/disable all lighting

Alt+x

Set X view

Alt+y

Set Y view

Alt+z

Set Z view

Alt+1

Set 1:1 view

Alt+Shift+a

Hide/show small axes

Alt+Shift+b

Hide/show mesh volume faces

Alt+Shift+c

Loop through predefined colormaps

Alt+Shift+d

Hide/show mesh surface faces

Alt+Shift+l

Hide/show mesh lines

Alt+Shift+p

Hide/show mesh nodes

Alt+Shift+s

Hide/show mesh surface edges

Alt+Shift+t

Same as Alt+t, but with numeric mode included

Alt+Shift+v

Hide/show mesh volume edges

Alt+Shift+x

Set -X view

Alt+Shift+y

Set -Y view

Alt+Shift+z

Set -Z view

Alt+Shift+1

Reset bounding box around visible entities

Alt+Ctrl++1

Sync scale between viewports

4.1 Comments

Gmsh script files support both C and C++ style comments:

1. any text comprised between /* and */ pairs is ignored;
2. the rest of a line after a double slash // is ignored.

These commands won’t have the described effects inside double quotes or inside keywords. Also note that ‘white space’ (spaces, tabs, new line characters) is ignored inside all expressions.

4.2 Expressions

The two constant types used in Gmsh scripts are real and string (there is no integer type). These types have the same meaning and syntax as in the C or C++ programming languages.

• Floating point expressions
• Character expressions
• Color expressions

expression:
  real |
  string |
  string ~ { expression }
  string [ expression ] |
  # string [ ] |
  ( expression ) |
  operator-unary-left expression |
  expression operator-unary-right |
  expression operator-binary expression |
  expression operator-ternary-left expression
    operator-ternary-right expression |
  built-in-function |
  real-option |
  Find(expression-list-item, expression-list-item) |
  StrFind(char-expression, char-expression) |
  StrCmp(char-expression, char-expression) |
  StrLen(char-expression) |
  TextAttributes(char-expression<,char-expression…>) |
  Exists(string) | Exists(string~{ expression }) |
  FileExists(char-expression) |
  StringToName(char-expression) | S2N(char-expression) |
  GetNumber(char-expression <,expression>) |
  GetValue("string", expression) |
  DefineNumber(expression, onelab-options)

For i In {1:3}
  x~{i} = i;
EndFor

x_1 = 1;
x_2 = 2;
x_3 = 3;

expression-list:
  expression-list-item <, expression-list-item> …

expression-list-item:
  expression |
  expression : expression |
  expression : expression : expression |
  string [ ] |  string ( ) |
  List [ string ] |
  List [ expression-list-item ] |
  List [ { expression-list } ] |
  Unique [ expression-list-item ] |
  Abs [ expression-list-item ] |
  ListFromFile [ expression-char ] |
  LinSpace[ expression, expression, expression ] |
  LogSpace[ expression, expression, expression ] |
  string [ { expression-list } ] |
  Point { expression } |
  transform |
  extrude |
  boolean |
  Point|Curve|Surface|Volume In BoundingBox { expression-list } |
  BoundingBox Point|Curve|Surface|Volume { expression-list } |
  Mass Curve|Surface|Volume { expression } |
  CenterOfMass Curve|Surface|Volume { expression } |
  MatrixOfInertia Curve|Surface|Volume { expression } |
  Point { expression } |
  Physical Point|Curve|Surface|Volume { expression-list } |
  <Physical> Point|Curve|Surface|Volume { : } |

expression-list-or-all:
  expression-list | :

char-expression:
  "string" |
  string | string[ expression ] |
  Today | OnelabAction | GmshExecutableName |
  CurrentDirectory | CurrentDir | CurrentFileName
  StrPrefix ( char-expression ) |
  StrRelative ( char-expression ) |
  StrCat ( char-expression <,…> ) |
  Str ( char-expression <,…> ) |
  StrChoice ( expression, char-expression, char-expression ) |
  StrSub( char-expression, expression, expression ) |
  StrSub( char-expression, expression ) |
  UpperCase ( char-expression ) |
  AbsolutePath ( char-expression ) |
  DirName ( char-expression ) |
  Sprintf ( char-expression , expression-list ) |
  Sprintf ( char-expression ) |
  Sprintf ( char-option ) |
  GetEnv ( char-expression ) |
  GetString ( char-expression <,char-expression>) |
  GetStringValue ( char-expression , char-expression ) |
  StrReplace ( char-expression , char-expression , char-expression )
  NameToString ( string ) | N2S ( string ) |
  <Physical> Point|Curve|Surface|Volume { expression } |
  DefineString(char-expression, onelab-options)

char-expression-list:
  char-expression <,…>

color-expression:
  char-expression |
  { expression, expression, expression } |
  { expression, expression, expression, expression } |
  color-option

4.3 Operators

Gmsh’s operators are similar to the corresponding operators in C and C++. Here is the list of the unary, binary and ternary operators currently implemented.

operator-unary-left:

- ¶

Unary minus.

! ¶

Logical not.

operator-unary-right:

++ ¶

Post-incrementation.

-- ¶

Post-decrementation.

operator-binary:

^ ¶

Exponentiation.

* ¶

Multiplication.

/ ¶

Division.

% ¶

Modulo.

+ ¶

Addition.

- ¶

Subtraction.

== ¶

Equality.

!= ¶

Inequality.

> ¶

Greater.

>= ¶

Greater or equality.

< ¶

Less.

<= ¶

Less or equality.

&& ¶

Logical ‘and’.

|| ¶

Logical ‘or’. (Warning: the logical ‘or’ always implies the evaluation of both arguments. That is, unlike in C or C++, the second operand of || is evaluated even if the first one is true).

operator-ternary-left:

? ¶

operator-ternary-right:

: ¶

The only ternary operator, formed by operator-ternary-left and operator-ternary-right, returns the value of its second argument if the first argument is non-zero; otherwise it returns the value of its third argument.

The evaluation priorities are summarized below³ (from stronger to weaker, i.e., * has a highest evaluation priority than +). Parentheses () may be used anywhere to change the order of evaluation:

1. (), [], ., #
2. ^
3. !, ++, --, - (unary)
4. *, /, %
5. +, -
6. <, >, <=, >=
7. ==, !=
8. &&
9. ||
10. ?:
11. =, +=, -=, *=, /=

4.4 Built-in functions

A built-in function is composed of an identifier followed by a pair of parentheses containing an expression-list, the list of its arguments. This list of arguments can also be provided in between brackets, instead of parentheses. Here is the list of the built-in functions currently implemented:

build-in-function:

Acos ( expression ) ¶

Arc cosine (inverse cosine) of an expression in [-1,1]. Returns a value in [0,Pi].

Asin ( expression ) ¶

Arc sine (inverse sine) of an expression in [-1,1]. Returns a value in [-Pi/2,Pi/2].

Atan ( expression ) ¶

Arc tangent (inverse tangent) of expression. Returns a value in [-Pi/2,Pi/2].

Atan2 ( expression, expression ) ¶

Arc tangent (inverse tangent) of the first expression divided by the second. Returns a value in [-Pi,Pi].

Ceil ( expression ) ¶

Rounds expression up to the nearest integer.

Cos ( expression ) ¶

Cosine of expression.

Cosh ( expression ) ¶

Hyperbolic cosine of expression.

Exp ( expression ) ¶

Returns the value of e (the base of natural logarithms) raised to the power of expression.

Fabs ( expression ) ¶

Absolute value of expression.

Fmod ( expression, expression ) ¶

Remainder of the division of the first expression by the second, with the sign of the first.

Floor ( expression ) ¶

Rounds expression down to the nearest integer.

Hypot ( expression, expression ) ¶

Returns the square root of the sum of the square of its two arguments.

Log ( expression ) ¶

Natural logarithm of expression (expression > 0).

Log10 ( expression ) ¶

Base 10 logarithm of expression (expression > 0).

Max ( expression, expression ) ¶

Maximum of the two arguments.

Min ( expression, expression ) ¶

Minimum of the two arguments.

Modulo ( expression, expression ) ¶

see Fmod( expression, expression ).

Rand ( expression ) ¶

Random number between zero and expression.

Round ( expression ) ¶

Rounds expression to the nearest integer.

Sqrt ( expression ) ¶

Square root of expression (expression >= 0).

Sin ( expression ) ¶

Sine of expression.

Sinh ( expression ) ¶

Hyperbolic sine of expression.

Tan ( expression ) ¶

Tangent of expression.

Tanh ( expression ) ¶

Hyperbolic tangent of expression.

4.5 User-defined macros

User-defined macros take no arguments, and are evaluated as if a file containing the macro body was included at the location of the Call statement.

Macro string | char-expression ¶

Begins the declaration of a user-defined macro named string. The body of the macro starts on the line after ‘Macro string’, and can contain any Gmsh command. A synonym for Macro is Function.

Return ¶

Ends the body of the current user-defined macro. Macro declarations cannot be imbricated.

Call string | char-expression ; ¶

Executes the body of a (previously defined) macro named string.

See t5: Mesh sizes, macros, loops, holes in volumes, for an example of a user-defined macro. A shortcoming of Gmsh’s scripting language is that all variables are “public”. Variables defined inside the body of a macro will thus be available outside, too!

4.6 Loops and conditionals

Loops and conditionals are defined as follows, and can be imbricated:

For ( expression : expression ) ¶

Iterates from the value of the first expression to the value of the second expression, with a unit incrementation step. At each iteration, the commands comprised between ‘For ( expression : expression )’ and the matching EndFor are executed.

For ( expression : expression : expression ) ¶

Iterates from the value of the first expression to the value of the second expression, with a positive or negative incrementation step equal to the third expression. At each iteration, the commands comprised between ‘For ( expression : expression : expression )’ and the matching EndFor are executed.

For string In { expression : expression } ¶

Iterates from the value of the first expression to the value of the second expression, with a unit incrementation step. At each iteration, the value of the iterate is affected to an expression named string, and the commands comprised between ‘For string In { expression : expression }’ and the matching EndFor are executed.

For string In { expression : expression : expression } ¶

Iterates from the value of the first expression to the value of the second expression, with a positive or negative incrementation step equal to the third expression. At each iteration, the value of the iterate is affected to an expression named string, and the commands comprised between ‘For string In { expression : expression : expression }’ and the matching EndFor are executed.

EndFor ¶

Ends a matching For command.

If ( expression ) ¶

The body enclosed between ‘If ( expression )’ and the matching ElseIf, Else or EndIf, is evaluated if expression is non-zero.

ElseIf ( expression ) ¶

The body enclosed between ‘ElseIf ( expression )’ and the next matching ElseIf, Else or EndIf, is evaluated if expression is non-zero and none of the expression of the previous matching codes If and ElseIf were non-zero.

Else ¶

The body enclosed between Else and the matching EndIf is evaluated if none of the expression of the previous matching codes If and ElseIf were non-zero.

EndIf ¶

Ends a matching If command.

4.7 General commands

The following commands can be used anywhere in a Gmsh script:

string = expression; ¶

Creates a new expression identifier string, or affects expression to an existing expression identifier. The following expression identifiers are predefined (hardcoded in Gmsh’s parser):

Pi ¶

Returns 3.1415926535897932.

GMSH_MAJOR_VERSION ¶

Returns Gmsh’s major version number.

GMSH_MINOR_VERSION ¶

Returns Gmsh’s minor version number.

GMSH_PATCH_VERSION ¶

Returns Gmsh’s patch version number.

MPI_Size ¶

Returns the number of processors on which Gmsh is running. It is always 1, except if you compiled Gmsh with ENABLE_MPI (see Compiling the source code).

MPI_Rank ¶

Returns the rank of the current processor.

Cpu ¶

Returns the current CPU time (in seconds).

Memory ¶

Returns the current memory usage (in Mb).

TotalMemory ¶

Returns the total memory available (in Mb).

newp ¶

Returns the next available point tag. As explained in Geometry module, a unique tag must be associated with every geometrical point: newp permits to know the highest tag already attributed (plus one). This is mostly useful when writing user-defined macros (see User-defined macros) or general geometric primitives, when one does not know a priori which tags are already attributed, and which ones are still available.

newl ¶

Returns the next available curve tag.

news ¶

Returns the next available surface tag.

newv ¶

Returns the next available volume tag.

newll ¶

Returns the next available curve loop tag.

newsl ¶

Returns the next available surface loop tag.

newreg ¶

Returns the next available region tag. That is, newreg returns the maximum of newp, newl, news, newv, newll, newsl and all physical group tags⁴.

string = { }; ¶

Creates a new expression list identifier string with an empty list.

string[] = { expression-list }; ¶

Creates a new expression list identifier string with the list expression-list, or affects expression-list to an existing expression list identifier. Parentheses are also allowed instead of square brackets; although not recommended, brackets and parentheses can also be completely ommitted.

string [ { expression-list } ] = { expression-list }; ¶

Affects each item in the right hand side expression-list to the elements (indexed by the left hand side expression-list) of an existing expression list identifier. The two expression-lists must contain the same number of items. Parentheses can also be used instead of brackets.

string += expression; ¶

Adds and affects expression to an existing expression identifier.

string -= expression; ¶

Subtracts and affects expression to an existing expression identifier.

string *= expression; ¶

Multiplies and affects expression to an existing expression identifier.

string /= expression; ¶

Divides and affects expression to an existing expression identifier.

string += { expression-list }; ¶

Appends expression-list to an existing expression list or creates a new expression list with expression-list.

string -= { expression-list }; ¶

Removes the items in expression-list from the existing expression list.

string [ { expression-list } ] += { expression-list }; ¶

Adds and affects, item per item, the right hand side expression-list to an existing expression list identifier. Parentheses can also be used instead of brackets.

string [ { expression-list } ] -= { expression-list }; ¶

Subtracts and affects, item per item, the right hand side expression-list to an existing expression list identifier. Parentheses can also be used instead of brackets.

string [ { expression-list } ] *= { expression-list }; ¶

Multiplies and affects, item per item, the right hand side expression-list to an existing expression list identifier. Parentheses can also be used instead of brackets.

string [ { expression-list } ] /= { expression-list }; ¶

Divides and affects, item per item, the right hand side expression-list to an existing expression list identifier. Parentheses can also be used instead of brackets.

string = char-expression; ¶

Creates a new character expression identifier string with a given char-expression.

string[] = Str( char-expression-list ) ; ¶

Creates a new character expression list identifier string with a given char-expression-list. Parentheses can also be used instead of brackets.

string[] += Str( char-expression-list ) ; ¶

Appends a character expression list to an existing list. Parentheses can also be used instead of brackets.

DefineConstant[ string = expression|char-expression <, ...>]; ¶

Creates a new expression identifier string, with value expression, only if has not been defined before.

DefineConstant[ string = { expression|char-expression, onelab-options } <, ...>]; ¶

Same as the previous case, except that the variable is also exchanged with the ONELAB database if it has not been defined before. See the ONELAB tutorial wiki for more information.

SetNumber( char-expression , expression ); ¶

Sets the value a numeric ONELAB variable char-expression.

SetString( char-expression , char-expression ); ¶

Sets the value a string ONELAB variable char-expression.

real-option = expression; ¶

Affects expression to a real option.

char-option = char-expression; ¶

Affects char-expression to a character option.

color-option = color-expression; ¶

Affects color-expression to a color option.

real-option += expression; ¶

Adds and affects expression to a real option.

real-option -= expression; ¶

Subtracts and affects expression to a real option.

real-option *= expression; ¶

Multiplies and affects expression to a real option.

real-option /= expression; ¶

Divides and affects expression to a real option.

Abort; ¶

Aborts the current script.

Exit; ¶

Exits Gmsh.

CreateDir char-expression; ¶

Create the directory char-expression.

Printf ( char-expression <, expression-list> ); ¶

Prints a character expression in the information window and/or on the terminal. Printf is equivalent to the printf C function: char-expression is a format string that can contain formatting characters (%f, %e, etc.). Note that all expressions are evaluated as floating point values in Gmsh (see Expressions), so that only valid floating point formatting characters make sense in char-expression. See t5: Mesh sizes, macros, loops, holes in volumes, for an example of the use of Printf.

Printf ( char-expression , expression-list ) > char-expression; ¶

Same as Printf above, but output the expression in a file.

Printf ( char-expression , expression-list ) >> char-expression; ¶

Same as Printf above, but appends the expression at the end of the file.

Warning|Error ( char-expression <, expression-list> ); ¶

Same as Printf, but raises a warning or an error.

Merge char-expression; ¶

Merges a file named char-expression. This command is equivalent to the ‘File->Merge’ menu in the GUI. If the path in char-expression is not absolute, char-expression is appended to the path of the current file. This operation triggers a synchronization of the CAD model with the internal Gmsh model.

ShapeFromFile( char-expression ); ¶

Merges a BREP, STEP or IGES file and returns the tags of the highest-dimensional entities. Only available with the OpenCASCADE geometry kernel.

Draw; ¶

Redraws the scene.

SplitCurrentWindowHorizontal expression; ¶

Splits the current window horizontally, with the ratio given by expression.

SplitCurrentWindowVertical expression; ¶

Splits the current window vertically, with the ratio given by expression.

SetCurrentWindow expression; ¶

Sets the current window by speficying its index (starting at 0) in the list of all windows. When new windows are created by splits, new windows are appended at the end of the list.

UnsplitWindow; ¶

Restore a single window.

SetChanged; ¶

Force the mesh and post-processing vertex arrays to be regenerated. Useful e.g. for creating animations with changing clipping planes, etc.

BoundingBox; ¶

Recomputes the bounding box of the scene (which is normally computed only after new model entities are added or after files are included or merged). The bounding box is computed as follows:

1. If there is a mesh (i.e., at least one mesh node), the bounding box is taken as the box enclosing all the mesh nodes;
2. If there is no mesh but there is a geometry (i.e., at least one geometrical point), the bounding box is taken as the box enclosing all the geometrical points;
3. If there is no mesh and no geometry, but there are some post-processing views, the bounding box is taken as the box enclosing all the primitives in the views.

This operation triggers a synchronization of the CAD model with the internal Gmsh model.

BoundingBox { expression, expression, expression, expression, expression, expression }; ¶

Forces the bounding box of the scene to the given expressions (X min, X max, Y min, Y max, Z min, Z max). Beware that order of the coordinates is different than in the BoundingBox commands for model entities: see Floating point expressions.

Delete Model; ¶

Deletes the current model (all model entities and their associated meshes).

Delete Physicals; ¶

Deletes all physical groups.

Delete Variables; ¶

Deletes all the expressions.

Delete Options; ¶

Deletes the current options and revert to the default values.

Delete string; ¶

Deletes the expression string.

Print char-expression; ¶

Prints the graphic window in a file named char-expression, using the current Print.Format (see General options list). If the path in char-expression is not absolute, char-expression is appended to the path of the current file. This operation triggers a synchronization of the CAD model with the internal Gmsh model.

Sleep expression; ¶

Suspends the execution of Gmsh during expression seconds.

SystemCall char-expression; ¶

Executes a (blocking) system call.

NonBlockingSystemCall char-expression; ¶

Executes a (non-blocking) system call.

OnelabRun ( char-expression <, char-expression > ) ¶

Runs a ONELAB client (first argument is the client name, second optional arguement is the command line).

SetName char-expression; ¶

Changes the name of the current model.

SetFactory(char-expression); ¶

Changes the current geometry kernel (i.e. determines the CAD kernel that is used for all subsequent geometrical commands). Currently available kernels: "Built-in" and "OpenCASCADE".

SyncModel; ¶

Forces an immediate transfer from the old geometrical database into the new one (this transfer normally occurs right after a file is read).

NewModel; ¶

Creates a new current model.

Include char-expression; ¶

Includes the file named char-expression at the current position in the input file. The include command should be given on a line of its own. If the path in char-expression is not absolute, char-expression is appended to the path of the current file.

4.8 General options

The list of all the general char-options, real-options and color-options (in that order—check the default values to see the actual types) is given in General options list. Most of these options are accessible in the GUI, but not all of them. When running Gmsh interactively, changing an option in the script file will modify the option in the GUI in real time. This permits for example to resize the graphical window in a script, or to interact with animations in the script and in the GUI at the same time.

5.1 Geometry commands

The next subsections describe all the available geometry commands in the scripting language. For the equivalent commands in the Gmsh API, see the gmsh/model/geo and gmsh/model/occ namespaces in Gmsh API.

Note that the following general syntax rule is followed for the definition of model entities: “If an expression defines a new entity, it is enclosed between parentheses. If an expression refers to a previously defined entity, it is enclosed between braces.”

• Points
• Curves
• Surfaces
• Volumes
• Extrusions
• Boolean operations
• Transformations
• Miscellaneous

extrude-list:
  <Physical> Point | Curve | Surface { expression-list-or-all }; …

  Point(1) = {0,0,0};
  Point(2) = {1,0,0};
  Line(1) = {1, 2};
  out[] = Extrude{0,1,0}{ Curve{1}; };
  Printf("top curve = %g", out[0]);
  Printf("surface = %g", out[1]);
  Printf("side curves = %g and %g", out[2], out[3]);

boolean-list:
  <Physical> Curve | Surface | Volume { expression-list-or-all }; … |
  Delete ;

transform-list:
  <Physical> Point | Curve | Surface | Volume
    { expression-list-or-all }; … |
  Duplicata { <Physical> Point | Curve | Surface | Volume
    { expression-list-or-all }; … } |
  transform

5.2 Geometry options

The list of all the options that control the behavior of geometry commands, as well as the way model entities are handled in the GUI, is given in Geometry options list.

6.1 Choosing the right unstructured algorithm

Gmsh provides a choice between several 2D and 3D unstructured algorithms. Each algorithm has its own advantages and disadvantages.

For all 2D unstructured algorithms a Delaunay mesh that contains all the points of the 1D mesh is initially constructed using a divide-and-conquer algorithm⁵. Missing edges are recovered using edge swaps⁶. After this initial step several algorithms can be applied to generate the final mesh:

• The “MeshAdapt” algorithm⁷ is based on local mesh modifications. This technique makes use of edge swaps, splits, and collapses: long edges are split, short edges are collapsed, and edges are swapped if a better geometrical configuration is obtained.
• The “Delaunay” algorithm is inspired by the work of the GAMMA team at INRIA⁸. New points are inserted sequentially at the circumcenter of the element that has the largest adimensional circumradius. The mesh is then reconnected using an anisotropic Delaunay criterion.
• The “Frontal-Delaunay” algorithm is inspired by the work of S. Rebay⁹.
• Other experimental algorithms with specific features are also available. In particular, “Frontal-Delaunay for Quads”¹⁰ is a variant of the “Frontal-Delaunay” algorithm aiming at generating right-angle triangles suitable for recombination; and “BAMG”¹¹ allows to generate anisotropic triangulations.

For very complex curved surfaces the “MeshAdapt” algorithm is the most robust. When high element quality is important, the “Frontal-Delaunay” algorithm should be tried. For very large meshes of plane surfaces the “Delaunay” algorithm is the fastest; it usually also handles complex mesh size fields better than the “Frontal-Delaunay”. When the “Delaunay” or “Frontal-Delaunay” algorithms fail, “MeshAdapt” is automatically triggered. The “Automatic” algorithm uses “Delaunay” for plane surfaces and “MeshAdapt” for all other surfaces.

Several 3D unstructured algorithms are also available:

• The “Delaunay” algorithm is split into three separate steps. First, an initial mesh of the union of all the volumes in the model is performed, without inserting points in the volume. The surface mesh is then recovered using H. Si’s boundary recovery algorithm Tetgen/BR. Then a three-dimensional version of the 2D Delaunay algorithm described above is applied to insert points in the volume to respect the mesh size constraints.
• The “Frontal” algorithm uses J. Schoeberl’s Netgen algorithm ¹².
• The “HXT” algorithm¹³ is a new efficient and parallel reimplementaton of the Delaunay algorithm.
• Other experimental algorithms with specific features are also available. In particular, “MMG3D”¹⁴ allows to generate anisotropic tetrahedralizations.

The “Delaunay” algorithm is currently the most robust and is the only one that supports the automatic generation of hybrid meshes with pyramids. Embedded model entities and the Field mechanism to specify element sizes (see Specifying mesh element sizes) are currently only supported by the “Delaunay” and “HXT” algorithms.

If your version of Gmsh is compiled with OpenMP support (see Compiling the source code), most of the meshing steps can be performed in parallel:

• 1D and 2D meshing is parallelized using a coarse-grained approach, i.e. curves (resp. surfaces) are each meshed sequentially, but several curves (resp. surfaces) can be meshed at the same time.
• 3D meshing using HXT is parallelized using a fine-grained approach, i.e. the actual meshing procedure for a single volume is done is parallel.

The number of threads can be controlled with the -nt flag on the command line (see Command-line options), or with the General.NumThreads, Mesh.MaxNumThreads1D, Mesh.MaxNumThreads2D and Mesh.MaxNumThreads3D options (see General options list and Mesh options list).

6.2 Elementary entities vs. physical groups

It is usually convenient to combine elementary geometrical entities into more meaningful groups, e.g. to define some mathematical (“domain”, “boundary with Neumann condition”), functional (“left wing”, “fuselage”) or material (“steel”, “carbon”) properties. Such grouping is done in Gmsh’s geometry module (see Geometry module) through “physical groups”.

By default in the MSH file format and in most other formats (see File formats), if physical groups are defined, the output mesh only contains those elements that belong to at least one physical group. (Different mesh file formats treat physical groups in slightly different ways, depending on their capability to define groups.)

To save all mesh elements wether or not physical groups are defined, use the Mesh.SaveAll option (see Mesh options list) or specify -save_all on the command line. In some formats (e.g. MSH2), setting Mesh.SaveAll=1 will however discard all physical group definitions.

6.3 Mesh commands

The mesh module commands allow to modify the mesh element sizes and specify structured grid parameters. Certain mesh “actions” (i.e., “mesh the curves”, “mesh the surfaces” and “mesh the volumes”) can also be specified in the script files but are usually performed either in the GUI or on the command line (see Running Gmsh on your system, and Command-line options).

In the Gmsh API, the mesh commands are available in the gmsh/model/mesh module (see Gmsh API).

• Specifying mesh element sizes
• Structured grids
• Miscellaneous

Mesh.MeshSizeFromPoints = 0;
Mesh.MeshSizeFromCurvature = 0;
Mesh.MeshSizeExtendFromBoundary = 0;

6.4 Mesh options

The list of all the options that control the behavior of mesh commands, as well as the way meshes are displayed in the GUI, is given in Mesh options list.

8.1 Post-processing commands

This section describes the post-processing commands availanble in the scripting language. For the equivalent commands in the Gmsh API, see the gmsh/view module in Gmsh API.

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.

CopyOptions View[expression, expression]; ¶

Copy all the options from the first expression-th post-processing view to the second one.

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 indices 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 indices 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: Plugins, for some examples.

Save View[expression] char-expression; ¶

Saves 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.

SendToServer View[expression] char-expression; ¶

Sends the expression-th post-processing view to the ONELAB server, with parameter name char-expression.

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: Built-in functions, holes in surfaces, annotations, entity colors), 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. If the char-expression starts with file://, the remainder of the string is interpreted as the name of an image file, and the image is displayed instead of the string. A format string in the form @wxh or @wxh,wx,wy,wz,hx,hy,hz, where w and h are the width and height (in model coordinates for T3 or in pixels for T2) of the image, wx,wy,wz is the direction of the bottom edge of the image and hx,hy,hz is the direction of the left edge of the image.

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 geo-coef-matrix denotes the m x m matrix G and geo-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}
};

8.2 Post-processing plugins

Post-processing plugins permit to extend the functionality of Gmsh’s post-processing module. The difference between regular post-processing options (see Post-processing options list) and post-processing plugins is that regular post-processing options only change the way the data is displayed, while post-processing plugins either create new post-processing views, or modify the data stored in a view (in a destructive, non-reversible way).

Plugins are available in the GUI by right-clicking on a view button (or by clicking on the black arrow next to the view button) and then selecting the ‘Plugin’ submenu. In the API, plugins are available in the gmsh/plugin module (see Gmsh API).

Here is the list of the plugins that are shipped by default with Gmsh:

Plugin(AnalyseMeshQuality) ¶

Plugin(AnalyseMeshQuality) analyses the quality of the elements of a given dimension in the current model. Depending on the input parameters it computes the minimum of the Jacobian determinant (J), the IGE quality measure (Inverse Gradient Error) and/or the ICN quality measure (Condition Number). Statistics are printed and, if requested, a model-based post-processing view is created for each quality measure. The plugin can optionally hide elements by comparing the measure to a prescribed threshold.

J is faster to compute but gives information only on element validity while the other measures also give information on element quality. The IGE measure is related to the error on the gradient of the finite element solution. It is the scaled Jacobian for quads and hexes and a new measure for triangles and tetrahedra. The ICN measure is related to the condition number of the stiffness matrix. (See the article "Efficient computation of the minimum of shape quality measures on curvilinear finite elements" for details.)

Parameters:

- ‘JacobianDeterminant’: compute J?

- ‘IGEMeasure’: compute IGE?

- ‘ICNMeasure’: compute ICN?

- ‘HidingThreshold’: hide all elements for which min(mu) is strictly greater than (if ‘ThresholdGreater’ == 1) or less than (if ‘ThresholdGreater’ == 0) the threshold, where mu is ICN if ‘ICNMeasure’ == 1, IGE if ‘IGEMeasure’ == 1 or min(J)/max(J) if ‘JacobianDeterminant’ == 1.

- ‘CreateView’: create a model-based view of min(J)/max(J), min(IGE) and/or min(ICN)?

- ‘Recompute’: force recomputation (set to 1 if the mesh has changed).

- ‘DimensionOfElements’: analyse elements of the given dimension if equal to 1, 2 or 3; analyse 2D and 3D elements if equal to 4; or analyse elements of the highest dimension if equal to -1. Numeric options:

JacobianDeterminant

Default value: 0

IGEMeasure

Default value: 0

ICNMeasure

Default value: 0

HidingThreshold

Default value: 99

ThresholdGreater

Default value: 1

CreateView

Default value: 0

Recompute

Default value: 0

DimensionOfElements

Default value: -1

Plugin(Annotate) ¶

Plugin(Annotate) adds the text string ‘Text’, in font ‘Font’ and size ‘FontSize’, in the view ‘View’. The string is aligned according to ‘Align’.

If ‘ThreeD’ is equal to 1, the plugin inserts the string in model coordinates at the position (‘X’,‘Y’,‘Z’). If ‘ThreeD’ is equal to 0, the plugin inserts the string in screen coordinates at the position (‘X’,‘Y’).

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Annotate) is executed in-place for list-based datasets or creates a new list-based view for other datasets. String options:

Text

Default value: "My Text"

Font

Default value: "Helvetica"

Align

Default value: "Left"

Numeric options:

X

Default value: 50

Y

Default value: 30

Z

Default value: 0

ThreeD

Default value: 0

FontSize

Default value: 14

View

Default value: -1

Plugin(BoundaryAngles) ¶

Plugin(BoundaryAngles) computes the (interior) angles between the line elements on the boundary of all surfaces. The angles, computed modulo 2*Pi, are stored in a new post-processing view, one for each surface. The plugin currently only works for planar surfaces.Available options:- Visible (1=True, 0 = False, Default = 1): Visibility of the Views in the GUI - Save (1=True, 0 = False, Default = 0): Save the Views on disk ?- Remove (1=True, 0 = False, Default = 0): Remove the View from the memory after execution?- Filename (Default = ’Angles_Surface’): Root name for the Views (in case of save / Visibility)- Dir (Default = ”): Output directory (possibly nested) String options:

Filename

Default value: "Angles_Surface"

Dir

Default value: ""

Numeric options:

View

Default value: -1

Save

Default value: 0

Visible

Default value: 0

Remove

Default value: 0

Plugin(Bubbles) ¶

Plugin(Bubbles) constructs a geometry consisting of ‘bubbles’ inscribed in the Voronoi of an input triangulation. ‘ShrinkFactor’ allows to change the size of the bubbles. The plugin expects a triangulation in the ‘z = 0’ plane to exist in the current model.

Plugin(Bubbles) creates one ‘.geo’ file. String options:

OutputFile

Default value: "bubbles.geo"

Numeric options:

ShrinkFactor

Default value: 0

Plugin(Crack) ¶

Plugin(Crack) creates a crack around the physical group ‘PhysicalGroup’ of dimension ‘Dimension’ (1 or 2), embedded in a mesh of dimension ‘Dimension’ + 1. The plugin duplicates the nodes and the elements on the crack and stores them in a new discrete curve (‘Dimension’ = 1) or surface (‘Dimension’ = 2). The elements touching the crack on the “negative” side are modified to use the newly generated nodes.If ‘OpenBoundaryPhysicalGroup’ is given (> 0), its nodes are duplicated and the crack will be left open on that (part of the) boundary. Otherwise, the lips of the crack are sealed, i.e., its nodes are not duplicated. For 1D cracks, ‘NormalX’, ‘NormalY’ and ‘NormalZ’ provide the reference normal of the surface in which the crack is supposed to be embedded. Numeric options:

Dimension

Default value: 1

PhysicalGroup

Default value: 1

OpenBoundaryPhysicalGroup

Default value: 0

NormalX

Default value: 0

NormalY

Default value: 0

NormalZ

Default value: 1

Plugin(Curl) ¶

Plugin(Curl) computes the curl of the field in the view ‘View’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Curl) creates one new list-based view. Numeric options:

View

Default value: -1

Plugin(CurvedBndDist) ¶

Plugin(CurvedBndDist) ...

Plugin(CutBox) ¶

Plugin(CutBox) cuts the view ‘View’ with a rectangular box defined by the 4 points (‘X0’,‘Y0’,‘Z0’) (origin), (‘X1’,‘Y1’,‘Z1’) (axis of U), (‘X2’,‘Y2’,‘Z2’) (axis of V) and (‘X3’,‘Y3’,‘Z3’) (axis of W).

The number of points along U, V, W is set with the options ‘NumPointsU’, ‘NumPointsV’ and ‘NumPointsW’.

If ‘ConnectPoints’ is zero, the plugin creates points; otherwise, the plugin generates hexahedra, quadrangles, lines or points depending on the values of ‘NumPointsU’, ‘NumPointsV’ and ‘NumPointsW’.

If ‘Boundary’ is zero, the plugin interpolates the view inside the box; otherwise the plugin interpolates the view at its boundary.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(CutBox) creates one new list-based view. Numeric options:

X0

Default value: 0

Y0

Default value: 0

Z0

Default value: 0

X1

Default value: 1

Y1

Default value: 0

Z1

Default value: 0

X2

Default value: 0

Y2

Default value: 1

Z2

Default value: 0

X3

Default value: 0

Y3

Default value: 0

Z3

Default value: 1

NumPointsU

Default value: 20

NumPointsV

Default value: 20

NumPointsW

Default value: 20

ConnectPoints

Default value: 1

Boundary

Default value: 1

View

Default value: -1

Plugin(CutGrid) ¶

Plugin(CutGrid) cuts the view ‘View’ with a rectangular grid defined by the 3 points (‘X0’,‘Y0’,‘Z0’) (origin), (‘X1’,‘Y1’,‘Z1’) (axis of U) and (‘X2’,‘Y2’,‘Z2’) (axis of V).

The number of points along U and V is set with the options ‘NumPointsU’ and ‘NumPointsV’.

If ‘ConnectPoints’ is zero, the plugin creates points; otherwise, the plugin generates quadrangles, lines or points depending on the values of ‘NumPointsU’ and ‘NumPointsV’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(CutGrid) creates one new list-based view. Numeric options:

X0

Default value: 0

Y0

Default value: 0

Z0

Default value: 0

X1

Default value: 1

Y1

Default value: 0

Z1

Default value: 0

X2

Default value: 0

Y2

Default value: 1

Z2

Default value: 0

NumPointsU

Default value: 20

NumPointsV

Default value: 20

ConnectPoints

Default value: 1

View

Default value: -1

Plugin(CutMesh) ¶

Plugin(CutMesh) cuts the mesh of the current GModel with the zero value of the levelset defined with the view ’View’.Sub-elements are created in the new model (polygons in 2D and polyhedra in 3D) and border elements are created on the zero-levelset.

If ‘Split’ is nonzero, the plugin splits the meshalong the edges of the cut elements in the positive side.

If ’SaveTri’ is nonzero, the sub-elements are saved as simplices.

Plugin(CutMesh) creates one new GModel. Numeric options:

View

Default value: -1

Split

Default value: 0

SaveTri

Default value: 0

Plugin(CutParametric) ¶

Plugin(CutParametric) cuts the view ‘View’ with the parametric function (‘X’(u,v), ‘Y’(u,v), ‘Z’(u,v)), using ‘NumPointsU’ values of the parameter u in [‘MinU’, ‘MaxU’] and ‘NumPointsV’ values of the parameter v in [‘MinV’, ‘MaxV’].

If ‘ConnectPoints’ is set, the plugin creates surface or line elements; otherwise, the plugin generates points.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(CutParametric) creates one new list-based view. String options:

X

Default value: "2 * Cos(u) * Sin(v)"

Y

Default value: "4 * Sin(u) * Sin(v)"

Z

Default value: "0.1 + 0.5 * Cos(v)"

Numeric options:

MinU

Default value: 0

MaxU

Default value: 6.2832

NumPointsU

Default value: 180

MinV

Default value: 0

MaxV

Default value: 6.2832

NumPointsV

Default value: 180

ConnectPoints

Default value: 0

View

Default value: -1

Plugin(CutPlane) ¶

Plugin(CutPlane) cuts the view ‘View’ with the plane ‘A’*X + ‘B’*Y + ‘C’*Z + ‘D’ = 0.

If ‘ExtractVolume’ is nonzero, the plugin extracts the elements on one side of the plane (depending on the sign of ‘ExtractVolume’).

If ‘View’ < 0, the plugin is run on the current view.

Plugin(CutPlane) creates one new list-based view. Numeric options:

A

Default value: 1

B

Default value: 0

C

Default value: 0

D

Default value: -0.01

ExtractVolume

Default value: 0

RecurLevel

Default value: 4

TargetError

Default value: 0

View

Default value: -1

Plugin(CutSphere) ¶

Plugin(CutSphere) cuts the view ‘View’ with the sphere (X-‘Xc’)^2 + (Y-‘Yc’)^2 + (Z-‘Zc’)^2 = ‘R’^2.

If ‘ExtractVolume’ is nonzero, the plugin extracts the elements inside (if ‘ExtractVolume’ < 0) or outside (if ‘ExtractVolume’ > 0) the sphere.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(CutSphere) creates one new list-based view. Numeric options:

Xc

Default value: 0

Yc

Default value: 0

Zc

Default value: 0

R

Default value: 0.25

ExtractVolume

Default value: 0

RecurLevel

Default value: 4

TargetError

Default value: 0

View

Default value: -1

Plugin(DiscretizationError) ¶

Plugin(DiscretizationError) computes the error between the mesh and the geometry. It does so by supersampling the elements and computing the distance between the supersampled points dans their projection on the geometry. Numeric options:

SuperSamplingNodes

Default value: 10

Plugin(Distance) ¶

Plugin(Distance) computes distances to entities in a mesh.

If ‘PhysicalPoint’, ‘PhysicalLine’ and ‘PhysicalSurface’ are 0, the distance is computed to all the boundaries. Otherwise the distance is computed to the given physical group.

If ‘DistanceType’ is 0, the plugin computes the geometrical Euclidean distance using the naive O(N^2) algorithm. If ‘DistanceType’ > 0, the plugin computes an approximate distance by solving a PDE with a diffusion constant equal to ‘DistanceType’ time the maximum size of the bounding box of the mesh as in [Legrand et al. 2006].

Positive ‘MinScale’ and ‘MaxScale’ scale the distance function.

Plugin(Distance) creates one new list-based view. Numeric options:

PhysicalPoint

Default value: 0

PhysicalLine

Default value: 0

PhysicalSurface

Default value: 0

DistanceType

Default value: 0

MinScale

Default value: 0

MaxScale

Default value: 0

Plugin(Divergence) ¶

Plugin(Divergence) computes the divergence of the field in the view ‘View’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Divergence) creates one new list-based view. Numeric options:

View

Default value: -1

Plugin(Eigenvalues) ¶

Plugin(Eigenvalues) computes the three real eigenvalues of each tensor in the view ‘View’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Eigenvalues) creates three new list-based scalar views. Numeric options:

View

Default value: -1

Plugin(Eigenvectors) ¶

Plugin(Eigenvectors) computes the three (right) eigenvectors of each tensor in the view ‘View’ and sorts them according to the value of the associated eigenvalues.

If ‘ScaleByEigenvalues’ is set, each eigenvector is scaled by its associated eigenvalue. The plugin gives an error if the eigenvectors are complex.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Eigenvectors) creates three new list-based vector view. Numeric options:

ScaleByEigenvalues

Default value: 1

View

Default value: -1

Plugin(ExtractEdges) ¶

Plugin(ExtractEdges) extracts sharp edges from a triangular mesh.

Plugin(ExtractEdges) creates one new view. Numeric options:

Angle

Default value: 40

IncludeBoundary

Default value: 1

Plugin(ExtractElements) ¶

Plugin(ExtractElements) extracts some elements from the view ‘View’. If ‘MinVal’ != ‘MaxVal’, it extracts the elements whose ‘TimeStep’-th values (averaged by element) are comprised between ‘MinVal’ and ‘MaxVal’. If ‘Visible’ != 0, it extracts visible elements.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(ExtractElements) creates one new list-based view. Numeric options:

MinVal

Default value: 0

MaxVal

Default value: 0

TimeStep

Default value: 0

Visible

Default value: 1

Dimension

Default value: -1

View

Default value: -1

Plugin(FieldFromAmplitudePhase) ¶

Plugin(FieldFromAmplitudePhase) builds a complex field ’u’ from amplitude ’a’ (complex) and phase ’phi’ given in two different ’Views’ u = a * exp(k*phi), with k the wavenumber.

The result is to be interpolated in a sufficiently fine mesh: ’MeshFile’.

Plugin(FieldFromAmplitudePhase) generates one new view. String options:

MeshFile

Default value: "fine.msh"

Numeric options:

Wavenumber

Default value: 5

AmplitudeView

Default value: 0

PhaseView

Default value: 1

Plugin(GaussPoints) ¶

Given an input mesh, Plugin(GaussPoints) creates a list-based view containing the Gauss points for a given polynomial ‘Order’.

If ‘PhysicalGroup’ is nonzero, the plugin only creates points for the elements belonging to the group. Numeric options:

Order

Default value: 0

Dimension

Default value: 2

PhysicalGroup

Default value: 0

Plugin(Gradient) ¶

Plugin(Gradient) computes the gradient of the field in the view ‘View’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Gradient) creates one new list-based view. Numeric options:

View

Default value: -1

Plugin(HarmonicToTime) ¶

Plugin(HarmonicToTime) takes the values in the time steps ‘RealPart’ and ‘ImaginaryPart’ of the view ‘View’, and creates a new view containing

‘View’[‘RealPart’] * cos(p) +- ‘View’[‘ImaginaryPart’] * sin(p)
with
p = 2*Pi*k/‘NumSteps’, k = 0, ..., ‘NumSteps’-1
and ’NumSteps’ the total number of time steps
over ’NumPeriods’ periods at frequency ’Frequency’ [Hz].
The ’+’ sign is used if ‘TimeSign’>0, the ’-’ sign otherwise.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(HarmonicToTime) creates one new list-based view. Numeric options:

RealPart

Default value: 0

ImaginaryPart

Default value: 1

NumSteps

Default value: 20

TimeSign

Default value: -1

Frequency

Default value: 1

NumPeriods

Default value: 1

View

Default value: -1

Plugin(HomologyComputation) ¶

Plugin(HomologyComputation) computes representative chains of basis elements of (relative) homology and cohomology spaces.

Define physical groups in order to specify the computation domain and the relative subdomain. Otherwise the whole mesh is the domain and the relative subdomain is empty.

Plugin(HomologyComputation) creates new views, one for each basis element. The resulting basis chains of desired dimension together with the mesh are saved to the given file. String options:

DomainPhysicalGroups

Default value: ""

SubdomainPhysicalGroups

Default value: ""

ReductionImmunePhysicalGroups

Default value: ""

DimensionOfChainsToSave

Default value: "0, 1, 2, 3"

Filename

Default value: "homology.msh"

Numeric options:

ComputeHomology

Default value: 1

ComputeCohomology

Default value: 0

HomologyPhysicalGroupsBegin

Default value: -1

CohomologyPhysicalGroupsBegin

Default value: -1

CreatePostProcessingViews

Default value: 1

ReductionOmit

Default value: 1

ReductionCombine

Default value: 3

PostProcessSimplify

Default value: 1

ReductionHeuristic

Default value: 1

Plugin(HomologyPostProcessing) ¶

Plugin(HomologyPostProcessing) operates on representative basis chains of homology and cohomology spaces. Functionality:

1. (co)homology basis transformation:
’TransformationMatrix’: Integer matrix of the transformation.
’PhysicalGroupsOfOperatedChains’: (Co)chains of a (co)homology space basis to be transformed.
Results a new (co)chain basis that is an integer cobination of the given basis.

2. Make basis representations of a homology space and a cohomology space compatible:
’PhysicalGroupsOfOperatedChains’: Chains of a homology space basis.
’PhysicalGroupsOfOperatedChains2’: Cochains of a cohomology space basis.
Results a new basis for the homology space such that the incidence matrix of the new basis and the basis of the cohomology space is the identity matrix.

Options:
’PhysicalGroupsToTraceResults’: Trace the resulting (co)chains to the given physical groups.
’PhysicalGroupsToProjectResults’: Project the resulting (co)chains to the complement of the given physical groups.
’NameForResultChains’: Post-processing view name prefix for the results.
’ApplyBoundaryOperatorToResults’: Apply boundary operator to the resulting chains.

String options:

TransformationMatrix

Default value: "1, 0; 0, 1"

PhysicalGroupsOfOperatedChains

Default value: "1, 2"

PhysicalGroupsOfOperatedChains2

Default value: ""

PhysicalGroupsToTraceResults

Default value: ""

PhysicalGroupsToProjectResults

Default value: ""

NameForResultChains

Default value: "c"

Numeric options:

ApplyBoundaryOperatorToResults

Default value: 0

Plugin(Integrate) ¶

Plugin(Integrate) integrates a scalar field over all the elements of the view ‘View’ (if ‘Dimension’ < 0), or over all elements of the prescribed dimension (if ‘Dimension’ > 0). If the field is a vector field, the circulation/flux of the field over line/surface elements is calculated.

If ‘View’ < 0, the plugin is run on the current view.

If ‘OverTime’ = i > -1 , the plugin integrates the scalar view over time (using the trapezoidal rule) instead of over space, starting at step i. If ‘Visible’ = 1, the plugin only integrates over visible entities.

Plugin(Integrate) creates one new list-based view. Numeric options:

View

Default value: -1

OverTime

Default value: -1

Dimension

Default value: -1

Visible

Default value: 1

Plugin(Invisible) ¶

Plugin(Invisible) deletes (if ‘DeleteElements’ is set) or reverses (if ‘ReverseElements’ is set) all the invisible elements in the current model. Numeric options:

DeleteElements

Default value: 1

ReverseElements

Default value: 0

Plugin(Isosurface) ¶

Plugin(Isosurface) extracts the isosurface of value ‘Value’ from the view ‘View’, and draws the ‘OtherTimeStep’-th step of the view ‘OtherView’ on this isosurface.

If ‘ExtractVolume’ is nonzero, the plugin extracts the isovolume with values greater (if ‘ExtractVolume’ > 0) or smaller (if ‘ExtractVolume’ < 0) than the isosurface ‘Value’.

If ‘OtherTimeStep’ < 0, the plugin uses, for each time step in ‘View’, the corresponding time step in ‘OtherView’. If ‘OtherView’ < 0, the plugin uses ‘View’ as the value source.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Isosurface) creates as many list-based views as there are time steps in ‘View’. Numeric options:

Value

Default value: 0

ExtractVolume

Default value: 0

RecurLevel

Default value: 4

TargetError

Default value: 0

View

Default value: -1

OtherTimeStep

Default value: -1

OtherView

Default value: -1

Plugin(Lambda2) ¶

Plugin(Lambda2) computes the eigenvalues Lambda(1,2,3) of the tensor (S_ik S_kj + Om_ik Om_kj), where S_ij = 0.5 (ui,j + uj,i) and Om_ij = 0.5 (ui,j - uj,i) are respectively the symmetric and antisymmetric parts of the velocity gradient tensor.

Vortices are well represented by regions where Lambda(2) is negative.

If ‘View’ contains tensor elements, the plugin directly uses the tensors as the values of the velocity gradient tensor; if ‘View’ contains vector elements, the plugin uses them as the velocities from which to derive the velocity gradient tensor.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Lambda2) creates one new list-based view. Numeric options:

Eigenvalue

Default value: 2

View

Default value: -1

Plugin(LongitudeLatitude) ¶

Plugin(LongituteLatitude) projects the view ‘View’ in longitude-latitude.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(LongituteLatitude) is executed in place. Numeric options:

View

Default value: -1

Plugin(MakeSimplex) ¶

Plugin(MakeSimplex) decomposes all non-simplectic elements (quadrangles, prisms, hexahedra, pyramids) in the view ‘View’ into simplices (triangles, tetrahedra).

If ‘View’ < 0, the plugin is run on the current view.

Plugin(MakeSimplex) is executed in-place. Numeric options:

View

Default value: -1

Plugin(MathEval) ¶

Plugin(MathEval) creates a new view using data from the time step ‘TimeStep’ in the view ‘View’.

If only ‘Expression0’ is given (and ‘Expression1’, ..., ‘Expression8’ are all empty), the plugin creates a scalar view. If ‘Expression0’, ‘Expression1’ and/or ‘Expression2’ are given (and ‘Expression3’, ..., ‘Expression8’ are all empty) the plugin creates a vector view. Otherwise the plugin creates a tensor view.

In addition to the usual mathematical functions (Exp, Log, Sqrt, Sin, Cos, Fabs, etc.) and operators (+, -, *, /, ^), all expressions can contain:

- the symbols v0, v1, v2, ..., vn, which represent the n components in ‘View’;

- the symbols w0, w1, w2, ..., wn, which represent the n components of ‘OtherView’, at time step ‘OtherTimeStep’;

- the symbols x, y and z, which represent the three spatial coordinates.

If ‘TimeStep’ < 0, the plugin extracts data from all the time steps in the view.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(MathEval) creates one new view.If ‘PhysicalRegion’ < 0, the plugin is run on all physical regions.

Plugin(MathEval) creates one new list-based view. String options:

Expression0

Default value: "Sqrt(v0^2+v1^2+v2^2)"

Expression1

Default value: ""

Expression2

Default value: ""

Expression3

Default value: ""

Expression4

Default value: ""

Expression5

Default value: ""

Expression6

Default value: ""

Expression7

Default value: ""

Expression8

Default value: ""

Numeric options:

TimeStep

Default value: -1

View

Default value: -1

OtherTimeStep

Default value: -1

OtherView

Default value: -1

ForceInterpolation

Default value: 0

PhysicalRegion

Default value: -1

Plugin(MeshSizeFieldView) ¶

Plugin(MeshSizeFieldView) evaluates the mesh size field ‘MeshSizeField’ on specified ‘Component‘ (0 for scalar) of the post-processing view ‘View’. Numeric options:

MeshSizeField

Default value: 0

View

Default value: -1

Component

Default value: 0

Plugin(MeshSubEntities) ¶

Plugin(MeshSubEntities) creates mesh elements for the entities of dimension ‘OutputDimension’ (0 for vertices, 1 for edges, 2 for faces) of the ‘InputPhysicalGroup’ of dimension ‘InputDimension’. The plugin creates new elements belonging to ‘OutputPhysicalGroup’. Numeric options:

InputDimension

Default value: 1

InputPhysicalGroup

Default value: 1

OuputDimension

Default value: 0

OuputPhysicalGroup

Default value: 2000

Plugin(MeshVolume) ¶

Plugin(MeshVolume) computes the volume of the mesh.

Only the elements in the physical group ‘PhysicalGroup’ of dimension ‘Dimension’ are taken into account, unless ’PhysicalGroup’ is negative, in which case all the elements of the given ‘Dimension’ are considered. If ‘Dimension‘ is negative, all the elments are considered.

Plugin(MeshVolume) creates one new list-based view. Numeric options:

PhysicalGroup

Default value: -1

Dimension

Default value: 3

Plugin(MinMax) ¶

Plugin(MinMax) computes the min/max of a view.

If ‘View’ < 0, the plugin is run on the current view. If ‘OverTime’ = 1, the plugin calculates the min/max over space and time. If ‘Argument’ = 1, the plugin calculates the min/max and the argmin/argmax. If ‘Visible’ = 1, the plugin is only applied to visible entities.

Plugin(MinMax) creates two new list-based views. Numeric options:

View

Default value: -1

OverTime

Default value: 0

Argument

Default value: 0

Visible

Default value: 1

Plugin(ModifyComponents) ¶

Plugin(ModifyComponents) modifies the components of the ‘TimeStep’-th time step in the view ‘View’, using the expressions provided in ‘Expression0’, ..., ‘Expression8’. If an expression is empty, the corresponding component in the view is not modified.

The expressions can contain:

- the usual mathematical functions (Log, Sqrt, Sin, Cos, Fabs, ...) and operators (+, -, *, /, ^);

- the symbols x, y and z, to retrieve the coordinates of the current node;

- the symbols Time and TimeStep, to retrieve the current time and time step values;

- the symbols v0, v1, v2, ..., v8, to retrieve each component of the field in ‘View’ at the ‘TimeStep’-th time step;

- the symbols w0, w1, w2, ..., w8, to retrieve each component of the field in ‘OtherView’ at the ‘OtherTimeStep’-th time step. If ‘OtherView’ and ‘View’ are based on different spatial grids, or if their data types are different, ‘OtherView’ is interpolated onto ‘View’.

If ‘TimeStep’ < 0, the plugin automatically loops over all the time steps in ‘View’ and evaluates the expressions for each one.

If ‘OtherTimeStep’ < 0, the plugin uses ‘TimeStep’ instead.

If ‘View’ < 0, the plugin is run on the current view.

If ‘OtherView’ < 0, the plugin uses ‘View’ instead.

Plugin(ModifyComponents) is executed in-place. String options:

Expression0

Default value: "v0 * Sin(x)"

Expression1

Default value: ""

Expression2

Default value: ""

Expression3

Default value: ""

Expression4

Default value: ""

Expression5

Default value: ""

Expression6

Default value: ""

Expression7

Default value: ""

Expression8

Default value: ""

Numeric options:

TimeStep

Default value: -1

View

Default value: -1

OtherTimeStep

Default value: -1

OtherView

Default value: -1

ForceInterpolation

Default value: 0

Plugin(ModulusPhase) ¶

Plugin(ModulusPhase) interprets the time steps ‘realPart’ and ‘imaginaryPart’ in the view ‘View’ as the real and imaginary parts of a complex field and replaces them with their corresponding modulus and phase.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(ModulusPhase) is executed in-place. Numeric options:

RealPart

Default value: 0

ImaginaryPart

Default value: 1

View

Default value: -1

Plugin(NearToFarField) ¶

Plugin(NearToFarField) computes the far field pattern from the near electric E and magnetic H fields on a surface enclosing the radiating device (antenna).

Parameters: the wavenumber, the angular discretisation (phi in [0, 2*Pi] and theta in [0, Pi]) of the far field sphere and the indices of the views containing the complex-valued E and H fields. If ‘Normalize’ is set, the far field is normalized to 1. If ‘dB’ is set, the far field is computed in dB. If ‘NegativeTime’ is set, E and H are assumed to have exp(-iwt) time dependency; otherwise they are assume to have exp(+iwt) time dependency. If ‘MatlabOutputFile’ is given the raw far field data is also exported in Matlab format.

Plugin(NearToFarField) creates one new view. String options:

MatlabOutputFile

Default value: "farfield.m"

Numeric options:

Wavenumber

Default value: 1

PhiStart

Default value: 0

PhiEnd

Default value: 6.28319

NumPointsPhi

Default value: 60

ThetaStart

Default value: 0

ThetaEnd

Default value: 3.14159

NumPointsTheta

Default value: 30

EView

Default value: 0

HView

Default value: 1

Normalize

Default value: 1

dB

Default value: 1

NegativeTime

Default value: 0

RFar

Default value: 0

Plugin(NearestNeighbor) ¶

Plugin(NearestNeighbor) computes the distance from each point in ‘View’ to its nearest neighbor.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(NearestNeighbor) is executed in-place. Numeric options:

View

Default value: -1

Plugin(NewView) ¶

Plugin(NewView) creates a new model-based view from the current mesh, with ‘NumComp’ field components, set to value ‘Value’.

If ‘ViewTag’ is positive, force that tag for the created view. The view type is determined by ‘Type’ (NodeData or ElementData). In the case of an ElementData type, the view can be restricted to a specific physical group with a positive ‘PhysicalGroup’. String options:

Type

Default value: "NodeData"

Numeric options:

NumComp

Default value: 1

Value

Default value: 0

ViewTag

Default value: -1

PhysicalGroup

Default value: -1

Plugin(Particles) ¶

Plugin(Particles) computes the trajectory of particules in the force field given by the ‘TimeStep’-th time step of a vector view ‘View’.

The plugin takes as input a grid defined by the 3 points (‘X0’,‘Y0’,‘Z0’) (origin), (‘X1’,‘Y1’,‘Z1’) (axis of U) and (‘X2’,‘Y2’,‘Z2’) (axis of V).

The number of particles along U and V that are to be transported is set with the options ‘NumPointsU’ and ‘NumPointsV’. The equation

A2 * d^2X(t)/dt^2 + A1 * dX(t)/dt + A0 * X(t) = F

is then solved with the initial conditions X(t=0) chosen as the grid, dX/dt(t=0)=0, and with F interpolated from the vector view.

Time stepping is done using a Newmark scheme with step size ‘DT’ and ‘MaxIter’ maximum number of iterations.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Particles) creates one new list-based view containing multi-step vector points. Numeric options:

X0

Default value: 0

Y0

Default value: 0

Z0

Default value: 0

X1

Default value: 1

Y1

Default value: 0

Z1

Default value: 0

X2

Default value: 0

Y2

Default value: 1

Z2

Default value: 0

NumPointsU

Default value: 10

NumPointsV

Default value: 1

A2

Default value: 1

A1

Default value: 0

A0

Default value: 0

DT

Default value: 0.1

MaxIter

Default value: 100

TimeStep

Default value: 0

View

Default value: -1

Plugin(Probe) ¶

Plugin(Probe) gets the value of the view ‘View’ at the point (‘X’,‘Y’,‘Z’).

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Probe) creates one new view. Numeric options:

X

Default value: 0

Y

Default value: 0

Z

Default value: 0

View

Default value: -1

Plugin(Remove) ¶

Plugin(Remove) removes the marked items from the list-based view ‘View’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Remove) is executed in-place. Numeric options:

Text2D

Default value: 1

Text3D

Default value: 1

Points

Default value: 0

Lines

Default value: 0

Triangles

Default value: 0

Quadrangles

Default value: 0

Tetrahedra

Default value: 0

Hexahedra

Default value: 0

Prisms

Default value: 0

Pyramids

Default value: 0

Scalar

Default value: 1

Vector

Default value: 1

Tensor

Default value: 1

View

Default value: -1

Plugin(Scal2Tens) ¶

Plugin(Scal2Tens) converts some scalar fields into a tensor field. The number of components must be given (max. 9). The new view ’NameNewView’ contains the new tensor field. If the number of a view is -1, the value of the corresponding component is 0. String options:

NameNewView

Default value: "NewView"

Numeric options:

NumberOfComponents

Default value: 9

View0

Default value: -1

View1

Default value: -1

View2

Default value: -1

View3

Default value: -1

View4

Default value: -1

View5

Default value: -1

View6

Default value: -1

View7

Default value: -1

View8

Default value: -1

Plugin(Scal2Vec) ¶

Plugin(Scal2Vec) converts the scalar fields into a vectorial field. The new view ’NameNewView’ contains it. If the number of a view is -1, the value of the corresponding component of the vector field is 0. String options:

NameNewView

Default value: "NewView"

Numeric options:

ViewX

Default value: -1

ViewY

Default value: -1

ViewZ

Default value: -1

Plugin(ShowNeighborElements) ¶

Plugin(ShowNeighborElements) sets visible some elements and a layer of elements around them, the other being set invisible. Numeric options:

NumLayers

Default value: 1

Element1

Default value: 0

Element2

Default value: 0

Element3

Default value: 0

Element4

Default value: 0

Element5

Default value: 0

Plugin(SimplePartition) ¶

Plugin(SimplePartition) partitions the current mesh into ‘NumSlicesX’, ‘NumSlicesY’ and ‘NumSlicesZ’ slices along the X-, Y- and Z-axis, respectively. The distribtion of these slices is governed by ‘MappingX’, ‘MappingY’ and ‘MappingZ’, where ‘t’ is a normalized absissa along each direction. (Setting ‘MappingX’ to ‘t’ will thus lead to equidistant slices along the X-axis.)

The plugin creates the topology of the partitioned entities if ‘CreateTopology’ is set. String options:

MappingX

Default value: "t"

MappingY

Default value: "t"

MappingZ

Default value: "t"

Numeric options:

NumSlicesX

Default value: 4

NumSlicesY

Default value: 1

NumSlicesZ

Default value: 1

CreateTopology

Default value: 1

Plugin(Skin) ¶

Plugin(Skin) extracts the boundary (skin) of the current mesh (if ‘FromMesh’ = 1), or from the the view ‘View’ (in which case it creates a new view). If ‘View’ < 0 and ‘FromMesh’ = 0, the plugin is run on the current view.
If ‘Visible’ is set, the plugin only extracts the skin of visible entities. Numeric options:

Visible

Default value: 1

FromMesh

Default value: 0

View

Default value: -1

Plugin(Smooth) ¶

Plugin(Smooth) averages the values at the nodes of the view ‘View’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Smooth) is executed in-place. Numeric options:

View

Default value: -1

Plugin(SpanningTree) ¶

Plugin(SpanningTree) builds a tree spanning every vertex of a mesh and stores it directly in the model.
The tree is constructed by starting first on the curves, then on the surfaces and finally on the volumes.

Parameters
- PhysicalVolumes: list of the physical volumes upon which the tree must be built.
- PhysicalSurfaces: list of the physical surfaces upon which the tree must be built.
- PhysicalCurves: list of the physical curves upon which the tree must be built.
- OutputPhysical: physical tag of the generated tree (-1 will select a new tag automatically).

Note - Lists must be comma separated integers and spaces are ignored.
Remark - This plugin does not overwrite a physical group.Therefore, if an existing physical tag is used in OutputPhysical, the edges of the tree will be /added/ to the specified group. String options:

PhysicalVolumes

Default value: ""

PhysicalSurfaces

Default value: ""

PhysicalCurves

Default value: ""

Numeric options:

OutputPhysical

Default value: -1

Plugin(SphericalRaise) ¶

Plugin(SphericalRaise) transforms the coordinates of the elements in the view ‘View’ using the values associated with the ‘TimeStep’-th time step.

Instead of elevating the nodes along the X, Y and Z axes as with the View[‘View’].RaiseX, View[‘View’].RaiseY and View[‘View’].RaiseZ options, the raise is applied along the radius of a sphere centered at (‘Xc’, ‘Yc’, ‘Zc’).

To produce a standard radiation pattern, set ‘Offset’ to minus the radius of the sphere the original data lives on.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(SphericalRaise) is executed in-place. Numeric options:

Xc

Default value: 0

Yc

Default value: 0

Zc

Default value: 0

Raise

Default value: 1

Offset

Default value: 0

TimeStep

Default value: 0

View

Default value: -1

Plugin(StreamLines) ¶

Plugin(StreamLines) computes stream lines from the ‘TimeStep’-th time step of a vector view ‘View’ and optionally interpolates the scalar view ‘OtherView’ on the resulting stream lines.

The plugin takes as input a grid defined by the 3 points (‘X0’,‘Y0’,‘Z0’) (origin), (‘X1’,‘Y1’,‘Z1’) (axis of U) and (‘X2’,‘Y2’,‘Z2’) (axis of V).

The number of points along U and V that are to be transported is set with the options ‘NumPointsU’ and ‘NumPointsV’. The equation

dX(t)/dt = V(x,y,z)

is then solved with the initial condition X(t=0) chosen as the grid and with V(x,y,z) interpolated on the vector view.

The time stepping scheme is a RK44 with step size ‘DT’ and ‘MaxIter’ maximum number of iterations.

If ‘TimeStep’ < 0, the plugin tries to compute streamlines of the unsteady flow.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(StreamLines) creates one new list-based view. This view contains multi-step vector points if ‘OtherView’ < 0, or single-step scalar lines if ‘OtherView’ >= 0. Numeric options:

X0

Default value: 0

Y0

Default value: 0

Z0

Default value: 0

X1

Default value: 1

Y1

Default value: 0

Z1

Default value: 0

X2

Default value: 0

Y2

Default value: 1

Z2

Default value: 0

NumPointsU

Default value: 10

NumPointsV

Default value: 1

DT

Default value: 0.1

MaxIter

Default value: 100

TimeStep

Default value: 0

View

Default value: -1

OtherView

Default value: -1

Plugin(Summation) ¶

Plugin(Summation) sums every time steps of ’Reference View’ and (every) ’Other View X’and store the result in a new view.
If ’View 0’ < 0 then the current view is selected.
If ’View 1...8’ < 0 then this view is skipped.
Views can have diffrent number of time steps
Warning: the Plugin assume that every views sharethe same mesh and that meshes do not move between time steps! String options:

Resuling View Name

Default value: "default"

Numeric options:

View 0

Default value: -1

View 1

Default value: -1

View 2

Default value: -1

View 3

Default value: -1

View 4

Default value: -1

View 5

Default value: -1

View 6

Default value: -1

View 7

Default value: -1

Plugin(Tetrahedralize) ¶

Plugin(Tetrahedralize) tetrahedralizes the points in the view ‘View’.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Tetrahedralize) creates one new list-based view. Numeric options:

View

Default value: -1

Plugin(Transform) ¶

Plugin(Transform) transforms the homogeneous node coordinates (x,y,z,1) of the elements in the view ‘View’ by the matrix

[‘A11’ ‘A12’ ‘A13’ ‘Tx’]
[‘A21’ ‘A22’ ‘A23’ ‘Ty’]
[‘A31’ ‘A32’ ‘A33’ ‘Tz’].

If ‘SwapOrientation’ is set, the orientation of the elements is reversed.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Transform) is executed in-place. Numeric options:

A11

Default value: 1

A12

Default value: 0

A13

Default value: 0

A21

Default value: 0

A22

Default value: 1

A23

Default value: 0

A31

Default value: 0

A32

Default value: 0

A33

Default value: 1

Tx

Default value: 0

Ty

Default value: 0

Tz

Default value: 0

SwapOrientation

Default value: 0

View

Default value: -1

Plugin(Triangulate) ¶

Plugin(Triangulate) triangulates the points in the view ‘View’, assuming that all the points belong to a surface that can be projected one-to-one onto a plane. Algorithm selects the old (0) or new (1) meshing algorithm.

If ‘View’ < 0, the plugin is run on the current view.

Plugin(Triangulate) creates one new list-based view. Numeric options:

Algorithm

Default value: 1

View

Default value: -1

Plugin(VoroMetal) ¶

Plugin(VoroMetal) creates microstructures using Voronoi diagrams.

String options:

SeedsFile

Default value: "seeds.txt"

Numeric options:

ComputeBestSeeds

Default value: 0

ComputeMicrostructure

Default value: 1

Plugin(Warp) ¶

Plugin(Warp) transforms the elements in the view ‘View’ by adding to their node coordinates the vector field stored in the ‘TimeStep’-th time step of the view ‘OtherView’, scaled by ‘Factor’.

If ‘View’ < 0, the plugin is run on the current view.

If ‘OtherView’ < 0, the vector field is taken as the field of surface normals multiplied by the ‘TimeStep’ value in ‘View’. (The smoothing of the surface normals is controlled by the ‘SmoothingAngle’ parameter.)

Plugin(Warp) is executed in-place. Numeric options:

Factor

Default value: 1

TimeStep

Default value: 0

SmoothingAngle

Default value: 180

View

Default value: -1

OtherView

Default value: -1