Assemblers

This section describes the assemblers that are currently available and their abstract interface.

All assemblers must possess at minimum a DofManager.

Matrices

FiniteElementContainers._assemble_block_matrix! — Method

_assemble_block_matrix!(
    field::AbstractVector{<:Number},
    pattern::FiniteElementContainers.SparsityPattern,
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s33", var"#s32"} where {var"#s33"<:(StaticArraysCore.SVector), var"#s32"<:L2ElementField},
    t::Number,
    dt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    backend::KernelAbstractions.Backend
)

Assembly method for a block labelled as block_id. This is a GPU agnostic implementation using KernelAbstractions and Atomix for eliminating race conditions

TODO add state variables and physics properties

source

FiniteElementContainers._assemble_block_matrix! — Method

_assemble_block_matrix!(
    field::AbstractVector{<:Number},
    pattern::FiniteElementContainers.SparsityPattern,
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s28", var"#s27"} where {var"#s28"<:(StaticArraysCore.SVector), var"#s27"<:L2ElementField},
    t::Number,
    dt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    _::KernelAbstractions.CPU
)

Assembly method for a block labelled as block_id. This is a CPU implementation with no threading.

TODO add state variables and physics properties

source

FiniteElementContainers.assemble_matrix! — Method

assemble_matrix!(
    storage,
    pattern,
    dof,
    func::Function,
    Uu,
    p
)

Note this is hard coded to storing the assembled sparse matrix in the stiffness_storage field of assembler.

source

Matrix Action

FiniteElementContainers._assemble_block_matrix_action! — Method

_assemble_block_matrix_action!(
    field::FiniteElementContainers.AbstractField,
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    V::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s31", var"#s30"} where {var"#s31"<:(StaticArraysCore.SVector), var"#s30"<:L2ElementField},
    t::Number,
    Δt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    _::KernelAbstractions.CPU
)

Assembly method for a block labelled as block_id. This is a CPU implementation with no threading.

TODO improve typing of fields to ensure they mathc up in terms of function spaces

source

FiniteElementContainers._assemble_block_matrix_action! — Method

_assemble_block_matrix_action!(
    field::FiniteElementContainers.AbstractField,
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    V::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s178", var"#s34"} where {var"#s178"<:(StaticArraysCore.SVector), var"#s34"<:L2ElementField},
    t::Number,
    Δt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    backend::KernelAbstractions.Backend
)

Assembly method for a block labelled as block_id. This is a GPU agnostic implementation using KernelAbstractions and Atomix for eliminating race conditions

TODO add state variables and physics properties

source

Matrix Action

FiniteElementContainers._assemble_block_vector_neumann_bc! — Method

_assemble_block_vector_neumann_bc!(
    field::FiniteElementContainers.AbstractField,
    U::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    t::Number,
    bc::FiniteElementContainers.NeumannBCContainer,
    backend::KernelAbstractions.Backend
)

source

FiniteElementContainers._assemble_block_vector_neumann_bc! — Method

_assemble_block_vector_neumann_bc!(
    field::FiniteElementContainers.AbstractField,
    U::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    t::Number,
    bc::FiniteElementContainers.NeumannBCContainer,
    _::KernelAbstractions.CPU
)

source

FiniteElementContainers.assemble_vector_neumann_bc! — Method

assemble_vector_neumann_bc!(assembler, Uu, p)

source

Scalar

FiniteElementContainers._assemble_block_quadrature_quantity! — Method

_assemble_block_quadrature_quantity!(
    field::AbstractMatrix{<:Number},
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s29", var"#s28"} where {var"#s29"<:(StaticArraysCore.SVector), var"#s28"<:L2ElementField},
    t::Number,
    Δt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    _::KernelAbstractions.CPU
)

Assembly method for a block labelled as block_id. This is a CPU implementation with no threading.

TODO improve typing of fields to ensure they mathc up in terms of function spaces

source

FiniteElementContainers._assemble_block_quadrature_quantity! — Method

_assemble_block_quadrature_quantity!(
    field::AbstractMatrix{<:Number},
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s33", var"#s32"} where {var"#s33"<:(StaticArraysCore.SVector), var"#s32"<:L2ElementField},
    t::Number,
    Δt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    backend::KernelAbstractions.Backend
)

Assembly method for a block labelled as block_id. This is a GPU agnostic implementation using KernelAbstractions and Atomix for eliminating race conditions

TODO add state variables and physics properties

source

FiniteElementContainers.assemble_quadrature_quantity! — Method

assemble_quadrature_quantity!(
    storage,
    dof,
    func::Function,
    Uu,
    p
)

source

FiniteElementContainers.assemble_scalar! — Method

assemble_scalar!(assembler, func::Function, Uu, p)

source

Vector

FiniteElementContainers._assemble_block_vector! — Method

_assemble_block_vector!(
    field::FiniteElementContainers.AbstractField,
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s31", var"#s30"} where {var"#s31"<:(StaticArraysCore.SVector), var"#s30"<:L2ElementField},
    t::Number,
    Δt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    _::KernelAbstractions.CPU
)

Assembly method for a block labelled as block_id. This is a CPU implementation with no threading.

TODO improve typing of fields to ensure they mathc up in terms of function spaces

source

FiniteElementContainers._assemble_block_vector! — Method

_assemble_block_vector!(
    field::FiniteElementContainers.AbstractField,
    physics::AbstractPhysics,
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    U::FiniteElementContainers.AbstractField,
    U_old::FiniteElementContainers.AbstractField,
    X::FiniteElementContainers.AbstractField,
    state_old::L2QuadratureField,
    state_new::L2QuadratureField,
    props::Union{var"#s178", var"#s34"} where {var"#s178"<:(StaticArraysCore.SVector), var"#s34"<:L2ElementField},
    t::Number,
    Δt::Number,
    conns::L2ElementField,
    block_id::Int64,
    func::Function,
    backend::KernelAbstractions.Backend
)

Assembly method for a block labelled as block_id. This is a GPU agnostic implementation using KernelAbstractions and Atomix for eliminating race conditions

TODO add state variables and physics properties

source

FiniteElementContainers.assemble_vector! — Method

assemble_vector!(assembler, func::Function, Uu, p)

source

Abstract Interface

FiniteElementContainers.AbstractAssembler — Type

abstract type AbstractAssembler{Dof<:DofManager}

source

FiniteElementContainers._assemble_element! — Method

_assemble_element!(
    global_val::H1Field,
    local_val,
    conn,
    e,
    b
)

Assembly method for an H1Field, e.g. internal force Called on a single element e for a given block b where local_val has already been constructed from quadrature contributions.

source

FiniteElementContainers._cell_interpolants — Method

_cell_interpolants(
    ref_fe::ReferenceFiniteElements.ReferenceFE,
    q::Int64
) -> Any

source

FiniteElementContainers._element_level_fields — Method

_element_level_fields(U::H1Field, ref_fe, conns, e) -> Any

source

FiniteElementContainers._element_level_fields_flat — Method

_element_level_fields_flat(
    U::H1Field,
    ref_fe,
    conns,
    e
) -> Any

source

FiniteElementContainers._element_level_properties — Method

_element_level_properties(
    props::L2ElementField,
    e::Int64
) -> Any

source

FiniteElementContainers._element_level_properties — Method

_element_level_properties(
    props::StaticArraysCore.SArray{Tuple{NP}, T, 1, NP},
    _::Int64
) -> StaticArraysCore.SVector

source

FiniteElementContainers._element_scratch_matrix — Method

_element_scratch_matrix(ref_fe, U) -> Any

source

FiniteElementContainers._element_scratch_vector — Method

_element_scratch_vector(ref_fe, U) -> Any

source

FiniteElementContainers._quadrature_level_state — Method

_quadrature_level_state(
    state::L2QuadratureField,
    q::Int64,
    e::Int64
) -> Any

source

FiniteElementContainers.hvp — Method

hvp(
    asm::FiniteElementContainers.AbstractAssembler,
    v
) -> Any

source

FiniteElementContainers.mass — Method

mass(
    assembler::FiniteElementContainers.AbstractAssembler
) -> SparseArrays.SparseMatrixCSC{Float64, Int64}

source

FiniteElementContainers.residual — Method

residual(
    asm::FiniteElementContainers.AbstractAssembler
) -> Any

assumes assemble_vector! has already been called

source

FiniteElementContainers.stiffness — Method

stiffness(
    assembler::FiniteElementContainers.AbstractAssembler
) -> SparseArrays.SparseMatrixCSC{Float64, Int64}

source

KernelAbstractions.get_backend — Method

get_backend(
    asm::FiniteElementContainers.AbstractAssembler
) -> Any

source

SparseMatrixAssembler

FiniteElementContainers.SparseMatrixAssembler — Type

struct SparseMatrixAssembler{Dof<:DofManager, Pattern<:FiniteElementContainers.SparsityPattern, Storage1<:(AbstractVector{<:Number}), Storage2<:FiniteElementContainers.AbstractField, Storage3<:NamedTuple} <: FiniteElementContainers.AbstractAssembler{Dof<:DofManager}

General sparse matrix assembler that can handle first or second order problems in time.

source

FiniteElementContainers.SparseMatrixAssembler — Method

SparseMatrixAssembler(
    dof::DofManager
) -> SparseMatrixAssembler{Dof, Pattern, Vector{Float64}, Storage2, Storage3} where {Dof<:DofManager, Pattern<:(FiniteElementContainers.SparsityPattern{Vector{Int64}, _A, Vector{Float64}} where _A), Storage2<:FiniteElementContainers.AbstractField, Storage3<:(NamedTuple{_A, Tuple{Vararg{Matrix{Float64}, N}}} where {_A, N})}

Construct a SparseMatrixAssembler for a specific field type, e.g. H1Field. Can be used to create block arrays for mixed FEM problems.

source

FiniteElementContainers._assemble_element! — Method

_assemble_element!(
    pattern::FiniteElementContainers.SparsityPattern,
    storage,
    K_el::StaticArraysCore.SMatrix,
    el_id::Int64,
    block_id::Int64
)

Specialization of of _assemble_element! for SparseMatrixAssembler.

source

SparsityPattern

FiniteElementContainers.SparsityPattern — Type

struct SparsityPattern{I<:AbstractVector{Int64}, B, R<:AbstractVector{Float64}}

Is::AbstractVector{Int64}
Js::AbstractVector{Int64}
unknown_dofs::AbstractVector{Int64}
block_sizes::Any
block_offsets::Any
klasttouch::AbstractVector{Int64}
csrrowptr::AbstractVector{Int64}
csrcolval::AbstractVector{Int64}
csrnzval::AbstractVector{Float64}
csccolptr::AbstractVector{Int64}
cscrowval::AbstractVector{Int64}
cscnzval::AbstractVector{Float64}

Book-keeping struct for sparse matrices in FEM settings. This has all the information to construct a sparse matrix for either case where you want to eliminate fixed-dofs or not.

source