Grid & AbstractGrid

generate_grid(celltype::Cell, nel::NTuple, [left::Vec, right::Vec)

Return a Grid for a rectangle in 1, 2 or 3 dimensions. celltype defined the type of cells, e.g. Triangle or Hexahedron. nel is a tuple of the number of elements in each direction. left and right are optional endpoints of the domain. Defaults to -1 and 1 in all directions.

Node{dim, T}

A Node is a point in space.

Fields

• x::Vec{dim,T}: stores the coordinates

A CellIndex wraps an Int and corresponds to a cell with that number in the mesh

A VertexIndex wraps an (Int, Int) and defines a local vertex by pointing to a (cell, vert).

A EdgeIndex wraps an (Int, Int) and defines a local edge by pointing to a (cell, edge).

A FaceIndex wraps an (Int, Int) and defines a local face by pointing to a (cell, face).

Grid{dim, C<:AbstractCell, T<:Real} <: AbstractGrid}

A Grid is a collection of Cells and Nodes which covers the computational domain, together with Sets of cells, nodes and faces. There are multiple helper structures to apply boundary conditions or define subdomains. They are gathered in the cellsets, nodesets, facesets, edgesets and vertexsets.

Fields

• cells::Vector{C}: stores all cells of the grid
• nodes::Vector{Node{dim,T}}: stores the dim dimensional nodes of the grid
• cellsets::Dict{String,Set{Int}}: maps a String key to a Set of cell ids
• nodesets::Dict{String,Set{Int}}: maps a String key to a Set of global node ids
• facesets::Dict{String,Set{FaceIndex}}: maps a String to a Set of Set{FaceIndex} (global_cell_id, local_face_id)
• edgesets::Dict{String,Set{EdgeIndex}}: maps a String to a Set of Set{EdgeIndex} (global_cell_id, local_edge_id
• vertexsets::Dict{String,Set{VertexIndex}}: maps a String key to a Set of local vertex ids
• boundary_matrix::SparseMatrixCSC{Bool,Int}: optional, only needed by onboundary to check if a cell is on the boundary, see, e.g. Helmholtz example

getcells(grid::AbstractGrid)
getcells(grid::AbstractGrid, v::Union{Int,Vector{Int}}
getcells(grid::AbstractGrid, setname::String)

Returns either all cells::Collection{C<:AbstractCell} of a <:AbstractGrid or a subset based on an Int, Vector{Int} or String. Whereas the last option tries to call a cellset of the grid. Collection can be any indexable type, for Grid it is Vector{C<:AbstractCell}.

Returns the number of cells in the <:AbstractGrid.

getnodes(grid::AbstractGrid)
getnodes(grid::AbstractGrid, v::Union{Int,Vector{Int}}
getnodes(grid::AbstractGrid, setname::String)

Returns either all nodes::Collection{N} of a <:AbstractGrid or a subset based on an Int, Vector{Int} or String. The last option tries to call a nodeset of the <:AbstractGrid. Collection{N} refers to some indexable collection where each element corresponds to a Node.

Returns the number of nodes in the grid.

Returns the number of nodes of the i-th cell.

getcellset(grid::AbstractGrid, setname::String)

Returns all cells as cellid in a Set of a given setname.

getnodeset(grid::AbstractGrid, setname::String)

Returns all nodes as nodeid in a Set of a given setname.

getfaceset(grid::AbstractGrid, setname::String)

Returns all faces as FaceIndex in a Set of a given setname.

getedgeset(grid::AbstractGrid, setname::String)

Returns all edges as EdgeIndex in a Set of a given setname.

getedgeset(grid::AbstractGrid, setname::String)

Returns all vertices as VertexIndex in a Set of a given setname.

transform_coordinates!(grid::Abstractgrid, f::Function)

Transform all nodes of the grid based on some transformation function f.

getcoordinates(grid::AbstractGrid, idx::Union{Int,CellIndex})
getcoordinates(cache::CellCache)

Get a vector with the coordinates of the cell corresponding to idx or cache

getcoordinates!(x::Vector{<:Vec}, grid::AbstractGrid, idx::Union{Int,CellIndex})
getcoordinates!(x::Vector{<:Vec}, grid::AbstractGrid, cell::AbstractCell)

Mutate x to the coordinates of the cell corresponding to idx or cell.

get_node_coordinate(::Node)

Get the value of the node coordinate.

get_node_coordinate(grid::AbstractGrid, n::Int)

Return the coordinate of the nth node in grid

ExclusiveTopology(cells::Vector{C}) where C <: AbstractCell
ExclusiveTopology(grid::Grid)

ExclusiveTopology saves topological (connectivity/neighborhood) data of the grid. The constructor works with an AbstractCell vector for all cells that dispatch vertices, faces and in 3D edges. The struct saves the highest dimensional neighborhood, i.e. if something is connected by a face and an edge only the face neighborhood is saved. The lower dimensional neighborhood is recomputed, if needed.

Fields

• vertex_to_cell::Vector{Set{Int}}: global vertex id to all cells containing the vertex
• cell_neighbor::Vector{EntityNeighborhood{CellIndex}}: cellid to all connected cells
• face_neighbor::Matrix{EntityNeighborhood,Int}: face_neighbor[cellid,local_face_id] -> neighboring face
• vertex_neighbor::Matrix{EntityNeighborhood,Int}: vertex_neighbor[cellid,local_vertex_id] -> neighboring vertex
• edge_neighbor::Matrix{EntityNeighborhood,Int}: edge_neighbor[cellid_local_vertex_id] -> neighboring edge
• face_skeleton::Union{Vector{FaceIndex}, Nothing}:

!!! note Currently mixed-dimensional queries do not work at the moment. They will be added back later.

getneighborhood(topology, grid::AbstractGrid, cellidx::CellIndex, include_self=false)
getneighborhood(topology, grid::AbstractGrid, faceidx::FaceIndex, include_self=false)
getneighborhood(topology, grid::AbstractGrid, vertexidx::VertexIndex, include_self=false)
getneighborhood(topology, grid::AbstractGrid, edgeidx::EdgeIndex, include_self=false)

Returns all connected entities of the same type as defined by the respective topology. If include_self is true, the given entity is included in the returned list as well.

face_skeleton(top::ExclusiveTopology, grid::Grid) -> Vector{FaceIndex}

Creates an iterateable face skeleton. The skeleton consists of FaceIndex that can be used to reinit FaceValues.

vertex_star_stencils(top::ExclusiveTopology, grid::Grid) -> Vector{Int, EntityNeighborhood{VertexIndex}}()

Computes the stencils induced by the edge connectivity of the vertices.

getstencil(top::Dict{Int, EntityNeighborhood{VertexIndex}}, grid::AbstractGrid, vertex_idx::VertexIndex) -> EntityNeighborhood{VertexIndex}

Get an iterateable over the stencil members for a given local entity.

addcellset!(grid::AbstractGrid, name::String, cellid::Union{Set{Int}, Vector{Int}})
addcellset!(grid::AbstractGrid, name::String, f::function; all::Bool=true)

Adds a cellset to the grid with key name. Cellsets are typically used to define subdomains of the problem, e.g. two materials in the computational domain. The DofHandler can construct different fields which live not on the whole domain, but rather on a cellset. all=true implies that f(x) must return true for all nodal coordinates x in the cell if the cell should be added to the set, otherwise it suffices that f(x) returns true for one node.

addcellset!(grid, "left", Set((1,3))) #add cells with id 1 and 3 to cellset left
addcellset!(grid, "right", x -> norm(x[1]) < 2.0 ) #add cell to cellset right, if x[1] of each cell's node is smaller than 2.0

addfaceset!(grid::AbstractGrid, name::String, faceid::Union{Set{FaceIndex},Vector{FaceIndex}})
addfaceset!(grid::AbstractGrid, name::String, f::Function; all::Bool=true)

Adds a faceset to the grid with key name. A faceset maps a String key to a Set of tuples corresponding to (global_cell_id, local_face_id). Facesets are used to initialize Dirichlet structs, that are needed to specify the boundary for the ConstraintHandler. all=true implies that f(x) must return true for all nodal coordinates x on the face if the face should be added to the set, otherwise it suffices that f(x) returns true for one node.

addfaceset!(grid, "right", Set(((2,2),(4,2))) #see grid manual example for reference
addfaceset!(grid, "clamped", x -> norm(x[1]) ≈ 0.0) #see incompressible elasticity example for reference

addboundaryfaceset!(grid::AbstractGrid, topology::ExclusiveTopology, name::String, f::Function; all::Bool=true)

Adds a boundary faceset to the grid with key name. A faceset maps a String key to a Set of tuples corresponding to (global_cell_id, local_face_id). Facesets are used to initialize Dirichlet structs, that are needed to specify the boundary for the ConstraintHandler. all=true implies that f(x) must return true for all nodal coordinates x on the face if the face should be added to the set, otherwise it suffices that f(x) returns true for one node.

julia> using Ferrite

julia> grid = generate_grid(Tetrahedron, (1,1,1));

julia> topology = ExclusiveTopology(grid);

julia> addboundaryfaceset!(grid, topology, "b", x -> true);

julia> grid.facesets["b"]
Set{FaceIndex} with 12 elements:
FaceIndex((3, 1))
FaceIndex((4, 3))
FaceIndex((3, 3))
FaceIndex((4, 1))
FaceIndex((5, 1))
FaceIndex((2, 2))
FaceIndex((1, 4))
FaceIndex((2, 1))
FaceIndex((6, 1))
FaceIndex((6, 3))
FaceIndex((5, 3))
FaceIndex((1, 1))

addboundaryedgeset!(grid::AbstractGrid, topology::ExclusiveTopology, name::String, f::Function; all::Bool=true)

Adds a boundary edgeset to the grid with key name. An edgeset maps a String key to a Set of tuples corresponding to (global_cell_id, local_edge_id). all=true implies that f(x) must return true for all nodal coordinates x on the face if the face should be added to the set, otherwise it suffices that f(x) returns true for one node.

julia> using Ferrite

julia> grid = generate_grid(Tetrahedron, (1,1,1));

julia> topology = ExclusiveTopology(grid);

julia> addboundaryedgeset!(grid, topology, "b", x -> true);

julia> grid.edgesets["b"]
Set{EdgeIndex} with 30 elements:
EdgeIndex((6, 6))
EdgeIndex((2, 1))
EdgeIndex((5, 3))
.
.
.
EdgeIndex((2, 5))
EdgeIndex((1, 4))

addboundaryvertexset!(grid::AbstractGrid, topology::ExclusiveTopology, name::String, f::Function; all::Bool=true)

Adds a boundary vertexset to the grid with key name. A vertexset maps a String key to a Set of tuples corresponding to (global_cell_id, local_vertex_id). all=true implies that f(x) must return true for all nodal coordinates x on the face if the face should be added to the set, otherwise it suffices that f(x) returns true for one node.

julia> using Ferrite

julia> grid = generate_grid(Tetrahedron, (1,1,1));

julia> topology = ExclusiveTopology(grid);

julia> addboundaryvertexset!(grid, topology, "b", x -> true);

julia> grid.vertexsets["b"]
Set{VertexIndex} with 24 elements:
VertexIndex((2, 3))
VertexIndex((5, 2))
VertexIndex((4, 1))
.
.
.
VertexIndex((1, 4))
VertexIndex((4, 4))

addnodeset!(grid::AbstractGrid, name::String, nodeid::Union{Vector{Int},Set{Int}})
addnodeset!(grid::AbstractGrid, name::String, f::Function)

Adds a nodeset::Dict{String, Set{Int}} to the grid with key name. Has the same interface as addcellset. However, instead of mapping a cell id to the String key, a set of node ids is returned.

create_coloring(g::Grid, cellset=1:getncells(g); alg::ColoringAlgorithm)

Create a coloring of the cells in grid g such that no neighboring cells have the same color. If only a subset of cells should be colored, the cells to color can be specified by cellset.

Returns a vector of vectors with cell indexes, e.g.:

ret = [
   [1, 3, 5, 10, ...], # cells for color 1
   [2, 4, 6, 12, ...], # cells for color 2
]

Two different algorithms are available, specified with the alg keyword argument:

• alg = ColoringAlgorithm.WorkStream (default): Three step algorithm from Turcksin et al. [6], albeit with a greedy coloring in the second step. Generally results in more colors than ColoringAlgorithm.Greedy, however the cells are more equally distributed among the colors.
• alg = ColoringAlgorithm.Greedy: greedy algorithm that works well for structured quadrilateral grids such as e.g. quadrilateral grids from generate_grid.

The resulting colors can be visualized using vtk_cell_data_colors.

colors = create_coloring(...)
cell_colormap = Dict{Int,Int}(
    cellid => color for (color, cellids) in enumerate(final_colors) for cellid in cellids
)

References

• [6] Turcksin et al. ACM Trans. Math. Softw. 43 (2016).