FESpace

abstract type AbstractFiniteElement

root type for finite element types

abstract type AbstractH1FiniteElement <: AbstractFiniteElement

root type for H1-conforming finite element types

abstract type AbstractH1FiniteElementWithCoefficients <: AbstractH1FiniteElement

root type for H1-conforming finite element types with additional coefficients

abstract type AbstractHcurlFiniteElement <: AbstractFiniteElement

root type for Hcurl-conforming finite element types with additional coefficients

abstract type AbstractHdivFiniteElement <: AbstractFiniteElement

root type for Hdiv-conforming finite element types

struct FESpace{Tv, Ti, FEType<:AbstractFiniteElement,AT<:AssemblyType}
	name::String                          
	broken::Bool                         
	ndofs::Int                            
	coffset::Int                          
	xgrid::ExtendableGrid[Tv,Ti}           
	dofgrid::ExtendableGrid{Tv,Ti}	      
	dofmaps::Dict{Type{<:AbstractGridComponent},Any} 
    interpolators::Dict{Type{<:AssemblyType}, Any} 
end

A finite element space representing the global collection of degrees of freedom (DOFs) for a given finite element type and assembly type on a computational grid.

FESpace encapsulates the mapping between mesh entities (cells, faces, edges, etc.) and DOFs, as well as metadata and auxiliary structures needed for assembly, interpolation, and evaluation of finite element functions.

Type Parameters

• Tv: Value type for grid coordinates (e.g., Float64).
• Ti: Integer type for grid indices (e.g., Int64).
• FEType: The finite element type (e.g., H1P1).
• AT: The assembly type (e.g., ON_CELLS).

Fields

• name::String: Name of the finite element space.
• broken::Bool: Whether the space is "broken" (discontinuous across elements).
• ndofs::Int64: Total number of global degrees of freedom.
• coffset::Int: Offset for component DOFs (for vector-valued or mixed spaces).
• xgrid::ExtendableGrid{Tv, Ti}: Reference to the computational grid.
• dofgrid::ExtendableGrid{Tv, Ti}: Grid used for DOF numbering (may be a subgrid of xgrid).
• dofmaps::Dict{Type{<:AbstractGridComponent}, Any}: Dictionary of DOF maps for different grid components (cells, faces, edges, etc.).
• interpolators::Dict{Type{<:AssemblyType}, Any}: Dictionary of interpolation operators for different assembly types.

FESpace{FEType, AT}(xgrid::ExtendableGrid{Tv, Ti}; name = "", regions = nothing, broken::Bool = false)

Constructs a finite element space (FESpace) of the given finite element type (FEType) and assembly type (AT) on the provided computational grid.

• The FESpace represents the global collection of degrees of freedom (DOFs) for the specified finite element type and assembly type, and manages the mapping between mesh entities (cells, faces, edges, etc.) and DOFs.
• The broken switch allows the creation of a "broken" (discontinuous) finite element space, where basis functions are not required to be continuous across element boundaries.
• The regions argument can be used to restrict the space to a subset of the grid.
• If no AT is provided, the space is generated on cells (ON_CELLS).

Arguments

• xgrid::ExtendableGrid{Tv, Ti}: The computational grid on which the finite element space is defined.

Keyword Arguments

• `name::String: Name for the finite element space (for identification and debugging) (default: "", triggers automatic generation from FEType and broken).
• regions: Optional subset of the grid to restrict the space (default: all regions).
• broken: Whether to create a broken (discontinuous) space (default: false).

eltype(
    _::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT}
) -> Type{FEType} where FEType<:AbstractFiniteElement

Custom eltype function for FESpace returns the finite element type parameter of the finite element space.

get!(FES::FESpace, DM::Type{<:DofMap}) -> Any

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

Base.getindex(FES::FESpace,DM::Type{<:DofMap})

Generic method for obtaining dofmap. This method is mutating in the sense that non-existing dofmaps are created on demand. Due to the fact that components are stored as Any the return value triggers type instability.

setindex!(FES::FESpace, v, DM::Type{<:DofMap}) -> Any

Set new dofmap

show(
    io::IO,
    FES::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT}
)

Custom show function for FESpace that prints some information and all available dofmaps.

assemblytype(
    _::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT}
) -> Any

returns the assembly type parameter of the finite element space, i.e. on which entities of the grid the finite element is defined.

broken(FES::FESpace) -> Bool

returns true if the finite element space is broken, false if not

coffset(FES::FESpace) -> Int64

returns the offset between the degrees of freedom of each component (i.e. the number of scalar degrees of freedom that influence a component, vector-valued degrees of freedom are stored at the end).

count_ndofs(
    xgrid,
    FEType,
    broken::Bool
) -> Tuple{Int64, Int64}

counts the total number of degrees of freedom for the FEType for the whole grid

dofgrid(FES::FESpace) -> ExtendableGrids.ExtendableGrid

returns the dofgrid of the finite element space.

get_AT(_::FESpace{Tv, Ti, FEType, AT}) -> Any

returns the support of the finite element space

get_FEType(_::FESpace{Tv, Ti, FEType, AT}) -> Any

returns the finite element type of the finite element space

get_basis(
    AT::Type{<:ExtendableGrids.AssemblyType},
    FEType::Type{<:AbstractFiniteElement},
    EG::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> ExtendableFEMBase.var"#closure#get_basis##40"

returns the closure function of form

closure(refbasis, xref)

that computes the evaluations of the basis functions on the reference geometry

get_basissubset(
    ::Type{<:ExtendableGrids.AssemblyType},
    FE::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT},
    ::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> ExtendableFEMBase.var"#closure#get_basissubset##5"{_A, Int64} where _A
get_basissubset(
    ::Type{<:ExtendableGrids.AssemblyType},
    FE::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT},
    ::Type{<:ExtendableGrids.AbstractElementGeometry},
    xgrid
) -> Union{ExtendableFEMBase.var"#20#21", ExtendableFEMBase.var"#closure#get_basissubset##6"{_A, _B, _C, Int64, Int64} where {_A, _B, _C}}

returns a closure function of the form

closure(subset_ids::Array{Int, 1}, cell)

which returns the ids of the local basis functions needed on the cell. Usually, subset_ids = 1:ndofs (meaning that all basis functions on the reference cells are used),

See e.g. the 3D implementation of BDM1 or H1P3 where different basis functions are chosen depending on the face orientations (which in 3D is not just a sign)

get_coefficients(
    ::Type{<:ExtendableGrids.AssemblyType},
    FE::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT},
    ::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> ExtendableFEMBase.var"#closure#get_coefficients##15"
get_coefficients(
    ::Type{<:ExtendableGrids.AssemblyType},
    FE::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT},
    ::Type{<:ExtendableGrids.AbstractElementGeometry},
    xgrid
) -> ExtendableFEMBase.var"#closure#get_coefficients##21"

returns the coefficients for local evaluations of finite element functions ( see e.g. h1v_br.jl for a use-case)

get_edim(FEType::Type{<:AbstractFiniteElement}) -> Any

returns the element dimension of the finite element

get_ncomponents(FES::FESpace) -> Any

returns the number of components of the FESpace (= number of components of its FEType)

get_ndofs(
    AT::Type{<:ExtendableGrids.AssemblyType},
    FEType::Type{<:AbstractFiniteElement},
    EG::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> Any

returns the number of degrees of freedom for the given AssemblyType, FEType and geometry

get_ndofs_all(
    AT::Type{<:ExtendableGrids.AssemblyType},
    FEType::Type{<:AbstractFiniteElement},
    EG::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> Int64

returns the total number of degrees of freedom for the given AssemblyType, FEType and geometry

get_polynomialorder(
    AT::Type{<:ExtendableGrids.AssemblyType},
    FE::Type{<:AbstractFiniteElement},
    EG::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> Int64

returns the expected polynomial order of the basis functions (used to determine default quadrature orders)

interior_dofs_offset(
    AT::Type{<:ExtendableGrids.AssemblyType},
    FE::Type{<:AbstractFiniteElement},
    EG::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> Int64

returns the offset for the interior degrees of freedom (all vertex, face and edge dofs are assumed to come first and before that number)

isdefined(
    FEType::Type{<:AbstractFiniteElement},
    EG::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> Bool

tells if FEType is defined on this ElementGeometry

name(FES::FESpace) -> String

returns the name of the finite element space.

ndofs(FES::FESpace) -> Int64

returns the total number of degrees of freedom of the finite element space.

xgrid(FES::FESpace) -> ExtendableGrids.ExtendableGrid

returns the computational grid of the finite element space.

abstract type BEdgeDofs <: DofMap

Key type describing the dofs for each boundary edge of the dofgrid

abstract type BEdgeDofsParent <: DofMap

Key type describing the dofs for each boundary edge of the parentgrid

abstract type BFaceDofs <: DofMap

Key type describing the dofs for each boundary face of the dofgrid

abstract type BFaceDofsParent <: DofMap

Key type describing the dofs for each boundary face of the parentgrid

abstract type CellDofs <: DofMap

Key type describing the dofs for each cell of the dofgrid

abstract type CellDofsParent <: DofMap

Key type describing the dofs for each cell of the parentgrid

abstract type DofMap <: ExtendableGrids.AbstractGridAdjacency

A DofMap encodes the association of global DoF indices to mesh entities of a given type (e.g., cells, faces, edges) for a particular finite element space. This mapping is essential for assembling system matrices and vectors, applying boundary conditions, and extracting solution values. DofMaps are typically not constructed directly by users. Instead, they are generated/managed internally by the finite element space and accessed as needed for assembly or evaluation tasks.

Implementation

• All concrete DofMap subtypes (e.g., CellDofs, FaceDofs, EdgeDofs, etc.) specify the mesh entity type to which DoFs are attached.
• DofMaps are stored as ExtendableGrids.AbstractGridAdjacency (usually VariableTargetAdjacency, SerialVariableTargetAdjacency or AbstractGridIntegerArray2D) objects within the finite element space and are generated automatically as needed.
• The appropriate DofMap for a given assembly type can be accessed via FESpace[DofMapSubtype].

Example

cell_dofs = FESpace[CellDofs]   # Get the cell-based DoF map
face_dofs = FESpace[FaceDofs]   # Get the face-based DoF map

struct DofMapPatternSegment

Pattern segment of a dofmap sequence

abstract type DofType

Abstract type for all dof types

DofType(c::Char) -> Union{Nothing, Type}

parses a Char into a DofType

abstract type DofTypeEdge <: ExtendableFEMBase.DofType

Dof connected to an edge

abstract type DofTypeFace <: ExtendableFEMBase.DofType

Dof connected to a face

abstract type DofTypeInterior <: ExtendableFEMBase.DofType

Dof connected to the interior of an item

abstract type DofTypeNode <: ExtendableFEMBase.DofType

Dof connected to a single vertex

abstract type DofTypePCell <: ExtendableFEMBase.DofType

Dof connected to a parent cell

abstract type EdgeDofs <: DofMap

Key type describing the dofs for each edge of the dofgrid

abstract type EdgeDofsParent <: DofMap

Key type describing the dofs for each edge of the parentgrid

abstract type FaceDofs <: DofMap

Key type describing the dofs for each face of the dofgrid

abstract type FaceDofsParent <: DofMap

Key type describing the dofs for each face of the parentgrid

struct ParsedDofMap

Parsed dofmap, basically a sequence of DofMapPatternSegment

ParsedDofMap(
    pattern::String,
    ncomponents,
    EG::Type{<:ExtendableGrids.AbstractElementGeometry}
) -> ExtendableFEMBase.ParsedDofMap

parses a dofmap string (defined in each finite element definition file) and generated a ParsedDofMap for a certain number of components and the given geometry

Dofmap4AssemblyType(
    FES::FESpace,
    AT::Type{<:ExtendableGrids.AssemblyType}
) -> Any

yields the coressponding dofmap of the FESpace for a given AssemblyType (assumed with respect to the (parent)grid of the FESpace)

Dofmap4AssemblyType(_::Type{ON_CELLS}) -> Type{CellDofs}

Default Dofmap for AssemblyType

EffAT4AssemblyType(
    _::Type{ON_CELLS},
    _::Type{ON_CELLS}
) -> Type{ON_CELLS}

Effective AssemblyType (on the subgrid) for two AssemblyTypes where the first one is related to where the finite element functions live and the second one to where something should be assembled both with respect to the common parent grid (e.g. face-based finite elements live on a subgrid of all faces, where the faces are the cells in this subgrid, and they cannot be evaluated over the cells of the parentgrid, but on the faces of the parengrid, which are the cells in the subgrid)

ItemEdges4DofMap(
    _::Type{CellDofs}
) -> Type{ExtendableGrids.CellEdges}

ItemEdges grid component for dofmaps

ItemGeometries4DofMap(
    _::Type{CellDofs}
) -> Type{ExtendableGrids.CellGeometries}

ItemGeomtries grid component for dofmaps

ParentDofmap4Dofmap(
    _::Type{CellDofs}
) -> Type{CellDofsParent}

Parent Dofmap for Dofmap

Sub2Sup4DofMap(
    _::Type{<:DofMap}
) -> Type{ExtendableGrids.BFaceFaces}

SubItemEdges grid component for dofmaps

SuperItemNodes4DofMap(
    _::Type{CellDofs}
) -> Type{ExtendableGrids.CellNodes}

ItemNodes grid component for dofmaps

UCG4DofMap(
    _::Type{CellDofs}
) -> Type{ExtendableGrids.UniqueCellGeometries}

Unique geometry grid component for dofmaps

boundarydofs(FES; dofmap, regions) -> Any

returns an array with the number of all dofs associated to a boundary dofmap (default: BFaceDofs) and certain boundary regions (default: all regions)

get_ndofs(
    P::ExtendableFEMBase.ParsedDofMap,
    _::Type{ExtendableFEMBase.DofTypeNode}
) -> Int64

total number of dofs of the DofType

get_ndofs4c(
    P::ExtendableFEMBase.ParsedDofMap,
    _::Type{ExtendableFEMBase.DofTypeNode}
) -> Int64

total number of dofs of the DofType for a single component

init_broken_dofmap!(
    FES::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT},
    DM::Union{Type{BFaceDofs}, Type{FaceDofs}}
) -> ExtendableGrids.VariableTargetAdjacency

generates the BFaceDofs or FaceDofs DofMap for a broken FESpace based on the pattern of the FEType

init_dofmap!(FES::FESpace, DM::Type{<:DofMap}) -> Any

generates the requested DofMap for the FESpace

init_dofmap_from_pattern!(
    FES::FESpace{Tv, Ti, FEType<:AbstractFiniteElement, APT},
    DM::Type{<:DofMap}
) -> Any

generates the DofMap for the FESpace based on the pattern of the FEType

parse_pattern(
    pattern::String
) -> Vector{ExtendableFEMBase.DofMapPatternSegment}

splits a pattern string into pairs of single chars and Ints and generated a sequence of DofMapPatternSegments