GitHub

Gridap.FESpaces

Gridap.FESpaces — Module

The exported names are

source
Gridap.FESpaces.CellConformity — Type

Minimum data required to describe dof ownership. At this moment, the cell-wise ownership is compressed on cell types. This can be relaxed in the future, to have an arbitrary cell-wise dof ownership.

source
Gridap.FESpaces.CellFE — Type

Minimum data required to build a conforming FE space. At this moment, the some cell-wise info is compressed on cell types. This can be relaxed in the future, and have an arbitrary cell-wise data.

source
Gridap.FESpaces.ConstantFESpace — Type
struct ConstantFESpace <: SingleFieldFESpace
  # private fields
end

ConstantFESpace(model::DiscreteModel; vector_type=Vector{Float64}, field_type=Float64)
ConstantFESpace(trian::Triangulation; vector_type=Vector{Float64}, field_type=Float64)

FESpace that is constant over the provided model/triangulation. Typically used as lagrange multipliers. The kwargs vector_type and field_type are used to specify the types of the dof-vector and dof-value respectively.

source
Gridap.FESpaces.FEFunction — Method
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_dof_values(fs)

source
Gridap.FESpaces.FEOperator — Type
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

source
Gridap.FESpaces.GridWithFEMap — Type

Given a Discrete Model and a reffe, builds a new grid in which the geometrical map is a FEFunction. This is useful when considering geometrical maps that are the result of a FE problem (mesh displacement).

source
Gridap.FESpaces.MultiConstantFESpace — Type
struct MultiConstantFESpace{N,V,T} <: SingleFieldFESpace end

MultiConstantFESpace(model::DiscreteModel,tags::Vector,D::Integer)
MultiConstantFESpace(trians::Vector{<:BoundaryTriangulation{Df}})

Extension of ConstantFESpace, representing a FESpace which is constant on each of it's N triangulations.

source
Gridap.FESpaces.NodeToDofGlue — Type
struct NodeToDofGlue{T}
  free_dof_to_node::Vector{Int32}
  free_dof_to_comp::Vector{Int16}
  dirichlet_dof_to_node::Vector{Int32}
  dirichlet_dof_to_comp::Vector{Int16}
  node_and_comp_to_dof::Vector{T}
end
source
Gridap.Algebra.solve! — Method
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.

source
Gridap.Algebra.solve! — Method
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.

source
Gridap.FESpaces.compute_conforming_cell_dofs — Function

The result is the tuple

(cell_dofs, nfree, ndiri, dirichlet_dof_tag, dirichlet_cells)

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

source
Gridap.FESpaces.generate_cell_dof_mask — Method
generate_cell_dof_mask(
  scell_conformity::CellConformity,
  tcell_to_scell::Vector{<:Integer},
  d_to_tcell_to_tdface,
  d_to_tdface_to_mask;
  reverse::Bool=false
)

Given a CellConformity object, defined on a set of source cells (scell), and given a cell/face/edge/node masks on a set of target cells (tcell), this function generates a mask for the degrees of freedom (dofs) on the target cells.

Parameters:

  • scell_conformity: The CellConformity object on the source cells (scell).
  • tcell_to_scell: A vector mapping target cells (tcell) to source cells (scell).
  • d_to_tcell_to_tdface: For each dimension d, a Table mapping target cells to its d-faces (edges, faces, ...)
  • d_to_tdface_to_mask: For each dimension d, an array of booleans indicating whether the d-face is masked or not.

Returns:

  • tcell_dof_mask: A vector that for each target cell contains a boolean vector of size equal to the number of dofs in that cell, containing the mask.

Modes of operation:

  • If reverse = false, the function generates a mask where the dofs are true if the corresponding d-face is masked (true).
  • If reverse = true, the mask is reversed, meaning that the dofs are true if the corresponding d-face is not masked (false).
source
Gridap.FESpaces.get_algebraic_operator — Method
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.

source
Gridap.FESpaces.interpolate — Method

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)

source