L8+ v5.2.11 serial key or number

Table of Contents

Christophe Geuzaine and Jean-François Remacle

Gmsh is an automatic 3D finite element mesh generator with build-in pre- and post-processing facilities. This is the Gmsh Reference Manual for Gmsh (June 22, ).

Obtaining Gmsh

The source code and various pre-compiled versions of Gmsh (for Windows, Mac and Unix) can be downloaded from cromwellpsi.com Gmsh is also directly available in pre-packaged form in various Linux and BSD distributions (Debian, Ubuntu, FreeBSD, ).

If you use Gmsh, we would appreciate that you mention it in your work by citing the following paper: “C. Geuzaine and J.-F. Remacle, Gmsh: a three-dimensional finite element mesh generator with built-in pre- and post-processing facilities. International Journal for Numerical Methods in Engineering, Volume 79, Issue 11, pages , ”. A preprint of that paper as well as other references and the latest news about Gmsh development are available on cromwellpsi.com

Copying conditions

Gmsh is “free software”; this means that everyone is free to use it and to redistribute it on a free basis. Gmsh is not in the public domain; it is copyrighted and there are restrictions on its distribution, but these restrictions are designed to permit everything that a good cooperating citizen would want to do. What is not allowed is to try to prevent others from further sharing any version of Gmsh that they might get from you.

Specifically, we want to make sure that you have the right to give away copies of Gmsh, that you receive source code or else can get it if you want it, that you can change Gmsh or use pieces of Gmsh in new free programs, and that you know you can do these things.

To make sure that everyone has such rights, we have to forbid you to deprive anyone else of these rights. For example, if you distribute copies of Gmsh, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights.

Also, for our own protection, we must make certain that everyone finds out that there is no warranty for Gmsh. If Gmsh is modified by someone else and passed on, we want their recipients to know that what they have is not what we distributed, so that any problems introduced by others will not reflect on our reputation.

The precise conditions of the license for Gmsh are found in the General Public License that accompanies the source code (see License). Further information about this license is available from the GNU Project webpage cromwellpsi.com Detailed copyright information can be found in Copyright and credits.

If you want to integrate parts of Gmsh into a closed-source software, or want to sell a modified closed-source version of Gmsh, you will need to obtain a different license. Please contact us directly for more information.

1 Overview

Gmsh is a three-dimensional finite element mesh generator with a build-in CAD engine and post-processor. Its design goal is to provide a fast, light and user-friendly meshing tool with parametric input and advanced visualization capabilities.

Gmsh is built around four modules: geometry, mesh, solver and post-processing. All geometrical, mesh, solver and post-processing instructions are prescribed either interactively using the graphical user interface (GUI) or in text files using Gmsh’s own scripting language. Interactive actions generate language bits in the input files, and vice versa. A programming API is also available, for integrating Gmsh in your own C++, C, Python or Julia code: see Gmsh API. A brief description of the four modules is given hereafter.

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.

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 “size field” (also called “characteristic length 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.

Solver: external solver interface

Gmsh implements a ONELAB (cromwellpsi.com) 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 (cromwellpsi.com), 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_cromwellpsi.com and custom_cromwellpsi.com

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

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);
• 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)!

… 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!

Bug reports

Please file issues on cromwellpsi.com 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 How to read this reference manual?

Gmsh can be used at three levels:

1. as a stand-alone application manipulated through its graphical user interface (GUI);
2. as a stand-alone script-driven application;
3. as a library.

You can skip most of this reference manual if you only want to use Gmsh at the first level (i.e., interactively with the GUI). Just read the next chapter (see Running Gmsh on your system) to learn how to launch Gmsh on your system, then go experiment with the GUI and the tutorial files (see Tutorial) provided in the distribution. Screencasts that show how to use the GUI are available here: cromwellpsi.com

The aim of the reference manual is to explain everything you need to use Gmsh at the second level, i.e., using the built-in scripting language. A Gmsh script file is an ASCII text file that contains instructions in Gmsh’s built-in scripting language. Such a file is interpreted by Gmsh’s parser, and can be given any extension (or no extension at all). By convention, Gmsh uses the extension for geometry scripts, and the extension for parsed post-processing datasets. Once you master the tutorial (read the source files: they are heavily commented!), start reading chapter General tools, then proceed with the next four chapters, which detail the syntax of the geometry, mesh, solver and post-processing scripting commands. You will see that most of the interactive actions in the GUI have a direct equivalent in the scripting language. If you want to use Gmsh as a pre- or post-processor for your own software, you will also want to learn about the non-scripting input/output files that Gmsh can read/write. In addition to Gmsh’s native “MSH” file format (see File formats), Gmsh can read/write many standard mesh files, depending on how it was built: check the ‘File->Export’ menu for a list of available formats.

Finally, to use Gmsh at the third level (i.e., to link the Gmsh library with your own code), you will need to learn the Gmsh Application Programming Interface (API). This API is available in C++, C, Python and Julia, and is fully documented in Gmsh API.

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 .
2. Metasyntactic variables (i.e., text bits that are not part of the syntax, but stand for other text bits) are printed like .
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 Running Gmsh on your system

Interactive mode

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

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 cromwellpsi.com When using a terminal, you can specify the file name directly on the command line, i.e.:

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 to finish the selection (or 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 cromwellpsi.com and cromwellpsi.com together with the geometry of the first tutorial t1, you can type the following command:

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

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:

To mesh the same example, but with the background mesh available in the file cromwellpsi.com, type:

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

The script can contain e.g. meshing commands, like .

Command-line options

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

Geometry:

Output model, then exit

Set geometrical tolerance (cromwellpsi.comnce)

Match geometries and meshes

Mesh:

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

Save mesh, then exit

Specify output file name

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 (cromwellpsi.com)

Create binary files when possible (cromwellpsi.com)

Perform uniform mesh refinement, then exit

Perform barycentric mesh refinement, then exit

Reclassify surface mesh, then exit

Reparametrize surface mesh, then exit

Partition after batch mesh generation (cromwellpsi.comitions)

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

Save mesh partitions in separate files (cromwellpsi.comionSplitMeshFiles)

Create the partition topology (cromwellpsi.comionCreateTopology)

Create ghost cells (cromwellpsi.comionCreateGhostCells)

Create physical groups for partitions (cromwellpsi.comionCreatePhysicals)

Save the partition topology .pro file (cromwellpsi.comionTopologyFile)

Preserve element numbering in MSH2 format (cromwellpsi.comveNumberingMsh2)

Save all elements (cromwellpsi.coml)

Save nodes with their parametric coordinates (cromwellpsi.comrametric)

Save model topology (cromwellpsi.compology)

Select mesh algorithm: auto, meshadapt, del2d, front2d, delquad, pack, initial2d, del3d, front3d, mmg3d, hxt, initial3d (cromwellpsi.comthm and cromwellpsi.comthm3D)

Set number of mesh smoothing steps (cromwellpsi.coming)

Set mesh order (cromwellpsi.comtOrder)

Optimize quality of tetrahedral elements (cromwellpsi.comze[Netgen])

Optimize tetrahedral elements that have a quality less than a threshold (cromwellpsi.comzeThreshold)

Optimize high order meshes (cromwellpsi.comderOptimize)

High-order optimization parameters (cromwellpsi.comderThreshold[Min,Max], cromwellpsi.comderNumLayers)

Set mesh element size factor (cromwellpsi.comteristicLengthFactor)

Set minimum mesh element size (cromwellpsi.comteristicLengthMin)

Set maximum mesh element size (cromwellpsi.comteristicLengthMax)

Compute mesh element size from curvature, with given minimum number of elements per 2*pi radians (cromwellpsi.comteristicLengthFromCurvature and cromwellpsi.commElementsPerTwoPi)

Set maximum anisotropy for bamg (cromwellpsi.comax)

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

Set accuracy of evaluation of mesh size field for 1D mesh (cromwellpsi.comgrationPrecision)

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

Set random perturbation factor (cromwellpsi.comFactor)

Load background mesh from file

Perform various consistency checks on mesh

Ignore periodic boundaries (cromwellpsi.comPeriodicity)

Post-processing:

Select link mode between views (cromwellpsi.com)

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

Solver:

Always listen to incoming connection requests (cromwellpsi.comListen)

Name of Octave interpreter (cromwellpsi.comInterpreter)

Name of Python interpreter (cromwellpsi.comInterpreter)

Run ONELAB solver(s)

Display:

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

Disable double buffering (cromwellpsi.comBuffer)

Set num of subdivisions for high order element display (cromwellpsi.comEdges)

Specify the font size for the GUI (cromwellpsi.comze)

Specify FLTK GUI theme (cromwellpsi.comeme)

Specify display (cromwellpsi.comy)

Use camera mode view (cromwellpsi.comMode)

OpenGL quad-buffered stereo rendering (cromwellpsi.com)

Use gamepad controller if available

Other:

Parse input files, then exit

Create new model before merge next file

Merge next files

Open next files

Log all messages to filename

Start in automatic, geometry, mesh, solver or post-processing mode (cromwellpsi.comlModule)

Print process id on stdout

Pattern of files to merge as they become available (cromwellpsi.comilePattern)

Load background (image or PDF) file (cromwellpsi.comoundImageFileName)

Set verbosity level (cromwellpsi.comity)

Don’t popup dialog windows in scripts (cromwellpsi.comp)

Parse command string at startup

Set constant or option number name=value

Set constant or option string name=value

Parse option file at startup

Convert files into latest binary formats, then exit

Set number of threads (cromwellpsi.comeads)

Report CPU times for all operations

Show version number

Show detailed version information

Show command line usage

Show all options

Mouse actions

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

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

Start a lasso zoom or a lasso (un)selection

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

Orthogonalize display

Pan / Cancel a lasso zoom or a lasso (un)selection / Pop-up menu on post-processing view 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.

Keyboard shortcuts

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

Go to previous time step

Go to next time step

Make previous view visible

Make next view visible

Reload geometry

Reload full project

Mesh lines

Mesh surfaces

Mesh volumes

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

End/accept selection in geometry creation mode

Go to geometry module

Go to mesh module

Go to post-processing module

Abort selection in geometry creation mode

Go to solver module

Toogle x coordinate freeze in geometry creation mode

Toogle y coordinate freeze in geometry creation mode

Toogle z coordinate freeze in geometry creation mode

Bring all windows to front

Show geometry options

Show mesh options

Show general options

Show post-processing options

Show solver options

Show post-processing view plugins

Show post-processing view options

Move only along x coordinate in geometry creation mode

Move only along y coordinate in geometry creation mode

Move only along z coordinate in geometry creation mode

Enable full mouse selection

Attach/detach menu

Export project

Enter full screen

Show statistics window

Save model options

Show message console

Minimize window

Create new project file

Open project file

Quit

Rename project file

Save mesh in default format

Show clipping plane window

Show current options and workspace window

Save options as default

Show manipulator window

Show option window

Merge file(s)

Show plugin window

Show visibility window

Loop through axes modes

Hide/show bounding boxes

Loop through predefined color schemes

Hide/Show element outlines for visible post-pro views

Change redraw mode (fast/full)

Hide/show all post-processing views

Hide/show all post-processing view scales

Hide/show geometry lines

Toggle visibility of all mesh entities

Hide/show all post-processing view annotations

Change projection mode (orthographic/perspective)

Hide/show geometry points

Loop through range modes for visible post-pro views

Hide/show geometry surfaces

Loop through interval modes for visible post-pro views

Hide/show geometry volumes

Enable/disable all lighting

Set X view

Set Y view

Set Z view

Hide/show small axes

Hide/show mesh volume faces

Loop through predefined colormaps

Hide/show mesh surface faces

Hide/show mesh lines

Hide/show mesh points

Hide/show mesh surface edges

Same as Alt+t, but with numeric mode included

Hide/show mesh volume edges

Set -X view

Set -Y view

Set -Z view

4 General tools

This chapter describes the general commands and options that can be used in Gmsh’s script files. By “general”, we mean “not specifically related to one of the geometry, mesh, solver or post-processing modules”. Commands peculiar to these modules will be introduced in Geometry module, Mesh module, Solver module, and Post-processing module, respectively.

If you plan to use Gmsh through its API (see Gmsh API) instead of the built-in scripting language, you can skip this chapter entirely.

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.

Expressions

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

Floating point expressions

Floating point expressions (or, more simply, “expressions”) are denoted by the metasyntactic variable (remember the definition of the syntactic rules in Syntactic rules), and are evaluated during the parsing of the script file:

Such s are used in most of Gmsh’s scripting commands. When is appended to a string , the result is a new string formed by the concatenation of , (an underscore) and the value of the . This is most useful in loops (see Loops and conditionals), where it permits to define unique strings automatically. For example,

is the same as

The brackets permit to extract one item from a list (parentheses can also be used instead of brackets). The permits to get the size of a list. The operators , , , and are defined in Operators. For the definition of s, see Built-in functions. The various s are listed in Options. searches for occurrences of the first expression in the second (both of which can be lists). searches the first for any occurrence of the second . compares the two strings (returns an integer greater than, equal to, or less than 0, according as the first string is greater than, equal to, or less than the second string). returns the length of the string. creates attributes for text strings. checks if a variable with the given name exists (i.e., has been defined previously), and checks if the file with the given name exists. creates a name from the provided string. allows to get the value of a ONELAB variable (the optional second argument is the default value returned if the variable does not exist). allows to ask the user for a value interactively (the second argument is the value returned in non-interactive mode). For example, inserting in an input file will query the user for the value of a certain parameter alpha, assuming the default value is If the option is set (see General options list), no question is asked and the default value is automatically used.

allows to define a ONELAB variable in-line. The given as the first argument is the default value; this is followed by the various ONELAB options. See the ONELAB tutorial wiki for more information.

List of expressions are also widely used, and are defined as:

with

The second case in this last definition permits to create a list containing the range of numbers comprised between two s, with a unit incrementation step. The third case also permits to create a list containing the range of numbers comprised between two s, but with a positive or negative incrementation step equal to the third . The fourth, fifth and sixth cases permit to reference an expression list (parentheses can also be used instead of brackets). sorts the entries in the list and removes all duplicates. takes the absolute value of all entries in the list. reads a list of numbers from a file. and construct lists using linear or logarithmic spacing. The next two cases permit to reference an expression sublist (whose elements are those corresponding to the indices provided by the ). The next cases permit to retrieve the indices of entities created through geometrical transformations, extrusions and boolean operations (see Transformations, Extrusions and Boolean operations).

The next two cases allow to retrieve entities in a given bounding box, or get the bounding box of a given entity. The last five cases permit to retrieve the mass or the center of mass of an entity, the coordinates of a given geometry point (see Points), the elementary entities making up physical groups, and the tags of all (physical or elementary) points, curves, surfaces or volumes in the model. These operations all trigger a synchronization of the CAD model with the internal Gmsh model.

To see the practical use of such expressions, have a look at the first couple of examples in Tutorial. Note that, in order to lighten the syntax, you can omit the braces enclosing an if this only contains a single item. Also note that a braced can be preceded by a minus sign in order to change the sign of all the s.

For some commands it makes sense to specify all the possible expressions in a list. This is achieved with , defined as:

The meaning of “all” () depends on context. For example, will get the ids of all the existing curves in the model, while will get the ids of all existing surfaces.

Character expressions

Character expressions are defined as:

returns the current date. returns the current ONELAB action (e.g. or ). returns the full path of the Gmsh executable. (or ) and return the directory and file name of the script being parsed. and take the prefix (e.g. to remove the extension) or the relative path of a given file name. and concatenate character expressions ( adds a newline character after each string except the last). returns the first or second depending on the value of . returns the portion of the string that starts at the character position given by the first and spans the number of characters given by the second or until the end of the string (whichever comes first; or always if the second is not provided). converts the to upper case. returns the absolute path of a file. returns the directory of a file. is equivalent to the C function (where is a format string that can contain floating point formatting characters: , , etc.) The various s are listed in Options. gets the value of an environment variable from the operating system. allows to get a ONELAB string value (the second optional argument is the default value returned if the variable does not exist). asks the user for a value interactively (the second argument is the value used in non-interactive mode). ’s arguments are: input string, old substring, new substring (brackets can be used instead of parentheses in and ). , etc., or , etc., retrieve the name of the physical or elementary entity, if any. converts a variable name into a string.

allows to define a ONELAB variable in-line. The given as the first argument is the default value; this is followed by the various ONELAB options. See the ONELAB tutorial wiki for more information.

Character expressions are mostly used to specify non-numeric options and input/output file names. See t8, for an interesting usage of s in an animation script.

List of character expressions are defined as:

Color expressions

Colors expressions are hybrids between fixed-length braced s and s:

The first case permits to use the X Windows names to refer to colors, e.g., , , , … (see Common/Colors.h in the source code for a complete list). The second case permits to define colors by using three expressions to specify their red, green and blue components (with values comprised between 0 and ). The third case permits to define colors by using their red, green and blue color components as well as their alpha channel. The last case permits to use the value of a as a . The various s are listed in Options.

See t3, for an example of the use of color expressions.

Red Hat Enterprise Linux (RHEL) minor releases are an aggregation of individual security, enhancement, and bug fix errata. The Red Hat Enterprise Linux  Release Notes document describes the major changes made to the Red Hat Enterprise Linux 7 operating system and its accompanying applications for this minor release, as well as known problems and a complete list of all currently available Technology Previews.

Additional resources

In-place upgrade

An in-place upgrade offers a way of upgrading a system to a new major release of Red Hat Enterprise Linux by replacing the existing operating system. For a list of currently supported upgrade pahts, see Supported in-place upgrade paths for Red Hat Enterprise Linux.

In-place upgrade from RHEL 6 to RHEL 7

The procedure of an in-place upgrade from RHEL 6 to RHEL 7 and the usage of the and the is documented in the Knowledgebase solution How do I upgrade from Red Hat Enterprise Linux 6 to Red Hat Enterprise Linux 7?. Further details are provided in the RHEL 7 Migration Planning Guide. Note that the and the are available in the RHEL 6 Extras repository.

If you are using CentOS 6 or Oracle Linux 6, you can convert your operating system to RHEL 6 using the utility prior to upgrading to RHEL 7. For instructions, see How to convert from CentOS or Oracle Linux to RHEL.

In-place upgrade from RHEL 7 to RHEL 8

Instructions on how to perform an in-place upgrade from RHEL 7 to RHEL 8 using the utility are provided by the document Upgrading from RHEL 7 to RHEL 8. Major differences between RHEL 7 and RHEL 8 are documented in Considerations in adopting RHEL 8. The utility is available in the RHEL 7 Extras repository.

If you are using CentOS 7 or Oracle Linux 7, you can convert your operating system to RHEL 7 using the utility prior to upgrading to RHEL 8. For instructions, see