Gridap.FESpaces

The exported names are

• AffineFEOperator
• AffineFETerm
• AffineFETermFromCellMatVec
• Assembler
• AssemblyStrategy
• CLagrangianFESpace
• ConformingFESpace
• DefaultAssemblyStrategy
• DirichletFESpace
• DiscontinuousFESpace
• EvaluationFunction
• ExtendedFESpace
• FECellBasisStyle
• FEEnergy
• FEFunction
• FEFunctionStyle
• FEOperator
• FEOperatorFromTerms
• FESolver
• FESource
• FESpace
• FESpaceWithConstantFixed
• FESpaceWithLastDofRemoved
• FESpaceWithLinearConstraints
• FETerm
• FETermFromCellJacRes
• GenericSparseMatrixAssembler
• GradConformingFESpace
• HomogeneousTrialFESpace
• HomogeneousTrialFESpace!
• LinearFESolver
• LinearFETerm
• NonlinearFESolver
• SingleFieldFEFunction
• SingleFieldFESpace
• SparseMatrixAssembler
• TestFESpace
• TrialFESpace
• TrialFESpace!
• UnconstrainedFESpace
• ZeroMeanFESpace
• allocate_matrix
• allocate_matrix_and_vector
• allocate_vector
• assemble_matrix
• assemble_matrix!
• assemble_matrix_add!
• assemble_matrix_and_vector
• assemble_matrix_and_vector!
• assemble_matrix_and_vector_add!
• assemble_vector
• assemble_vector!
• assemble_vector_add!
• autodiff_cell_jacobian_from_energy
• autodiff_cell_jacobian_from_residual
• autodiff_cell_residual_from_energy
• col_map
• col_mask
• collect_cell_jacobian
• collect_cell_jacobian_and_residual
• collect_cell_matrix
• collect_cell_matrix_and_vector
• collect_cell_residual
• collect_cell_vector
• compute_conforming_cell_dofs
• compute_dirichlet_values
• compute_dirichlet_values_for_tags
• compute_dirichlet_values_for_tags!
• compute_free_and_dirichlet_values
• compute_free_values
• constraint_style
• count_matrix_and_vector_nnz_coo
• count_matrix_nnz_coo
• fill_matrix_and_vector_coo_numeric!
• fill_matrix_and_vector_coo_symbolic!
• fill_matrix_coo_numeric!
• fill_matrix_coo_symbolic!
• gather_dirichlet_values
• gather_dirichlet_values!
• gather_free_and_dirichlet_values
• gather_free_and_dirichlet_values!
• gather_free_values
• gather_free_values!
• get_algebraic_operator
• get_cell_axes
• get_cell_axes_with_constraints
• get_cell_basis
• get_cell_constraints
• get_cell_dof_basis
• get_cell_dofs
• get_cell_isconstrained
• get_cell_jacobian
• get_cell_jacobian_and_residual
• get_cell_matrix
• get_cell_residual
• get_cell_values
• get_cell_vector
• get_dirichlet_dof_tag
• get_dirichlet_values
• get_fe_space
• get_free_values
• get_matrix_type
• get_test
• get_trial
• get_vector_type
• has_constraints
• interpolate
• interpolate!
• interpolate_dirichlet
• interpolate_dirichlet!
• interpolate_everywhere
• interpolate_everywhere!
• is_a_fe_cell_basis
• is_a_fe_function
• num_dirichlet_dofs
• num_dirichlet_tags
• num_free_dofs
• row_map
• row_mask
• scatter_free_and_dirichlet_values
• test_assembler
• test_fe_function
• test_fe_operator
• test_fe_solver
• test_fe_space
• test_single_field_fe_space
• test_sparse_matrix_assembler
• zero_dirichlet_values
• zero_free_values

AffineFEOperator

Reprepresent a fully assembled affine (linear) finite element problem. See also FEOperator

AffineFEOperator(test::FESpace,trial::FESpace,assem::Assembler,terms::AffineFETerm...) AffineFEOperator(test::FESpace,trial::FESpace,terms::AffineFETerm...)

See also FETerm.

struct CLagrangianFESpace{S} <: SingleFieldFESpace
  grid::Grid
  dof_to_node::Vector{Int}
  dof_to_comp::Vector{Int8}
  node_and_comp_to_dof::Vector{S}
  # + private fields
end

CLagrangianFESpace(::Type{T},grid::Grid) where T

struct DirichletFESpace <: SingleFieldFESpace
  space::SingleFieldFESpace
end

abstract type FEOperator <: GridapType

A FEOperator contains finite element problem, that is assembled as far as possible and ready to be solved. See also FETerm

FESpace(; kwargs...)

Construct a FESpace. Supported keywords are: [:reffe, :conformity, :order, :labels, :valuetype, :model, :triangulation, :dirichlettags, :dirichletmasks, :dofspace, :constraint, :zeromeantrian, :zeromean_quad]

FESpaceWithConstantFixed(space::SingleFieldFESpace, fix_constant::Bool,
dof_to_fix::Int=num_free_dofs(space))

abstract type FETerm <: GridapType end

A FETerm is a lazy representation of a summand of a finite element problem. It is not assembled. See also FEOperator.

The solver that solves a LinearFEOperator

See also FETerm.

A general NonlinearFESolver

Generic implementation of an unconstrained single-field FE space Private fields and type parameters

struct ZeroMeanFESpace <: SingleFieldFESpace
  # private fields
end

ZeroMeanFESpace(
  space::SingleFieldFESpace,
  trian::Triangulation,
  quad::CellQuadrature)

DiscontinuousFESpace(reffes::Vector{<:ReferenceFE}, trian::Triangulation)

FEFunction(
  fs::SingleFieldFESpace, free_values::AbstractVector, dirichlet_values::AbstractVector)

The resulting FEFunction will be in the space if and only if dirichlet_values are the ones provided by get_dirichlet_values(fs)

Types marked with this trait need to implement the following queries

• [get_free_values(object)]
• [get_fe_space(object)]

computeconformingcelldofs( reffes, conf, gridtopology, facelabeling, dirichlettags)

computeconformingcelldofs( reffes, conf, gridtopology, facelabeling, dirichlettags, dirichlet_components)

The result is the tuple

(cell_dofs, nfree, ndiri, dirichlet_dof_tag, dirichlet_cells)

Assumes that the reffes are aligned with the cell type in the grid_topology and that it is possible to build a conforming space without imposing constraints

If dirichlet_components is given, then get_dof_to_comp has to be defined for the reference elements in reffes.

get_algebraic_operator(feop)

Return an "algebraic view" of an operator. Algebraic means, that the resulting operator acts on plain arrays, instead of FEFunctions. This can be useful for solving with external tools like NLsolve.jl. See also FEOperator.

Returns an object representing the contribution to the Jacobian of the given term. Returns nothing if the term has not contribution to the Jacobian (typically for source terms)

Returns an object representing the contribution to the system matrix of the given term. Returns nothing if the term has not contribution (typically for source terms)

Returns an object representing the contribution to the residual of the given term. Returns always something.

Returns an object (e.g. a CellVector) representing the contribution to the system rhs of the given term (with Dirichlet bcs included). Returns nothing if the term has not contribution (typically for linear terms)

Returns an object (e.g. a CellVector) representing the contribution to the system rhs of the given term (without Dirichlet bcs). Returns nothing if the term has not contribution (typically for linear terms)

The resulting FE function is in the space (in particular it fulfills Dirichlet BCs even in the case that the given cell field does not fulfill them)

like interpolate, but also compute new degrees of freedom for the dirichlet component. The resulting FEFunction does not necessary belongs to the underlying space

jacobian!(A, op, u)

Inplace version of jacobian.

jacobian(op, u)

Compute the jacobian of an operator op. See also get_algebraic_operator, residual_and_jacobian!.

residual!(b, op, u)

Inplace version of residual.

residual(op, u)

Compute the residual of op at u. See also residual_and_jacobian

residual_and_jacobian!(b, A, op, u)

Inplace version of residual_and_jacobian.

residual, jacobian =

residual_and_jacobian(op, u)

Compute the residual and jacobian of an operator op at a given point u. Depending on the nature of op the point u can either be a plain array or a FEFunction.

See also jacobian, residual, get_algebraic_operator.

uh, cache = solve!(uh,solver,op,cache)

This function changes the state of the input and can render it in a corrupted state. It is recommended to rewrite the input uh with the output as illustrated to prevent any issue. If cache===nothing, then it creates a new cache object.

uh, cache = solve!(uh,solver,op)

This function changes the state of the input and can render it in a corrupted state. It is recommended to rewrite the input uh with the output as illustrated to prevent any issue.

Solve that allocates, and sets initial guess to zero and returns the solution

It creates the cell-wise DOF basis and shape functions, when the DOFs are evaluated at the physical space. The DOFs (moments) for the prebasis are assumed to be computable at a reference FE space.