abstract type AbstractField{T, N, NF, Vals} <: AbstractArray{T, N}

Thin wrapper that subtypes AbstractArray and serves as the base Field type

abstract type AbstractMechanicsFormulation{ND}

abstract type AbstractMesh <: FiniteElementContainers.FEMContainer

abstract type Assembler{Rtype, Itype}

abstract type ElementField{T, N, NN, NE, Vals} <: FiniteElementContainers.AbstractField{T, N, NN, Vals}

Default constructor from a mesh

DofManager{A}(ND::Int, NN::Int) where A

DofManager{ND, NN, I, ArrType}() where {ND, NN, I, ArrType}

DofManager{ND, NN, ArrType}() where {ND, NN, ArrType}

struct DynamicAssembler{Rtype, Itype, I<:AbstractArray{Itype, 1}, J<:AbstractArray{Itype, 1}, U<:AbstractArray{Itype, 1}, Sizes<:AbstractArray{Itype, 1}, Offsets<:AbstractArray{Itype, 1}, R<:NodalField, K<:AbstractArray{Rtype, 1}, M<:AbstractArray{Rtype, 1}, C1, C2, C3, C4, C5, C6, C7} <: Assembler{Rtype, Itype}

• Is::AbstractVector

• Js::AbstractVector

• unknown_dofs::AbstractVector

• block_sizes::AbstractVector

• block_offsets::AbstractVector

• residuals::NodalField

• stiffnesses::AbstractVector

• masses::AbstractVector

• klasttouch::Any

• csrrowptr::Any

• csrcolval::Any

• csrnzval::Any

• csccolptr::Any

• cscrowval::Any

• cscnzval::Any

Assembler for dynamic problems without damping

Provides both a mass and stiffness matrix

Default initialization Assumes no dirichlet bcs

TODO add typing to constructor

abstract type ElementField{T, N, NN, NE, Vals} <: FiniteElementContainers.AbstractField{T, N, NN, Vals}

Abstract type for implementations of fields that live on elements.

Constructors

ElementField{NN, NE, Vector}(vals::M) where {NN, NE, M <: AbstractArray{<:Number, 2}}

ElementField{NN, NE, Matrix}(vals::M) where {NN, NE, M <: AbstractArray{<:Number, 2}}

ElementField{NN, NE, Vector}(vals::V) where {NN, NE, V <: AbstractArray{<:Number, 1}}

ElementField{NN, NE, Vector, T}(::UndefInitializer) where {NN, NE, T}

ElementField{NN, NE, Matrix, T}(::UndefInitializer) where {NN, NE, T <: Number}

ElementField{NN, NE, StructArray, T}(::UndefInitializer) where {NN, NE, T}

ElementField{Tup, A, T}(::UndefInitializer) where {Tup, A, T}

ElementField{Tup, A}(vals::M) where {Tup, A, M <: AbstractArray}

struct FileMesh{MeshObj} <: FiniteElementContainers.AbstractMesh

• file_name::String

• mesh_obj::Any

Mesh type that has a handle to an open mesh file object. This type's methods are "overridden" in extensions.

See FiniteElementContainersExodusExt for an example.

abstract type FunctionSpace{NDof, RefFE, Conn}

struct IncompressiblePlaneStress <: AbstractMechanicsFormulation{2}

struct Interpolants{A1, A2, A3, A4}

• X_q::Any

• N::Any

• ∇N_X::Any

• JxW::Any

abstract type NodalField{T, N, NF, NN, Vals} <: FiniteElementContainers.AbstractField{T, N, NF, Vals}

Abstract type for implementations of fields that live on nodes.

Constructors

NodalField{NF, NN, Vector}(vals::M) where {NF, NN, M <: AbstractArray{<:Number, 2}}

NodalField{NF, NN, Matrix}(vals::M) where {NF, NN, M <: AbstractArray{<:Number, 2}}

NodalField{NF, NN, Vector}(vals::V) where {NF, NN, V <: AbstractArray{<:Number, 1}}

NodalField{NF, NN, Vector}(vals::V) where {NF, NN, V <: AbstractArray{<:Number, 1}}

NodalField{NF, NN, Vector, T}(::UndefInitializer) where {NF, NN, T}

NodalField{NF, NN, Matrix, T}(::UndefInitializer) where {NF, NN, T <: Number}

NodalField{NF, NN, StructArray, T}(::UndefInitializer) where {NF, NN, T}

NodalField{Tup, A, T}(::UndefInitializer) where {Tup, A, T}

struct NonAllocatedFunctionSpace{NDof, Conn<:(ElementField), DofConn<:(ElementField), RefFE<:ReferenceFiniteElements.ReferenceFE} <: FunctionSpace{NDof, Conn<:(ElementField), RefFE<:ReferenceFiniteElements.ReferenceFE}

• conn::ElementField

• dof_conn::ElementField

• ref_fe::ReferenceFiniteElements.ReferenceFE

struct PlaneStrain <: AbstractMechanicsFormulation{2}

abstract type QuadratureField{T, N, NF, NQ, NE, Vals} <: FiniteElementContainers.AbstractField{T, N, NF, Vals}

Abstract type for implementations of fields that live on quadrature points.

Constructors

QuadratureField{NF, NQ, NE, Matrix}(vals::Matrix{<:Number}) where {NF, NQ, NE}

QuadratureField{NF, NQ, NE, Vector}(vals::Matrix{<:Number}) where {NF, NQ, NE}

QuadratureField{NF, NQ, NE, Matrix, T}(::UndefInitializer) where {NF, NQ, NE, T}

QuadratureField{NF, NQ, NE, StructArray, T}(::UndefInitializer) where {NF, NQ, NE, T}

QuadratureField{NF, NQ, NE, StructVector, T}(::UndefInitializer) where {NF, NQ, NE, T}

QuadratureField{NF, NQ, NE, Vector, T}(::UndefInitializer) where {NF, NQ, NE, T}

QuadratureField{Tup, A, T}(::UndefInitializer) where {Tup, A, T}

QuadratureField{Tup, A}(vals::M) where {Tup, A, M <: AbstractArray}

struct SimpleElementField{T, N, NN, NE, Vals} <: ElementField{T, N, NN, NE, Vals}

struct SimpleElementField{T, N, NN, NE, Vals} <: ElementField{T, N, NN, NE, Vals}

SimpleElementField{NN, NE}(vals::M) where {NN, NE, M <: AbstractArray{<:Number, 2}}

SimpleElementField{NN, NE, Matrix, T}(::UndefInitializer) where {NN, NE, T}

struct SimpleNodalField{T, N, NF, NN, Vals<:AbstractArray{T, 2}} <: NodalField{T, N, NF, NN, Vals<:AbstractArray{T, 2}}

SimpleNodalField{NF, NN, T}(::UndefInitializer) where {NF, NN, T}

SimpleNodalField{NF, NN}(vals::V) where {NF, NN, V <: AbstractArray{<:Number, 2}}

struct SimpleQuadratureField{T, N, NF, NQ, NE, Vals<:AbstractArray{T, 2}} <: QuadratureField{T, N, NF, NQ, NE, Vals<:AbstractArray{T, 2}}

SimpleQuadratureField{1, NQ, NE}(vals::M) where {NQ, NE, M <: AbstractArray{<:Number, 2}}

SimpleQuadratureField{NF, NQ, NE}(vals::S) where {NF, NQ, NE, S <: StructArray}

SimpleQuadratureField{NF, NQ, NE, StructArray, T}(::UndefInitializer) where {NF, NQ, NE, T}

SimpleQuadratureField{1, NQ, NE, Matrix, T}(::UndefInitializer) where {NQ, NE, T <: AbstractArray}

SimpleQuadratureField{1, NQ, NE, Matrix, T}(::UndefInitializer) where {NQ, NE, T <: Number}

struct StaticAssembler{Rtype, Itype, I<:AbstractArray{Itype, 1}, J<:AbstractArray{Itype, 1}, U<:AbstractArray{Itype, 1}, Sizes<:AbstractArray{Itype, 1}, Offsets<:AbstractArray{Itype, 1}, R<:NodalField, K<:AbstractArray{Rtype, 1}, C1, C2, C3, C4, C5, C6, C7} <: Assembler{Rtype, Itype}

• Is::AbstractVector

• Js::AbstractVector

• unknown_dofs::AbstractVector

• block_sizes::AbstractVector

• block_offsets::AbstractVector

• residuals::NodalField

• stiffnesses::AbstractVector

• klasttouch::Any

• csrrowptr::Any

• csrcolval::Any

• csrnzval::Any

• csccolptr::Any

• cscrowval::Any

• cscnzval::Any

Assembler for static or quasistatic problems where only a stiffness matrix is necessary

Default initialization Assumes no dirichlet bcs

TODO add typing to constructor

struct ThreeDimensional <: AbstractMechanicsFormulation{3}

struct VectorizedElementField{T, N, NN, NE, Vals} <: ElementField{T, N, NN, NE, Vals}

struct VectorizedElementField{T, N, NN, NE, Vals<:AbstractArray{T, 1}} <: ElementField{T, N, NN, NE, Vals<:AbstractArray{T, 1}}

VectorizedElementField{NN, NE}(vals::Matrix{<:Number}) where {NN, NE}

VectorizedElementField{NN, NE, T}(::UndefInitializer) where {NN, NE, T <: AbstractArray}

VectorizedElementField{NN, NE, T}(::UndefInitializer) where {NN, NE, T <: Number}

VectorizedElementField{NN, NE, StructArray, T}(::UndefInitializer) where {NN, NE, T}

VectorizedElementField{NN, NE}(vals::V) where {NN, NE, V <: AbstractArray{<:AbstractArray, 1}}

VectorizedElementField{NN, NE}(vals::V) where {NN, NE, V <: AbstractArray{<:Number, 1}}

struct VectorizedNodalField{T, N, NF, NN, Vals<:AbstractArray{T, 1}} <: NodalField{T, N, NF, NN, Vals<:AbstractArray{T, 1}}

VectorizedNodalField{NF, NN}(vals::M) where {NF, NN, M <: AbstractArray{<:Number, 2}}

VectorizedNodalField{NF, NN, T}(::UndefInitializer) where {NF, NN, T <: AbstractArray}

VectorizedNodalField{NF, NN, T}(::UndefInitializer) where {NF, NN, T <: Number}

VectorizedNodalField{NF, NN, StructArray, T}(::UndefInitializer) where {NF, NN, T}

VectorizedNodalField{NF, NN}(vals::V) where {NF, NN, V <: AbstractArray{<:AbstractArray, 1}}

VectorizedNodalField{NF, NN}(vals::V) where {NF, NN, V <: AbstractArray{<:Number, 1}}

struct VectorizedPreAllocatedFunctionSpace{NDof, Conn<:(ElementField), DofConn<:(ElementField), RefFE<:ReferenceFiniteElements.ReferenceFE, V1<:QuadratureField, V2<:QuadratureField, V3<:QuadratureField} <: FunctionSpace{NDof, Conn<:(ElementField), RefFE<:ReferenceFiniteElements.ReferenceFE}

• conn::ElementField

• dof_conn::ElementField

• ref_fe::ReferenceFiniteElements.ReferenceFE

• Ns::QuadratureField

• ∇N_Xs::QuadratureField

• JxWs::QuadratureField

struct VectorizedQuadratureField{T, N, NF, NQ, NE, Vals<:AbstractArray{T, 1}} <: QuadratureField{T, N, NF, NQ, NE, Vals<:AbstractArray{T, 1}}

VectorizedQuadratureField{1, NQ, NE}(vals::M) where {NQ, NE, M <: AbstractArray{<:Number, 2}}

VectorizedQuadratureField{NF, NQ, NE}(vals::S) where {NF, NQ, NE, S <: StructVector}

VectorizedQuadratureField{NF, NQ, NE, Vector, T}(::UndefInitializer) where {NF, NQ, NE, T}

VectorizedQuadratureField{1, NQ, NE}(vals::V) where {NQ, NE, V <: AbstractArray{<:Number, 1}}

eltype(
    _::Type{FiniteElementContainers.AbstractField{T, N, NF, Vals}}
) -> Any

similar(
    asm::StaticAssembler
) -> StaticAssembler{_A, Int64, var"#s178", var"#s1781", var"#s1782", var"#s1783", var"#s1784", _B, <:AbstractVector{_A}} where {_A, var"#s178"<:AbstractVector{Int64}, var"#s1781"<:AbstractVector{Int64}, var"#s1782"<:AbstractVector{Int64}, var"#s1783"<:AbstractVector{Int64}, var"#s1784"<:AbstractVector{Int64}, _B<:NodalField}

similar(
    field::FiniteElementContainers.SimpleElementField{T, N, NN, NE, Vals}
) -> FiniteElementContainers.SimpleElementField

similar(
    field::FiniteElementContainers.SimpleNodalField{T, N, NF, NN, Vals}
) -> FiniteElementContainers.SimpleNodalField

similar(
    field::FiniteElementContainers.SimpleQuadratureField{T, N, NF, NQ, NE, Vals}
) -> FiniteElementContainers.SimpleQuadratureField

similar(
    field::FiniteElementContainers.VectorizedElementField{T, N, NN, NE, Vals}
) -> FiniteElementContainers.VectorizedElementField

zero(
    _::FiniteElementContainers.SimpleElementField{T, N, NN, NE, Vals<:(StructArrays.StructVector)}
) -> FiniteElementContainers.SimpleElementField{_A, _B, _C, _D, Vals} where {_A, _B, _C, _D, Vals<:(StructArrays.StructVector)}

zero(
    field::FiniteElementContainers.SimpleElementField{T, N, NN, NE, Vals<:AbstractArray}
) -> FiniteElementContainers.SimpleElementField{_A, _B, _C, _D, Vals} where {_A, _B, _C, _D, Vals<:(StructArrays.StructVector)}

zero(
    _::FiniteElementContainers.SimpleNodalField{T, N, NF, NN, Vals}
) -> FiniteElementContainers.SimpleNodalField

zero(
    field::FiniteElementContainers.SimpleQuadratureField{T, N, NF, NQ, NE, Vals}
) -> FiniteElementContainers.SimpleQuadratureField

zero(
    field::FiniteElementContainers.VectorizedElementField{T, N, NN, NE, Vals}
) -> FiniteElementContainers.VectorizedElementField

zero(
    field::FiniteElementContainers.VectorizedNodalField{T, N, NF, NN, Vals}
) -> FiniteElementContainers.VectorizedNodalField

zero(
    _::Type{FiniteElementContainers.SimpleElementField{T, N, NN, NE, Vals<:(AbstractMatrix)}}
)

zero(
    _::Type{FiniteElementContainers.SimpleElementField{T, N, NN, NE, Vals<:(StructArrays.StructVector)}}
) -> FiniteElementContainers.SimpleElementField{_A, _B, _C, _D, Vals} where {_A, _B, _C, _D, Vals<:(StructArrays.StructVector)}

zero(
    _::Type{FiniteElementContainers.SimpleElementField{T, N, NN, NE, Vals<:StructArrays.StructArray}}
) -> FiniteElementContainers.SimpleElementField{_A, _B, _C, _D, Vals} where {_A, _B, _C, _D, Vals<:(StructArrays.StructVector)}

zero(
    _::Type{FiniteElementContainers.SimpleNodalField{T, N, NF, NN, Vals}}
) -> FiniteElementContainers.SimpleNodalField

zero(
    _::Type{FiniteElementContainers.SimpleQuadratureField{T, N, NF, NQ, NE, Vals<:(AbstractMatrix)}}
) -> FiniteElementContainers.SimpleQuadratureField{_A, _B, _C, _D, _E, Vals} where {_A, _B, _C, _D, _E, Vals<:(StructArrays.StructArray{_A, 2})}

zero(
    _::Type{FiniteElementContainers.SimpleQuadratureField{T, N, NF, NQ, NE, Vals<:StructArrays.StructArray}}
) -> FiniteElementContainers.SimpleQuadratureField{_A, _B, _C, _D, _E, Vals} where {_A, _B, _C, _D, _E, Vals<:(StructArrays.StructArray{_A, 2})}

zero(
    _::Type{FiniteElementContainers.VectorizedElementField{T, N, NN, NE, Vals<:(AbstractVector)}}
) -> FiniteElementContainers.VectorizedElementField

zero(
    _::Type{FiniteElementContainers.VectorizedNodalField{T, N, NF, NN, Vals<:(AbstractVector{<:Number})}}
) -> FiniteElementContainers.VectorizedNodalField{_A, _B, _C, _D, Vals} where {_A<:Number, _B, _C, _D, Vals<:(StructArrays.StructVector{_A})}

zero(
    _::Type{FiniteElementContainers.VectorizedNodalField{T, N, NF, NN, Vals<:(StructArrays.StructVector)}}
) -> FiniteElementContainers.VectorizedNodalField{_A, _B, _C, _D, Vals} where {_A, _B, _C, _D, Vals<:(StructArrays.StructVector{_A})}

assemble!(
    assembler::DynamicAssembler,
    dof::DofManager,
    fspace::FunctionSpace,
    X,
    U,
    block_id,
    residual_func,
    tangent_func,
    mass_func
)

Simple method for assembling in serial

assemble!(
    assembler::DynamicAssembler,
    dof::DofManager,
    fspaces,
    X,
    U,
    residual_func,
    tangent_func,
    mass_func
)

assembly method for matrix free assembler when functions for the element level residual and tangent_func are provided

assemble!(
    global_val::NodalField,
    fspace,
    block_num,
    e,
    local_val
)

Assembly method for residuals

assemble!(
    global_val::StaticAssembler,
    fspace,
    block_num,
    e,
    local_val
)

assemble!(
    global_val::Vector,
    fspace,
    block_num,
    e,
    local_val
)

Assembly method for a scalar field stored as a size 1 vector

assemble!(
    assembler::DynamicAssembler,
    K_el::AbstractMatrix{<:Number},
    M_el::AbstractMatrix{<:Number},
    block_id::Int64,
    el_id::Int64
) -> AbstractMatrix{<:Number}

assembly for stiffness matrix

assemble!(
    assembler::StaticAssembler,
    K_el::AbstractMatrix,
    block_id::Int64,
    el_id::Int64
) -> Any

assembly for stiffness matrix

assemble!(
    R::AbstractArray{<:Number},
    Kv::AbstractArray{<:Number},
    R_el::AbstractArray{<:Number},
    Kv_el::AbstractArray{<:Number},
    conn::AbstractArray{<:Integer}
)

generic assembly method that directly goes into a vector for doing a residual and matrix vector product at once

assemble!(
    R::AbstractArray{<:Number},
    R_el::AbstractArray{<:Number},
    conn::AbstractArray{<:Integer}
)

generic assembly method that directly goes into a vector

assemble_atomic!(
    assembler::StaticAssembler,
    K_el::AbstractMatrix,
    block_id::Int64,
    el_id::Int64
)

assembly for stiffness matrix

assemble_atomic!(
    R::NodalField,
    R_el::AbstractVector{<:Number},
    conn::AbstractVector{<:Integer}
)

assembly method for just a residual vector

TODO need to add an Atomix lock here TODO add block_id to fspace or something like that

connectivity(
    conn::FiniteElementContainers.SimpleElementField,
    e::Int64
) -> Any

connectivity(
    conn::FiniteElementContainers.SimpleElementField
) -> Any

connectivity(
    conn::FiniteElementContainers.VectorizedElementField{T, N, NN, NE, Vals} where {T, N, NN, NE, Vals}
) -> Any

connectivity(fspace::FunctionSpace, e::Int64) -> Any

connectivity(fspace::FunctionSpace) -> Any

connectivity(
    conn::FiniteElementContainers.VectorizedElementField{T, 1, NN, NE, Vals},
    e::Int64
) -> Any

connectivity(
    conn::FiniteElementContainers.VectorizedElementField{T, 2, NN, NE, Vals},
    e::Int64
) -> SubArray{T, 1} where T

Dummy method to be overriden for specific mesh file format

Dummy method to be overriden for specific mesh file format

create_unknowns(dof::DofManager{T, ND, NN, A, V}) -> Any

discrete_gradient(_::IncompressiblePlaneStress, ∇N_X) -> Any

discrete_gradient(_::PlaneStrain, ∇N_X) -> Any

discrete_gradient(_::ThreeDimensional, ∇N_X) -> Any

discrete_gradient(
    fspace::FunctionSpace,
    type::AbstractMechanicsFormulation,
    X,
    q,
    e
) -> Any

discrete_symmetric_gradient(
    _::IncompressiblePlaneStress,
    ∇N_X
) -> Any

discrete_symmetric_gradient(_::PlaneStrain, ∇N_X) -> Any

discrete_symmetric_gradient(
    _::ThreeDimensional,
    ∇N_X
) -> Any

discrete_symmetric_gradient(
    fspace,
    type::AbstractMechanicsFormulation,
    X,
    q,
    e
) -> Any

dof_connectivity(fspace::FunctionSpace, e::Int64) -> Any

dof_connectivity(fspace::FunctionSpace) -> Any

dof_ids(_::DofManager{T, ND, NN, A, V}) -> Any

Dummy method to be overriden for specific mesh file format

Dummy method to be overriden for specific mesh file format

element_level_coordinates(
    fspace::FunctionSpace,
    x,
    e::Int64
) -> Any

element_level_fields(
    fspace::FunctionSpace,
    u,
    e::Int64
) -> Any

element_level_fields(
    fspace::FunctionSpace,
    u::NodalField
) -> Any

element_level_fields_reinterpret(
    fspace::FunctionSpace,
    u::NodalField,
    e::Int64
) -> Any

element_level_fields_reinterpret(
    fspace::FunctionSpace,
    u::NodalField
) -> Any

Dummy method to be overriden for specific mesh file format

extract_stiffness(
    _::IncompressiblePlaneStress,
    A::Tensors.Tensor{4, 3, T<:Number, 81}
) -> StaticArraysCore.SArray

extract_stiffness(
    _::PlaneStrain,
    A::Tensors.Tensor{4, 3, T<:Number, 81}
) -> StaticArraysCore.SArray

extract_stiffness(
    _::ThreeDimensional,
    A_in::Tensors.Tensor{4, 3, T<:Number, 81}
) -> StaticArraysCore.SArray

extract_stress(
    _::IncompressiblePlaneStress,
    P::Tensors.Tensor{2, 3, T<:Number, 9}
) -> StaticArraysCore.SArray

extract_stress(
    _::PlaneStrain,
    P::Tensors.Tensor{2, 3, T<:Number, 9}
) -> StaticArraysCore.SArray

extract_stress(
    _::ThreeDimensional,
    P::Tensors.Tensor{2, 3, T<:Number, 9}
) -> StaticArraysCore.SArray

file_name(mesh::FiniteElementContainers.AbstractMesh) -> Any

Returns file name for an mesh type

float_type(_::Assembler{R, I}) -> Any

int_type(_::Assembler{R, I}) -> Any

modify_field_gradients(form::ThreeDimensional, ∇u_q) -> Any
modify_field_gradients(
    form::ThreeDimensional,
    ∇u_q,
    type
) -> Any

modify_field_gradients(
    _::ThreeDimensional,
    ∇u_q,
    _::Type{<:StaticArraysCore.SArray}
) -> Any

modify_field_gradients(
    _::ThreeDimensional,
    ∇u_q,
    _::Type{<:Tensors.Tensor}
) -> Any

modify_field_gradients(
    _::IncompressiblePlaneStress,
    ∇u_q::StaticArraysCore.SArray{Tuple{2, 2}, T<:Number, 2, 4},
    _::Type{<:StaticArraysCore.SArray}
) -> StaticArraysCore.SArray

modify_field_gradients(
    _::IncompressiblePlaneStress,
    ∇u_q::StaticArraysCore.SArray{Tuple{2, 2}, T<:Number, 2, 4},
    _::Type{<:Tensors.Tensor}
) -> Tensors.Tensor{2, 3, _A, 9} where _A

modify_field_gradients(
    _::IncompressiblePlaneStress,
    ∇u_q::Tensors.Tensor{2, 2, T<:Number, 4},
    _::Type{<:Tensors.Tensor}
) -> Tensors.Tensor{2, 3, _A, 9} where _A

modify_field_gradients(
    _::PlaneStrain,
    ∇u_q::StaticArraysCore.SArray{Tuple{2, 2}, T<:Number, 2, 4},
    _::Type{<:StaticArraysCore.SArray}
) -> StaticArraysCore.SArray

modify_field_gradients(
    _::PlaneStrain,
    ∇u_q::StaticArraysCore.SArray{Tuple{2, 2}, T<:Number, 2, 4},
    _::Type{<:Tensors.Tensor}
) -> Tensors.Tensor{2, 3, _A, 9} where _A

To deprecate or not to deprecate?

modify_field_gradients(
    form::PlaneStrain,
    ∇u_q::StaticArraysCore.SArray{Tuple{2, 2}, T<:Number, 2, 4};
    type
) -> Tensors.Tensor{2, 3, _A, 9} where _A

modify_field_gradients(
    _::PlaneStrain,
    ∇u_q::Tensors.Tensor{2, 2, T<:Number, 4},
    _::Type{<:Tensors.Tensor}
) -> Tensors.Tensor{2, 3, _A, 9} where _A

Dummy method to be overriden for specific mesh file format

Dummy method to be overriden for specific mesh file format

Dummy method to be overriden for specific mesh file format

num_dimensions(fspace::FunctionSpace) -> Any

num_dimensions(_::AbstractMechanicsFormulation{ND}) -> Any

num_dofs_per_node(_::FunctionSpace{ND, RefFE, Conn}) -> Any

num_elements(fspace::FunctionSpace) -> Any

num_elements(_::ElementField{T, N, NN, NE, Vals}) -> Any

num_elements(
    _::QuadratureField{T, N, NF, NQ, NE, Vals}
) -> Any

num_fields(
    _::FiniteElementContainers.AbstractField{T, N, NF, Vals}
) -> Any

Dummy method to be overriden for specific mesh file format

num_nodes(_::NodalField{T, N, NF, NN, Vals}) -> Any

num_nodes_per_element(field::ElementField) -> Any

num_nodes_per_element(fspace::FunctionSpace) -> Any

num_q_points(fspace::FunctionSpace) -> Any

num_q_points(
    _::QuadratureField{T, N, NF, NQ, NE, Vals}
) -> Any

quadrature_level_field_gradients(
    fspace::FunctionSpace,
    X::NodalField,
    u::NodalField,
    q::Int64,
    e::Int64
) -> Any

quadrature_level_field_values(
    fspace::FunctionSpace,
    _::NodalField,
    u::NodalField,
    q::Int64,
    e::Int64
) -> Any

quadrature_points(fspace::FunctionSpace, q::Int64) -> Any

quadrature_weights(fspace::FunctionSpace, q::Int64) -> Any

reference_element(fspace::FunctionSpace) -> Any

shape_function_gradients(
    fspace::FunctionSpace,
    q::Int64
) -> Any

shape_function_hessians(
    fspace::FunctionSpace,
    q::Int64
) -> Any

shape_function_values(
    fspace::FunctionSpace,
    q::Int64
) -> Any

Dummy method to be overriden for specific mesh file format

Dummy method to be overriden for specific mesh file format

update_fields!(
    U::NodalField,
    dof::DofManager,
    Uu::AbstractVector{<:Number}
) -> AbstractVector{<:Number}

update_unknown_dofs!(dof::DofManager{T, ND, NN, A, V})

"Default" method to reset all dofs to unknown

update_unknown_dofs!(
    dof_manager::DofManager,
    dofs::AbstractVector{<:Integer}
)

Method when all dofs are updated at once

First it resets all dofs to unknowns, then one by one sets dofs to bcs in dofs

Assumes there's a unique set of nodes provided

update_unknown_dofs!(
    assembler::Union{DynamicAssembler, StaticAssembler},
    dof,
    fspaces,
    nodes_in::AbstractVector{<:Integer}
)

method that assumes first dof TODO move sorting of nodes up stream TODO remove other scratch unknowns and unknown_dofs arrays

volume(
    fspace::FunctionSpace,
    X::NodalField,
    e::Int64
) -> Any

volume(fspace::FunctionSpace, X::NodalField) -> Any

volume(
    fspace::FunctionSpace,
    _::ReferenceFiniteElements.ReferenceFEType,
    X::NodalField,
    q::Int64,
    e::Int64
) -> Any

sparse!(
    assembler::DynamicAssembler
) -> Tuple{SparseArrays.SparseMatrixCSC, SparseArrays.SparseMatrixCSC}

sparse!(
    assembler::StaticAssembler
) -> SparseArrays.SparseMatrixCSC

sparse(
    assembler::DynamicAssembler
) -> Tuple{SparseArrays.SparseMatrixCSC, SparseArrays.SparseMatrixCSC}

sparse(
    assembler::StaticAssembler
) -> SparseArrays.SparseMatrixCSC