FEniCS.jl: Finite Element PDE Solving in Julia

FEniCS

Julia wrappers around FEniCS/DOLFIN finite element meshes, function spaces, forms, solvers, and related helper utilities.

CellType

FEniCS/DOLFIN cell-type namespace used to select mesh cell shapes.

dP

FEniCS point integration measure used to construct a variational form.

Use dP when the form integrates over point entities supported by the underlying FEniCS installation.

dS

FEniCS interior-facet integration measure used to construct a variational form.

Use dS to integrate over interior facets in a discontinuous Galerkin form.

ds

FEniCS exterior-facet integration measure used to construct a variational form.

Use ds to integrate over the exterior boundary of a mesh.

dx

FEniCS cell integration measure used to construct a variational form.

Use dx to integrate over the cells of a mesh, for example inner(grad(u), grad(v)) * dx.

hexahedron

FEniCS cell object describing a hexahedral finite-element cell.

Use it as the cell argument to FiniteElement when constructing a hexahedral element.

quadrilateral

FEniCS cell object describing a quadrilateral finite-element cell.

Use it as the cell argument to FiniteElement when constructing a quadrilateral element.

tetrahedron

FEniCS cell object describing a tetrahedral finite-element cell.

Use it as the cell argument to FiniteElement when constructing a tetrahedral element.

triangle

FEniCS cell object describing a triangular finite-element cell.

Use it as the cell argument to FiniteElement when constructing a triangular element.

BoundaryCondition

Abstract wrapper for a FEniCS boundary condition.

Cell

Abstract wrapper for a FEniCS mesh cell.

Cell(mesh::MeshImpl, i::Int)

Wrap cell i from a FEniCS mesh.

Arguments

• mesh: Underlying mesh implementation.
• i: Cell index understood by FEniCS.

Constant

Abstract wrapper for a FEniCS constant expression.

Constant(x::Union{Real, Tuple})

Construct a constant symbolic expression from a scalar or tuple value.

Arguments

• x: Scalar or vector value represented by the constant.

Expression

Abstract wrapper for a FEniCS/UFL symbolic expression.

Expression(cppcode; kw...)

Construct a symbolic FEniCS expression from C++ expression code.

Arguments

• cppcode: Expression code accepted by FEniCS.
• kw...: Keyword arguments forwarded to the FEniCS expression constructor, such as degree.

FeFunction

Abstract wrapper for a FEniCS finite-element function.

FeFunction(V::FunctionSpace; name::String = "")

Construct a finite-element function on V.

Arguments

• V: Function space containing the function.

Keyword Arguments

• name: Optional name passed to FEniCS. The default creates an unnamed function.

FiniteElement(family::StringOrSymbol, cell = nothing, degree = nothing,
    form_degree = nothing, quad_scheme = nothing, variant = nothing)

Construct a FEniCS finite element.

Arguments

• family: Finite-element family name.
• cell: Geometric cell, such as triangle.
• degree: Polynomial degree.
• form_degree: Optional FEEC form degree.
• quad_scheme: Optional quadrature scheme.
• variant: Optional local-basis variant.

FiniteElement

Abstract wrapper for a FEniCS finite element.

Form

Abstract wrapper for a FEniCS variational form.

FunctionSpace

Abstract wrapper for a FEniCS finite-element function space.

FunctionSpace(mesh::Mesh, element::Union{FiniteElement, MixedElement})

Construct a function space from a finite element or mixed finite element.

FunctionSpace(mesh::Mesh, family::StringOrSymbol, degree::Int)

Construct a scalar finite-element function space on mesh.

Arguments

• mesh: Mesh on which the space is defined.
• family: FEniCS finite-element family, such as "CG".
• degree: Polynomial degree of the basis.

MPI_Comm

Wrapper for a FEniCS MPI communicator object.

Matrix

Abstract wrapper for a FEniCS assembled matrix.

Matrix(a::T) where {T <: Real}

Return a scalar unchanged when a FEniCS form reduces to a real number.

Measure

Abstract wrapper for a FEniCS integration measure.

Mesh

Abstract wrapper for a FEniCS/DOLFIN mesh.

Concrete values contain a PyCall.PyObject in the internal pyobject field. Use the constructors below to load or generate meshes; extend mesh behavior on Mesh rather than on its implementation type.

Mesh(object::Mesh)

Creates a copy of a mesh

Mesh(path::StringOrSymbol)

Load a FEniCS mesh from path.

Arguments

• path: Filename or path understood by FEniCS.

MixedElement

Abstract wrapper for a FEniCS mixed finite element.

MixedElement(vec::Array{FEniCS.FiniteElementImpl, 1})

Construct a mixed finite element from a vector of finite-element wrappers.

Arguments

• vec: Finite-element components to combine.

Creates a type which incorporates the mesh attributes alongside the necessary values to solve finite element problems. It works by taking in a FEniCS mesh, working out the necessary values, and then creating an ordering of the internal/boundary nodes and applying the DirichletBC (via a function) to the respective nodes.

sub_domain

Abstract wrapper for a FEniCS boundary subdomain.

div(u::Union{Expression, FeFunction})

Construct the FEniCS symbolic divergence of u.

Arguments

• u: FEniCS symbolic expression or finite-element function.

Examples

julia> divergence = div(vector_expression);

repr(obj::fenicsobject)

Return the Python/FEniCS representation of obj as a Julia string.

Arguments

• obj: Wrapped FEniCS object to represent.

Examples

julia> repr(mesh)
"<dolfin.cpp.mesh.Mesh object ...>"

size(mesh::Mesh, dim::Int)

Return the number of local mesh entities in topological dimension dim.

Arguments

• mesh: FEniCS mesh to query.
• dim: Topological dimension of the requested entities.

Examples

julia> size(mesh, 0) # vertices
4

split(fun::FeFunction)

Split a mixed FEniCS finite-element function into its component functions.

Arguments

• fun: Mixed finite-element function to split.

Examples

julia> components = split(mixed_solution);

sqrt(u::Union{Expression, FeFunction})

Construct the symbolic square root of a FEniCS expression or function.

Arguments

• u: FEniCS symbolic expression or finite-element function.

Examples

julia> magnitude = sqrt(inner(gradient, gradient));

write(path::PyObject, solution::fenicsobject, time::Number)

Write a FEniCS mesh or function to an FEniCS XDMFFile or TimeSeries at time.

Arguments

• path: Python-backed FEniCS output object returned by XDMFFile or TimeSeries.
• solution: FEniCS mesh or function to write.
• time: Time associated with the output sample.

Examples

julia> write(XDMFFile("solution.xdmf"), u, 0.0)

Argument(V, number, part = nothing)

Construct a symbolic UFL argument associated with function space V.

Arguments

• V: Function space associated with the argument.
• number: Argument number used by UFL.
• part: Optional component identifier for mixed spaces.

BoundaryMesh(mesh::Mesh,type_boundary::StringOrSymbol="exterior",order=true)

A BoundaryMesh is a mesh over the boundary of some given mesh.

The cells of the boundary mesh (facets of the original mesh) are oriented to

produce outward pointing normals relative to the original mesh.

The type_boundary can be "exterior", "interior" or "local". "exterior" is the globally

external boundary, "interior" is the inter-process mesh and "local" is the boundary

of the local (this process) mesh.

order:(bool) Optional argument which can be used to control whether or not the

boundary mesh should be ordered according to the UFC ordering convention.

If set to false, the boundary mesh will be ordered with right-oriented facets

(outward-pointing unit normals). The default value is true.

BoxMesh(p0, p1, nx::Int, ny::Int, nz::Int)

Construct a tetrahedral mesh of the rectangular prism between p0 and p1.

Arguments

• p0, p1: Opposite prism corners.
• nx, ny, nz: Number of cells in each coordinate direction.

CellDiameter(mesh::Mesh)

Construct the symbolic cell-diameter expression for mesh.

Arguments

• mesh: Mesh used to determine the cell diameter.

Returns

A symbolic Expression suitable for use in a variational form.

CellNormal(mesh::Mesh)

Construct the symbolic cell-normal expression for mesh.

Arguments

• mesh: Mesh used to determine the cell normal.

Returns

A symbolic Expression suitable for use in a variational form.

CellVolume(mesh::Mesh)

Construct the symbolic cell-volume expression for mesh.

Arguments

• mesh: Mesh used to determine the cell volume.

Returns

A symbolic Expression suitable for use in a variational form.

CompiledSubDomain(cppcode::String)

Compile a C++ boundary predicate into a FEniCS subdomain object.

Arguments

• cppcode: C++ predicate source accepted by FEniCS.

DOLFIN_EPS()

Return the DOLFIN floating-point epsilon.

DOLFIN_PI()

Return the DOLFIN value of pi.

DOLFIN_SQRT_EPS()

Return the square root of the DOLFIN floating-point epsilon.

DirichletBC(V::FunctionSpace, g, sub_domain)

Construct a Dirichlet boundary condition on V.

The boundary value g may be a FEniCS expression, number, or tuple. The sub_domain argument identifies the boundary on which the condition applies.

Arguments

• V: Function space constrained by the boundary condition.
• g: Boundary value.
• sub_domain: Boundary selector accepted by FEniCS.

FacetNormal(mesh::Mesh)

Construct the outward facet-normal expression for mesh.

File(path::StringOrSymbol)

Create a FEniCS output file at path.

Identity(dim::Int)

Construct a symbolic identity tensor of dimension dim.

For a full list of supported arguments, and their usage please refer to http://matplotlib.org/api/pyplot_api.html not all kwargs have been imported. Should you require any that are not imported open as issue, and I will attempt to add them. Deprecate this in a future version

Point(point::Union{Vector, Tuple})

Construct an underlying Python FEniCS point from a Julia vector or tuple.

Arguments

• point: Coordinate vector or tuple.

RectangleMesh(p0, p1, nx::Int, ny::Int, diagdir::StringOrSymbol = "right")

Construct a triangular mesh of the rectangle between p0 and p1.

Arguments

• p0, p1: Opposite rectangle corners.
• nx, ny: Number of cells in each coordinate direction.
• diagdir: Diagonal orientation: "left", "right", "right/left", "left/right", or "crossed".

TestFunction(V::FunctionSpace)

Construct a symbolic test function for V.

TestFunctions(V::FunctionSpace)

Return the component test functions for a mixed function space V.

TimeSeries(path::StringOrSymbol)

Create a FEniCS time-series storage object at path.

Transpose(object::Expression)

Return the transpose of a symbolic FEniCS expression.

Arguments

• object: Expression to transpose.

TrialFunction(V::FunctionSpace)

Construct a symbolic trial function for V.

TrialFunctions(V::FunctionSpace)

Return the component trial functions for a mixed function space V.

UnitCubeMesh(nx::Int, ny::Int, nz::Int)

Construct a tetrahedral mesh of the three-dimensional unit cube.

The mesh has 6 * nx * ny * nz tetrahedra and (nx + 1) * (ny + 1) * (nz + 1) vertices.

Arguments

• nx, ny, nz: Number of cells in each coordinate direction.

UnitIntervalMesh(nx::Int)

Construct a mesh of the unit interval (0, 1) with nx cells and nx + 1 vertices.

Arguments

• nx: Number of cells in the interval.

UnitQuadMesh(nx::Int, ny::Int)

Deprecated compatibility helper for constructing a unit quadrilateral mesh.

Use a current FEniCS quadrilateral mesh constructor instead.

UnitSquareMesh(nx::Int, ny::Int, diagonal::StringOrSymbol="right" )

Triangular/quadrilateral mesh of the 2D unit square [0,1] x [0,1].

Given the number of cells (nx, ny) in each direction, the total number of triangles

will be 2nxny and the total number of vertices will be (nx + 1)*(ny + 1)

diagonal ("left", "right", "right//left", "left//right", or "crossed") indicates the direction of the diagonals.

UnitTetrahedronMesh()

A mesh consisting of a single tetrahedron with vertices at

(0, 0, 0) (1, 0, 0) (0, 1, 0) (0, 0, 1)

UnitTriangleMesh()

A mesh consisting of a single triangle with vertices at

(0, 0) (1, 0) (0, 1)

VectorFunctionSpace(mesh::Mesh, family::StringOrSymbol, degree::Int)

Construct a vector-valued finite-element function space on mesh.

Arguments

• mesh: Mesh on which the space is defined.
• family: FEniCS finite-element family.
• degree: Polynomial degree of the basis.

XDMFFile(path::StringOrSymbol)

Create a FEniCS XDMF output object at path.

anlvsolve(F, a, u, bcs, tol, M)

Solve an adaptive nonlinear variational problem through the wrapped FEniCS solver.

This lower-level helper is kept for compatibility and is not exported.

apply(bcs::BoundaryCondition, matrix::Matrix)

Apply a boundary condition to an assembled matrix.

Arguments

• bcs: Boundary condition to apply.
• matrix: Assembled matrix to modify.

array(matrix)

Gather a FEniCS matrix or vector-like object into a Julia array on rank zero.

assemble(assembly_item; tensor = nothing,
    form_compiler_parameters = nothing, add_values = false,
    finalize_tensor = true, keep_diagonal = false, backend = nothing)

Assemble a FEniCS form or expression into a matrix-like object.

Arguments

• assembly_item: Form or expression to assemble.

Keyword Arguments

• tensor: Optional existing tensor to fill.
• form_compiler_parameters: Optional FEniCS compiler parameters.
• add_values: Whether to add into an existing tensor.
• finalize_tensor: Whether to finalize the assembled tensor.
• keep_diagonal: Whether to preserve the tensor diagonal.
• backend: Optional assembly backend.

assemble_local(assembly_item::Union{Form, Expression}, cell::Cell)

Assemble assembly_item locally on cell.

Arguments

• assembly_item: Form or expression to assemble.
• cell: Cell on which local assembly is performed.

assemble_system(a::Expression, L::Expression, bc = nothing)

Assemble a variational system and return FEniCS-backed matrix objects.

Arguments

• a: Bilinear form.
• L: Linear form.
• bc: Optional boundary condition or collection of boundary conditions.

Returns

A tuple (A, b) containing the assembled system matrix and right-hand side.

assemble_system_julia(a::Expression, L::Expression, bc = nothing)

Assemble a variational system and return Julia arrays.

Arguments

• a: Bilinear form.
• L: Linear form.
• bc: Optional boundary condition or collection of boundary conditions.

Returns

A tuple (A, b) containing the assembled Julia matrix and right-hand side.

assign(solution1::FeFunction, solution2)
assign(solution::FeFunction, data::AbstractArray)

Assign values from another finite-element function or an array into a finite-element function.

Arguments

• solution1, solution: Destination finite-element function.
• solution2: Source finite-element function.
• data: Array of local coefficient values.

bounding_box_tree(mesh::Mesh)

Return the bounding-box tree associated with mesh.

Arguments

• mesh: Mesh whose spatial index is requested.

cell(finiteelement::FiniteElement)

Return the geometric cell of finiteelement.

cell_orientations(mesh::Mesh)

Return the orientation associated with each cell in mesh.

The result is supplied by the wrapped FEniCS mesh and is useful when a finite-element computation needs the orientation data explicitly.

Arguments

• mesh: Mesh whose cell orientations are requested.

Returns

The FEniCS cell-orientation array.

cells(mesh::Mesh)

Return the cell-to-vertex connectivity of mesh.

Arguments

• mesh: Mesh whose connectivity is requested.

Returns

The FEniCS cell-connectivity array.

compute_vertex_values(expr, mesh::Mesh)

Compute the values of expr at the vertices of mesh.

Arguments

• expr: FEniCS expression or finite-element function.
• mesh: Mesh whose vertices are used for evaluation.

coordinates(mesh::Mesh)

Return the coordinates of all vertices in mesh.

Arguments

• mesh: Mesh whose vertex coordinates are requested.

Returns

An array containing one coordinate vector per mesh vertex.

cross(u, v)

Construct the symbolic cross product of two FEniCS expressions.

data(mesh::Mesh)

Return the auxiliary data object associated with mesh.

Arguments

• mesh: Mesh whose auxiliary data is requested.

degree(finiteelement::FiniteElement)

Return the polynomial degree of finiteelement.

directional_derivative(solution1::FeFunction, direction)

Return the directional derivative of solution1 in direction.

domains(mesh::Mesh)

Return the domain markers associated with mesh.

Arguments

• mesh: Mesh whose domain markers are requested.

dot(u, v)

Construct the symbolic dot product of two FEniCS expressions.

errornorm(ans, sol; norm = "L2")

Compute the FEniCS error norm between an exact solution ans and a computed solution sol.

Keyword Arguments

• norm: FEniCS norm identifier. The default is "L2".

family(finiteelement::FiniteElement)

Return the family name of finiteelement.

fenicspycall(object::fenicsobject, func::Union{Symbol, String}, args...)

Call a named method on the wrapped FEniCS Python object.

This is a low-level developer interface for operations that do not yet have a dedicated Julia wrapper. Prefer a dedicated wrapper when one is available.

Arguments

• object: Wrapped FEniCS object on which the method is called.
• func: Python method name as a symbol or string.
• args...: Positional arguments forwarded to the Python method.

finds node numbering for a specific FeMesh. Not currently exported as it is only used to create the FeMesh type.

geometric_dimension(expr::Union{FeFunction, Expression})

Return the geometric dimension associated with expr.

geometry(mesh::Mesh)

Return the geometric structure of mesh.

Arguments

• mesh: Mesh whose geometry object is requested.

get_array(form::Expression)
get_array(solution::FeFunction)
get_array(assembled_form::Matrix)

Extract a Julia array from a FEniCS expression, finite-element function, or assembled matrix.

get_vertex_coordinates(cell::Cell)

Return the coordinates of the vertices of cell.

grad(u)
∇(u)

Construct the symbolic gradient of u.

h(cell::Cell)

Return the greatest distance between two vertices of cell.

hmax(mesh::Mesh)

Return the maximum cell diameter in mesh.

Arguments

• mesh: Mesh to inspect.

Returns

The maximum cell diameter as reported by FEniCS.

hmin(mesh::Mesh)

Return the minimum cell diameter in mesh.

Arguments

• mesh: Mesh to inspect.

Returns

The minimum cell diameter as reported by FEniCS.

info_LinearVariatonalSolver()

Print the default parameters for the FEniCS linear variational solver.

info_NonLinearVariationalSolver()

Print the default parameters for the FEniCS nonlinear variational solver.

init(mesh::Mesh)
init(mesh::Mesh, dim::Int)

Initialize mesh connectivity data.

The one-argument form initializes all connectivity data. The two-argument form initializes connectivity involving topological dimension dim.

Arguments

• mesh: Mesh whose connectivity should be initialized.
• dim: Optional topological dimension used to restrict initialization.

init_global(mesh::Mesh)

Initialize global mesh connectivity data for mesh.

Arguments

• mesh: Mesh whose global connectivity should be initialized.

inner(u, v)

Construct the symbolic inner product of two FEniCS expressions.

Arguments

• u, v: Symbolic expressions or finite-element functions.

interpolate(solution1::FeFunction, solution2::Expression)
interpolate(ex, V::FunctionSpace)

Interpolate an expression into a finite-element function or function space.

Arguments

• solution1: Destination finite-element function for the first method.
• solution2: Expression to interpolate for the first method.
• ex: Expression to interpolate for the second method.
• V: Destination function space for the second method.

len(u)

Return the Python length of a FEniCS expression or finite-element function.

lhs(equation::Expression)

Extract the bilinear left-hand side from a combined variational form.

Example

a = u * v * dx + f * v * dx
A = lhs(a)

list_krylov_solver_methods()

Return the Krylov solver methods available in the FEniCS installation.

list_krylov_solver_preconditioners()

Return the Krylov preconditioners available in the FEniCS installation.

list_linear_solver_methods()

Return the linear solver methods available in the FEniCS installation.

list_lu_solver_methods()

Return the LU solver methods available in the FEniCS installation.

lvsolve(a, L, u, bcs = nothing;
    solver_parameters = Dict("linear_solver" => "default"),
    form_compiler_parameters = Dict("optimize" => true))

Solve a linear variational problem.

Arguments

• a: Bilinear form.
• L: Linear form.
• u: Unknown finite-element function.
• bcs: Optional boundary condition or collection of boundary conditions.

Keyword Arguments

• solver_parameters: FEniCS linear-solver parameters.
• form_compiler_parameters: FEniCS form-compiler parameters.

midpoint(cell::Cell)

Return the midpoint of cell.

mpi_comm_self()

Return the FEniCS self MPI communicator.

mpi_comm_world()

Return the FEniCS world MPI communicator.

nabla_div(u)

Construct the UFL nabla divergence of u.

nabla_grad(u)

Construct the UFL nabla gradient of u.

nlvsolve(F, u, bcs = nothing; J = nothing,
    solver_parameters = Dict("nonlinear_solver" => "newton"),
    form_compiler_parameters = Dict("optimize" => true))

Solve a nonlinear variational problem.

Arguments

• F: Nonlinear residual form.
• u: Unknown finite-element function.
• bcs: Optional boundary condition or collection of boundary conditions.
• J: Optional Jacobian form.

Keyword Arguments

• solver_parameters: FEniCS nonlinear-solver parameters.
• form_compiler_parameters: FEniCS form-compiler parameters.

num_cells(mesh::Mesh)

Return the number of cells in mesh.

Arguments

• mesh: Mesh to inspect.

num_edges(mesh::Mesh)

Return the number of edges in mesh.

Arguments

• mesh: Mesh to inspect.

num_entities(mesh::Mesh, dim::Int)

Return the number of mesh entities of topological dimension dim.

Arguments

• mesh: Mesh to inspect.
• dim: Topological dimension of the entities to count.

num_faces(mesh::Mesh)

Return the number of faces in mesh.

Arguments

• mesh: Mesh to inspect.

num_facets(mesh::Mesh)

Return the number of facets in mesh.

Arguments

• mesh: Mesh to inspect.

num_vertices(mesh::Mesh)

Return the number of vertices in mesh.

Arguments

• mesh: Mesh to inspect.

outer(u, v)

Construct the symbolic outer product of two FEniCS expressions.

project(v::Union{FeFunction, Expression}, V::FunctionSpace)

Project v onto the finite-element space V.

Example

v = Expression("sin(pi*x[0])", degree = 2)
V = FunctionSpace(mesh, "Lagrange", 1)
Pv = project(v, V)

pyBoxMesh(p0, p1, nx::Int, ny::Int, nz::Int)

Construct the underlying Python box mesh object.

Arguments

• p0, p1: Opposite box corners.
• nx, ny, nz: Number of cells in each coordinate direction.

pyMesh(path::StringOrSymbol)

Load the underlying Python FEniCS mesh object from path.

pyRectangleMesh(p0, p1, nx::Int, ny::Int, diagdir::StringOrSymbol = "right")

Construct the underlying Python rectangle mesh object.

Arguments

• p0, p1: Opposite rectangle corners.
• nx, ny: Number of cells in each coordinate direction.
• diagdir: Diagonal orientation passed to FEniCS.

pyUnitCubeMesh(nx::Int, ny::Int, nz::Int)

Construct the underlying Python unit-cube mesh object.

Arguments

• nx, ny, nz: Number of cells in each coordinate direction.

pyUnitIntervalMesh(nx::Int)

Construct the underlying Python unit-interval mesh object.

Arguments

• nx: Number of cells in the interval.

pyUnitQuadMesh(nx::Int, ny::Int)

Construct the underlying Python quadrilateral mesh object.

pyUnitSquareMesh(nx::Int, ny::Int, diagdir::StringOrSymbol = "right")

Construct the underlying Python unit-square mesh object. diagdir may be "left", "right", "right/left", "left/right", or "crossed".

pyUnitTetrahedronMesh()

Return the underlying Python reference tetrahedron mesh object.

pyUnitTriangleMesh()

Return the underlying Python reference triangle mesh object.

py_split(fun::FeFunction)

Split fun using the wrapped Python method and return its component functions.

reconstruct(finiteelement::FiniteElement; family = nothing,
    cell = nothing, degree = nothing)

Construct a new finite element with selected properties replaced.

Keyword Arguments

• family: Replacement family, or nothing to preserve the current family.
• cell: Replacement cell, or nothing to preserve the current cell.
• degree: Replacement degree, or nothing to preserve the current degree.

retrieve(timeseries, placeholder, time)

Retrieve the value associated with placeholder at time from a FEniCS time series.

rhs(equation::Expression)

Extract the right-hand side from a combined bilinear and linear form. The linear part is negated by the FEniCS convention.

Example

a = u * v * dx + f * v * dx
L = rhs(a)

rmax(mesh::Mesh)

Return the maximum cell inradius in mesh.

Arguments

• mesh: Mesh to inspect.

rmin(mesh::Mesh)

Return the minimum cell inradius in mesh.

Arguments

• mesh: Mesh to inspect.

sobolev_space(finiteelement::FiniteElement)

Return the Sobolev space associated with finiteelement.

solve(A::Matrix, x, b::Matrix, solvers...)

Solve the linear algebraic system represented by A, x, and b using the wrapped FEniCS solver.

Arguments

• A: Assembled system matrix.
• x: Solution vector or FEniCS solution object.
• b: Right-hand-side matrix or vector.
• solvers...: Additional solver arguments forwarded to FEniCS.

store(path::PyObject, solution, time::Number)

Store solution at time in a FEniCS time-series object.

str(obj::fenicsobject)

Return the Python string representation of obj.

sym(u)

Construct the symmetric part of u.

topology(mesh::Mesh)

Return the topological structure of mesh.

Arguments

• mesh: Mesh whose topology object is requested.

tr(u)

Construct the symbolic trace of u.

ufl_cell(mesh::Mesh)

Return the UFL cell associated with mesh.

ufl_domain(mesh::Mesh)

Return the UFL domain associated with mesh.

ufl_id(mesh::Mesh)

Return the UFL identifier associated with mesh.

variant(finiteelement::FiniteElement)

Return the local-basis variant of finiteelement.

vector(solution::FeFunction)

Return the vector backing solution.

volume(cell::Cell)

Return the volume of cell.

∇(u)

Construct the symbolic gradient of u.

norm(u::FeFunction; normType = "L2", mesh = nothing)

Compute a FEniCS norm of a finite-element function.

Arguments

• u: Finite-element function whose norm is computed.

Keyword Arguments

• normType = "L2": FEniCS norm identifier.
• mesh = nothing: Optional mesh used by FEniCS for the norm computation.

Examples

julia> norm(u; normType = "H1")
1.0

besseli(nu::Int, u::Union{Expression, FeFunction})

Construct the modified Bessel function of the first kind for a FEniCS value.

Arguments

• nu: Integer Bessel order.
• u: FEniCS symbolic expression or finite-element function.

Examples

julia> radial_mode = besseli(0, radius);

besselj(nu::Int, u::Union{Expression, FeFunction})

Construct the Bessel function of the first kind for a FEniCS value.

Arguments

• nu: Integer Bessel order.
• u: FEniCS symbolic expression or finite-element function.

Examples

julia> radial_mode = besselj(0, radius);

besselk(nu::Int, u::Union{Expression, FeFunction})

Construct the modified Bessel function of the second kind for a FEniCS value.

Arguments

• nu: Integer Bessel order.
• u: FEniCS symbolic expression or finite-element function.

Examples

julia> radial_mode = besselk(0, radius);

bessely(nu::Int, u::Union{Expression, FeFunction})

Construct the Bessel function of the second kind for a FEniCS value.

Arguments

• nu: Integer Bessel order.
• u: FEniCS symbolic expression or finite-element function.

Examples

julia> radial_mode = bessely(0, radius);

@fenicsclass name [base = FEniCS.fenicsobject]

Define a Julia wrapper hierarchy for a FEniCS Python object.

Arguments

• name: Name of the abstract wrapper type to define.
• base: Optional abstract supertype. It defaults to FEniCS's wrapper base type.

Extension rules

The macro defines name <: base, a concrete nameImpl <: name with one PyCall.PyObject field named pyobject, and a constructor from that field. Use it from a module that imports FEniCS; importing PyCall is not required to expand the macro. Extend wrapper behavior on name, not on nameImpl, so all implementations of the abstract wrapper share the extension.

Example

module MyFEniCSExtension
using FEniCS
FEniCS.@fenicsclass MyObject
end