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

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

dim_grid(grid)

Grid dimension dimension of grid (larges element dimension)

dim_space(grid)

Space dimension of grid

gridcomponents()

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

index_type(grid)

Type of indices

"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

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)

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