GitHub

Problem Description

Central object is the ProblemDescription which is given as a weak form of your problem and usually does not need any information on the discretisation at this point (but of course can depend on region numbers).

ExtendableFEM.ProblemDescription — Type
struct ProblemDescription

Structure holding data for a problem description with the following fields:

  • name::String: The name of the problem used for printout messages. Default: "My Problem"
  • unknowns::Vector{Unknown}: A vector of Unknowns that are involved in the problem.
  • operators::Vector{ExtendableFEM.AbstractOperator}: A vector of operators that are involved in the problem.
source

Constructors and assign functions

ExtendableFEM.assign_operator! — Method
assign_operator!(PD::ProblemDescription, o::AbstractOperator)

Assigns the AbstractOperator o to the ProblemDescription PD and returns its position in the operators array of the ProblemDescription.

source
ExtendableFEM.assign_unknown! — Method
assign_unknown!(PD::ProblemDescription, u::Unknown)

Assigns the Unknown u to the ProblemDescription PD and returns its position in the unknowns array of the ProblemDescription.

source
ExtendableFEM.replace_operator! — Method
replace_operator!(PD::ProblemDescription, j::Int, o::AbstractOperator)

Replaces the j-th operator of the ProblemDescription PD by the new operator o. Here, j is the position in operator array returned by the assign_operator! function. Nothing is returned (as the new operator gets position j).

source

Unknowns

An Unknown is an identifies that encodes a physical quantity in the ProblemDescription.

ExtendableFEM.Unknown — Type
struct Unknown

Structure holding information for an unknown with the following fields:

  • name::String: The name of the unknown used for printout messages.
  • identifier::Any: The identifier of the unknown used for assignments to operators.
  • parameters::Dict{Symbol, Any}: Further properties of the unknown can be stored in a Dict, see constructor.
source
ExtendableFEM.Unknown — Method
function Unknown(
	u::String;
	identifier = Symbol(u),
	name = u,
	kwargs...)

Generates and returns an Unknown with the specified name, identifier and other traits.

Example: BilinearOperator([grad(1)], [grad(1)]; kwargs...) generates a weak Laplace operator.

Keyword arguments:

  • algebraic_constraint: is this unknown an algebraic constraint?. Default: nothing

  • dimension: dimension of the unknown. Default: nothing

  • symbol_ansatz: symbol for ansatz functions of this unknown in printouts. Default: nothing

  • symbol_test: symbol for test functions of this unknown in printouts. Default: nothing

source
ExtendableFEM.jump — Method
jump(o:Tuple{Union{Unknown, Int}, StandardFunctionOperator})

alias for (o[1], Jump{o[2]})

source
ExtendableFEM.other — Method
other(o:Tuple{Union{Unknown, Int}, StandardFunctionOperator})

alias for (o[1], Right{o[2]})

source
ExtendableFEM.symgrad_voigt — Method
symgrad_voigt(u, factor)

alias for (u, SymmetricGradient{factor}) in Voigt notation.

The factor is a real number applied to the (summed) off-diagonal entries. In the current implementation in ExtendableFEMBase, factor = 0.5 represents the Voigt strain mapping [σ₁₁ σ₂₂ σ₃₃ σ₁₃ σ₂₃ σ₁₂], while factor = 1.0 represents the Voigt strain mapping [ε₁₁ ε₂₂ ε₃₃ 2ε₁₃ 2ε₂₃ 2ε₁₂].

source
ExtendableFEM.this — Method
this(o:Tuple{Union{Unknown, Int}, StandardFunctionOperator})

alias for (o[1], Left{o[2]})

source

Operators

Operator is a quite general concept and is everything that makes modifications to the system matrix, hence classical representations of weak discretisations of differential operators, penalisations for boundary conditions or constraints, or stabilisation terms.

Types of operators

The three most important operator classes are:

  • NonlinearOperator (e.g. the convection term in a Navier-Stokes problem)
  • BilinearOperator (e.g. the Laplacian in a Poisson problem)
  • LinearOperator (e.g. the right-hand side in a Poisson or Navier-Stokes problem)

To assign boundary conditions or global constraints there are three possibilities:

  • InterpolateBoundaryData
  • HomogeneousData
  • FixDofs
  • CombineDofs

Entities and Regions

Each operator assembles on certain entities of the mesh, the default is a cell-wise assembly. Most operators have the entities kwarg to changes that. Restrictions to subsets of the entities can be made via the regions kwarg.

EntitiesDescription
AT_NODESinterpolate at vertices of the mesh (only for H1-conforming FEM)
ON_CELLSassemble/interpolate on the cells of the mesh
ON_FACESassemble/interpolate on all faces of the mesh
ON_IFACESassemble/interpolate on the interior faces of the mesh
ON_BFACESassemble/interpolate on the boundary faces of the mesh
ON_EDGES (*)assemble/interpolate on all edges of the mesh (in 3D)
ON_BEDGES (*)assemble/interpolate on the boundary edges of the mesh (in 3D)
Note

(*) = only reasonable in 3D and still experimental, might have some issues

Function Operators

The definition of operators often involves paris of an Unknown and a FunctionOperator (or an alias as listed above). FunctionOperators are something like Identity, Gradient etc. (see here for a complete list). Additional FunctionOperators for the evaluation of discontinuous operators on faces available (needed in particular for defining operators in DG context or face terms in a posteriori error estimators):

ExtendableFEM.Left — Type
Left{StandardFunctionOperator}

evaluates the left (w.r.t. orientation of the face) value of a StandardFunctionOperator

source
ExtendableFEM.Right — Type
Average{StandardFunctionOperator}

evaluates the right (w.r.t. orientation of the face) value of a StandardFunctionOperator

source