API

abstract type AbstractDomain <: AbstractType end

Abstract type representing a subset of $\mathbb{R}^d$, typically $d\in\{0,1,2,3\}$. Domains are defined using an underlying computational mesh. See also AbstractMesh.

Level

Beginner

Basic constructors

• unit_simplex
• unit_n_cube
• domain
• interior
• boundary
• skeleton

Basic queries

• num_dims
• num_ambient_dims
• num_codims
• is_axis_aligned
• is_simplex
• is_n_cube
• is_unit_n_cube
• is_unit_simplex
• is_unitary
• bounding_box
• vertex_permutations
• mesh
• faces
• inverse_faces
• options
• is_boundary
• face_around

abstract type AbstractFaceDomain <: AbstractDomain end

A domain defined on a single mesh face. Typically used as helper to identify cases that only make sense for a single mesh face.

Level

Advanced

Basic constructors

• unit_simplex
• unit_n_cube

abstract type AbstractFaceSpace <: AbstractSpace end

Like AbstractSpace, but for a single mesh face. Typically used as helper to identify cases that only make sense for a single mesh face.

Level

Advanced

abstract type AbstractFaceTopology <: AbstractTopology end

Like AbstractTopology, but for a single mesh face. Typically used as helper to identify cases that only make sense for a single mesh face.

Level

Advanced

abstract type AbstractMesh <: AbstractType end

Abstract type representing a computational mesh.

Level

Beginner

Constructors

• create_mesh
• mesh_from_msh
• mesh_from_gmsh
• cartesian_mesh
• moebius_strip
• complexify
• simplexify

Iteration

• each_face

Data retrival

• num_dims
• num_ambient_dims
• num_codims
• num_faces
• num_nodes
• node_coordinates
• face_nodes
• face_reference_id
• reference_spaces
• group_faces
• group_names
• is_face_complex
• normals

abstract type AbstractMeshDomain <: AbstractDomain end

abstract type AbstractQuadrature

Basic queries

• domain
• coordinates
• weights
• num_points
• face_reference_id
• reference_quadratures

Basic constructors

• quadrature
• duffy_quadrature
• tensor_product_quadrature
• node_quadrature

Supertype hierarchy

AbstractQuadrature <: GT.AbstractType

abstract type AbstractSpace <: AbstractType end

Abstract type representing a finite element space.

Level

Basic

Basic constructors

lagrange_space raviart_thomas_space

Basic queries

• domain
• num_dofs
• face_dofs
• face_nodes
• face_reference_id
• reference_spaces
• geometry_own_dofs
• geometry_own_dofs_permutations

Additional queries

For spaces, used as reference spaces in AbstractMesh specializations.

• num_nodes
• interior_nodes
• interior_nodes_permutations
• geometry_interior_nodes
• geometry_interior_nodes_permutations
• geometry_nodes
• geometry_nodes_permutations

abstract type AbstractTopology

Abstract type representing the incidence relations in a face complex.

Level

Intermediate

Constructors

• topology

Queries

• face_incidence
• face_reference_id
• face_permutation_ids
• reference_topologies
• vertex_permutations

abstract type AbstractType end

Parent of all types defined in GalerkinToolkit.

struct Options{...} <: AbstractType

Type of the objects returned by function options. All properties and type parameters are private.

Basic queries

• reference_int_type
• int_type
• global_int_type
• real_type

struct UnitNCube{...} <: AbstractFaceDomain

struct UnitSimplex{...} <: AbstractFaceDomain

ast_hoist!(ast)

Hoist loop invariant definitions in ast. The new AST is overwritten in ast.

Hypotheses:

• The root of the AST is a code block.
• The code block contains only for-loops, function calls, array indexing, definitions, and increments. No while loops, if statements, lambdas, etc.
• Functions that appear in a rhs of a definition are pure functions.
• RHSs contain a function call at most.

ast_lhs_indices(ast)

p0,p1 = bounding_box(x)

Return a tuple of two vectors, where the vectors p0 and p1 define the span of the bounding box of x.

Level

Intermediate

cartesian_mesh(domain,cells_per_dir)

Create a multi-dimensional Cartesian mesh. The dimension of the mesh is defined by the length of cells_per_dir. The number of cells in direction i is given by cells_per_dir[i]. The extends of the Cartesian mesh are given in domain. The range in direction i covered by the mesh is given by domain[2*i-1,2*i].

Keyword arguments

• boundary=true [optional]: Include faces on the boundary and generate face groups identifying which faces are on which face of bounding box of the mesh. The groups are named $d-face-$i for the face i of dimension d of the bounding box.
• complexify=true [optional]: Generate all low dimensional faces so that the mesh is a face complex.
• simplexify=false [optional]: Generate a mesh of simplex faces instead of hyper-cubes.

complexify(x)

Convert x into a mesh representing a face complex.

See also is_face_complex.

Level

Intermediate

create_chain(;kwargs...)

Build an arbitrary mesh object, containing all faces of the same dimension. This function is similar to create_mesh but it only receives face arrays of one dimension.

See also create_mesh.

Level

Intermediate

Keyword arguments

• node_coordinates: Like for create_mesh.
• face_nodes: A nested vector containing the node ids for each face in the mesh. node_coordinates[n] with n=face_nodes[i][k] is the global node coordinate vector for local node number k in face i.
• reference_spaces: A tuple containing the reference spaces for faces. reference_spaces[i] is the reference space number i.
• face_reference_id [optional]: A vector containing which reference space is assigned to each face. reference_sapces[r] with r=face_reference_id[i] is the reference space associated with face number i. By default, all faces are assigned to the first reference space in its dimension.
• group_faces [optional]: A Dictionary containing labeled groups of faces. group_faces[group_name] is a vector of integers containing the ids of the faces in the group named group_name. These groups might overlap. By default, no faces groups are created.
• normals=nothing [optinal]: Like for create_mesh.

create_mesh(;kwargs...)

Build an arbitrary mesh object.

See also cartesian_mesh, mesh_from_msh, and mesh_from_gmsh.

Level

Intermediate

Keyword arguments

• node_coordinates: The vector containing the coordinates of all mesh nodes. node_coordinates[i] is the coordinate vector for global node number i.
• face_nodes: A highly-nested vector containing the node ids for each face in the mesh. node_coordinates[n] with n=face_nodes[d+1][i][k] is the global node coordinate vector for local node number k in face i of dimension d. The object face_nodes[d+1] is a long vector of small vectors of integers. It is often represented using a JaggedArray object that uses continuous linear memory for performance.
• reference_spaces: A nested tuple containing the reference spaces for faces. reference_spaces[d+1][i] is the reference space number i in dimension d. Reference interpolation spaces are defined with functions like lagrange_space.
• face_reference_id [optional]: A nested vector containing which reference space is assigned to each face. reference_sapces[d+1][r] with r=face_reference_id[d+1][i] is the reference space associated with face number i of dimension d. By default, all faces are assigned to the first reference space in its dimension.
• group_faces [optional]: A vector of dictionaries containing labeled groups of faces. group_faces[d+1][group_name] is a vector of integers containing the ids of the faces of dimension d in the group named group_name. These groups might overlap. By default, no faces groups are created.
• is_face_complex=Val(false) [optional]: Val(true) if the input data represents a face complex, Val(false) otherwise.
• normals=nothing [optinal]: Vector containing the normal vectors for the faces of maximum dimension of the mesh. This is relevant for meshes of dimension d embedded in d+1 dimensions as there is no way to tell which should be the orientation of the normals from the other quantities in the mesh. normals[f] gives the normal vector of face number f of dimension d=length(face_nodes)-1.

face_around(x)

Return an integer that allows to break ties when faces in x need to point to faces around of one dimension higher. Return nothing if x does not break such ties.

Note: This function will eventually return a vector of integers.

Level

Intermediate

face_incidence(x,d)

faces(x)

Return the subset of face ids in mesh(x) of dimension num_dims(x) defining the domain x. This is effectively the map from domain face id to mesh face id.

See also inverse_faces.

Level

Intermediate

geometries(x,d)
geometries(x,Val(d))

Return a vector of domains representing the geometrical entities of x of dimension d. The returned domains and x are defined on the same mesh. That is, faces(geometries(x,1)[2]) are the face ids in mesh(x) representing the second edge of x.

Notation

geometries(x,Val(0)) are referred to as the vertices of x. geometries(x,Val(1)) are referred to as the edges of x. geometries(x,Val(d)) are referred to as the d-faces of x.

Level

Advanced

global_int_type(options::Options)

Return the type of the integers used to enumerate global quantities.

group_faces(mesh)
group_faces(mesh,d)

Return the dictionary containing the faces in each group in dimension d. If d is omitted, it returns the dictionaries for all dimensions in a vector. I.e., calling group_faces(mesh,d) is equivalent to group_faces(mesh)[d+1].

The faces of dimension d in group group are group_faces(mesh,d)[group_name], where group_name is a string with the group name. One can create new groups by adding new keys to these dictionaries as long as the key is not already present. Calling group_faces(mesh,d)[new_group_name] = faces_in_newgroup will add a new group to dimension d with name equal to the string new_group_name with faces in vector faces_in_newgroup.

See also group_names.

Level

Beginner

group_names(mesh)
group_names(mesh,d)

Return the names of the groups in dimension d. Calling group_names(mesh,d) is equivalent to group_names(mesh)[d+1].

See also group_faces.

Level

Beginner

int_type(options::Options)

Return the default integer type used in the computation except for reference and global quantities.

inverse_faces(x)

Return the inverse integer mas of faces(x). This is effectively the map from mesh face id to domain face id. Mesh faces not present in the domain, receive an invalid index id.

See also faces.

Level

Intermediate

is_axis_aligned(x)

True if x is a unit simplex or a unit cube.

Level

Advanced

is_boundary(x)

True if x represent an (internal) boundary. Faces in an internal boundary "point" to only of the two faces around of a dimension higher.

See also face_around.

Level

Intermediate

is_n_cube(x)

True if x is a n-cube (hypercube).

See also is_simplex, is_unit_simplex, is_unit_n_cube.

Level

Intermediate

is_simplex(x)

True if x is a simplex.

See also is_n_cube, is_unit_simplex, is_unit_n_cube.

Level

Intermediate

is_unit_n_cube(x)

True if x is a unit n-cube.

See also is_n_cube, is_unit_simplex, is_simplex.

Level

Intermediate

is_unit_simplex(x)

True if x is a unit simplex.

See also is_n_cube, is_unit_n_cube, is_simplex.

Level

Intermediate

is_unitary(x)

True bounding_box(x) coincides with a unit n-cube.

Level

Advanced

mesh_from_gmsh(gmsh::Module;complexify=true)

Create a mesh objects from the current state of the gmsh module. If complexify==true, the mesh will be completed with all low dimensional faces into a face complex.

See also mesh_from_msh and with_gmsh.

Level

Beginner

mesh_from_msh(msh_file;kwargs...)

Create a mesh object from a .msh file found in path msh_file.

See also mesh_from_gmsh and with_gmsh.

Keyword arguments

• complexify=true [optional]: If complexify==true, the mesh will be completed with all low dimensional faces into a face complex.
• renumber=true [optional]: If renumber==true, then gmsh.model.mesh.renumberNodes() and gmsh.model.mesh.renumberElements() will be called.
• Any other keyword argument will be passed to function with_gmsh.

Level

Beginner

mesh_from_space(space)

Return the mesh induced by space. For instance, a (high order) Lagrange space can be interpreted as a mesh using this function.

Level

Advanced

node_coordinates(x)

Return the vector of node coordinates associated with `x.

num_ambient_dims(x)

Return the ambient dimension where object x lives.

See also num_codims, num_dims.

Level

Beginner

num_codims(x)

Return num_ambient_dims(x)-num_dims(x).

See also num_ambient_dims, num_dims.

Level

Beginner

num_dims(x)

Return the parametric dimension of x.

See also num_ambient_dims, num_codims.

Level

Beginner

num_dofs(x)

Return the number of degrees of freedom of x.

See also num_nodes.

Level

Beginner

num_faces(x)
num_faces(x,d)

Return the number of faces of dimension d in mesh(x). If d is omitted, return a vector with the number of faces in each dimension, starting from dimension 0 up to num_dims(x).

Level

Beginner

num_nodes(x)

Return the number of nodes of x.

See also num_dofs.

Level

Beginner

num_points(x)

Return the number of integration points in x.

See also num_nodes.

Level

Beginner

options(;kwargs...) -> Options

Create an object representing the default options for the current simulation. This object can be used as an optional argument in several object constructors in GalerkinToolkit, such as the mesh constructors cartesian_mesh and mesh_from_msh. In this case, the computations using the generated mesh, will use the given options by default.

push(a,ai)

Like push!, but creates a new object to store the result. This function is used to push to immutable collections such as tuples.

real_type(options::Options)

Return the default real type used in the computation.

reference_int_type(options::Options)

Return the type of the integers used to enumerate reference quantities.

reference_topologies(topo)
reference_topologies(topo,d)
reference_topologies(topo,Val(d))

Return the list (a vector or a tuple) of reference topologies in topo of dimension d. If the second argument is omitted, then the function returns a collection such that reference_topologies(topo)[d+1] is equivalent to reference_topologies(topo,Val(d)).

The face reference topology of face f of dimension d, is accessed as reference_topologies(topo,d)[r] with r=face_reference_id(topo,d)[f].

See also face_reference_id.

Level

Intermediate

simplexify(x)

Convert x into a mesh made of simplex cells.

Level

Intermediate

unit_n_cube(d)
unit_n_cube(Val(d))

Return an object representing a unit d-cube.

unit_simplex(d)
unit_simplex(Val(d))

Return an object representing a unit simplex of dimension d.

val_parameter(a)

For a::Val{A} it returns A. Otherwise, it returns a.

vertex_permutations(x)

Return a list of permutations representing the admissible re-labelings of the vertices of x.

Level

Advanced

with_gmsh(f[;options])

A safe way of initialize and finalize the gmsh module. The given function is called f(gmsh) on the gmsh module after is has been initialized. The module is finalized automatically when the function returns.

The optional keyword argument options is a vector for pairs k=>v containing gmesh options. Each of these options are set with gmsh.option.setNumber(k,v) just after gmsh has been initialized.

Level

Beginner

with_mesh_partitioner(mesher[,partitioner];[parts])

Generate a mesh calling mesher() partition it, and distribute it over the part ids in parts.

Arguments

• Function mesher() should have no arguments and returns a sequential mesh object. This function is called only on one process.
• partitioner [optional]: A function that takes a graph encoded as a sparse matrix, and returns a vector containing the part id of each node in the graph. Defaults to Metis.partition.

Keyword arguments

• parts [optional]: A vector containing the part indices 1:P where P is the number of parts in the data distribution. By default, P is the number of MPI ranks and 1:P is distributed one item per rank.