Gmsh interoperability

simplexgrid_from_gmsh(file; incomplete=false, Tc=Float32, Ti=Int32)
simplexgrid_from_gmsh(mod::Module; incomplete=false, Tc=Float32, Ti=Int32)

Create a grid from a gmsh mesh file (or from a mesh in a gmsh module). Requires the Gmsh.jl extension.

simplexgrid_to_gmsh(g::ExtendableGrid; filename::String="")

Load a grid into a gmsh module, optionally writing the mesh to filename. Requires the Gmsh.jl extension.

mixedgrid_from_gmsh(filename::String; Tc=Float32, Ti=Int32)

The msh file is read and an ExtendableGrid is created. This only works for dim=2 grids and the orientation may be wrong. Tc is the type of coordinates, Ti is the index type.

mixedgrid_from_gmsh(mod::Module; Tc=Float32, Ti=Int32)

The mesh contained in the gmsh module is converted to an ExtendableGrid. Tc is the type of coordinates, Ti is the index type.

mixedgrid_to_gmsh(g::ExtendableGrid; filename::String="")

The ExtendableGrid 'g' is loaded into a gmsh module. If a string (not "") is passed via 'filename', the mesh is written into this file.

function seal!(grid::ExtendableGrid; bfaceregions=[], encode=true, Ti=Int64)

Take an (simplex-) ExtendableGrid and compute and add the BoundaryFaces. A so called incomplete ExtendableGrid can e.g. be read from an msh file using the Gmsh.jl-extension of the ExtendableGrids package and the function $simplexgrid_from_gmsh(filename::String; incomplete=true)$. If a non empty vector is passed as bfaceregions, this vector is used for the 'BFaceRegions'. If bfaceregions is empty, all BoundaryFaces get the region number 1.

For performance reasons, the faces (=the nodes contained in the face) can be encoded (see the function $encode(x::Vector, nn::Integer)$) to Integers encoding_type. To do this, encode=true is used. But for each encoding_type there is a limit on the number of nodes:

- For Int64  and a 2d grid: 3*10^9 nodes- For Int64  and a 3d grid: 2*10^6 nodes- For Int128 and a 2d grid: 1.3*10^19 nodes- For Int128 and a 3d grid: 5.5*10^12 nodes

If encode=false is passed, there is no limit (besides the MaxValue of the Integer type used).

gmshfile_to_mixedgrid(filename::String, Tc, Ti)

Read an msh file, create a gmsh model from it and convert it to a mixed grid.

The function then calls mod_to_mixedgrid, which is also reachable through mixedgrid_from_gmsh. Tc is the type of coordinates, Ti is the index type.

This function initializes and finalizes gmsh.

take_second(x)

x is a list of 2-tuples, with an Int as second entry an array of the second entries is returned

gmshfile_to_simplexgrid(filename::String, Tc, Ti)

This function reads a .msh or a .geo file, and creates a gmsh.model If it is a .geo file, gmsh.model.mesh.generate() is called. Finally, it calls the 'modtosimplexgrid' function. This function is called in 'simplexgridfromgmsh' Tc is the type of coordinates, Ti is the index type.

The function initializes and finalized the gmsh module.

test_gmsh_init()

Very primitive function to test, via a try-catch-block, whether gmsh is already initialized. If not, it will be initialized.

mixedgrid_to_gmshfile(grid::ExtendableGrid, filename::String)

This function takes a mixed grid, uses 'gridtomod' to create a corresponding gmsh module Then it writes the module to a file

grid[CellNodes] must be a VariableTargetAdjacency structure This function initializes and finalized gmsh.

multiply_indices(indices, n)

Expand cell indices to the indices of all their nodes in a flattened node list.

for n=3: [i, j, ..., k], 3 -> [3i-2, 3i-1, 3i, 3j-1, 3j-2, 3j, ..., 3k-2, 3k-1, 3k] in general: [i, j, ..., k], n -> [ni-(n-1), ni-(n-2), ..., ni, n*j-(n-1), ...] This function can be used, if you have the indices of cells, and you want to get all their nodes, but the nodes are stored in one list for all cells: [node1ofcell1, node2ofcell1, ... nodenofcell1, node1ofcell2, ...]

mod_to_mixedgrid(model::Module, Tc, Ti)

Function that tries to create a (mixed-) ExtendableGrid from a gmsh.model. Model has to be a gmsh.model. (This function has to be called with an initialized gmsh environment). This function is called in 'mixedgridfromgmsh'. Tc is the type of coordinates, Ti is the index type.

function simplexgrid_to_gmshfile(grid::ExtendableGrid, filename::String)

This function takes a simplexgrid, uses 'gridtomod' to create a corresponding gmsh module Then it writes the module to a file.

This function initializes and finalized gmsh.

grid_to_mod(grid::ExtendableGrid)

This function writes an ExtendableGrid into a gmsh module. (This function has to be called with an initialized gmsh environment) At the moment, this function can only be used from the outside via 'write_gmsh', where the newly created gmsh module is written into a msh file.

mod_to_grid(model::Module, Tc, Ti)

Function that tries to create an (simplex-) ExtendableGrid from a gmsh.model. Model has to be a gmsh.model. (This function has to be called with an initialized gmsh environment). This function is called in 'simplexgridfromgmsh'. Tc is the type of coordinates, Ti is the index type.

incomplete_mod_to_simplexgrid(model::Module, Tc, Ti)

Loads an incomplete mesh from a msh file. Then converts into an ExtendableGrids. 'incomplete' in this context means the boundary is missing. With the 'ExtendableGrids.seal!(grid::ExtendableGrid)' the boundary can be added. Tc is the type of coordinates, Ti is the index type.

use_geoms(cellgeoms, ids)

If cellgeoms would just be an array/vector, the result would be equivalent to cellgeoms[ids].

use_vta(VTA, col_ids, num)

If VTA were a matrix, the result would be equivalent to VTA[:, col_ids]. Each column of the VTA contains the nodes of one cell.

function faces_of_ndim_simplex(x::Vector, dim::Integer, nn::Integer)

Return all faces of a n-dim simplex. The orientation is not guaranteed to be right. x contains the nodes of the simplex. nn is the total number of nodes. The faces (=the nodes contained in the face), are encoded to Integers (of nn's type).

function assemble_bfaces_direct(simplices, dim, Ti)

Assemble the BoundaryFaces corresponding to the simplices passed. In this function, the faces are not encoded. This may make sense for grids with many nodes. For smaller grids it can lead to performance losses. simplices is a $(dim+1) x 'number cells'$ matrix and nn is the total number of nodes. We can not guarantee, that the orientation of the BoundaryFaces is correct.

function decode(y::Integer, nn::Integer, dim::Integer)

Decode y to the vector x. x has the length dim. The en/-decoding is similar to using the base-nn number system. For details of the encoding, see the documentation of the function encode.

function encode(x::Vector, nn::Integer)

Encode th vector x into an Int y. The en/-decoding is similar to using the base-nn number system. Example: $[x₁, x₂, x₃] → (x₁-1) + (x₂-1)*nn + (x₃-1)*nn²$``

function faces_of_ndim_simplex(x::Vector, dim::Integer, nn::Integer)

Return all faces of a n-dim simplex. The orientation is not guaranteed to be right. x contains the nodes of the simplex. nn is the total number of nodes. The faces (=the nodes contained in the face), are not encoded to Integers.

function assemble_bfaces(simplices, dim, nn, Ti)

Assemble the BoundaryFaces corresponding to the simplices passed. In this function, the faces are encoded for performance reasons. If a large grid with many nodes is used, Ti has to be chosen accordingly (e.g. Int128), or encode=false has to be passed to seal!. simplices is a $(dim+1) x 'number cells'$ matrix and nn is the total number of nodes. We can not guarantee, that the orientation of the BoundaryFaces is correct.