SpecialSpaces

Base.eltype(::Type{S}) where {Dim,T<:Integer,S<:VectorSplineSpaceConstraints{Dim,<:Any,T}}

Return element type of VectorSplineSpaceConstraints collection.

Base.eltype(::Type{S}) where {T<:Integer,S<:ScalarSplineSpaceConstraints{<:Any,T}}

Return element type of ScalarSplineSpaceConstraints collection.

Base.getindex(V::S, i::Int64) where {S<:VectorFunctionSpace}

Return ith vector function space component.

Base.getindex(C::ScalarSplineSpaceConstraints, i::T) where {T<:Integer}

Return ith component constraints in a ScalarSplineSpaceConstraints

Base.getindex(C::ScalarSplineSpaceConstraints, i::T) where {T<:Integer}

Return ith component constraints in a VectorSplineSpaceConstraints

Base.iterate(C::ScalarSplineSpaceConstraints)
Base.iterate(C::ScalarSplineSpaceConstraints, i::T) where {T<:Integer} = iterate(C.data, i)

Iterate of the collection of UnivariateSplineSpaceConstraints stored in ScalarSplineSpaceConstraints.

Base.iterate(V::S) where {S<:VectorFunctionSpace} = iterate(parent(V))
Base.iterate(V::S, i::Int) where {S<:VectorFunctionSpace} = iterate(parent(V), i)

Iterate over vector function space components.

Base.iterate(C::VectorSplineSpaceConstraints)
Base.iterate(C::VectorSplineSpaceConstraints, i::T) where {T<:Integer} = iterate(C.data, i)

Iterate of the collection of ScalarSplineSpaceConstraints stored in VectorSplineSpaceConstraints.

Base.length(V::S) where {S<:VectorFunctionSpace}

Return the number of vector function space components.

Base.length(C::ScalarSplineSpaceConstraints{Dim}) where {Dim}

Return number of dimensions Dim.

Base.length(C::VectorSplineSpaceConstraints{<:Any,Codim}) where {Codim}

Return number of dimensions Dim.

dimensions(V::ScalarSplineSpace)

Return the dimension of a ScalarSplineSpace.

IgaBase.dimension(V::T) where {T<:MixedFunctionSpace}

Return the dimension of a mixed function space.

IgaBase.dimension(V::T) where {T<:VectorFunctionSpace}

Return the dimension of a vector function space.

IgaBase.dimension(V::T, k::Int) where {T<:VectorFunctionSpace}

Return the dimension of the ith component of a vector function space.

IgaBase.dimension(V::T, field::Symbol, i::Int64) where {T<:MixedFunctionSpace}

Return the dimension of the ith component of a vector function space field in a mixed space V.

IgaBase.dimension(V::T, field::Symbol) where {T<:MixedFunctionSpace}

Return the dimension of a scalar function space field in a mixed space V.

IgaBase.numbertype(::FunctionSpace{<:Any,<:Any,T}) where {T}

Return the data type used by a function space to represent numbers.

IgaBase.numbertype(::MixedFunctionSpace{<:Any,T}) where {T}

Return the data type for numbers used in space.

boundary_number(s::Symbol)

Return the boundary number corresponding to boundary s.

                                               5
                            4                 back
                           top                  . . . . . . .
                     . . . . . . . .            . .         . .
η                    .             .            .   .       .   .
.                    .             .            .     . . . . . . .
.             left   .             .  right     .     .     .     .
.               1    .             .    2       .     .     .     .
· · · ·  ξ           .             .            . . . . . . .     .
  ·                  . . . . . . . .              .   .       .   .
    ·                    bottom                     . .         . .
      ζ                     3                         . . . . . . .
                                                                 front
                                                                   6

boundary_symbol(s::Int)

Return the boundary label (symbol) for boundary number s.

clamped_constraint!(C::ScalarSplineSpaceConstraints, side::Vararg{Symbol,N}) where {N}

Clamp a scalar spline space at side, where side is one of the boundary labels:

• :left
• :right
• :bottom
• :top
• :back
• :front

clamped_constraint!(C::VectorSplineSpaceConstraints{Dim}, side::Vararg{Symbol,N}; dim=1:Dim) where {Dim,N}

Clamp a vector spline space in dimensions dim at side, where side is one of the boundary labels:

• :left
• :right
• :bottom
• :top
• :back
• :front

codimfunspace(::FunctionSpace{<:Any,Codim})

Return codomain dimension of function space

dimensions(V::ScalarSplineSpace)

Return the dimension of a ScalarSplineSpace in each tensor-product direction as a tuple.

dimensions(V::T) where {T<:MixedFunctionSpace}

Return the dimension in each tensor-product direction of a mixed function space as a tuple.

dimensions(V::T) where {T<:VectorFunctionSpace}

Return the dimension in each tensor-product direction of a vector function space as a tuple.

dimensions(V::T, i::Int64) where {T<:VectorFunctionSpace}

Return the dimension in each tensor-product direction of the ith component of a vector function space as a tuple.

dimensions(V::T, field::Symbol, i::Int64) where {T<:MixedFunctionSpace}

Return the dimension in each tensor-product direction of the ith component of a vector function space field in the mixed space V as a tuple.

dimensions(V::T, field::Symbol, i::Int64) where {T<:MixedFunctionSpace}

Return the dimension in each tensor-product direction of the vector function space field in the mixed space V as a tuple.

dimfunspace(::FunctionSpace{Dim}) where {Dim}

Return domain dimension of function space.

extraction_operator(S::ScalarSplineSpace; sparse::Bool=false)

Return the extraction operator for a scalar function space.

If sparse is true, return a sparse matrix.

extraction_operator(S::T, field::Symbol; sparse::Bool=false) where {T<:MixedFunctionSpace}

Return the extraction operator for a scalar function space field in mixed function space S.

If sparse is true, return a sparse matrix.

extraction_operators(S::T; sparse::Bool=false) where {T<:VectorFunctionSpace}

Return the extraction operator for a vector function space.

If sparse is true, return a tuple of sparse matrices.

extraction_operators(S::T, field::Symbol; sparse::Bool=false) where {T<:MixedFunctionSpace}

Return the extraction operators for a vector function space field in mixed function space S in a tuple.

If sparse is true, return a tuple of sparse matrices.

getcoeffs(f::Field)
getcoeffs(f::GeometricMapping)

Return a vector of vertically concatenated (tensor-product Bspline) mapping coefficients.

indices(V::ScalarSplineSpace)

Return linear indices for a scalar function space.

indices(space::S) where {S<:MixedFunctionSpace}

Return linear indices for a mixed function space.

indices(space::S) where {S<:VectorFunctionSpace}

Return linear indices for a vector function space.

indices(space::S, i::Int) where {S<:VectorFunctionSpace}

Return linear indices for ith component of a vector function space.

indices(space::S, field::Symbol, i::Int) where {S<:MixedFunctionSpace}

Return linear indices for ith component of a vector function space field in mixed function space space.

indices(space::S, field::Symbol) where {S<:MixedFunctionSpace}

Return linear indices for a function space field in mixed function space space.

left_constraint!(C::ScalarSplineSpaceConstraints{Dim}; c::Vector{Int}=Int[1], dim::Int) where {Dim}

Push c to vector in left field of UnivariateSplineSpaceConstraints stored at index dim in ScalarSplineSpaceConstraints.

periodic_constraint!(C::ScalarSplineSpaceConstraints{Dim}; c::Vector{Int}, dim::Int) where {Dim}

Push c to vector in periodic field of UnivariateSplineSpaceConstraints stored at index dim in ScalarSplineSpaceConstraints.

right_constraint!(C::ScalarSplineSpaceConstraints{Dim}; c::Vector{Int}=Int[1], dim::Int) where {Dim}

Push c to vector in right field of UnivariateSplineSpaceConstraints stored at index dim in ScalarSplineSpaceConstraints.

setcoeffs!(f::M, v::Vector{T}, k::Int=1, slice::Base.UnitRange{Int}=Base.UnitRange(1,length(v))) where {M<:AbstractMapping,T<:Real}

Set coefficients of a mapping component to a slice of coefficients in a vector.

Arguments:

• f: mapping in question
• v: vector with coeffs
• slice: range of indices of vector v
• k: component of field f

setcoeffs!(f::M, mixedspace::S, field::Symbol, v::Vector{T}) where {M<:AbstractMapping,S<:MixedSplineSpace,T<:Real}

Set coefficients of a mapping defined on a mixedspace.

Arguments:

• f: mapping in question
• mixedspace: space
• field: space field
• v: vector with coeffs with length dim(mixedspace)

setcoeffs!(f::M, scalarspace::S, v::Vector{T}) where {M<:AbstractMapping,S<:ScalarSplineSpace,T<:Real}

Set coefficients of a mapping defined on a scalar space.

Arguments:

• f: mapping in question
• scalarspace: space
• v: vector with coeffs with length dim(scalarspace)

setcoeffs!(f::M, vectorspace::S, v::Vector{T}) where {M<:AbstractMapping,S<:VectorSplineSpace,T<:Real}

Set coefficients of a mapping defined on a vector space.

Arguments:

• f: mapping in question
• vectorspace: space
• v: vector with coeffs with length dim(vectorspace)

Field(space::S) where {S<:ScalarSplineSpace}
Field(space::S) where {S<:VectorSplineSpace}
Field(space::S, s::Symbol) where {S<:MixedSplineSpace}

Construct field on some spline spaces.

AbstractMappings.GeometricMapping(domain, args::ScalarScalarSpace; orientation::Int=1)
AbstractMappings.GeometricMapping(domain, args::VectorSplineSpace; orientation::Int=1)
AbstractMappings.GeometricMapping(domain, args::MixedSplineSpace, field::Symbol; orientation::Int=1)

Construct geometric mapping on some spline spaces.

const Domain{Dim,T} = CartesianProduct{Dim,Tuple{Vararg{T,Dim}},Tuple{Vararg{Interval{T},Dim}}}

Alias for CartesianProduct of Interval defining a domain.

abstract type FunctionSpace{Dim,Codim,T}

Concrete function spaces subtype this.

Parameters

• Dim: dimension of the domain
• Codim: dimension of the codomain
• T: data type used for numbers (returned by IgaBase.numbertype)

struct IterableMixedSplineSpace{Dim,Codim,T} <: MixedSplineSpace{Dim,Codim,T}

A general purpose mixed spline space, which can be constructed from a named tuple consisting of scalar and vector spline spaces. Besides the usual interface to mixed function spaces, it additionally supports iteration over the collection of spaces.

The supplied spaces must have the same domain dimension, partition and number type.

abstract type MixedFunctionSpace{Dim,T}

Mixed spaces like MixedSplineSpace subtype this.

Mixed function spaces are expected to collect components as struct fields.

abstract type MixedSplineSpace{Dim,Codim,T} <: MixedFunctionSpace{Dim,Codim,T}

Concrete mixed spaces like RaviartThomas subtype this.

const MixedSplineSpaceConstraints

Type alias for NamedTuple which serves as a container for mixed space constraints.

MixedSplineSpaceConstraints(S::RaviartThomas{Dim}) where {Dim}

Construct a constraints container for TaylorHood.

MixedSplineSpaceConstraints(S::RaviartThomas{Dim}) where {Dim}

Construct a constraints container for RaviartThomas.

const Partition{Dim,T} = CartesianProduct{Dim,Tuple{Vararg{T,Dim}},Tuple{Vararg{IncreasingRange{T},Dim}}}

Alias for CartesianProduct defining a partition.

Partition(S::ScalarSplineSpace)

Return the partition corresponding to a ScalarSplineSpace.

Partition(space::MixedSplineSpace)

Return the partition corresponding to a MixedSplineSpace.

Partition(S::VectorSplineSpace)

Return the partition corresponding to a VectorSplineSpace.

Partition(domain::S, n::NTuple{Dim, Int64}) where {Dim,T<:Real,S<:Domain{Dim,T}}

Return an uniform Partition of Domain with nₖ breakpoints in kth dimension.

struct RaviartThomas{Dim,Codim,T} <: MixedSplineSpace{Dim,Codim,T}

Structure preserving pair of spline spaces for velocities and pressure in two and three dimensions.

RaviartThomas(p::Degree, Δ::Partition{Dim,T}) where {Dim,T<:Real}
RaviartThomas(p::Degree, Δ::Partition{2,T}, C::MixedSplineSpaceConstraints{(:V,:Q)})
RaviartThomas(p::Degree, Δ::Partition{3,T}, C::MixedSplineSpaceConstraints{(:V,:Q)}) where {T<:Real}

Construct a RaviartThomas mixed spline space.

Type alias for a tensor-product SplineSpace.

ScalarSplineSpace(S::ScalarSplineSpace{Dim,T}) where {Dim,T<:Real}
ScalarSplineSpace(p::Degree, partition::Partition{Dim,T}) where {Dim,T<:Real}
ScalarSplineSpace(degrees::NTuple{Dim,Degree}, partition::Partition{Dim,T}) where {Dim,T<:Real}
ScalarSplineSpace(degrees::NTuple{Dim,Degree}, partition::Partition{Dim,T}, C::ScalarSplineSpaceConstraints{Dim}) where {Dim,T<:Real}
ScalarSplineSpace(S::ScalarSplineSpace{Dim,T}, C::ScalarSplineSpaceConstraints{Dim}) where {Dim,T<:Real}

Construct a ScalarSplineSpace.

If constructed from another ScalarSplineSpace, discard constraint conditions.

struct ScalarSplineSpaceConstraints{Dim,T}

Container for ScalarSplineSpace constraints.

Field data stores a tuple of UnivariateSplineSpaceConstraints for each tensor-product dimension of ScalarSplineSpace.

ScalarSplineSpaceConstraints(::F) where {Dim,F<:ScalarSplineSpace{Dim}}

Construct a constraints container for a ScalarSplineSpace.

ScalarSplineSpaceConstraints{Dim}() where {Dim}
ScalarSplineSpaceConstraints{Dim,T}() where {Dim,T<:Integer}

Construct default ScalarSplineSpaceConstraints for a ScalarSplineSpace of dimension Dim.

abstract type SplineSpaceConstraints{T}

Concrete spline space constraints container subtype this.

struct TaylorHood{Dim,T} <: MixedSplineSpace{Dim,T}

An inf-sup stable pair of spline spaces for velocities and pressure in two and three dimensions.

TaylorHood(p::Degree, Δ::Partition{Dim,T}) where {Dim,T<:Real}
TaylorHood(p::Degree, Δ::Partition{Dim,T}, C::MixedSplineSpaceConstraints{(:V,:Q)}) where {Dim,T<:Real}

Construct a TaylorHood mixed spline space.

struct UnivariateSplineSpaceConstraints{T}

Container for SplineSpace constraints, i.e. cleft, cright, cperiodic vectors in SplineSpace constructor stored as left, rightand periodic field.

UnivariateSplineSpaceConstraints()

Construct default UnivariateSplineSpaceConstraints

abstract type VectorFunctionSpace{Dim,T}

Concrete vector spaces like VectorSplineSpace subtype this.

Vector function spaces are expected to collect components as a tuple in field :V.

VectorSplineSpace(degree::Degree, partition::Partition{Dim,T}) where {Dim,T<:Real}
VectorSplineSpace(degrees::NTuple{Dim,Degree}, partition::Partition{Dim,T}) where {Dim,T<:Real}
VectorSplineSpace(V::VectorSplineSpace{Dim,Codim,T}, C::VectorSplineSpaceConstraints{Dim,Codim}) where {Dim,Codim,T<:Real}
VectorSplineSpace(S::ScalarSplineSpace{Dim,T}) where {Dim,T<:Real}
VectorSplineSpace(V::NTuple{Codim,ScalarSplineSpace{Dim,T}}) where {Dim,Codim,T}
VectorSplineSpace(V::Vararg{ScalarSplineSpace{Dim,T},Codim}) where {Dim,Codim,T}

Construct a VectorSplineSpace.

Constraints on scalar spline space arguments are preserved.

struct ScalarSplineSpaceConstraints{Dim,T}

Container for ScalarSplineSpaceConstraints.

Field data stores a tuple of ScalarSplineSpaceConstraints for each component of VectorSplineSpace.

VectorSplineSpaceConstraints(::F) where {Dim,Codim,F<:VectorSplineSpace{Dim,Codim}}

Construct a constraints container for a VectorSplineSpace.

VectorSplineSpaceConstraints{Dim}() where {Dim}
VectorSplineSpaceConstraints{Dim,Codim}() where {Dim,Codim}
VectorSplineSpaceConstraints(args::Vararg{ScalarSplineSpaceConstraints{Dim},Codim}) where {Dim,Codim}
VectorSplineSpaceConstraints{T}(args::Vararg{ScalarSplineSpaceConstraints{Dim},Codim}) where {Dim,Codim,T}
VectorSplineSpaceConstraints{Dim,Codim,T}() where {Dim,Codim,T<:Integer}

Construct VectorSplineSpaceConstraints for a VectorSplineSpace of dimension Dim and codomain dimension Codim.