Extendable grid

const ElementInfo{T}=Union{Vector{T},VectorOfConstants{T}}

Union type for element information arrays. If all elements have the same information, it can be stored in an economical form as a VectorOfConstants.

abstract type AbstractElementGeometries <: AbstractGridComponent

Array of element geometry information.

abstract type AbstractElementRegions <: AbstractGridComponent

Array of element region number information.

abstract type AbstractGridAdjacency <: AbstractGridComponent

Any kind of adjacency between grid components

abstract type AbstractGridComponent <: AbstractExtendableGridApexType

Apex type for grid components.

abstract type AbstractGridFloatArray1D <: AbstractGridComponent

1D Array of floating point data

abstract type AbstractGridFloatArray2D <: AbstractGridComponent

2D Array of floating point data

abstract type AbstractGridFloatConstant <: AbstractGridComponent

Floating point number

abstract type AbstractGridIntegerArray1D <: AbstractGridComponent

1D Array of integer data

abstract type AbstractGridIntegerArray2D <: AbstractGridComponent

2D Array of integer data

abstract type AbstractGridIntegerConstant <: AbstractGridComponent

Integer number

abstract type BEdgeRegions <: AbstractElementRegions

Boundary edge region number per boundary edge

Description of boundary face geometries

abstract type BFaceGeometries <: AbstractElementGeometries

abstract type BFaceNodes <: AbstractGridAdjacency

Adjacency describing nodes per grid boundary face. The node order within each bface column is the one provided by the user and is never modified by lazy component creation. Consumers which need bface local node order to coincide with face local node order (e.g. consistently oriented boundary grids) should use grid[BFaceNodesCanonical].

abstract type BFaceRegions <: AbstractElementRegions

Boundary region number per boundary face

abstract type CellGeometries <: AbstractElementGeometries

Description of cell geometries

abstract type CellNodes <: AbstractGridAdjacency

Adjacency describing nodes per grid cell

abstract type CellRegions <: AbstractElementRegions

Cell region number per cell

abstract type CoordinateSystem <: AbstractGridComponent

Coordinate system

abstract type Coordinates <: AbstractGridFloatArray2D

Node coordinates

mutable struct ExtendableGrid{Tc, Ti}

Grid type wrapping Dict

abstract type NumBEdgeRegions <: ExtendableGrids.AbstractGridIntegerConstant

Number of boundary edge regions

abstract type NumBFaceRegions <: ExtendableGrids.AbstractGridIntegerConstant

Number of boundary face regions

abstract type NumCellRegions <: ExtendableGrids.AbstractGridIntegerConstant

Number of cell regions

delete!(
    grid::ExtendableGrid,
    T::Type{<:AbstractGridComponent}
) -> Dict{Type{<:AbstractGridComponent}, Any}

Remove grid component

get!(
    grid::ExtendableGrid,
    T::Type{<:AbstractGridComponent}
) -> Any

To be called by getindex. This triggers lazy creation of non-existing gridcomponents

Base.getindex(grid::ExtendableGrid,T::Type{<:AbstractGridComponent})

Generic method for obtaining grid component.

This method is mutating in the sense that non-existing grid components are created on demand.

Due to the fact that components are stored as Any the return value triggers type instability. To prevent this, specialized methods must be (and are) defined.

haskey(g::ExtendableGrid, k) -> Bool

Check if key is in grid

keys(
    g::ExtendableGrid
) -> Base.KeySet{Type{<:AbstractGridComponent}, Dict{Type{<:AbstractGridComponent}, Any}}

Keys in grid

map(f,grid)

Map function f returning a number onto node coordinates of grid. Returns a vector of length corresponding to the number of nodes of the grid. The function can take either a vector or a numbers as arguments. E.g. for a two-dimensional grid g, both

 map(X->X[1]+X[2], g)

and

 map((x,y)->x+y, g)

are possible.

setindex!(
    grid::ExtendableGrid,
    v,
    T::Type{<:AbstractGridComponent}
) -> Any

Set new grid component

coord_type(grid)

Type of coordinates in grid

dangling_nodes(grid)

Coordinates of nodes that belong to no cell, as columns of the coordinate array, nothing if there are none.

dim_grid(grid)

Grid dimension dimension of grid (larges element dimension)

dim_space(grid)

Space dimension of grid

explode(grid::ExtendableGrid) -> ExtendableGrid

Remove all adjacency information from a grid, creating independent cells by duplicating coordinates and assigning new node indices while keeping the original coordinates.

This function creates a new grid where each cell has its own independent set of nodes by duplicating the coordinate information and creating new node indices. The original coordinates are preserved, but adjacency information is removed.

Arguments

• grid::ExtendableGrid: The input grid to be processed

Returns

• ::ExtendableGrid: A new grid with duplicated coordinates and independent cells

gridcomponents()

Print the hierarchy of grid component key types (subtypes of AbstractGridComponent. This includes additionally user defined subptypes.

index_type(grid)

Type of indices

instantiate(xgrid::ExtendableGrid, ComponentType::Type)

"Hook" for methods instantiating lazy components.

instantiate(grid, _::Type{NumBEdgeRegions}) -> Any

Instantiate number of boundary edge regions

instantiate(grid, _::Type{NumBFaceRegions}) -> Any

Instantiate number of bface regions

instantiate(grid, _::Type{NumCellRegions}) -> Any

Instantiate number of cell regions

isconsistent(grid; warnonly=false)

Check consistency of grid: a grid is consistent if

• Grid has no dangling nodes
• ... more to be added

If grid is consistent, return true, otherwise throw an error, or, if warnoly==true, return false.

num_bedgeregions(grid::ExtendableGrid) -> Any

Maximum boundary edge region numbers

num_bedges(grid::ExtendableGrid) -> Int64

Number of boundary edges in grid.

num_bfaceregions(grid::ExtendableGrid) -> Any

Maximum boundary face region numbers

num_bfaces(grid::ExtendableGrid) -> Int64

Number of boundary faces in grid.

num_cellregions(grid::ExtendableGrid) -> Any

Maximum cell region number

num_cells(grid::ExtendableGrid) -> Int64

Number of cells in grid

num_nodes(grid)

Number of nodes in grid

numbers_match(grid, nn, nc, nb)

Check whether the grid has exactly nn nodes, nc cells and nb boundary faces.

seemingly_equal(array1, array2)

Check for seeming equality of two arrays by random sample.

seemingly_equal(grid1, grid2; sort=false, confidence=:full

Recursively check seeming equality of two grids. Seemingly means that long arrays are only compared via random samples.

Keyword args:

• sort: if true, sort grid points
• confidence: Confidence level:
  • :low : Point numbers etc are the same
  • :full : all arrays are equal (besides the coordinate array, the arrays only have to be equal up to permutations)

trim!(grid; keep)

Remove precomputed grid components for lightweight storage of the grid.

Use the keep list to exclude grid components from trimming.

trim(grid; keep)

Variant of trim! without modification of the original grid.

Returns a trimmed copy of the grid.

update!(
    grid::ExtendableGrid,
    T::Type{<:AbstractGridComponent}
) -> Any

Reinstantiate grid component (only if it exists)

veryform(
    grid::ExtendableGrid,
    v,
    _::Type{<:AbstractGridComponent}
) -> Any

Default veryform method.

"veryform" means "verify and/or transform" and is called to check and possibly transform components to be added to the grid via setindex!.

The default method just passes data through.

veryform(grid::ExtendableGrid{Tc,Ti},v,T::Type{<:AbstractGridAdjacency}) where{Tc,Ti}

Check proper type of adjacencies upon insertion