Assemblers

ReAssembler(r; fillzero=true, scaling=NoScaling())

ReAssembler will call element_residual! and assemble re into the system vector r. fillzero=true implies that r is zeroed upon construction of ReAssembler. Furthermore, remaining keyword arguments can enable the following features:

• scaling: Calculate a scaling measure locally at the residual level, see e.g., ElementResidualScaling.

reset_scaling! is called when creating ReAssembler

KeReAssembler(K, r; fillzero=true, kwargs...)
KeReAssembler(a::Ferrite.AbstractSparseAssembler; kwargs...)

The default KeReAssembler works just like a Ferrite.AbstractSparseAssembler: It will call element_routine! and assemble Ke and re into the global system matrix K and vector r. However, it comes with the additional possible features, that are controllable via the keyword arguments:

• ch::Union{Nothing,ConstraintHandler}=nothing: If a ConstraintHandler is given, local applications of constraints will be applied, using Ferrite.apply_assemble.
• apply_zero: Required if a constraint handler is given, and forwarded to Ferrite.apply_assemble.
• scaling: Calculate a scaling measure locally at the residual level, see e.g., ElementResidualScaling

a=Ferrite.start_assemble(K, r; fillzero=fillzero) is passed to the second definition if a matrix, K, and vector, r, are given as input.

reset_scaling! is called when creating KeReAssembler

element_routine!(
    Ke::AbstractMatrix, re::AbstractVector, state,
    ae::AbstractVector, material, cellvalues, buffer)

The main function to be overloaded for the specific material. In most cases, the same implementation can be used for different cellvalues (e.g. for different interpolation orders) This function should modify the element stiffness matrix Ke, the residual re, and potentially state. The element degree of freedom values, ae, are filled by NaNs unless a is passed to work!.

The following variables can be obtained from buffer.

• get_old_state(buffer)
• get_aeold(buffer)
• get_time_increment(buffer)
• dof_range(buffer, fieldname::Symbol)
• getcoordinates(buffer)
• celldofs(buffer)
• cellid(buffer)
• get_user_data(buffer)
• get_user_cache(buffer)

FerriteAssembly.element_routine!(
    Ke, re, state::Vector{<:MMB.AbstractMaterialState}, ae, 
    m::MMB.AbstractMaterial, cv::CellValues, buffer)

Solve the weak form

\[ \int_\Omega [\boldsymbol{\delta u}\otimes\nabla]^\mathrm{sym} : \boldsymbol{\sigma}\ \mathrm{d}\Omega = \int_\Gamma \boldsymbol{\delta u} \cdot \boldsymbol{t}\ \mathrm{d}\Gamma + \int_\Omega \boldsymbol{\delta u} \cdot \boldsymbol{b}\ \mathrm{d}\Omega\]

where $\sigma$ is calculated with the material_response function from MaterialModelsBase.jl. Note that create_cell_state is already implemented for <:AbstractMaterial.

element_residual!(
    re::AbstractVector, state,
    ae::AbstractVector, material, cellvalues, buffer)

To calculate the element tangent stiffness Ke automatically by using ForwardDiff, it is possible to overload element_residual! instead of element_routine!. See element_routine! for a description of the input parameters.

facet_routine!(Ke, re, ae, material, facetvalues, facetbuffer)

Calculate contributions to the stiffness matrix and residual vector from a facet domain. It can be used, for example, to implement Robin boundary conditions.

facet_residual!(re, ae, material, facetvalues, facetbuffer)

Calculate contributions to the residual vector from a facet domain. Internally, this is used for calculating Neumann boundary conditions.

ElementResidualScaling(dh::AbstractDofHandler, p=Val(2), T=Float64)

Create tolerance scaling based on the sum of the p-norm of each cell's residual vector, separately for each field. I.e. pseudo-code for field :u the scaling factor::T is

for each cell
    element_routine!(Ke, re, args...) # Calculate re
    factor += sum(abs.(re[dof_range(dh, :u)]).^p)^(1/p)

Note that p=Val(2) is a special case that is supported, for different values it should be given as a Real. p=2 is equivalent to Val(2), but is less efficient.