ufl package¶

Subpackages¶

Submodules¶

ufl.action module¶

This module defines the Action class.

class ufl.action.Action(*args, **kw)[source]¶

Bases: BaseForm

UFL base form type: respresents the action of an object on another.

For example:: res = Ax

A would be the first argument, left and x would be the second argument, right.

Action objects will result when the action of an assembled object (e.g. a Matrix) is taken. This delays the evaluation of the action until assembly occurs.

equals(other)[source]¶: Check if two Actions are equal.

left()[source]¶: Get left.

right()[source]¶: Get right.

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of the underlying form.

ufl_operands¶

ufl.adjoint module¶

This module defines the Adjoint class.

class ufl.adjoint.Adjoint(*args, **kw)[source]¶

Bases: BaseForm

UFL base form type: represents the adjoint of an object.

Adjoint objects will result when the adjoint of an assembled object (e.g. a Matrix) is taken. This delays the evaluation of the adjoint until assembly occurs.

equals(other)[source]¶: Check if two Adjoints are equal.

form()[source]¶: Return the form.

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of the underlying form.

ufl_operands¶

ufl.algebra module¶

Basic algebra operations.

class ufl.algebra.Abs(a)[source]¶

Bases: Operator

Absolute value.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.algebra.Conj(a)[source]¶

Bases: Operator

Complex conjugate.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.algebra.Division(a, b)[source]¶

Bases: Operator

Division.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.algebra.Imag(a)[source]¶

Bases: Operator

Imaginary part.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.algebra.Power(a, b)[source]¶

Bases: Operator

Power.

evaluate(x, mapping, component, index_values)[source]¶: Evalute.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.algebra.Product(a, b)[source]¶

Bases: Operator

The product of two or more UFL objects.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.algebra.Real(a)[source]¶

Bases: Operator

Real part.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.algebra.Sum(a, b)[source]¶

Bases: Operator

Sum.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

ufl.argument module¶

Argument.

This module defines the class Argument and a number of related classes (functions), including TestFunction and TrialFunction.

class ufl.argument.Argument(*args, **kw)[source]¶

Bases: FormArgument, BaseArgument

UFL value: Representation of an argument to a form.

ufl_domains()[source]¶: Return UFL domains.

ufl.argument.Arguments(function_space, number)[source]¶

Create an Argument in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

class ufl.argument.BaseArgument(function_space, number, part=None)[source]¶

Bases: object

UFL value: Representation of an argument to a form.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

number()[source]¶: Return the Argument number.

part()[source]¶: Return the part.

ufl_domain()[source]¶: Return the UFL domain.

ufl_domains()[source]¶: Return UFL domains.

ufl_element()[source]¶: Return The UFL element.

ufl_function_space()[source]¶: Get the function space of this Argument.

property ufl_shape¶: Return the associated UFL shape.

class ufl.argument.Coargument(*args, **kw)[source]¶

Bases: BaseForm, BaseArgument

UFL value: Representation of an argument to a form in a dual space.

arguments(outer_form=None)[source]¶: Return all Argument objects found in form.

equals(other)[source]¶: Check equality.

ufl_domain()[source]¶: Return the UFL domain.

ufl_operands¶

ufl.argument.TestFunction(function_space, part=None)[source]¶: UFL value: Create a test function argument to a form.

ufl.argument.TestFunctions(function_space)[source]¶

Create a TestFunction in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

ufl.argument.TrialFunction(function_space, part=None)[source]¶: UFL value: Create a trial function argument to a form.

ufl.argument.TrialFunctions(function_space)[source]¶

Create a TrialFunction in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

ufl.averaging module¶

Averaging operations.

class ufl.averaging.CellAvg(f)[source]¶

Bases: Operator

Cell average.

evaluate(x, mapping, component, index_values)[source]¶: Performs an approximate symbolic evaluation, since we don’t have a cell.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.averaging.FacetAvg(f)[source]¶

Bases: Operator

Facet average.

evaluate(x, mapping, component, index_values)[source]¶: Performs an approximate symbolic evaluation, since we dont have a cell.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

ufl.cell module¶

Types for representing a cell.

class ufl.cell.AbstractCell[source]¶

Bases: UFLObject

A base class for all cells.

abstract cellname() → str[source]¶: Return the cellname of the cell.

edge_types() → Tuple[AbstractCell, ...][source]¶: Get the unique edge types.

edges() → Tuple[AbstractCell, ...][source]¶: Get the edges.

face_types() → Tuple[AbstractCell, ...][source]¶: Get the unique face types.

faces() → Tuple[AbstractCell, ...][source]¶: Get the faces.

facet_types() → Tuple[AbstractCell, ...][source]¶

Get the unique facet types.

Facets are entities of dimension tdim-1.

facets() → Tuple[AbstractCell, ...][source]¶

Get the facets.

Facets are entities of dimension tdim-1.

abstract has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

abstract is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_edges() → int[source]¶: Get the number of edges.

num_faces() → int[source]¶: Get the number of faces.

num_facets() → int[source]¶

Get the number of facets.

Facets are entities of dimension tdim-1.

num_peaks() → int[source]¶

Get the number of peaks.

Peaks are entities of dimension tdim-3.

num_ridges() → int[source]¶

Get the number of ridges.

Ridges are entities of dimension tdim-2.

abstract num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

num_vertices() → int[source]¶: Get the number of vertices.

peak_types() → Tuple[AbstractCell, ...][source]¶

Get the unique peak types.

Peaks are entities of dimension tdim-3.

peaks() → Tuple[AbstractCell, ...][source]¶

Get the peaks.

Peaks are entities of dimension tdim-3.

abstract reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

ridge_types() → Tuple[AbstractCell, ...][source]¶

Get the unique ridge types.

Ridges are entities of dimension tdim-2.

ridges() → Tuple[AbstractCell, ...][source]¶

Get the ridges.

Ridges are entities of dimension tdim-2.

abstract sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

abstract sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

abstract topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

vertex_types() → Tuple[AbstractCell, ...][source]¶: Get the unique vertices types.

vertices() → Tuple[AbstractCell, ...][source]¶: Get the vertices.

class ufl.cell.Cell(cellname: str)[source]¶

Bases: AbstractCell

Representation of a named finite element cell with known structure.

cellname() → str[source]¶: Return the cellname of the cell.

has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

class ufl.cell.TensorProductCell(*cells: Cell)[source]¶

Bases: AbstractCell

Tensor product cell.

cellname() → str[source]¶: Return the cellname of the cell.

has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

sub_cells() → List[AbstractCell][source]¶: Return list of cell factors.

sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

ufl.cell.as_cell(cell: AbstractCell | str | Tuple[AbstractCell, ...]) → AbstractCell[source]¶

Convert any valid object to a Cell or return cell if it is already a Cell.

Allows an already valid cell, a known cellname string, or a tuple of cells for a product cell.

ufl.cell.hypercube(topological_dimension: int)[source]¶: Return a hypercube cell of the given dimension.

ufl.cell.simplex(topological_dimension: int)[source]¶: Return a simplex cell of the given dimension.

ufl.checks module¶

Utility functions for checking properties of expressions.

ufl.checks.is_cellwise_constant(expr)[source]¶: Return whether expression is constant over a single cell.

ufl.checks.is_python_scalar(expression)[source]¶: Return True iff expression is of a Python scalar type.

ufl.checks.is_scalar_constant_expression(expr)[source]¶: Check if an expression is a globally constant scalar expression.

ufl.checks.is_true_ufl_scalar(expression)[source]¶: Return True iff expression is scalar-valued, with no free indices.

ufl.checks.is_ufl_scalar(expression)[source]¶: Return True iff expression is scalar-valued, but possibly containing free indices.

ufl.classes module¶

Classes.

This file is useful for external code like tests and form compilers, since it enables the syntax “from ufl.classes import CellFacetooBar” for getting implementation details not exposed through the default ufl namespace. It also contains functionality used by algorithms for dealing with groups of classes, and for mapping types to different handler functions.

class ufl.classes.Abs(a)[source]¶

Bases: Operator

Absolute value.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.AbstractCell[source]¶

Bases: UFLObject

A base class for all cells.

abstract cellname() → str[source]¶: Return the cellname of the cell.

edge_types() → Tuple[AbstractCell, ...][source]¶: Get the unique edge types.

edges() → Tuple[AbstractCell, ...][source]¶: Get the edges.

face_types() → Tuple[AbstractCell, ...][source]¶: Get the unique face types.

faces() → Tuple[AbstractCell, ...][source]¶: Get the faces.

facet_types() → Tuple[AbstractCell, ...][source]¶

Get the unique facet types.

Facets are entities of dimension tdim-1.

facets() → Tuple[AbstractCell, ...][source]¶

Get the facets.

Facets are entities of dimension tdim-1.

abstract has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

abstract is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_edges() → int[source]¶: Get the number of edges.

num_faces() → int[source]¶: Get the number of faces.

num_facets() → int[source]¶

Get the number of facets.

Facets are entities of dimension tdim-1.

num_peaks() → int[source]¶

Get the number of peaks.

Peaks are entities of dimension tdim-3.

num_ridges() → int[source]¶

Get the number of ridges.

Ridges are entities of dimension tdim-2.

abstract num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

num_vertices() → int[source]¶: Get the number of vertices.

peak_types() → Tuple[AbstractCell, ...][source]¶

Get the unique peak types.

Peaks are entities of dimension tdim-3.

peaks() → Tuple[AbstractCell, ...][source]¶

Get the peaks.

Peaks are entities of dimension tdim-3.

abstract reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

ridge_types() → Tuple[AbstractCell, ...][source]¶

Get the unique ridge types.

Ridges are entities of dimension tdim-2.

ridges() → Tuple[AbstractCell, ...][source]¶

Get the ridges.

Ridges are entities of dimension tdim-2.

abstract sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

abstract sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

abstract topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

vertex_types() → Tuple[AbstractCell, ...][source]¶: Get the unique vertices types.

vertices() → Tuple[AbstractCell, ...][source]¶: Get the vertices.

class ufl.classes.AbstractDomain(topological_dimension, geometric_dimension)[source]¶

Bases: object

Symbolic representation of a geometric domain.

Domain has only a geometric and a topological dimension.

geometric_dimension()[source]¶: Return the dimension of the space this domain is embedded in.

topological_dimension()[source]¶: Return the dimension of the topology of this domain.

class ufl.classes.AbstractFiniteElement[source]¶

Bases: ABC

Base class for all finite elements.

To make your element library compatible with UFL, you should make a subclass of AbstractFiniteElement and provide implementions of all the abstract methods and properties. All methods and properties that are not marked as abstract are implemented here and should not need to be overwritten in your subclass.

An example of how the methods in your subclass could be implemented can be found in Basix; see https://github.com/FEniCS/basix/blob/main/python/basix/ufl.py

abstract property cell: Cell¶: Return the cell of the finite element.

abstract property embedded_subdegree: int¶

Degree of the maximum degree Lagrange space that is spanned by this element.

This returns the degree of the highest degree Lagrange space such that the polynomial space of the Lagrange space is a subspace of this element’s polynomial space. If this element’s polynomial space does not include the constant function, this function should return -1.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

abstract property embedded_superdegree: int | None¶

Degree of the minimum degree Lagrange space that spans this element.

This returns the degree of the lowest degree Lagrange space such that the polynomial space of the Lagrange space is a superspace of this element’s polynomial space. If this element contains basis functions that are not in any Lagrange space, this function should return None.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

is_cellwise_constant() → bool[source]¶: Check whether this element is spatially constant over each cell.

property num_sub_elements: int¶

Return number of sub-elements.

This function does not recurse: ie it does not count the sub-elements of sub-elements.

abstract property pullback: AbstractPullback¶: Return the pullback for this element.

abstract property reference_value_shape: Tuple[int, ...]¶: Return the shape of the value space on the reference cell.

property reference_value_size: int¶: Return the integer product of the reference value shape.

abstract property sobolev_space: SobolevSpace¶: Return the underlying Sobolev space.

abstract property sub_elements: List¶

Return list of sub-elements.

This function does not recurse: ie it does not extract the sub-elements of sub-elements.

class ufl.classes.AbstractFunctionSpace[source]¶

Bases: object

Abstract function space.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

class ufl.classes.AbstractPullback[source]¶

Bases: ABC

An abstract pull back.

apply(expr: Expr) → Expr[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

abstract property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

abstract physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.Acos(argument)[source]¶

Bases: MathFunction

Inverse cosine.

class ufl.classes.Action(*args, **kw)[source]¶

Bases: BaseForm

UFL base form type: respresents the action of an object on another.

For example:: res = Ax

A would be the first argument, left and x would be the second argument, right.

Action objects will result when the action of an assembled object (e.g. a Matrix) is taken. This delays the evaluation of the action until assembly occurs.

equals(other)[source]¶: Check if two Actions are equal.

left()[source]¶: Get left.

right()[source]¶: Get right.

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of the underlying form.

ufl_operands¶

class ufl.classes.Adjoint(*args, **kw)[source]¶

Bases: BaseForm

UFL base form type: represents the adjoint of an object.

Adjoint objects will result when the adjoint of an assembled object (e.g. a Matrix) is taken. This delays the evaluation of the adjoint until assembly occurs.

equals(other)[source]¶: Check if two Adjoints are equal.

form()[source]¶: Return the form.

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of the underlying form.

ufl_operands¶

class ufl.classes.AndCondition(left, right)[source]¶

Bases: BinaryCondition

And condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.Argument(*args, **kw)[source]¶

Bases: FormArgument, BaseArgument

UFL value: Representation of an argument to a form.

ufl_domains()[source]¶: Return UFL domains.

class ufl.classes.Asin(argument)[source]¶

Bases: MathFunction

Inverse sine.

class ufl.classes.Atan(argument)[source]¶

Bases: MathFunction

Inverse tangent.

class ufl.classes.Atan2(arg1, arg2)[source]¶

Bases: Operator

Inverse tangent with two inputs.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.BaseForm[source]¶

Bases: object

Description of an object containing arguments.

arguments()[source]¶: Return all Argument objects found in form.

coefficients()[source]¶: Return all Coefficient objects found in form.

ufl_domain()[source]¶

Return the single geometric integration domain occuring in the base form.

Fails if multiple domains are found.

class ufl.classes.BaseFormCoordinateDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: BaseFormDerivative, CoordinateDerivative

Derivative of a base form w.r.t. the SpatialCoordinates.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.BaseFormDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: CoefficientDerivative, BaseForm

Derivative of a base form w.r.t the degrees of freedom in a discrete Coefficient.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.BaseFormOperator(*operands, function_space, derivatives=None, argument_slots=())[source]¶

Bases: Operator, BaseForm, Counted

Base form operator.

argument_slots(outer_form=False)[source]¶

Returns a tuple of expressions containing argument and coefficient based expressions.

We get an argument uhat when we take the Gateaux derivative in the direction uhat: d/du N(u; v*) = dNdu(u; uhat, v*) where uhat is a ufl.Argument and v* a ufl.Coargument Applying the action replace the last argument by coefficient: action(dNdu(u; uhat, v*), w) = dNdu(u; w, v*) where du is a ufl.Coefficient.

coefficients()[source]¶: Return all BaseCoefficient objects found in base form operator.

count()[source]¶: Return the count associated to the base form operator.

ufl_free_indices = ()¶

ufl_function_space()[source]¶

Return the function space associated to the operator.

I.e. return the dual of the base form operator’s Coargument.

ufl_index_dimensions = ()¶

ufl_operands¶

property ufl_shape¶: Return the UFL shape of the coefficient.produced by the operator.

class ufl.classes.BaseFormOperatorCoordinateDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: BaseFormOperatorDerivative, CoordinateDerivative

Derivative of a base form operator w.r.t. the SpatialCoordinates.

property ufl_free_indices¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_index_dimensions¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_shape¶: Return the UFL shape of the coefficient.produced by the operator.

class ufl.classes.BaseFormOperatorDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: BaseFormDerivative, BaseFormOperator

Derivative of a base form operator w.r.t the degrees of freedom in a discrete Coefficient.

argument_slots(outer_form=False)[source]¶: Return a tuple of expressions containing argument and coefficient based expressions.

property ufl_free_indices¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_index_dimensions¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_shape¶: Return the UFL shape of the coefficient.produced by the operator.

class ufl.classes.BesselFunction(name, nu, argument)[source]¶

Bases: Operator

Base class for all bessel functions.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.BesselI(nu, argument)[source]¶

Bases: BesselFunction

Bessel I function.

class ufl.classes.BesselJ(nu, argument)[source]¶

Bases: BesselFunction

Bessel J function.

class ufl.classes.BesselK(nu, argument)[source]¶

Bases: BesselFunction

Bessel K function.

class ufl.classes.BesselY(nu, argument)[source]¶

Bases: BesselFunction

Bessel Y function.

class ufl.classes.BinaryCondition(name, left, right)[source]¶

Bases: Condition

Binary condition.

class ufl.classes.Cell(cellname: str)[source]¶

Bases: AbstractCell

Representation of a named finite element cell with known structure.

cellname() → str[source]¶: Return the cellname of the cell.

has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

class ufl.classes.CellAvg(f)[source]¶

Bases: Operator

Cell average.

evaluate(x, mapping, component, index_values)[source]¶: Performs an approximate symbolic evaluation, since we don’t have a cell.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.CellCoordinate(domain)[source]¶

Bases: GeometricCellQuantity

The coordinate in a reference cell.

In the context of expression integration, represents the reference cell coordinate of each quadrature point.

In the context of expression evaluation in a point in a cell, represents that point in the reference coordinate system of the cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'X'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.CellDiameter(domain)[source]¶

Bases: GeometricCellQuantity

The diameter of the cell, i.e., maximal distance of two points in the cell.

name = 'diameter'¶

class ufl.classes.CellEdgeVectors(domain)[source]¶

Bases: GeometricCellQuantity

The vectors between physical cell vertices for each edge in cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.CellFacetJacobian(domain)[source]¶

Bases: GeometricFacetQuantity

The Jacobian of the mapping from reference facet to reference cell coordinates.

CFJ_ij = dX_i/dXf_j

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CFJ'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.CellFacetJacobianDeterminant(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-determinant of the CellFacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'detCFJ'¶

class ufl.classes.CellFacetJacobianInverse(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-inverse of the CellFacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CFK'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.CellFacetOrigin(domain)[source]¶

Bases: GeometricFacetQuantity

The reference cell coordinate corresponding to origin of a reference facet.

name = 'X0f'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.CellNormal(domain)[source]¶

Bases: GeometricCellQuantity

The upwards pointing normal vector of the current manifold cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'cell_normal'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.CellOrientation(domain)[source]¶

Bases: GeometricCellQuantity

The orientation (+1/-1) of the current cell.

For non-manifold cells (tdim == gdim), this equals the sign of the Jacobian determinant, i.e. +1 if the physical cell is oriented the same way as the reference cell and -1 otherwise.

For manifold cells of tdim==gdim-1 this is input data belonging to the mesh, used to distinguish between the sides of the manifold.

name = 'cell_orientation'¶

class ufl.classes.CellOrigin(domain)[source]¶

Bases: GeometricCellQuantity

The spatial coordinate corresponding to origin of a reference cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'x0'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.CellVertices(domain)[source]¶

Bases: GeometricCellQuantity

Physical cell vertices.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.CellVolume(domain)[source]¶

Bases: GeometricCellQuantity

The volume of the cell.

name = 'volume'¶

class ufl.classes.Circumradius(domain)[source]¶

Bases: GeometricCellQuantity

The circumradius of the cell.

name = 'circumradius'¶

class ufl.classes.Coargument(*args, **kw)[source]¶

Bases: BaseForm, BaseArgument

UFL value: Representation of an argument to a form in a dual space.

arguments(outer_form=None)[source]¶: Return all Argument objects found in form.

equals(other)[source]¶: Check equality.

ufl_domain()[source]¶: Return the UFL domain.

ufl_operands¶

class ufl.classes.Coefficient(*args, **kw)[source]¶

Bases: FormArgument, BaseCoefficient

UFL form argument type: Representation of a form coefficient.

ufl_domains()[source]¶: Get the UFL domains.

class ufl.classes.CoefficientDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: Derivative

Derivative of form integrand w.r.t. the degrees of freedom in a discrete Coefficient.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.Cofactor(A)[source]¶

Bases: CompoundTensorOperator

Cofactor.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.Cofunction(*args, **kw)[source]¶

Bases: BaseCoefficient, BaseForm

UFL form argument type: Representation of a form coefficient from a dual space.

equals(other)[source]¶: Check equality.

ufl_operands¶

class ufl.classes.ComplexValue(value)[source]¶

Bases: ScalarValue

Representation of a constant, complex scalar.

argument()[source]¶: Get the argument.

modulus()[source]¶: Get the modulus.

class ufl.classes.ComponentTensor(expression, indices)[source]¶

Bases: Operator

Maps the free indices of a scalar valued expression to tensor axes.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

indices()[source]¶: Get indices.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape¶

class ufl.classes.CompoundDerivative(operands)[source]¶

Bases: Derivative

Base class for all compound derivative types.

class ufl.classes.CompoundTensorOperator(operands)[source]¶

Bases: Operator

Compount tensor operator.

class ufl.classes.Condition(operands)[source]¶

Bases: Operator

Condition.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.Conditional(condition, true_value, false_value)[source]¶

Bases: Operator

Conditional expression.

In C++ these take the format (condition ? true_value : false_value).

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.Conj(a)[source]¶

Bases: Operator

Complex conjugate.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.Constant(domain, shape=(), count=None)[source]¶

Bases: Terminal, Counted

Constant.

is_cellwise_constant()[source]¶: Return True if the function is cellwise constant.

ufl_domain()[source]¶: Get the UFL domain.

ufl_domains()[source]¶: Get the UFL domains.

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ConstantValue[source]¶

Bases: Terminal

Constant value.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

ufl_domains()[source]¶: Return tuple of domains related to this terminal object.

class ufl.classes.ContravariantPiola[source]¶

Bases: AbstractPullback

The contravariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.CoordinateDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: CoefficientDerivative

Derivative of the integrand of a form w.r.t. the SpatialCoordinates.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.Cos(argument)[source]¶

Bases: MathFunction

Cosine.

class ufl.classes.Cosh(argument)[source]¶

Bases: MathFunction

Hyperbolic cosine.

class ufl.classes.CovariantContravariantPiola[source]¶

Bases: AbstractPullback

The covariant contravariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.CovariantPiola[source]¶

Bases: AbstractPullback

The covariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.Cross(a, b)[source]¶

Bases: CompoundTensorOperator

Cross.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = (3,)¶

class ufl.classes.Curl(f)[source]¶

Bases: CompoundDerivative

Compound derivative.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape¶

class ufl.classes.CustomPullback[source]¶

Bases: AbstractPullback

Custom pull back.

This should probably be removed.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.Derivative(operands)[source]¶

Bases: Operator

Base class for all derivative types.

class ufl.classes.Determinant(A)[source]¶

Bases: CompoundTensorOperator

Determinant.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.Deviatoric(A)[source]¶

Bases: CompoundTensorOperator

Deviatoric.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.DirectionalSobolevSpace(orders)[source]¶

Bases: SobolevSpace

Directional Sobolev space.

Symbolic representation of a Sobolev space with varying smoothness in different spatial directions.

class ufl.classes.Div(f)[source]¶

Bases: CompoundDerivative

Div.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.Division(a, b)[source]¶

Bases: Operator

Division.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.classes.Dot(a, b)[source]¶

Bases: CompoundTensorOperator

Dot.

ufl_free_indices¶

ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.DoubleContravariantPiola[source]¶

Bases: AbstractPullback

The double contravariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.DoubleCovariantPiola[source]¶

Bases: AbstractPullback

The double covariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.DualSpace(domain, element, label='')[source]¶

Bases: BaseFunctionSpace, UFLObject

Representation of a Dual space.

dual()[source]¶: Get the dual of the space.

class ufl.classes.EQ(left, right)[source]¶

Bases: BinaryCondition

Equality condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.Equation(lhs, rhs)[source]¶

Bases: object

Equation.

This class is used to represent equations expressed by the “==” operator. Examples include a == L and F == 0 where a, L and F are Form objects.

class ufl.classes.Erf(argument)[source]¶

Bases: MathFunction

Erf function.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.Exp(argument)[source]¶

Bases: MathFunction

Exponentiation..

class ufl.classes.Expr[source]¶

Bases: object

Base class for all UFL expression types.

Instance properties

Every Expr instance will have certain properties. The most important ones are ufl_operands, ufl_shape, ufl_free_indices, and ufl_index_dimensions properties. Expressions are immutable and hashable.

Type traits

The Expr API defines a number of type traits that each subclass needs to provide. Most of these are specified indirectly via the arguments to the ufl_type class decorator, allowing UFL to do some consistency checks and automate most of the traits for most types. Type traits are accessed via a class or instance object of the form obj._ufl_traitname_. See the source code for description of each type trait.

Operators

Some Python special functions are implemented in this class, some are implemented in subclasses, and some are attached to this class in the ufl_type class decorator.

Defining subclasses

To define a new expression class, inherit from either Terminal or Operator, and apply the ufl_type class decorator with suitable arguments. See the docstring of ufl_type for details on its arguments. Looking at existing classes similar to the one you wish to add is a good idea. Looking through the comments in the Expr class and ufl_type to understand all the properties that may need to be specified is also a good idea. Note that many algorithms in UFL and form compilers will need handlers implemented for each new type::.

@ufl_type()
class MyOperator(Operator):
    pass

Type collections

All Expr subclasses are collected by ufl_type in global variables available via Expr.

Profiling

Object creation statistics can be collected by doing

Expr.ufl_enable_profiling()
# ... run some code
initstats, delstats = Expr.ufl_disable_profiling()

Giving a list of creation and deletion counts for each typecode.

property T¶

Transpose a rank-2 tensor expression.

For more general transpose operations of higher order tensor expressions, use indexing and Tensor.

dx(*ii)¶: Return the partial derivative with respect to spatial variable number ii.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate expression at given coordinate with given values for terminals.

static ufl_disable_profiling()[source]¶: Turn off the object counting mechanism. Return object init and del counts.

ufl_domain()[source]¶: Return the single unique domain this expression is defined on, or throw an error.

ufl_domains()[source]¶: Return all domains this expression is defined on.

static ufl_enable_profiling()[source]¶: Turn on the object counting mechanism and reset counts to zero.

class ufl.classes.ExprList(*operands)[source]¶

Bases: Operator

List of Expr objects. For internal use, never to be created by end users.

free_indices()[source]¶: Get the free indices.

index_dimensions()[source]¶: Get the index dimensions.

property ufl_free_indices¶: Get the UFL free indices.

property ufl_index_dimensions¶: Get the UFL index dimensions.

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ExprMapping(*operands)[source]¶

Bases: Operator

Mapping of Expr objects. For internal use, never to be created by end users.

free_indices()[source]¶: Get the free indices.

index_dimensions()[source]¶: Get the index dimensions.

ufl_domains()[source]¶: Get the UFL domains.

property ufl_free_indices¶: Get the UFL free indices.

property ufl_index_dimensions¶: Get the UFL index dimensions.

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ExternalOperator(*operands, function_space, derivatives=None, argument_slots=())[source]¶

Bases: BaseFormOperator

External operator.

assemble(*args, **kwargs)[source]¶: Assemble the external operator.

grad()[source]¶: Returns the symbolic grad of the external operator.

ufl_element()[source]¶: Shortcut to get the finite element of the function space of the external operator.

ufl_operands¶

class ufl.classes.FacetArea(domain)[source]¶

Bases: GeometricFacetQuantity

The area of the facet.

name = 'facetarea'¶

class ufl.classes.FacetAvg(f)[source]¶

Bases: Operator

Facet average.

evaluate(x, mapping, component, index_values)[source]¶: Performs an approximate symbolic evaluation, since we dont have a cell.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.FacetCoordinate(domain)[source]¶

Bases: GeometricFacetQuantity

The coordinate in a reference cell of a facet.

In the context of expression integration over a facet, represents the reference facet coordinate of each quadrature point.

In the context of expression evaluation in a point on a facet, represents that point in the reference coordinate system of the facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'Xf'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.FacetEdgeVectors(domain)[source]¶

Bases: GeometricFacetQuantity

The vectors between physical cell vertices for each edge in current facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'FEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.FacetJacobian(domain)[source]¶

Bases: GeometricFacetQuantity

The Jacobian of the mapping from reference facet to spatial coordinates.

FJ_ij = dx_i/dXf_j

The FacetJacobian is the product of the Jacobian and CellFacetJacobian:

FJ = dx/dXf = dx/dX dX/dXf = J * CFJ

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'FJ'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.FacetJacobianDeterminant(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-determinant of the FacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'detFJ'¶

class ufl.classes.FacetJacobianInverse(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-inverse of the FacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'FK'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.FacetNormal(domain)[source]¶

Bases: GeometricFacetQuantity

The outwards pointing normal vector of the current facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'n'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.FacetOrientation(domain)[source]¶

Bases: GeometricFacetQuantity

The orientation (+1/-1) of the current facet relative to the reference cell.

name = 'facet_orientation'¶

class ufl.classes.FacetOrigin(domain)[source]¶

Bases: GeometricFacetQuantity

The spatial coordinate corresponding to origin of a reference facet.

name = 'x0f'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.FiniteElement(family: str, cell: Cell, degree: int, reference_value_shape: Tuple[int, ...], pullback: AbstractPullback, sobolev_space: SobolevSpace, sub_elements=[], _repr: str | None = None, _str: str | None = None, subdegree: int | None = None)[source]¶

Bases: AbstractFiniteElement

A directly defined finite element.

property cell: Cell¶: Return the cell of the finite element.

property embedded_subdegree: int¶

Degree of the maximum degree Lagrange space that is spanned by this element.

This returns the degree of the highest degree Lagrange space such that the polynomial space of the Lagrange space is a subspace of this element’s polynomial space. If this element’s polynomial space does not include the constant function, this function should return -1.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

property embedded_superdegree: int | None¶

Degree of the minimum degree Lagrange space that spans this element.

This returns the degree of the lowest degree Lagrange space such that the polynomial space of the Lagrange space is a superspace of this element’s polynomial space. If this element contains basis functions that are not in any Lagrange space, this function should return None.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

property pullback: AbstractPullback¶: Return the pullback for this element.

property reference_value_shape: Tuple[int, ...]¶: Return the shape of the value space on the reference cell.

property sobolev_space: SobolevSpace¶: Return the underlying Sobolev space.

property sub_elements: List¶

Return list of sub-elements.

This function does not recurse: ie it does not extract the sub-elements of sub-elements.

class ufl.classes.FixedIndex(value)[source]¶

Bases: IndexBase

UFL value: An index with a specific value assigned.

class ufl.classes.FloatValue(value)[source]¶

Bases: RealValue

Representation of a constant scalar floating point value.

class ufl.classes.Form(integrals)[source]¶

Bases: BaseForm

Description of a weak form consisting of a sum of integrals over subdomains.

base_form_operators()[source]¶: Return all BaseFormOperator objects found in form.

coefficient_numbering()[source]¶: Return a contiguous numbering of coefficients in a mapping {coefficient:number}.

coefficients()[source]¶: Return all Coefficient objects found in form.

constant_numbering()[source]¶: Return a contiguous numbering of constants in a mapping {constant:number}.

constants()[source]¶: Get constants.

domain_numbering()[source]¶: Return a contiguous numbering of domains in a mapping {domain:number}.

empty()[source]¶: Returns whether the form has no integrals.

equals(other)[source]¶: Evaluate bool(lhs_form == rhs_form).

geometric_dimension()[source]¶: Return the geometric dimension shared by all domains and functions in this form.

integrals()[source]¶: Return a sequence of all integrals in form.

integrals_by_domain(domain)[source]¶: Return a sequence of all integrals with a particular integration domain.

integrals_by_type(integral_type)[source]¶: Return a sequence of all integrals with a particular domain type.

signature()[source]¶: Signature for use with jit cache (independent of incidental numbering of indices etc).

subdomain_data()[source]¶: Returns a mapping on the form {domain:{integral_type: subdomain_data}}.

terminal_numbering()[source]¶

Return a contiguous numbering for all counted objects in the form.

The returned object is mapping from terminal to its number (an integer).

The numbering is computed per type so :class:`Coefficient`s, :class:`Constant`s, etc will each be numbered from zero.

ufl_cell()[source]¶

Return the single cell this form is defined on.

Fails if multiple cells are found.

ufl_domains()[source]¶

Return the geometric integration domains occuring in the form.

NB! This does not include domains of coefficients defined on other meshes.

The return type is a tuple even if only a single domain exists.

class ufl.classes.FormArgument[source]¶

Bases: Terminal

An abstract class for a form argument (a thing in a primal finite element space).

class ufl.classes.FormSum(*args, **kwargs)[source]¶

Bases: BaseForm

Form sum.

Description of a weighted sum of variational forms and form-like objects components is the list of Forms to be summed arg_weights is a list of tuples of component index and weight

components()[source]¶: Get components.

equals(other)[source]¶: Evaluate bool(lhs_form == rhs_form).

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_operands¶

weights()[source]¶: Get weights.

class ufl.classes.FunctionSpace(domain, element, label='')[source]¶

Bases: BaseFunctionSpace, UFLObject

Representation of a Function space.

dual()[source]¶: Get the dual of the space.

class ufl.classes.GE(left, right)[source]¶

Bases: BinaryCondition

Greater than or equal to condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.GT(left, right)[source]¶

Bases: BinaryCondition

Greater than condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.GeometricCellQuantity(domain)[source]¶

Bases: GeometricQuantity

Geometric cell quantity.

class ufl.classes.GeometricFacetQuantity(domain)[source]¶

Bases: GeometricQuantity

Geometric facet quantity.

class ufl.classes.GeometricQuantity(domain)[source]¶

Bases: Terminal

Geometric quantity.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

ufl_domains()[source]¶: Get the UFL domains.

ufl_shape = ()¶

class ufl.classes.Grad(f)[source]¶

Bases: CompoundDerivative

Grad.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Get child from mapping and return the component asked for.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.Identity(dim)[source]¶

Bases: ConstantValue

Representation of an identity matrix.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_shape¶

class ufl.classes.IdentityPullback[source]¶

Bases: AbstractPullback

The identity pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.Imag(a)[source]¶

Bases: Operator

Imaginary part.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.Index(count=None)[source]¶

Bases: IndexBase, Counted

UFL value: An index with no value assigned.

Used to represent free indices in Einstein indexing notation.

class ufl.classes.IndexBase[source]¶

Bases: object

Base class for all indices.

class ufl.classes.IndexSum(summand, index)[source]¶

Bases: Operator

Index sum.

dimension()[source]¶: Get dimension.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

index()[source]¶: Get index.

ufl_free_indices¶

ufl_index_dimensions¶

property ufl_shape¶: Get UFL shape.

class ufl.classes.Indexed(expression, multiindex)[source]¶

Bases: Operator

Indexed expression.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Evaluate.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.classes.Inner(a, b)[source]¶

Bases: CompoundTensorOperator

Inner.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.classes.IntValue(value)[source]¶

Bases: RealValue

Representation of a constant scalar integer value.

class ufl.classes.Integral(integrand, integral_type, domain, subdomain_id, metadata, subdomain_data)[source]¶

Bases: object

An integral over a single domain.

integral_type()[source]¶: Return the domain type of this integral.

integrand()[source]¶: Return the integrand expression, which is an Expr instance.

metadata()[source]¶: Return the compiler metadata this integral has been annotated with.

reconstruct(integrand=None, integral_type=None, domain=None, subdomain_id=None, metadata=None, subdomain_data=None)[source]¶

Construct a new Integral object with some properties replaced with new values.

Example:: <a = Integral instance> b = a.reconstruct(expand_compounds(a.integrand())) c = a.reconstruct(metadata={‘quadrature_degree’:2})

subdomain_data()[source]¶: Return the domain data of this integral.

subdomain_id()[source]¶: Return the subdomain id of this integral.

ufl_domain()[source]¶: Return the integration domain of this integral.

class ufl.classes.Interpolate(expr, v)[source]¶

Bases: BaseFormOperator

Symbolic representation of the interpolation operator.

ufl_operands¶

class ufl.classes.Inverse(A)[source]¶

Bases: CompoundTensorOperator

Inverse.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.Jacobian(domain)[source]¶

Bases: GeometricCellQuantity

The Jacobian of the mapping from reference cell to spatial coordinates.

\[\begin{split}J_{ij} = \\frac{dx_i}{dX_j}\end{split}\]

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'J'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.JacobianDeterminant(domain)[source]¶

Bases: GeometricCellQuantity

The determinant of the Jacobian.

Represents the signed determinant of a square Jacobian or the pseudo-determinant of a non-square Jacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'detJ'¶

class ufl.classes.JacobianInverse(domain)[source]¶

Bases: GeometricCellQuantity

The inverse of the Jacobian.

Represents the inverse of a square Jacobian or the pseudo-inverse of a non-square Jacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'K'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.L2Piola[source]¶

Bases: AbstractPullback

The L2 Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.LE(left, right)[source]¶

Bases: BinaryCondition

Less than or equal condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.LT(left, right)[source]¶

Bases: BinaryCondition

Less than condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.Label(count=None)[source]¶

Bases: Terminal, Counted

Label.

is_cellwise_constant()[source]¶: Return true if the object is constant on each cell.

ufl_domains()[source]¶: Return tuple of domains related to this terminal object.

property ufl_free_indices¶: Get the UFL free indices.

property ufl_index_dimensions¶: Get the UFL index dimensions.

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ListTensor(*expressions)[source]¶

Bases: Operator

Wraps a list of expressions into a tensor valued expression of one higher rank.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.Ln(argument)[source]¶

Bases: MathFunction

Natural logarithm.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.MathFunction(name, argument)[source]¶

Bases: Operator

Base class for all unary scalar math functions.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.Matrix(row_space, column_space, count=None)[source]¶

Bases: BaseForm, Counted

An assemble linear operator between two function spaces.

equals(other)[source]¶: Check equality.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of this coefficient.

ufl_operands¶

class ufl.classes.MaxCellEdgeLength(domain)[source]¶

Bases: GeometricCellQuantity

The maximum edge length of the cell.

name = 'maxcelledgelength'¶

class ufl.classes.MaxFacetEdgeLength(domain)[source]¶

Bases: GeometricFacetQuantity

The maximum edge length of the facet.

name = 'maxfacetedgelength'¶

class ufl.classes.MaxValue(left, right)[source]¶

Bases: Operator

Take the maximum of two values.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.Measure(integral_type, domain=None, subdomain_id='everywhere', metadata=None, subdomain_data=None)[source]¶

Bases: object

Representation of an integration measure.

The Measure object holds information about integration properties to be transferred to a Form on multiplication with a scalar expression.

integral_type()[source]¶

Return the domain type.

Valid domain types are “cell”, “exterior_facet”, “interior_facet”, etc.

metadata()[source]¶

Return the integral metadata.

This data is not interpreted by UFL. It is passed to the form compiler which can ignore it or use it to compile each integral of a form in a different way.

reconstruct(integral_type=None, subdomain_id=None, domain=None, metadata=None, subdomain_data=None)[source]¶

Construct a new Measure object with some properties replaced with new values.

Example:: <dm = Measure instance> b = dm.reconstruct(subdomain_id=2) c = dm.reconstruct(metadata={ “quadrature_degree”: 3 })
Used by the call operator, so this is equivalent:: b = dm(2) c = dm(0, { “quadrature_degree”: 3 })

subdomain_data()[source]¶

Return the integral subdomain_data.

This data is not interpreted by UFL. Its intension is to give a context in which the domain id is interpreted.

subdomain_id()[source]¶: Return the domain id of this measure (integer).

ufl_domain()[source]¶

Return the domain associated with this measure.

This may be None or a Domain object.

class ufl.classes.MeasureProduct(*measures)[source]¶

Bases: object

Represents a product of measures.

This is a notational intermediate object to handle the notation

f*(dm1*dm2)

This is work in progress and not functional. It needs support in other parts of ufl and the rest of the code generation chain.

sub_measures()[source]¶: Return submeasures.

class ufl.classes.MeasureSum(*measures)[source]¶

Bases: object

Represents a sum of measures.

This is a notational intermediate object to translate the notation: f*(ds(1)+ds(3))
into: f*ds(1) + f*ds(3)

class ufl.classes.Mesh(coordinate_element, ufl_id=None, cargo=None)[source]¶

Bases: AbstractDomain, UFLObject

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()[source]¶: Check if the domain is a piecewise linear simplex.

ufl_cargo()[source]¶: Return carried object that will not be used by UFL.

ufl_cell()[source]¶: Get the cell.

ufl_coordinate_element()[source]¶: Get the coordinate element.

ufl_id()¶: Return the ufl_id of this object.

class ufl.classes.MeshView(mesh, topological_dimension, ufl_id=None)[source]¶

Bases: AbstractDomain, UFLObject

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()[source]¶: Check if the domain is a piecewise linear simplex.

ufl_cell()[source]¶: Get the cell.

ufl_id()¶: Return the ufl_id of this object.

ufl_mesh()[source]¶: Get the mesh.

class ufl.classes.MinCellEdgeLength(domain)[source]¶

Bases: GeometricCellQuantity

The minimum edge length of the cell.

name = 'mincelledgelength'¶

class ufl.classes.MinFacetEdgeLength(domain)[source]¶

Bases: GeometricFacetQuantity

The minimum edge length of the facet.

name = 'minfacetedgelength'¶

class ufl.classes.MinValue(left, right)[source]¶

Bases: Operator

Take the minimum of two values.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.MixedElement(sub_elements)[source]¶

Bases: FiniteElement

A mixed element.

class ufl.classes.MixedFunctionSpace(*args)[source]¶

Bases: AbstractFunctionSpace, UFLObject

Mixed function space.

dual(*args)[source]¶

Return the dual to this function space.

If no additional arguments are passed then a MixedFunctionSpace is returned whose components are the duals of the originals.

If additional arguments are passed, these must be integers. In this case, the MixedFunctionSpace which is returned will have dual components in the positions corresponding to the arguments passed, and the original components in the other positions.

num_sub_spaces()[source]¶: Return number of subspaces.

ufl_domain()[source]¶: Return ufl domain.

ufl_domains()[source]¶: Return ufl domains.

ufl_element()[source]¶: Return ufl element.

ufl_elements()[source]¶: Return ufl elements.

ufl_sub_space(i)[source]¶: Return i-th ufl sub space.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

class ufl.classes.MixedPullback(element: _AbstractFiniteElement)[source]¶

Bases: AbstractPullback

Pull back for a mixed element.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.MultiIndex(indices)[source]¶

Bases: Terminal

Represents a sequence of indices, either fixed or free.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate index.

indices()[source]¶: Return tuple of indices.

is_cellwise_constant()[source]¶

Check if cellwise constant.

Always True.

ufl_domains()[source]¶: Return tuple of domains related to this terminal object.

property ufl_free_indices¶

Get the UFL free indices.

This should not be used.

property ufl_index_dimensions¶

Get the UFL index dimensions.

This should not be used.

property ufl_shape¶

Get the UFL shape.

This should not be used.

class ufl.classes.NE(left, right)[source]¶

Bases: BinaryCondition

Not equal condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.NablaDiv(f)[source]¶

Bases: CompoundDerivative

Nabla div.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.NablaGrad(f)[source]¶

Bases: CompoundDerivative

Nabla grad.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.NegativeRestricted(f)[source]¶

Bases: Restricted

Negative restriction.

exception ufl.classes.NonStandardPullbackException[source]¶

Bases: BaseException

Exception to raise if a map is non-standard.

class ufl.classes.NotCondition(condition)[source]¶

Bases: Condition

Not condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.Operator(operands=None)[source]¶

Bases: Expr

Base class for all operators, i.e. non-terminal expression types.

ufl_operands¶

class ufl.classes.OrCondition(left, right)[source]¶

Bases: BinaryCondition

Or condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.classes.Outer(a, b)[source]¶

Bases: CompoundTensorOperator

Outer.

ufl_free_indices¶

ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.PermutationSymbol(dim)[source]¶

Bases: ConstantValue

Representation of a permutation symbol.

This is also known as the Levi-Civita symbol, antisymmetric symbol, or alternating symbol.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_shape¶

class ufl.classes.Perp(A)[source]¶

Bases: CompoundTensorOperator

Perp.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = (2,)¶

class ufl.classes.PhysicalPullback[source]¶

Bases: AbstractPullback

Physical pull back.

This should probably be removed.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.PositiveRestricted(f)[source]¶

Bases: Restricted

Positive restriction.

class ufl.classes.Power(a, b)[source]¶

Bases: Operator

Power.

evaluate(x, mapping, component, index_values)[source]¶: Evalute.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.classes.Product(a, b)[source]¶

Bases: Operator

The product of two or more UFL objects.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.classes.QuadratureWeight(domain)[source]¶

Bases: GeometricQuantity

The current quadrature weight.

Only used inside a quadrature context.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'weight'¶

class ufl.classes.Real(a)[source]¶

Bases: Operator

Real part.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.RealValue(value)[source]¶

Bases: ScalarValue

Abstract class used to differentiate real values from complex ones.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.classes.ReferenceCellEdgeVectors(domain)[source]¶

Bases: GeometricCellQuantity

The vectors between reference cell vertices for each edge in cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'RCEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ReferenceCellVolume(domain)[source]¶

Bases: GeometricCellQuantity

The volume of the reference cell.

name = 'reference_cell_volume'¶

class ufl.classes.ReferenceCurl(f)[source]¶

Bases: CompoundDerivative

Reference curl.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape¶

class ufl.classes.ReferenceDiv(f)[source]¶

Bases: CompoundDerivative

Reference divergence.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ReferenceFacetEdgeVectors(domain)[source]¶

Bases: GeometricFacetQuantity

The vectors between reference cell vertices for each edge in current facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'RFEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ReferenceFacetVolume(domain)[source]¶

Bases: GeometricFacetQuantity

The volume of the reference cell of the current facet.

name = 'reference_facet_volume'¶

class ufl.classes.ReferenceGrad(f)[source]¶

Bases: CompoundDerivative

Reference grad.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Get child from mapping and return the component asked for.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ReferenceNormal(domain)[source]¶

Bases: GeometricFacetQuantity

The outwards pointing normal vector of the current facet on the reference cell.

name = 'reference_normal'¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.ReferenceValue(f)[source]¶

Bases: Operator

Representation of the reference cell value of a form argument.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Get child from mapping and return the component asked for.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶: Get the UFL shape.

class ufl.classes.Restricted(f)[source]¶

Bases: Operator

Restriction.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

side()[source]¶: Get the side.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.ScalarValue(value)[source]¶

Bases: ConstantValue

A constant scalar value.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

imag()[source]¶: Imaginary part.

real()[source]¶: Real part.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

value()[source]¶: Get the value.

class ufl.classes.Sin(argument)[source]¶

Bases: MathFunction

Sine.

class ufl.classes.Sinh(argument)[source]¶

Bases: MathFunction

Hyperbolic sine.

class ufl.classes.Skew(A)[source]¶

Bases: CompoundTensorOperator

Skew.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.SobolevSpace(name, parents=None)[source]¶

Bases: object

Symbolic representation of a Sobolev space.

This implements a subset of the methods of a Python set so that finite elements and other Sobolev spaces can be tested for inclusion.

class ufl.classes.SpatialCoordinate(domain)[source]¶

Bases: GeometricCellQuantity

The coordinate in a domain.

In the context of expression integration, represents the domain coordinate of each quadrature point.

In the context of expression evaluation in a point, represents the value of that point.

count()[source]¶: Count.

evaluate(x, mapping, component, index_values)[source]¶: Return the value of the coordinate.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'x'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.Sqrt(argument)[source]¶

Bases: MathFunction

Square root.

class ufl.classes.Sum(a, b)[source]¶

Bases: Operator

Sum.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.Sym(A)[source]¶

Bases: CompoundTensorOperator

Sym.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.classes.SymmetricElement(symmetry: Dict[Tuple[int, ...], int], sub_elements: List[AbstractFiniteElement])[source]¶

Bases: FiniteElement

A symmetric finite element.

class ufl.classes.SymmetricPullback(element: _AbstractFiniteElement, symmetry: Dict[tuple[int, ...], int])[source]¶

Bases: AbstractPullback

Pull back for an element with symmetry.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.Tan(argument)[source]¶

Bases: MathFunction

Tangent.

class ufl.classes.Tanh(argument)[source]¶

Bases: MathFunction

Hyperbolic tangent.

class ufl.classes.TensorProductCell(*cells: Cell)[source]¶

Bases: AbstractCell

Tensor product cell.

cellname() → str[source]¶: Return the cellname of the cell.

has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

sub_cells() → List[AbstractCell][source]¶: Return list of cell factors.

sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

class ufl.classes.TensorProductFunctionSpace(*function_spaces)[source]¶

Bases: AbstractFunctionSpace, UFLObject

Tensor product function space.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

class ufl.classes.Terminal[source]¶

Bases: Expr

Base class for terminal objects.

A terminal node in the UFL expression tree.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Get self from mapping and return the component asked for.

ufl_domains()[source]¶: Return tuple of domains related to this terminal object.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_operands = ()¶

ufl.classes.TestFunction(function_space, part=None)[source]¶: UFL value: Create a test function argument to a form.

ufl.classes.TestFunctions(function_space)[source]¶

Create a TestFunction in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

class ufl.classes.Trace(A)[source]¶

Bases: CompoundTensorOperator

Trace.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.classes.Transposed(A)[source]¶

Bases: CompoundTensorOperator

Transposed tensor.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

ufl.classes.TrialFunction(function_space, part=None)[source]¶: UFL value: Create a trial function argument to a form.

ufl.classes.TrialFunctions(function_space)[source]¶

Create a TrialFunction in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

class ufl.classes.UndefinedPullback[source]¶

Bases: AbstractPullback

Undefined pull back.

This should probably be removed.

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.classes.Variable(expression, label=None)[source]¶

Bases: Operator

A Variable is a representative for another expression.

It will be used by the end-user mainly for defining a quantity to differentiate w.r.t. using diff. Example:

e = <...>
e = variable(e)
f = exp(e**2)
df = diff(f, e)

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

expression()[source]¶: Get expression.

label()[source]¶: Get label.

ufl_domains()[source]¶: Get the UFL domains.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶

class ufl.classes.VariableDerivative(f, v)[source]¶

Bases: Derivative

Variable Derivative.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape¶

class ufl.classes.Zero(shape=(), free_indices=(), index_dimensions=None)[source]¶

Bases: ConstantValue

Representation of a zero valued expression.

Class for representing zero tensors of different shapes.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape¶

class ufl.classes.ZeroBaseForm(arguments)[source]¶

Bases: BaseForm

Description of a zero base form.

ZeroBaseForm is idempotent with respect to assembly and is mostly used for sake of simplifying base-form expressions.

form¶

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_operands¶

ufl.coefficient module¶

This module defines the Coefficient class and a number of related classes, including Constant.

class ufl.coefficient.BaseCoefficient(function_space, count=None)[source]¶

Bases: Counted

UFL form argument type: Parent Representation of a form coefficient.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

ufl_domain()[source]¶: Shortcut to get the domain of the function space of this coefficient.

ufl_domains()[source]¶: Return tuple of domains related to this terminal object.

ufl_element()[source]¶: Shortcut to get the finite element of the function space of this coefficient.

ufl_function_space()[source]¶: Get the function space of this coefficient.

property ufl_shape¶: Return the associated UFL shape.

class ufl.coefficient.Coefficient(*args, **kw)[source]¶

Bases: FormArgument, BaseCoefficient

UFL form argument type: Representation of a form coefficient.

ufl_domains()[source]¶: Get the UFL domains.

ufl.coefficient.Coefficients(function_space)[source]¶

Create a Coefficient in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

class ufl.coefficient.Cofunction(*args, **kw)[source]¶

Bases: BaseCoefficient, BaseForm

UFL form argument type: Representation of a form coefficient from a dual space.

equals(other)[source]¶: Check equality.

ufl_operands¶

ufl.compound_expressions module¶

Support for compound expressions as equivalent representations using basic operators.

ufl.compound_expressions.adj_expr(A)[source]¶: Adjoint of a matrix.

ufl.compound_expressions.adj_expr_2x2(A)[source]¶: Adjoint of a 2 by 2 matrix.

ufl.compound_expressions.adj_expr_3x3(A)[source]¶: Adjoint of a 3 by 3 matrix.

ufl.compound_expressions.adj_expr_4x4(A)[source]¶: Adjoint of a 4 by 4 matrix.

ufl.compound_expressions.codeterminant_expr_nxn(A, rows, cols)[source]¶: Determinant of a n by n matrix.

ufl.compound_expressions.cofactor_expr(A)[source]¶: Cofactor of a matrix.

ufl.compound_expressions.cofactor_expr_2x2(A)[source]¶: Cofactor of a 2 by 2 matrix.

ufl.compound_expressions.cofactor_expr_3x3(A)[source]¶: Cofactor of a 3 by 3 matrix.

ufl.compound_expressions.cofactor_expr_4x4(A)[source]¶: Cofactor of a 4 by 4 matrix.

ufl.compound_expressions.cross_expr(a, b)[source]¶: Symbolic cross product.

ufl.compound_expressions.determinant_expr(A)[source]¶: Compute the (pseudo-)determinant of A.

ufl.compound_expressions.determinant_expr_2x2(B)[source]¶: Determinant of a 2 by 2 matrix.

ufl.compound_expressions.determinant_expr_3x3(A)[source]¶: Determinant of a 3 by 3 matrix.

ufl.compound_expressions.determinant_expr_nxn(A)[source]¶: Determinant of a n by n matrix.

ufl.compound_expressions.deviatoric_expr(A)[source]¶: Deviatoric of a matrix.

ufl.compound_expressions.deviatoric_expr_2x2(A)[source]¶: Deviatoric of a 2 by 2 matrix.

ufl.compound_expressions.deviatoric_expr_3x3(A)[source]¶: Deviatoric of a 3 by 3 matrix.

ufl.compound_expressions.generic_pseudo_determinant_expr(A)[source]¶: Compute the pseudo-determinant of A: sqrt(det(A.T*A)).

ufl.compound_expressions.generic_pseudo_inverse_expr(A)[source]¶: Compute the Penrose-Moore pseudo-inverse of A: (A.T*A)^-1 * A.T.

ufl.compound_expressions.inverse_expr(A)[source]¶: Compute the inverse of A.

ufl.compound_expressions.pseudo_determinant_expr(A)[source]¶: Compute the pseudo-determinant of A.

ufl.compound_expressions.pseudo_inverse_expr(A)[source]¶: Compute the Penrose-Moore pseudo-inverse of A: (A.T*A)^-1 * A.T.

ufl.conditional module¶

This module defines classes for conditional expressions.

class ufl.conditional.AndCondition(left, right)[source]¶

Bases: BinaryCondition

And condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.BinaryCondition(name, left, right)[source]¶

Bases: Condition

Binary condition.

class ufl.conditional.Condition(operands)[source]¶

Bases: Operator

Condition.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.conditional.Conditional(condition, true_value, false_value)[source]¶

Bases: Operator

Conditional expression.

In C++ these take the format (condition ? true_value : false_value).

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.conditional.EQ(left, right)[source]¶

Bases: BinaryCondition

Equality condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.GE(left, right)[source]¶

Bases: BinaryCondition

Greater than or equal to condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.GT(left, right)[source]¶

Bases: BinaryCondition

Greater than condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.LE(left, right)[source]¶

Bases: BinaryCondition

Less than or equal condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.LT(left, right)[source]¶

Bases: BinaryCondition

Less than condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.MaxValue(left, right)[source]¶

Bases: Operator

Take the maximum of two values.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.conditional.MinValue(left, right)[source]¶

Bases: Operator

Take the minimum of two values.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.conditional.NE(left, right)[source]¶

Bases: BinaryCondition

Not equal condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.NotCondition(condition)[source]¶

Bases: Condition

Not condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.conditional.OrCondition(left, right)[source]¶

Bases: BinaryCondition

Or condition.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl.constant module¶

Support fpr non-literal values which are constant with respect to a domain.

class ufl.constant.Constant(domain, shape=(), count=None)[source]¶

Bases: Terminal, Counted

Constant.

is_cellwise_constant()[source]¶: Return True if the function is cellwise constant.

ufl_domain()[source]¶: Get the UFL domain.

ufl_domains()[source]¶: Get the UFL domains.

property ufl_shape¶: Get the UFL shape.

ufl.constant.TensorConstant(domain, count=None)[source]¶: Tensor constant.

ufl.constant.VectorConstant(domain, count=None)[source]¶: Vector constant.

ufl.constantvalue module¶

This module defines classes representing constant values.

class ufl.constantvalue.ComplexValue(value)[source]¶

Bases: ScalarValue

Representation of a constant, complex scalar.

argument()[source]¶: Get the argument.

modulus()[source]¶: Get the modulus.

class ufl.constantvalue.ConstantValue[source]¶

Bases: Terminal

Constant value.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

ufl_domains()[source]¶: Return tuple of domains related to this terminal object.

class ufl.constantvalue.FloatValue(value)[source]¶

Bases: RealValue

Representation of a constant scalar floating point value.

class ufl.constantvalue.Identity(dim)[source]¶

Bases: ConstantValue

Representation of an identity matrix.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_shape¶

class ufl.constantvalue.IntValue(value)[source]¶

Bases: RealValue

Representation of a constant scalar integer value.

class ufl.constantvalue.PermutationSymbol(dim)[source]¶

Bases: ConstantValue

Representation of a permutation symbol.

This is also known as the Levi-Civita symbol, antisymmetric symbol, or alternating symbol.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_shape¶

class ufl.constantvalue.RealValue(value)[source]¶

Bases: ScalarValue

Abstract class used to differentiate real values from complex ones.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.constantvalue.ScalarValue(value)[source]¶

Bases: ConstantValue

A constant scalar value.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

imag()[source]¶: Imaginary part.

real()[source]¶: Real part.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

value()[source]¶: Get the value.

class ufl.constantvalue.Zero(shape=(), free_indices=(), index_dimensions=None)[source]¶

Bases: ConstantValue

Representation of a zero valued expression.

Class for representing zero tensors of different shapes.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape¶

ufl.constantvalue.as_ufl(expression)[source]¶: Converts expression to an Expr if possible.

ufl.constantvalue.format_float(x)[source]¶: Format float value based on global UFL precision.

ufl.constantvalue.zero(*shape)[source]¶: UFL literal constant: Return a zero tensor with the given shape.

ufl.differentiation module¶

Differential operators.

class ufl.differentiation.BaseFormCoordinateDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: BaseFormDerivative, CoordinateDerivative

Derivative of a base form w.r.t. the SpatialCoordinates.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.differentiation.BaseFormDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: CoefficientDerivative, BaseForm

Derivative of a base form w.r.t the degrees of freedom in a discrete Coefficient.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.differentiation.BaseFormOperatorCoordinateDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: BaseFormOperatorDerivative, CoordinateDerivative

Derivative of a base form operator w.r.t. the SpatialCoordinates.

property ufl_free_indices¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_index_dimensions¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_shape¶: Return the UFL shape of the coefficient.produced by the operator.

class ufl.differentiation.BaseFormOperatorDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: BaseFormDerivative, BaseFormOperator

Derivative of a base form operator w.r.t the degrees of freedom in a discrete Coefficient.

argument_slots(outer_form=False)[source]¶: Return a tuple of expressions containing argument and coefficient based expressions.

property ufl_free_indices¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_index_dimensions¶

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

property ufl_shape¶: Return the UFL shape of the coefficient.produced by the operator.

class ufl.differentiation.CoefficientDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: Derivative

Derivative of form integrand w.r.t. the degrees of freedom in a discrete Coefficient.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.differentiation.CompoundDerivative(operands)[source]¶

Bases: Derivative

Base class for all compound derivative types.

class ufl.differentiation.CoordinateDerivative(integrand, coefficients, arguments, coefficient_derivatives)[source]¶

Bases: CoefficientDerivative

Derivative of the integrand of a form w.r.t. the SpatialCoordinates.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.differentiation.Curl(f)[source]¶

Bases: CompoundDerivative

Compound derivative.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape¶

class ufl.differentiation.Derivative(operands)[source]¶

Bases: Operator

Base class for all derivative types.

class ufl.differentiation.Div(f)[source]¶

Bases: CompoundDerivative

Div.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.differentiation.Grad(f)[source]¶

Bases: CompoundDerivative

Grad.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Get child from mapping and return the component asked for.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.differentiation.NablaDiv(f)[source]¶

Bases: CompoundDerivative

Nabla div.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.differentiation.NablaGrad(f)[source]¶

Bases: CompoundDerivative

Nabla grad.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.differentiation.ReferenceCurl(f)[source]¶

Bases: CompoundDerivative

Reference curl.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape¶

class ufl.differentiation.ReferenceDiv(f)[source]¶

Bases: CompoundDerivative

Reference divergence.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.differentiation.ReferenceGrad(f)[source]¶

Bases: CompoundDerivative

Reference grad.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Get child from mapping and return the component asked for.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.differentiation.VariableDerivative(f, v)[source]¶

Bases: Derivative

Variable Derivative.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape¶

ufl.domain module¶

Types for representing a geometric domain.

class ufl.domain.AbstractDomain(topological_dimension, geometric_dimension)[source]¶

Bases: object

Symbolic representation of a geometric domain.

Domain has only a geometric and a topological dimension.

geometric_dimension()[source]¶: Return the dimension of the space this domain is embedded in.

topological_dimension()[source]¶: Return the dimension of the topology of this domain.

class ufl.domain.Mesh(coordinate_element, ufl_id=None, cargo=None)[source]¶

Bases: AbstractDomain, UFLObject

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()[source]¶: Check if the domain is a piecewise linear simplex.

ufl_cargo()[source]¶: Return carried object that will not be used by UFL.

ufl_cell()[source]¶: Get the cell.

ufl_coordinate_element()[source]¶: Get the coordinate element.

ufl_id()¶: Return the ufl_id of this object.

class ufl.domain.MeshView(mesh, topological_dimension, ufl_id=None)[source]¶

Bases: AbstractDomain, UFLObject

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()[source]¶: Check if the domain is a piecewise linear simplex.

ufl_cell()[source]¶: Get the cell.

ufl_id()¶: Return the ufl_id of this object.

ufl_mesh()[source]¶: Get the mesh.

ufl.domain.as_domain(domain)[source]¶: Convert any valid object to an AbstractDomain type.

ufl.domain.extract_domains(expr)[source]¶: Return all domains expression is defined on.

ufl.domain.extract_unique_domain(expr)[source]¶: Return the single unique domain expression is defined on or throw an error.

ufl.domain.find_geometric_dimension(expr)[source]¶: Find the geometric dimension of an expression.

ufl.domain.join_domains(domains)[source]¶

Take a list of domains and return a tuple with only unique domain objects.

Checks that domains with the same id are compatible.

ufl.domain.sort_domains(domains)[source]¶: Sort domains in a canonical ordering.

ufl.duals module¶

Predicates for recognising duals.

ufl.duals.is_dual(object)[source]¶

Determine if the object belongs to a dual space.

This is not simply the negation of is_primal, because a mixed function space containing both primal and dual components is neither primal nor dual.

ufl.duals.is_primal(object)[source]¶

Determine if the object belongs to a primal space.

This is not simply the negation of is_dual, because a mixed function space containing both primal and dual components is neither primal nor dual.

ufl.equation module¶

The Equation class, used to express equations like a == L.

class ufl.equation.Equation(lhs, rhs)[source]¶

Bases: object

Equation.

This class is used to represent equations expressed by the “==” operator. Examples include a == L and F == 0 where a, L and F are Form objects.

ufl.exprcontainers module¶

This module defines special types for representing mapping of expressions to expressions.

class ufl.exprcontainers.ExprList(*operands)[source]¶

Bases: Operator

List of Expr objects. For internal use, never to be created by end users.

free_indices()[source]¶: Get the free indices.

index_dimensions()[source]¶: Get the index dimensions.

property ufl_free_indices¶: Get the UFL free indices.

property ufl_index_dimensions¶: Get the UFL index dimensions.

property ufl_shape¶: Get the UFL shape.

class ufl.exprcontainers.ExprMapping(*operands)[source]¶

Bases: Operator

Mapping of Expr objects. For internal use, never to be created by end users.

free_indices()[source]¶: Get the free indices.

index_dimensions()[source]¶: Get the index dimensions.

ufl_domains()[source]¶: Get the UFL domains.

property ufl_free_indices¶: Get the UFL free indices.

property ufl_index_dimensions¶: Get the UFL index dimensions.

property ufl_shape¶: Get the UFL shape.

ufl.exprequals module¶

Expr equals.

ufl.exprequals.expr_equals(self, other)[source]¶

Checks whether the two expressions are represented the exact same way.

This does not check if the expressions are mathematically equal or equivalent! Used by sets and dicts.

ufl.exproperators module¶

Expr operators.

This module attaches special functions to Expr. This way we avoid circular dependencies between e.g. Sum and its superclass Expr.

ufl.finiteelement module¶

This module defines the UFL finite element classes.

class ufl.finiteelement.AbstractFiniteElement[source]¶

Bases: ABC

Base class for all finite elements.

To make your element library compatible with UFL, you should make a subclass of AbstractFiniteElement and provide implementions of all the abstract methods and properties. All methods and properties that are not marked as abstract are implemented here and should not need to be overwritten in your subclass.

An example of how the methods in your subclass could be implemented can be found in Basix; see https://github.com/FEniCS/basix/blob/main/python/basix/ufl.py

abstract property cell: Cell¶: Return the cell of the finite element.

abstract property embedded_subdegree: int¶

Degree of the maximum degree Lagrange space that is spanned by this element.

This returns the degree of the highest degree Lagrange space such that the polynomial space of the Lagrange space is a subspace of this element’s polynomial space. If this element’s polynomial space does not include the constant function, this function should return -1.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

abstract property embedded_superdegree: int | None¶

Degree of the minimum degree Lagrange space that spans this element.

This returns the degree of the lowest degree Lagrange space such that the polynomial space of the Lagrange space is a superspace of this element’s polynomial space. If this element contains basis functions that are not in any Lagrange space, this function should return None.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

is_cellwise_constant() → bool[source]¶: Check whether this element is spatially constant over each cell.

property num_sub_elements: int¶

Return number of sub-elements.

This function does not recurse: ie it does not count the sub-elements of sub-elements.

abstract property pullback: AbstractPullback¶: Return the pullback for this element.

abstract property reference_value_shape: Tuple[int, ...]¶: Return the shape of the value space on the reference cell.

property reference_value_size: int¶: Return the integer product of the reference value shape.

abstract property sobolev_space: SobolevSpace¶: Return the underlying Sobolev space.

abstract property sub_elements: List¶

Return list of sub-elements.

This function does not recurse: ie it does not extract the sub-elements of sub-elements.

class ufl.finiteelement.FiniteElement(family: str, cell: Cell, degree: int, reference_value_shape: Tuple[int, ...], pullback: AbstractPullback, sobolev_space: SobolevSpace, sub_elements=[], _repr: str | None = None, _str: str | None = None, subdegree: int | None = None)[source]¶

Bases: AbstractFiniteElement

A directly defined finite element.

property cell: Cell¶: Return the cell of the finite element.

property embedded_subdegree: int¶

Degree of the maximum degree Lagrange space that is spanned by this element.

This returns the degree of the highest degree Lagrange space such that the polynomial space of the Lagrange space is a subspace of this element’s polynomial space. If this element’s polynomial space does not include the constant function, this function should return -1.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

property embedded_superdegree: int | None¶

Degree of the minimum degree Lagrange space that spans this element.

This returns the degree of the lowest degree Lagrange space such that the polynomial space of the Lagrange space is a superspace of this element’s polynomial space. If this element contains basis functions that are not in any Lagrange space, this function should return None.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

property pullback: AbstractPullback¶: Return the pullback for this element.

property reference_value_shape: Tuple[int, ...]¶: Return the shape of the value space on the reference cell.

property sobolev_space: SobolevSpace¶: Return the underlying Sobolev space.

property sub_elements: List¶

Return list of sub-elements.

This function does not recurse: ie it does not extract the sub-elements of sub-elements.

class ufl.finiteelement.MixedElement(sub_elements)[source]¶

Bases: FiniteElement

A mixed element.

class ufl.finiteelement.SymmetricElement(symmetry: Dict[Tuple[int, ...], int], sub_elements: List[AbstractFiniteElement])[source]¶

Bases: FiniteElement

A symmetric finite element.

ufl.form module¶

The Form class.

class ufl.form.BaseForm[source]¶

Bases: object

Description of an object containing arguments.

arguments()[source]¶: Return all Argument objects found in form.

coefficients()[source]¶: Return all Coefficient objects found in form.

ufl_domain()[source]¶

Return the single geometric integration domain occuring in the base form.

Fails if multiple domains are found.

class ufl.form.Form(integrals)[source]¶

Bases: BaseForm

Description of a weak form consisting of a sum of integrals over subdomains.

base_form_operators()[source]¶: Return all BaseFormOperator objects found in form.

coefficient_numbering()[source]¶: Return a contiguous numbering of coefficients in a mapping {coefficient:number}.

coefficients()[source]¶: Return all Coefficient objects found in form.

constant_numbering()[source]¶: Return a contiguous numbering of constants in a mapping {constant:number}.

constants()[source]¶: Get constants.

domain_numbering()[source]¶: Return a contiguous numbering of domains in a mapping {domain:number}.

empty()[source]¶: Returns whether the form has no integrals.

equals(other)[source]¶: Evaluate bool(lhs_form == rhs_form).

geometric_dimension()[source]¶: Return the geometric dimension shared by all domains and functions in this form.

integrals()[source]¶: Return a sequence of all integrals in form.

integrals_by_domain(domain)[source]¶: Return a sequence of all integrals with a particular integration domain.

integrals_by_type(integral_type)[source]¶: Return a sequence of all integrals with a particular domain type.

signature()[source]¶: Signature for use with jit cache (independent of incidental numbering of indices etc).

subdomain_data()[source]¶: Returns a mapping on the form {domain:{integral_type: subdomain_data}}.

terminal_numbering()[source]¶

Return a contiguous numbering for all counted objects in the form.

The returned object is mapping from terminal to its number (an integer).

The numbering is computed per type so :class:`Coefficient`s, :class:`Constant`s, etc will each be numbered from zero.

ufl_cell()[source]¶

Return the single cell this form is defined on.

Fails if multiple cells are found.

ufl_domains()[source]¶

Return the geometric integration domains occuring in the form.

NB! This does not include domains of coefficients defined on other meshes.

The return type is a tuple even if only a single domain exists.

class ufl.form.FormSum(*args, **kwargs)[source]¶

Bases: BaseForm

Form sum.

Description of a weighted sum of variational forms and form-like objects components is the list of Forms to be summed arg_weights is a list of tuples of component index and weight

components()[source]¶: Get components.

equals(other)[source]¶: Evaluate bool(lhs_form == rhs_form).

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_operands¶

weights()[source]¶: Get weights.

class ufl.form.ZeroBaseForm(arguments)[source]¶

Bases: BaseForm

Description of a zero base form.

ZeroBaseForm is idempotent with respect to assembly and is mostly used for sake of simplifying base-form expressions.

form¶

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_operands¶

ufl.form.as_form(form)[source]¶: Convert to form if not a form, otherwise return form.

ufl.formoperators module¶

Various high level ways to transform a complete Form into a new Form.

ufl.formoperators.action(form, coefficient=None, derivatives_expanded=None)[source]¶

Get the action.

Given a bilinear form, return a linear form with an additional coefficient, representing the action of the form on the coefficient. This can be used for matrix-free methods. For formbase objects,coefficient can be any object of the correct type, and this function returns an Action object.

When action is being called multiple times on the same form, expanding derivatives become expensive -> derivatives_expanded enables to use caching mechanisms to avoid that.

ufl.formoperators.adjoint(form, reordered_arguments=None, derivatives_expanded=None)[source]¶

Get the adjoint.

Given a combined bilinear form, compute the adjoint form by changing the ordering (count) of the test and trial functions, and taking the complex conjugate of the result.

By default, new Argument objects will be created with opposite ordering. However, if the adjoint form is to be added to other forms later, their arguments must match. In that case, the user must provide a tuple *reordered_arguments*=(u2,v2).

If the form is a baseform instance instead of a Form object, we return an Adjoint object instructing the adjoint to be computed at a later point.

When adjoint is being called multiple times on the same form, expanding derivatives become expensive -> derivatives_expanded enables to use caching mechanisms to avoid that.

ufl.formoperators.derivative(form, coefficient, argument=None, coefficient_derivatives=None)[source]¶

Compute the Gateaux derivative of form w.r.t. coefficient in direction of argument.

If the argument is omitted, a new Argument is created in the same space as the coefficient, with argument number one higher than the highest one in the form.

The resulting form has one additional Argument in the same finite element space as the coefficient.

A tuple of Coefficient s may be provided in place of a single Coefficient, in which case the new Argument argument is based on a MixedElement created from this tuple.

An indexed Coefficient from a mixed space may be provided, in which case the argument should be in the corresponding subspace of the coefficient space.

If provided, coefficient_derivatives should be a mapping from Coefficient instances to their derivatives w.r.t. coefficient.

ufl.formoperators.energy_norm(form, coefficient=None)[source]¶

Get the energy norm.

Given a bilinear form a and a coefficient f, return the functional \(a(f,f)\).

ufl.formoperators.extract_blocks(form, i=None, j=None)[source]¶

Extract blocks.

Given a linear or bilinear form on a mixed space, extract the block corresponding to the indices ix, iy.

Example:: a = inner(grad(u), grad(v))*dx + div(u)*q*dx + div(v)*p*dx extract_blocks(a, 0, 0) -> inner(grad(u), grad(v))*dx extract_blocks(a) -> [inner(grad(u), grad(v))*dx, div(v)*p*dx, div(u)*q*dx, 0]

ufl.formoperators.functional(form)[source]¶: Extract the functional part of form.

ufl.formoperators.lhs(form)[source]¶

Get the left hand side.

Given a combined bilinear and linear form, extract the left hand side (bilinear form part).

Example:: a = u*v*dx + f*v*dx a = lhs(a) -> u*v*dx

ufl.formoperators.rhs(form)[source]¶

Get the right hand side.

Given a combined bilinear and linear form, extract the right hand side (negated linear form part).

Example:: a = u*v*dx + f*v*dx L = rhs(a) -> -f*v*dx

ufl.formoperators.sensitivity_rhs(a, u, L, v)[source]¶

Compute the right hand side for a sensitivity calculation system.

The derivation behind this computation is as follows. Assume a, L to be bilinear and linear forms corresponding to the assembled linear system

\[Ax = b.\]

Where x is the vector of the discrete function corresponding to u. Let v be some scalar variable this equation depends on. Then we can write

\[ \begin{align}\begin{aligned}\begin{split}0 = \\frac{d}{dv}(Ax-b) = \\frac{dA}{dv} x + A \\frac{dx}{dv} - \\frac{db}{dv},\end{split}\\\begin{split}A \\frac{dx}{dv} = \\frac{db}{dv} - \\frac{dA}{dv} x,\end{split}\end{aligned}\end{align} \]

and solve this system for \(\\frac{dx}{dv}\), using the same bilinear form a and matrix A from the original system. Assume the forms are written

v = variable(v_expression)
L = IL(v) * dx
a = Ia(v) * dx

where IL and Ia are integrand expressions. Define a Coefficient u representing the solution to the equations. Then we can compute \(\\frac{db}{dv}\) and \(\\frac{dA}{dv}\) from the forms

da = diff(a, v)
dL = diff(L, v)

and the action of da on u by

dau = action(da, u)

In total, we can build the right hand side of the system to compute \(\\frac{du}{dv}\) with the single line

dL = diff(L, v) - action(diff(a, v), u)

or, using this function,

dL = sensitivity_rhs(a, u, L, v)

ufl.formoperators.set_list_item(li, i, v)[source]¶: Set an item in a nested list.

ufl.formoperators.system(form)[source]¶

Split a form into the left hand side and right hand side.

See lhs and rhs.

ufl.formoperators.zero_lists(shape)[source]¶: Createa list of zeros of the given shape.

ufl.functionspace module¶

Types for representing function spaces.

class ufl.functionspace.AbstractFunctionSpace[source]¶

Bases: object

Abstract function space.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

class ufl.functionspace.BaseFunctionSpace(domain, element, label='')[source]¶

Bases: AbstractFunctionSpace, UFLObject

Base function space.

property components: Dict[Tuple[int, ...], int]¶

Get the numbering of the components of the element of this space.

Returns:: A map from the components of the values on a physical cell (eg (0, 1)) to flat component numbers on the reference cell (eg 1)

label()[source]¶: Return label of boundary domains to differentiate restricted and unrestricted.

ufl_domain()[source]¶: Return ufl domain.

ufl_domains()[source]¶: Return ufl domains.

ufl_element()[source]¶: Return ufl element.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

property value_shape: Tuple[int, ...]¶: Return the shape of the value space on a physical domain.

property value_size: int¶: Return the integer product of the value shape on a physical domain.

class ufl.functionspace.DualSpace(domain, element, label='')[source]¶

Bases: BaseFunctionSpace, UFLObject

Representation of a Dual space.

dual()[source]¶: Get the dual of the space.

class ufl.functionspace.FunctionSpace(domain, element, label='')[source]¶

Bases: BaseFunctionSpace, UFLObject

Representation of a Function space.

dual()[source]¶: Get the dual of the space.

class ufl.functionspace.MixedFunctionSpace(*args)[source]¶

Bases: AbstractFunctionSpace, UFLObject

Mixed function space.

dual(*args)[source]¶

Return the dual to this function space.

If no additional arguments are passed then a MixedFunctionSpace is returned whose components are the duals of the originals.

If additional arguments are passed, these must be integers. In this case, the MixedFunctionSpace which is returned will have dual components in the positions corresponding to the arguments passed, and the original components in the other positions.

num_sub_spaces()[source]¶: Return number of subspaces.

ufl_domain()[source]¶: Return ufl domain.

ufl_domains()[source]¶: Return ufl domains.

ufl_element()[source]¶: Return ufl element.

ufl_elements()[source]¶: Return ufl elements.

ufl_sub_space(i)[source]¶: Return i-th ufl sub space.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

class ufl.functionspace.TensorProductFunctionSpace(*function_spaces)[source]¶

Bases: AbstractFunctionSpace, UFLObject

Tensor product function space.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

ufl.geometry module¶

Types for representing symbolic expressions for geometric quantities.

class ufl.geometry.CellCoordinate(domain)[source]¶

Bases: GeometricCellQuantity

The coordinate in a reference cell.

In the context of expression integration, represents the reference cell coordinate of each quadrature point.

In the context of expression evaluation in a point in a cell, represents that point in the reference coordinate system of the cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'X'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.CellDiameter(domain)[source]¶

Bases: GeometricCellQuantity

The diameter of the cell, i.e., maximal distance of two points in the cell.

name = 'diameter'¶

class ufl.geometry.CellEdgeVectors(domain)[source]¶

Bases: GeometricCellQuantity

The vectors between physical cell vertices for each edge in cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.CellFacetJacobian(domain)[source]¶

Bases: GeometricFacetQuantity

The Jacobian of the mapping from reference facet to reference cell coordinates.

CFJ_ij = dX_i/dXf_j

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CFJ'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.CellFacetJacobianDeterminant(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-determinant of the CellFacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'detCFJ'¶

class ufl.geometry.CellFacetJacobianInverse(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-inverse of the CellFacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CFK'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.CellFacetOrigin(domain)[source]¶

Bases: GeometricFacetQuantity

The reference cell coordinate corresponding to origin of a reference facet.

name = 'X0f'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.CellNormal(domain)[source]¶

Bases: GeometricCellQuantity

The upwards pointing normal vector of the current manifold cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'cell_normal'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.CellOrientation(domain)[source]¶

Bases: GeometricCellQuantity

The orientation (+1/-1) of the current cell.

For non-manifold cells (tdim == gdim), this equals the sign of the Jacobian determinant, i.e. +1 if the physical cell is oriented the same way as the reference cell and -1 otherwise.

For manifold cells of tdim==gdim-1 this is input data belonging to the mesh, used to distinguish between the sides of the manifold.

name = 'cell_orientation'¶

class ufl.geometry.CellOrigin(domain)[source]¶

Bases: GeometricCellQuantity

The spatial coordinate corresponding to origin of a reference cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'x0'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.CellVertices(domain)[source]¶

Bases: GeometricCellQuantity

Physical cell vertices.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'CV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.CellVolume(domain)[source]¶

Bases: GeometricCellQuantity

The volume of the cell.

name = 'volume'¶

class ufl.geometry.Circumradius(domain)[source]¶

Bases: GeometricCellQuantity

The circumradius of the cell.

name = 'circumradius'¶

class ufl.geometry.FacetArea(domain)[source]¶

Bases: GeometricFacetQuantity

The area of the facet.

name = 'facetarea'¶

class ufl.geometry.FacetCoordinate(domain)[source]¶

Bases: GeometricFacetQuantity

The coordinate in a reference cell of a facet.

In the context of expression integration over a facet, represents the reference facet coordinate of each quadrature point.

In the context of expression evaluation in a point on a facet, represents that point in the reference coordinate system of the facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'Xf'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.FacetEdgeVectors(domain)[source]¶

Bases: GeometricFacetQuantity

The vectors between physical cell vertices for each edge in current facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'FEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.FacetJacobian(domain)[source]¶

Bases: GeometricFacetQuantity

The Jacobian of the mapping from reference facet to spatial coordinates.

FJ_ij = dx_i/dXf_j

The FacetJacobian is the product of the Jacobian and CellFacetJacobian:

FJ = dx/dXf = dx/dX dX/dXf = J * CFJ

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'FJ'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.FacetJacobianDeterminant(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-determinant of the FacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'detFJ'¶

class ufl.geometry.FacetJacobianInverse(domain)[source]¶

Bases: GeometricFacetQuantity

The pseudo-inverse of the FacetJacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'FK'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.FacetNormal(domain)[source]¶

Bases: GeometricFacetQuantity

The outwards pointing normal vector of the current facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'n'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.FacetOrientation(domain)[source]¶

Bases: GeometricFacetQuantity

The orientation (+1/-1) of the current facet relative to the reference cell.

name = 'facet_orientation'¶

class ufl.geometry.FacetOrigin(domain)[source]¶

Bases: GeometricFacetQuantity

The spatial coordinate corresponding to origin of a reference facet.

name = 'x0f'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.GeometricCellQuantity(domain)[source]¶

Bases: GeometricQuantity

Geometric cell quantity.

class ufl.geometry.GeometricFacetQuantity(domain)[source]¶

Bases: GeometricQuantity

Geometric facet quantity.

class ufl.geometry.GeometricQuantity(domain)[source]¶

Bases: Terminal

Geometric quantity.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

ufl_domains()[source]¶: Get the UFL domains.

ufl_shape = ()¶

class ufl.geometry.Jacobian(domain)[source]¶

Bases: GeometricCellQuantity

The Jacobian of the mapping from reference cell to spatial coordinates.

\[\begin{split}J_{ij} = \\frac{dx_i}{dX_j}\end{split}\]

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'J'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.JacobianDeterminant(domain)[source]¶

Bases: GeometricCellQuantity

The determinant of the Jacobian.

Represents the signed determinant of a square Jacobian or the pseudo-determinant of a non-square Jacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'detJ'¶

class ufl.geometry.JacobianInverse(domain)[source]¶

Bases: GeometricCellQuantity

The inverse of the Jacobian.

Represents the inverse of a square Jacobian or the pseudo-inverse of a non-square Jacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'K'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.MaxCellEdgeLength(domain)[source]¶

Bases: GeometricCellQuantity

The maximum edge length of the cell.

name = 'maxcelledgelength'¶

class ufl.geometry.MaxFacetEdgeLength(domain)[source]¶

Bases: GeometricFacetQuantity

The maximum edge length of the facet.

name = 'maxfacetedgelength'¶

class ufl.geometry.MinCellEdgeLength(domain)[source]¶

Bases: GeometricCellQuantity

The minimum edge length of the cell.

name = 'mincelledgelength'¶

class ufl.geometry.MinFacetEdgeLength(domain)[source]¶

Bases: GeometricFacetQuantity

The minimum edge length of the facet.

name = 'minfacetedgelength'¶

class ufl.geometry.QuadratureWeight(domain)[source]¶

Bases: GeometricQuantity

The current quadrature weight.

Only used inside a quadrature context.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'weight'¶

class ufl.geometry.ReferenceCellEdgeVectors(domain)[source]¶

Bases: GeometricCellQuantity

The vectors between reference cell vertices for each edge in cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'RCEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.ReferenceCellVolume(domain)[source]¶

Bases: GeometricCellQuantity

The volume of the reference cell.

name = 'reference_cell_volume'¶

class ufl.geometry.ReferenceFacetEdgeVectors(domain)[source]¶

Bases: GeometricFacetQuantity

The vectors between reference cell vertices for each edge in current facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'RFEV'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.ReferenceFacetVolume(domain)[source]¶

Bases: GeometricFacetQuantity

The volume of the reference cell of the current facet.

name = 'reference_facet_volume'¶

class ufl.geometry.ReferenceNormal(domain)[source]¶

Bases: GeometricFacetQuantity

The outwards pointing normal vector of the current facet on the reference cell.

name = 'reference_normal'¶

property ufl_shape¶: Get the UFL shape.

class ufl.geometry.SpatialCoordinate(domain)[source]¶

Bases: GeometricCellQuantity

The coordinate in a domain.

In the context of expression integration, represents the domain coordinate of each quadrature point.

In the context of expression evaluation in a point, represents the value of that point.

count()[source]¶: Count.

evaluate(x, mapping, component, index_values)[source]¶: Return the value of the coordinate.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'x'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

ufl.index_combination_utils module¶

Utilities for analysing and manipulating free index tuples.

ufl.index_combination_utils.create_slice_indices(component, shape, fi)[source]¶: Create slice indices.

ufl.index_combination_utils.merge_nonoverlapping_indices(a, b)[source]¶

Merge non-overlapping free indices into one representation.

Example:: C[i,j,r,s] = outer(A[i,s], B[j,r]) A, B -> (i,j,r,s), (idim,jdim,rdim,sdim)

ufl.index_combination_utils.merge_overlapping_indices(afi, afid, bfi, bfid)[source]¶

Merge overlapping free indices into one free and one repeated representation.

Example:: C[j,r] := A[i,j,k] * B[i,r,k] A, B -> (j,r), (jdim,rdim), (i,k), (idim,kdim)

ufl.index_combination_utils.merge_unique_indices(afi, afid, bfi, bfid)[source]¶

Merge two pairs of (index ids, index dimensions) sequences into one pair without duplicates.

The id tuples afi, bfi are assumed already sorted by id. Given a list of (id, dim) tuples already sorted by id, return a unique list with duplicates removed. Also checks that the dimensions of duplicates are matching.

ufl.index_combination_utils.remove_indices(fi, fid, rfi)[source]¶: Remove indices.

ufl.index_combination_utils.unique_sorted_indices(indices)[source]¶

Get unique sorted indices.

Given a list of (id, dim) tuples already sorted by id, return a unique list with duplicates removed. Also checks that the dimensions of duplicates are matching.

ufl.indexed module¶

This module defines the Indexed class.

class ufl.indexed.Indexed(expression, multiindex)[source]¶

Bases: Operator

Indexed expression.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Evaluate.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = ()¶

ufl.indexsum module¶

This module defines the IndexSum class.

class ufl.indexsum.IndexSum(summand, index)[source]¶

Bases: Operator

Index sum.

dimension()[source]¶: Get dimension.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

index()[source]¶: Get index.

ufl_free_indices¶

ufl_index_dimensions¶

property ufl_shape¶: Get UFL shape.

ufl.integral module¶

The Integral class.

class ufl.integral.Integral(integrand, integral_type, domain, subdomain_id, metadata, subdomain_data)[source]¶

Bases: object

An integral over a single domain.

integral_type()[source]¶: Return the domain type of this integral.

integrand()[source]¶: Return the integrand expression, which is an Expr instance.

metadata()[source]¶: Return the compiler metadata this integral has been annotated with.

reconstruct(integrand=None, integral_type=None, domain=None, subdomain_id=None, metadata=None, subdomain_data=None)[source]¶

Construct a new Integral object with some properties replaced with new values.

Example:: <a = Integral instance> b = a.reconstruct(expand_compounds(a.integrand())) c = a.reconstruct(metadata={‘quadrature_degree’:2})

subdomain_data()[source]¶: Return the domain data of this integral.

subdomain_id()[source]¶: Return the subdomain id of this integral.

ufl_domain()[source]¶: Return the integration domain of this integral.

ufl.mathfunctions module¶

This module provides basic mathematical functions.

class ufl.mathfunctions.Acos(argument)[source]¶

Bases: MathFunction

Inverse cosine.

class ufl.mathfunctions.Asin(argument)[source]¶

Bases: MathFunction

Inverse sine.

class ufl.mathfunctions.Atan(argument)[source]¶

Bases: MathFunction

Inverse tangent.

class ufl.mathfunctions.Atan2(arg1, arg2)[source]¶

Bases: Operator

Inverse tangent with two inputs.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.mathfunctions.BesselFunction(name, nu, argument)[source]¶

Bases: Operator

Base class for all bessel functions.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.mathfunctions.BesselI(nu, argument)[source]¶

Bases: BesselFunction

Bessel I function.

class ufl.mathfunctions.BesselJ(nu, argument)[source]¶

Bases: BesselFunction

Bessel J function.

class ufl.mathfunctions.BesselK(nu, argument)[source]¶

Bases: BesselFunction

Bessel K function.

class ufl.mathfunctions.BesselY(nu, argument)[source]¶

Bases: BesselFunction

Bessel Y function.

class ufl.mathfunctions.Cos(argument)[source]¶

Bases: MathFunction

Cosine.

class ufl.mathfunctions.Cosh(argument)[source]¶

Bases: MathFunction

Hyperbolic cosine.

class ufl.mathfunctions.Erf(argument)[source]¶

Bases: MathFunction

Erf function.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.mathfunctions.Exp(argument)[source]¶

Bases: MathFunction

Exponentiation..

class ufl.mathfunctions.Ln(argument)[source]¶

Bases: MathFunction

Natural logarithm.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

class ufl.mathfunctions.MathFunction(name, argument)[source]¶

Bases: Operator

Base class for all unary scalar math functions.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.mathfunctions.Sin(argument)[source]¶

Bases: MathFunction

Sine.

class ufl.mathfunctions.Sinh(argument)[source]¶

Bases: MathFunction

Hyperbolic sine.

class ufl.mathfunctions.Sqrt(argument)[source]¶

Bases: MathFunction

Square root.

class ufl.mathfunctions.Tan(argument)[source]¶

Bases: MathFunction

Tangent.

class ufl.mathfunctions.Tanh(argument)[source]¶

Bases: MathFunction

Hyperbolic tangent.

ufl.matrix module¶

This module defines the Matrix class.

class ufl.matrix.Matrix(row_space, column_space, count=None)[source]¶

Bases: BaseForm, Counted

An assemble linear operator between two function spaces.

equals(other)[source]¶: Check equality.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of this coefficient.

ufl_operands¶

ufl.measure module¶

The Measure class.

class ufl.measure.Measure(integral_type, domain=None, subdomain_id='everywhere', metadata=None, subdomain_data=None)[source]¶

Bases: object

Representation of an integration measure.

The Measure object holds information about integration properties to be transferred to a Form on multiplication with a scalar expression.

integral_type()[source]¶

Return the domain type.

Valid domain types are “cell”, “exterior_facet”, “interior_facet”, etc.

metadata()[source]¶

Return the integral metadata.

This data is not interpreted by UFL. It is passed to the form compiler which can ignore it or use it to compile each integral of a form in a different way.

reconstruct(integral_type=None, subdomain_id=None, domain=None, metadata=None, subdomain_data=None)[source]¶

Construct a new Measure object with some properties replaced with new values.

Example:: <dm = Measure instance> b = dm.reconstruct(subdomain_id=2) c = dm.reconstruct(metadata={ “quadrature_degree”: 3 })
Used by the call operator, so this is equivalent:: b = dm(2) c = dm(0, { “quadrature_degree”: 3 })

subdomain_data()[source]¶

Return the integral subdomain_data.

This data is not interpreted by UFL. Its intension is to give a context in which the domain id is interpreted.

subdomain_id()[source]¶: Return the domain id of this measure (integer).

ufl_domain()[source]¶

Return the domain associated with this measure.

This may be None or a Domain object.

class ufl.measure.MeasureProduct(*measures)[source]¶

Bases: object

Represents a product of measures.

This is a notational intermediate object to handle the notation

f*(dm1*dm2)

This is work in progress and not functional. It needs support in other parts of ufl and the rest of the code generation chain.

sub_measures()[source]¶: Return submeasures.

class ufl.measure.MeasureSum(*measures)[source]¶

Bases: object

Represents a sum of measures.

This is a notational intermediate object to translate the notation: f*(ds(1)+ds(3))
into: f*ds(1) + f*ds(3)

ufl.measure.as_integral_type(integral_type)[source]¶: Map short name to long name and require a valid one.

ufl.measure.integral_types()[source]¶: Return a tuple of all domain type strings.

ufl.measure.measure_names()[source]¶: Return a tuple of all measure name strings.

ufl.measure.register_integral_type(integral_type, measure_name)[source]¶: Register an integral type.

ufl.objects module¶

Utility objects for pretty syntax in user code.

ufl.operators module¶

Operators.

This module extends the form language with free function operators, which are either already available as member functions on UFL objects or defined as compound operators involving basic operations on the UFL objects.

ufl.operators.And(left, right)[source]¶: A boolean expression (left and right) for use with conditional.

ufl.operators.Dn(f)[source]¶

Take the directional derivative of f in the facet normal direction.

The facet normal is Dn(f) := dot(grad(f), n).

ufl.operators.Dx(f, *i)[source]¶

Take the partial derivative of f with respect to spatial variable number i.

Equivalent to f.dx(*i).

ufl.operators.Not(condition)[source]¶: A boolean expression (not condition) for use with conditional.

ufl.operators.Or(left, right)[source]¶: A boolean expression (left or right) for use with conditional.

ufl.operators.acos(f)[source]¶: Take the inverse cosine of f.

ufl.operators.asin(f)[source]¶: Take the inverse sine of f.

ufl.operators.atan(f)[source]¶: Take the inverse tangent of f.

ufl.operators.atan2(f1, f2)[source]¶: Take the inverse tangent with two the arguments f1 and f2.

ufl.operators.avg(v)[source]¶: Take the average of v across a facet.

ufl.operators.bessel_I(nu, f)[source]¶: Regular modified cylindrical Bessel function.

ufl.operators.bessel_J(nu, f)[source]¶: Cylindrical Bessel function of the first kind.

ufl.operators.bessel_K(nu, f)[source]¶: Irregular modified cylindrical Bessel function.

ufl.operators.bessel_Y(nu, f)[source]¶: Cylindrical Bessel function of the second kind.

ufl.operators.cell_avg(f)[source]¶: Take the average of v over a cell.

ufl.operators.cofac(A)[source]¶: Take the cofactor of A.

ufl.operators.conditional(condition, true_value, false_value)[source]¶

A conditional expression.

This takes the value of true_value when condition evaluates to true and false_value otherwise.

ufl.operators.conj(f)[source]¶: The complex conjugate of f.

ufl.operators.conjugate(f)¶: The complex conjugate of f.

ufl.operators.cos(f)[source]¶: Take the cosine of f.

ufl.operators.cosh(f)[source]¶: Take the hyperbolic cosine of f.

ufl.operators.cross(a, b)[source]¶: Take the cross product of a and b.

ufl.operators.curl(f)[source]¶: Take the curl of f.

ufl.operators.det(A)[source]¶: Take the determinant of A.

ufl.operators.dev(A)[source]¶: Take the deviatoric part of A.

ufl.operators.diag(A)[source]¶

Diagonal ranl-2 tensor.

Take the diagonal part of rank 2 tensor A or make a diagonal rank 2 tensor from a rank 1 tensor.

Always returns a rank 2 tensor. See also diag_vector.

ufl.operators.diag_vector(A)[source]¶

Take the diagonal part of rank 2 tensor A and return as a vector.

ufl.permutation module¶

This module provides utility functions for computing permutations and generating index lists.

ufl.permutation.build_component_numbering(shape, symmetry)[source]¶

Build a numbering of components within the given value shape.

This takes into consideration a symmetry mapping which leaves the mapping noncontiguous. Returns a dict { component -> numbering } and an ordered list of components [ numbering -> component ]. The dict contains all components while the list only contains the ones not mapped by the symmetry mapping.

ufl.permutation.compute_indices(shape)[source]¶: Compute all index combinations for given shape.

ufl.precedence module¶

Precedence handling.

ufl.precedence.assign_precedences(precedence_list)[source]¶: Given a precedence list, assign ints to class._precedence.

ufl.precedence.build_precedence_list()[source]¶: Build precedence list.

ufl.precedence.build_precedence_mapping(precedence_list)[source]¶

Given a precedence list, build a dict with class->int mappings.

Utility function used by some external code.

ufl.precedence.parstr(child, parent, pre='(', post=')', format=<class 'str'>)[source]¶: Parstr.

ufl.protocols module¶

Protocols.

ufl.protocols.id_or_none(obj)[source]¶

Returns None if the object is None, obj.ufl_id() if available, or id(obj) if not.

This allows external libraries to implement an alternative to id(obj) in the ufl_id() function, such that ufl can identify objects as the same without knowing about their types.

ufl.pullback module¶

Pull back and push forward maps.

class ufl.pullback.AbstractPullback[source]¶

Bases: ABC

An abstract pull back.

apply(expr: Expr) → Expr[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

abstract property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

abstract physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.ContravariantPiola[source]¶

Bases: AbstractPullback

The contravariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.CovariantContravariantPiola[source]¶

Bases: AbstractPullback

The covariant contravariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.CovariantPiola[source]¶

Bases: AbstractPullback

The covariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.CustomPullback[source]¶

Bases: AbstractPullback

Custom pull back.

This should probably be removed.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.DoubleContravariantPiola[source]¶

Bases: AbstractPullback

The double contravariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.DoubleCovariantPiola[source]¶

Bases: AbstractPullback

The double covariant Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.IdentityPullback[source]¶

Bases: AbstractPullback

The identity pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.L2Piola[source]¶

Bases: AbstractPullback

The L2 Piola pull back.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.MixedPullback(element: _AbstractFiniteElement)[source]¶

Bases: AbstractPullback

Pull back for a mixed element.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

exception ufl.pullback.NonStandardPullbackException[source]¶

Bases: BaseException

Exception to raise if a map is non-standard.

class ufl.pullback.PhysicalPullback[source]¶

Bases: AbstractPullback

Physical pull back.

This should probably be removed.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.SymmetricPullback(element: _AbstractFiniteElement, symmetry: Dict[tuple[int, ...], int])[source]¶

Bases: AbstractPullback

Pull back for an element with symmetry.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.pullback.UndefinedPullback[source]¶

Bases: AbstractPullback

Undefined pull back.

This should probably be removed.

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

ufl.referencevalue module¶

Representation of the reference value of a function.

class ufl.referencevalue.ReferenceValue(f)[source]¶

Bases: Operator

Representation of the reference cell value of a form argument.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Get child from mapping and return the component asked for.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶: Get the UFL shape.

ufl.restriction module¶

Restriction operations.

class ufl.restriction.NegativeRestricted(f)[source]¶

Bases: Restricted

Negative restriction.

class ufl.restriction.PositiveRestricted(f)[source]¶

Bases: Restricted

Positive restriction.

class ufl.restriction.Restricted(f)[source]¶

Bases: Operator

Restriction.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

side()[source]¶: Get the side.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

ufl.sobolevspace module¶

Sobolev spaces.

This module defines a symbolic heirarchy of Sobolev spaces to enable symbolic reasoning about the spaces in which finite elements lie.

class ufl.sobolevspace.DirectionalSobolevSpace(orders)[source]¶

Bases: SobolevSpace

Directional Sobolev space.

Symbolic representation of a Sobolev space with varying smoothness in different spatial directions.

class ufl.sobolevspace.SobolevSpace(name, parents=None)[source]¶

Bases: object

Symbolic representation of a Sobolev space.

This implements a subset of the methods of a Python set so that finite elements and other Sobolev spaces can be tested for inclusion.

ufl.sorting module¶

Sorting.

This module contains a sorting rule for expr objects that is more robust w.r.t. argument numbering than using repr.

ufl.sorting.cmp_expr(a, b)[source]¶: Replacement for cmp(a, b), removed in Python 3, for Expr objects.

ufl.sorting.sorted_expr(sequence)[source]¶: Return a canonically sorted list of Expr objects in sequence.

ufl.sorting.sorted_expr_sum(seq)[source]¶: Sorted expr sum.

ufl.split_functions module¶

Algorithm for splitting a Coefficient or Argument into subfunctions.

ufl.split_functions.split(v)[source]¶

Split a coefficient or argument.

If v is a Coefficient or Argument in a mixed space, returns a tuple with the function components corresponding to the subelements.

ufl.tensoralgebra module¶

Compound tensor algebra operations.

class ufl.tensoralgebra.Cofactor(A)[source]¶

Bases: CompoundTensorOperator

Cofactor.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶: Get the UFL shape.

class ufl.tensoralgebra.CompoundTensorOperator(operands)[source]¶

Bases: Operator

Compount tensor operator.

class ufl.tensoralgebra.Cross(a, b)[source]¶

Bases: CompoundTensorOperator

Cross.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = (3,)¶

class ufl.tensoralgebra.Determinant(A)[source]¶

Bases: CompoundTensorOperator

Determinant.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = ()¶

class ufl.tensoralgebra.Deviatoric(A)[source]¶

Bases: CompoundTensorOperator

Deviatoric.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.tensoralgebra.Dot(a, b)[source]¶

Bases: CompoundTensorOperator

Dot.

ufl_free_indices¶

ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.tensoralgebra.Inner(a, b)[source]¶

Bases: CompoundTensorOperator

Inner.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.tensoralgebra.Inverse(A)[source]¶

Bases: CompoundTensorOperator

Inverse.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶: Get the UFL shape.

class ufl.tensoralgebra.Outer(a, b)[source]¶

Bases: CompoundTensorOperator

Outer.

ufl_free_indices¶

ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

class ufl.tensoralgebra.Perp(A)[source]¶

Bases: CompoundTensorOperator

Perp.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

ufl_shape = (2,)¶

class ufl.tensoralgebra.Skew(A)[source]¶

Bases: CompoundTensorOperator

Skew.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.tensoralgebra.Sym(A)[source]¶

Bases: CompoundTensorOperator

Sym.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶

class ufl.tensoralgebra.Trace(A)[source]¶

Bases: CompoundTensorOperator

Trace.

property ufl_free_indices¶

property ufl_index_dimensions¶

ufl_shape = ()¶

class ufl.tensoralgebra.Transposed(A)[source]¶

Bases: CompoundTensorOperator

Transposed tensor.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

ufl.tensors module¶

Classes used to group scalar expressions into expressions with rank > 0.

class ufl.tensors.ComponentTensor(expression, indices)[source]¶

Bases: Operator

Maps the free indices of a scalar valued expression to tensor axes.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

indices()[source]¶: Get indices.

ufl_free_indices¶

ufl_index_dimensions¶

ufl_shape¶

class ufl.tensors.ListTensor(*expressions)[source]¶

Bases: Operator

Wraps a list of expressions into a tensor valued expression of one higher rank.

evaluate(x, mapping, component, index_values, derivatives=())[source]¶: Evaluate.

property ufl_free_indices¶

property ufl_index_dimensions¶

property ufl_shape¶: Get the UFL shape.

ufl.tensors.as_matrix(expressions, indices=None)[source]¶: As as_tensor(), but limited to rank 2 tensors.

ufl.tensors.as_scalar(expression)[source]¶

As scalar.

Given a scalar or tensor valued expression A, returns either of the tuples::: (a,b) = (A, ()) (a,b) = (A[indices], indices)

such that a is always a scalar valued expression.

ufl.tensors.as_scalars(*expressions)[source]¶

As scalars.

Given multiple scalar or tensor valued expressions A, returns either of the tuples::: (a,b) = (A, ()) (a,b) = ([A[0][indices], …, A[-1][indices]], indices)

such that a is always a list of scalar valued expressions.

ufl.tensors.as_tensor(expressions, indices=None)[source]¶

Make a tensor valued expression.

This works in two different ways, by using indices or lists.

1) Returns \(A\) such that \(A\) [indices] = expressions. If indices are provided, expressions must be a scalar valued expression with all the provided indices among its free indices. This operator will then map each of these indices to a tensor axis, thereby making a tensor valued expression from a scalar valued expression with free indices.

2) Returns \(A\) such that \(A[k,...]\) = expressions*[k]. If no indices are provided, *expressions must be a list or tuple of expressions. The expressions can also consist of recursively nested lists to build higher rank tensors.

ufl.tensors.as_vector(expressions, index=None)[source]¶: As as_tensor(), but limited to rank 1 tensors.

ufl.tensors.from_numpy_to_lists(expressions)[source]¶: Convert Numpy array to lists.

ufl.tensors.numpy2nestedlists(arr)[source]¶: Convert Numpy array to a nested list.

ufl.tensors.unit_indexed_tensor(shape, component)[source]¶: Unit indexed tensor.

ufl.tensors.unit_list(i, n)[source]¶: Create a list of zeros where the ith entry is 1.

ufl.tensors.unit_list2(i, j, n)[source]¶: Creage a two dimensional list of zeros where the (i,j)th entry is 1.

ufl.tensors.unit_matrices(d)[source]¶: A tuple of constant unit matrices in all directions with dimension d.

ufl.tensors.unit_matrix(i, j, d)[source]¶: A constant unit matrix in direction i,*j* with dimension d.

ufl.tensors.unit_vector(i, d)[source]¶: A constant unit vector in direction i with dimension d.

ufl.tensors.unit_vectors(d)[source]¶: A tuple of constant unit vectors in all directions with dimension d.

ufl.tensors.unwrap_list_tensor(lt)[source]¶: Unwrap a list tensor.

ufl.variable module¶

Define the Variable and Label classes.

These are used to label expressions as variables for differentiation.

class ufl.variable.Label(count=None)[source]¶

Bases: Terminal, Counted

Label.

is_cellwise_constant()[source]¶: Return true if the object is constant on each cell.

ufl_domains()[source]¶: Return tuple of domains related to this terminal object.

property ufl_free_indices¶: Get the UFL free indices.

property ufl_index_dimensions¶: Get the UFL index dimensions.

property ufl_shape¶: Get the UFL shape.

class ufl.variable.Variable(expression, label=None)[source]¶

Bases: Operator

A Variable is a representative for another expression.

It will be used by the end-user mainly for defining a quantity to differentiate w.r.t. using diff. Example:

e = <...>
e = variable(e)
f = exp(e**2)
df = diff(f, e)

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

expression()[source]¶: Get expression.

label()[source]¶: Get label.

ufl_domains()[source]¶: Get the UFL domains.

ufl_free_indices = ()¶

ufl_index_dimensions = ()¶

property ufl_shape¶

Module contents¶

UFL: The Unified Form Language.

The Unified Form Language is an embedded domain specific language for definition of variational forms intended for finite element discretization. More precisely, it defines a fixed interface for choosing finite element spaces and defining expressions for weak forms in a notation close to the mathematical one.

This Python module contains the language as well as algorithms to work with it.

To import the language, type:
```
import ufl
```
To import the underlying classes an UFL expression tree is built from, type
```
import ufl.classes
```
Various algorithms for working with UFL expression trees can be accessed by
```
import ufl.algorithms
```

Classes and algorithms are considered implementation details and should not be used in form definitions.

For more details on the language, see

http://www.fenicsproject.org

and

http://arxiv.org/abs/1211.4047

The development version can be found in the repository at

https://github.com/FEniCS/ufl

A very brief overview of the language contents follows:

Cells:

-AbstractCell
-Cell
-TensorProductCell
-vertex
-interval
-triangle
-tetrahedron
-quadrilateral
-hexahedron
-prism
-pyramid
-pentatope
-tesseract

Domains:
```
-AbstractDomain
-Mesh
-MeshView
```

Sobolev spaces:

-L2
-H1
-H2
-HInf
-HDiv
-HCurl
-HEin
-HDivDiv
-HCurlDiv

Pull backs:

-identity_pullback
-contravariant_piola
-covariant_piola
-l2_piola
-double_contravariant_piola
-double_covariant_piola
-covariant_contravariant_piola

Function spaces:
```
-FunctionSpace
-MixedFunctionSpace
```

Arguments:

-Argument
-TestFunction
-TrialFunction
-Arguments
-TestFunctions
-TrialFunctions

Coefficients:

-Coefficient
-Constant
-VectorConstant
-TensorConstant

Splitting form arguments in mixed spaces:
```
-split
```
Literal constants:
```
-Identity
-PermutationSymbol
```

Geometric quantities:

-SpatialCoordinate
-FacetNormal
-CellNormal
-CellVolume
-CellDiameter
-Circumradius
-MinCellEdgeLength
-MaxCellEdgeLength
-FacetArea
-MinFacetEdgeLength
-MaxFacetEdgeLength
-Jacobian
-JacobianDeterminant
-JacobianInverse

Indices:

-Index
-indices
-i, j, k, l
-p, q, r, s

Scalar to tensor expression conversion:
```
-as_tensor
-as_vector
-as_matrix
```

Unit vectors and matrices:

-unit_vector
-unit_vectors
-unit_matrix
-unit_matrices

Tensor algebra operators:

-outer, inner, dot, cross, perp
-det, inv, cofac
-transpose, tr, diag, diag_vector
-dev, skew, sym

Elementwise tensor operators:

-elem_mult
-elem_div
-elem_pow
-elem_op

Differential operators:

-variable
(-diff,)
-grad, nabla_grad
-div, nabla_div
-curl, rot
-Dx, Dn

Nonlinear functions:

-max_value, min_value
-abs, sign
-sqrt
-exp, ln, erf
-cos, sin, tan
-acos, asin, atan, atan2
-cosh, sinh, tanh
-bessel_J, bessel_Y, bessel_I, bessel_K

Complex operations:

- conj, real, imag
conjugate is an alias for conj

Discontinuous Galerkin operators:

-v("+"), v("-")
-jump
-avg
-cell_avg, facet_avg

Conditional operators:

- eq, ne, le, ge, lt, gt
- <, >, <=, >=
- And, Or, Not
- conditional

Integral measures:

-dx, ds, dS, dP
-dc, dC, dO, dI, dX
-ds_b, ds_t, ds_tb, ds_v, dS_h, dS_v

Form transformations:

-rhs, lhs
-system
-functional
-replace
-adjoint
-action
(-energy_norm,)
-sensitivity_rhs
-derivative

class ufl.AbstractCell[source]¶

Bases: UFLObject

A base class for all cells.

abstract cellname() → str[source]¶: Return the cellname of the cell.

edge_types() → Tuple[AbstractCell, ...][source]¶: Get the unique edge types.

edges() → Tuple[AbstractCell, ...][source]¶: Get the edges.

face_types() → Tuple[AbstractCell, ...][source]¶: Get the unique face types.

faces() → Tuple[AbstractCell, ...][source]¶: Get the faces.

facet_types() → Tuple[AbstractCell, ...][source]¶

Get the unique facet types.

Facets are entities of dimension tdim-1.

facets() → Tuple[AbstractCell, ...][source]¶

Get the facets.

Facets are entities of dimension tdim-1.

abstract has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

abstract is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_edges() → int[source]¶: Get the number of edges.

num_faces() → int[source]¶: Get the number of faces.

num_facets() → int[source]¶

Get the number of facets.

Facets are entities of dimension tdim-1.

num_peaks() → int[source]¶

Get the number of peaks.

Peaks are entities of dimension tdim-3.

num_ridges() → int[source]¶

Get the number of ridges.

Ridges are entities of dimension tdim-2.

abstract num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

num_vertices() → int[source]¶: Get the number of vertices.

peak_types() → Tuple[AbstractCell, ...][source]¶

Get the unique peak types.

Peaks are entities of dimension tdim-3.

peaks() → Tuple[AbstractCell, ...][source]¶

Get the peaks.

Peaks are entities of dimension tdim-3.

abstract reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

ridge_types() → Tuple[AbstractCell, ...][source]¶

Get the unique ridge types.

Ridges are entities of dimension tdim-2.

ridges() → Tuple[AbstractCell, ...][source]¶

Get the ridges.

Ridges are entities of dimension tdim-2.

abstract sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

abstract sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

abstract topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

vertex_types() → Tuple[AbstractCell, ...][source]¶: Get the unique vertices types.

vertices() → Tuple[AbstractCell, ...][source]¶: Get the vertices.

class ufl.AbstractDomain(topological_dimension, geometric_dimension)[source]¶

Bases: object

Symbolic representation of a geometric domain.

Domain has only a geometric and a topological dimension.

geometric_dimension()[source]¶: Return the dimension of the space this domain is embedded in.

topological_dimension()[source]¶: Return the dimension of the topology of this domain.

class ufl.AbstractFiniteElement[source]¶

Bases: ABC

Base class for all finite elements.

To make your element library compatible with UFL, you should make a subclass of AbstractFiniteElement and provide implementions of all the abstract methods and properties. All methods and properties that are not marked as abstract are implemented here and should not need to be overwritten in your subclass.

An example of how the methods in your subclass could be implemented can be found in Basix; see https://github.com/FEniCS/basix/blob/main/python/basix/ufl.py

abstract property cell: Cell¶: Return the cell of the finite element.

abstract property embedded_subdegree: int¶

Degree of the maximum degree Lagrange space that is spanned by this element.

This returns the degree of the highest degree Lagrange space such that the polynomial space of the Lagrange space is a subspace of this element’s polynomial space. If this element’s polynomial space does not include the constant function, this function should return -1.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

abstract property embedded_superdegree: int | None¶

Degree of the minimum degree Lagrange space that spans this element.

This returns the degree of the lowest degree Lagrange space such that the polynomial space of the Lagrange space is a superspace of this element’s polynomial space. If this element contains basis functions that are not in any Lagrange space, this function should return None.

Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1 Lagrange space includes the degree 2 polynomial xy.

is_cellwise_constant() → bool[source]¶: Check whether this element is spatially constant over each cell.

property num_sub_elements: int¶

Return number of sub-elements.

This function does not recurse: ie it does not count the sub-elements of sub-elements.

abstract property pullback: AbstractPullback¶: Return the pullback for this element.

abstract property reference_value_shape: Tuple[int, ...]¶: Return the shape of the value space on the reference cell.

property reference_value_size: int¶: Return the integer product of the reference value shape.

abstract property sobolev_space: SobolevSpace¶: Return the underlying Sobolev space.

abstract property sub_elements: List¶

Return list of sub-elements.

This function does not recurse: ie it does not extract the sub-elements of sub-elements.

class ufl.AbstractPullback[source]¶

Bases: ABC

An abstract pull back.

apply(expr: Expr) → Expr[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

abstract property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

abstract physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

class ufl.Action(*args, **kw)[source]¶

Bases: BaseForm

UFL base form type: respresents the action of an object on another.

For example:: res = Ax

A would be the first argument, left and x would be the second argument, right.

Action objects will result when the action of an assembled object (e.g. a Matrix) is taken. This delays the evaluation of the action until assembly occurs.

equals(other)[source]¶: Check if two Actions are equal.

left()[source]¶: Get left.

right()[source]¶: Get right.

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of the underlying form.

ufl_operands¶

class ufl.Adjoint(*args, **kw)[source]¶

Bases: BaseForm

UFL base form type: represents the adjoint of an object.

Adjoint objects will result when the adjoint of an assembled object (e.g. a Matrix) is taken. This delays the evaluation of the adjoint until assembly occurs.

equals(other)[source]¶: Check if two Adjoints are equal.

form()[source]¶: Return the form.

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of the underlying form.

ufl_operands¶

ufl.And(left, right)[source]¶: A boolean expression (left and right) for use with conditional.

class ufl.Argument(*args, **kw)[source]¶

Bases: FormArgument, BaseArgument

UFL value: Representation of an argument to a form.

ufl_domains()[source]¶: Return UFL domains.

ufl.Arguments(function_space, number)[source]¶

Create an Argument in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

class ufl.BaseForm[source]¶

Bases: object

Description of an object containing arguments.

arguments()[source]¶: Return all Argument objects found in form.

coefficients()[source]¶: Return all Coefficient objects found in form.

ufl_domain()[source]¶

Return the single geometric integration domain occuring in the base form.

Fails if multiple domains are found.

class ufl.Cell(cellname: str)[source]¶

Bases: AbstractCell

Representation of a named finite element cell with known structure.

cellname() → str[source]¶: Return the cellname of the cell.

has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

class ufl.CellDiameter(domain)[source]¶

Bases: GeometricCellQuantity

The diameter of the cell, i.e., maximal distance of two points in the cell.

name = 'diameter'¶

class ufl.CellNormal(domain)[source]¶

Bases: GeometricCellQuantity

The upwards pointing normal vector of the current manifold cell.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'cell_normal'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.CellVolume(domain)[source]¶

Bases: GeometricCellQuantity

The volume of the cell.

name = 'volume'¶

class ufl.Circumradius(domain)[source]¶

Bases: GeometricCellQuantity

The circumradius of the cell.

name = 'circumradius'¶

class ufl.Coargument(*args, **kw)[source]¶

Bases: BaseForm, BaseArgument

UFL value: Representation of an argument to a form in a dual space.

arguments(outer_form=None)[source]¶: Return all Argument objects found in form.

equals(other)[source]¶: Check equality.

ufl_domain()[source]¶: Return the UFL domain.

ufl_operands¶

class ufl.Coefficient(*args, **kw)[source]¶

Bases: FormArgument, BaseCoefficient

UFL form argument type: Representation of a form coefficient.

ufl_domains()[source]¶: Get the UFL domains.

ufl.Coefficients(function_space)[source]¶

Create a Coefficient in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

class ufl.Cofunction(*args, **kw)[source]¶

Bases: BaseCoefficient, BaseForm

UFL form argument type: Representation of a form coefficient from a dual space.

equals(other)[source]¶: Check equality.

ufl_operands¶

class ufl.Constant(domain, shape=(), count=None)[source]¶

Bases: Terminal, Counted

Constant.

is_cellwise_constant()[source]¶: Return True if the function is cellwise constant.

ufl_domain()[source]¶: Get the UFL domain.

ufl_domains()[source]¶: Get the UFL domains.

property ufl_shape¶: Get the UFL shape.

ufl.Dn(f)[source]¶

Take the directional derivative of f in the facet normal direction.

The facet normal is Dn(f) := dot(grad(f), n).

ufl.Dx(f, *i)[source]¶

Take the partial derivative of f with respect to spatial variable number i.

Equivalent to f.dx(*i).

class ufl.ExternalOperator(*operands, function_space, derivatives=None, argument_slots=())[source]¶

Bases: BaseFormOperator

External operator.

assemble(*args, **kwargs)[source]¶: Assemble the external operator.

grad()[source]¶: Returns the symbolic grad of the external operator.

ufl_element()[source]¶: Shortcut to get the finite element of the function space of the external operator.

ufl_operands¶

class ufl.FacetArea(domain)[source]¶

Bases: GeometricFacetQuantity

The area of the facet.

name = 'facetarea'¶

class ufl.FacetNormal(domain)[source]¶

Bases: GeometricFacetQuantity

The outwards pointing normal vector of the current facet.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'n'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.Form(integrals)[source]¶

Bases: BaseForm

Description of a weak form consisting of a sum of integrals over subdomains.

base_form_operators()[source]¶: Return all BaseFormOperator objects found in form.

coefficient_numbering()[source]¶: Return a contiguous numbering of coefficients in a mapping {coefficient:number}.

coefficients()[source]¶: Return all Coefficient objects found in form.

constant_numbering()[source]¶: Return a contiguous numbering of constants in a mapping {constant:number}.

constants()[source]¶: Get constants.

domain_numbering()[source]¶: Return a contiguous numbering of domains in a mapping {domain:number}.

empty()[source]¶: Returns whether the form has no integrals.

equals(other)[source]¶: Evaluate bool(lhs_form == rhs_form).

geometric_dimension()[source]¶: Return the geometric dimension shared by all domains and functions in this form.

integrals()[source]¶: Return a sequence of all integrals in form.

integrals_by_domain(domain)[source]¶: Return a sequence of all integrals with a particular integration domain.

integrals_by_type(integral_type)[source]¶: Return a sequence of all integrals with a particular domain type.

signature()[source]¶: Signature for use with jit cache (independent of incidental numbering of indices etc).

subdomain_data()[source]¶: Returns a mapping on the form {domain:{integral_type: subdomain_data}}.

terminal_numbering()[source]¶

Return a contiguous numbering for all counted objects in the form.

The returned object is mapping from terminal to its number (an integer).

The numbering is computed per type so :class:`Coefficient`s, :class:`Constant`s, etc will each be numbered from zero.

ufl_cell()[source]¶

Return the single cell this form is defined on.

Fails if multiple cells are found.

ufl_domains()[source]¶

Return the geometric integration domains occuring in the form.

NB! This does not include domains of coefficients defined on other meshes.

The return type is a tuple even if only a single domain exists.

class ufl.FormSum(*args, **kwargs)[source]¶

Bases: BaseForm

Form sum.

Description of a weighted sum of variational forms and form-like objects components is the list of Forms to be summed arg_weights is a list of tuples of component index and weight

components()[source]¶: Get components.

equals(other)[source]¶: Evaluate bool(lhs_form == rhs_form).

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_operands¶

weights()[source]¶: Get weights.

class ufl.FunctionSpace(domain, element, label='')[source]¶

Bases: BaseFunctionSpace, UFLObject

Representation of a Function space.

dual()[source]¶: Get the dual of the space.

class ufl.Identity(dim)[source]¶

Bases: ConstantValue

Representation of an identity matrix.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_shape¶

class ufl.Index(count=None)[source]¶

Bases: IndexBase, Counted

UFL value: An index with no value assigned.

Used to represent free indices in Einstein indexing notation.

class ufl.Integral(integrand, integral_type, domain, subdomain_id, metadata, subdomain_data)[source]¶

Bases: object

An integral over a single domain.

integral_type()[source]¶: Return the domain type of this integral.

integrand()[source]¶: Return the integrand expression, which is an Expr instance.

metadata()[source]¶: Return the compiler metadata this integral has been annotated with.

reconstruct(integrand=None, integral_type=None, domain=None, subdomain_id=None, metadata=None, subdomain_data=None)[source]¶

Construct a new Integral object with some properties replaced with new values.

Example:: <a = Integral instance> b = a.reconstruct(expand_compounds(a.integrand())) c = a.reconstruct(metadata={‘quadrature_degree’:2})

subdomain_data()[source]¶: Return the domain data of this integral.

subdomain_id()[source]¶: Return the subdomain id of this integral.

ufl_domain()[source]¶: Return the integration domain of this integral.

class ufl.Interpolate(expr, v)[source]¶

Bases: BaseFormOperator

Symbolic representation of the interpolation operator.

ufl_operands¶

class ufl.Jacobian(domain)[source]¶

Bases: GeometricCellQuantity

The Jacobian of the mapping from reference cell to spatial coordinates.

\[\begin{split}J_{ij} = \\frac{dx_i}{dX_j}\end{split}\]

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'J'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.JacobianDeterminant(domain)[source]¶

Bases: GeometricCellQuantity

The determinant of the Jacobian.

Represents the signed determinant of a square Jacobian or the pseudo-determinant of a non-square Jacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'detJ'¶

class ufl.JacobianInverse(domain)[source]¶

Bases: GeometricCellQuantity

The inverse of the Jacobian.

Represents the inverse of a square Jacobian or the pseudo-inverse of a non-square Jacobian.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'K'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.Matrix(row_space, column_space, count=None)[source]¶

Bases: BaseForm, Counted

An assemble linear operator between two function spaces.

equals(other)[source]¶: Check equality.

ufl_function_spaces()[source]¶: Get the tuple of function spaces of this coefficient.

ufl_operands¶

class ufl.MaxCellEdgeLength(domain)[source]¶

Bases: GeometricCellQuantity

The maximum edge length of the cell.

name = 'maxcelledgelength'¶

class ufl.MaxFacetEdgeLength(domain)[source]¶

Bases: GeometricFacetQuantity

The maximum edge length of the facet.

name = 'maxfacetedgelength'¶

class ufl.Measure(integral_type, domain=None, subdomain_id='everywhere', metadata=None, subdomain_data=None)[source]¶

Bases: object

Representation of an integration measure.

The Measure object holds information about integration properties to be transferred to a Form on multiplication with a scalar expression.

integral_type()[source]¶

Return the domain type.

Valid domain types are “cell”, “exterior_facet”, “interior_facet”, etc.

metadata()[source]¶

Return the integral metadata.

This data is not interpreted by UFL. It is passed to the form compiler which can ignore it or use it to compile each integral of a form in a different way.

reconstruct(integral_type=None, subdomain_id=None, domain=None, metadata=None, subdomain_data=None)[source]¶

Construct a new Measure object with some properties replaced with new values.

Example:: <dm = Measure instance> b = dm.reconstruct(subdomain_id=2) c = dm.reconstruct(metadata={ “quadrature_degree”: 3 })
Used by the call operator, so this is equivalent:: b = dm(2) c = dm(0, { “quadrature_degree”: 3 })

subdomain_data()[source]¶

Return the integral subdomain_data.

This data is not interpreted by UFL. Its intension is to give a context in which the domain id is interpreted.

subdomain_id()[source]¶: Return the domain id of this measure (integer).

ufl_domain()[source]¶

Return the domain associated with this measure.

This may be None or a Domain object.

class ufl.Mesh(coordinate_element, ufl_id=None, cargo=None)[source]¶

Bases: AbstractDomain, UFLObject

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()[source]¶: Check if the domain is a piecewise linear simplex.

ufl_cargo()[source]¶: Return carried object that will not be used by UFL.

ufl_cell()[source]¶: Get the cell.

ufl_coordinate_element()[source]¶: Get the coordinate element.

ufl_id()¶: Return the ufl_id of this object.

class ufl.MeshView(mesh, topological_dimension, ufl_id=None)[source]¶

Bases: AbstractDomain, UFLObject

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()[source]¶: Check if the domain is a piecewise linear simplex.

ufl_cell()[source]¶: Get the cell.

ufl_id()¶: Return the ufl_id of this object.

ufl_mesh()[source]¶: Get the mesh.

class ufl.MinCellEdgeLength(domain)[source]¶

Bases: GeometricCellQuantity

The minimum edge length of the cell.

name = 'mincelledgelength'¶

class ufl.MinFacetEdgeLength(domain)[source]¶

Bases: GeometricFacetQuantity

The minimum edge length of the facet.

name = 'minfacetedgelength'¶

class ufl.MixedFunctionSpace(*args)[source]¶

Bases: AbstractFunctionSpace, UFLObject

Mixed function space.

dual(*args)[source]¶

Return the dual to this function space.

If no additional arguments are passed then a MixedFunctionSpace is returned whose components are the duals of the originals.

If additional arguments are passed, these must be integers. In this case, the MixedFunctionSpace which is returned will have dual components in the positions corresponding to the arguments passed, and the original components in the other positions.

num_sub_spaces()[source]¶: Return number of subspaces.

ufl_domain()[source]¶: Return ufl domain.

ufl_domains()[source]¶: Return ufl domains.

ufl_element()[source]¶: Return ufl element.

ufl_elements()[source]¶: Return ufl elements.

ufl_sub_space(i)[source]¶: Return i-th ufl sub space.

ufl_sub_spaces()[source]¶: Return ufl sub spaces.

class ufl.MixedPullback(element: _AbstractFiniteElement)[source]¶

Bases: AbstractPullback

Pull back for a mixed element.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

ufl.Not(condition)[source]¶: A boolean expression (not condition) for use with conditional.

ufl.Or(left, right)[source]¶: A boolean expression (left or right) for use with conditional.

class ufl.PermutationSymbol(dim)[source]¶

Bases: ConstantValue

Representation of a permutation symbol.

This is also known as the Levi-Civita symbol, antisymmetric symbol, or alternating symbol.

evaluate(x, mapping, component, index_values)[source]¶: Evaluate.

ufl_shape¶

class ufl.SpatialCoordinate(domain)[source]¶

Bases: GeometricCellQuantity

The coordinate in a domain.

In the context of expression integration, represents the domain coordinate of each quadrature point.

In the context of expression evaluation in a point, represents the value of that point.

count()[source]¶: Count.

evaluate(x, mapping, component, index_values)[source]¶: Return the value of the coordinate.

is_cellwise_constant()[source]¶: Return whether this expression is spatially constant over each cell.

name = 'x'¶

property ufl_shape¶: Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.SymmetricPullback(element: _AbstractFiniteElement, symmetry: Dict[tuple[int, ...], int])[source]¶

Bases: AbstractPullback

Pull back for an element with symmetry.

apply(expr)[source]¶

Apply the pull back.

Args:: expr: A function on a physical cell

Returns: The function pulled back to the reference cell

property is_identity: bool¶: Is this pull back the identity (or the identity applied to mutliple components).

physical_value_shape(element, domain) → Tuple[int, ...][source]¶

Get the physical value shape when this pull back is applied to an element on a domain.

Args:: element: The element that the pull back is applied to domain: The domain
Returns:: The value shape when the pull back is applied to the given element

ufl.TensorConstant(domain, count=None)[source]¶: Tensor constant.

class ufl.TensorProductCell(*cells: Cell)[source]¶

Bases: AbstractCell

Tensor product cell.

cellname() → str[source]¶: Return the cellname of the cell.

has_simplex_facets() → bool[source]¶: Return True if all the facets of this cell are simplex cells.

is_simplex() → bool[source]¶: Return True if this is a simplex cell.

num_sub_entities(dim: int) → int[source]¶: Get the number of sub-entities of the given dimension.

reconstruct(**kwargs: Any) → Cell[source]¶: Reconstruct this cell, overwriting properties by those in kwargs.

sub_cells() → List[AbstractCell][source]¶: Return list of cell factors.

sub_entities(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the sub-entities of the given dimension.

sub_entity_types(dim: int) → Tuple[AbstractCell, ...][source]¶: Get the unique sub-entity types of the given dimension.

topological_dimension() → int[source]¶: Return the dimension of the topology of this cell.

ufl.TestFunction(function_space, part=None)[source]¶: UFL value: Create a test function argument to a form.

ufl.TestFunctions(function_space)[source]¶

Create a TestFunction in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

ufl.TrialFunction(function_space, part=None)[source]¶: UFL value: Create a trial function argument to a form.

ufl.TrialFunctions(function_space)[source]¶

Create a TrialFunction in a mixed space.

Returns a tuple with the function components corresponding to the subelements.

ufl.VectorConstant(domain, count=None)[source]¶: Vector constant.

class ufl.ZeroBaseForm(arguments)[source]¶

Bases: BaseForm

Description of a zero base form.

ZeroBaseForm is idempotent with respect to assembly and is mostly used for sake of simplifying base-form expressions.

form¶

ufl_domains()[source]¶: Return all domains found in the base form.

ufl_operands¶

ufl.acos(f)[source]¶: Take the inverse cosine of f.

ufl.action(form, coefficient=None, derivatives_expanded=None)[source]¶

Get the action.

Given a bilinear form, return a linear form with an additional coefficient, representing the action of the form on the coefficient. This can be used for matrix-free methods. For formbase objects,coefficient can be any object of the correct type, and this function returns an Action object.

When action is being called multiple times on the same form, expanding derivatives become expensive -> derivatives_expanded enables to use caching mechanisms to avoid that.

ufl.adjoint(form, reordered_arguments=None, derivatives_expanded=None)[source]¶

Get the adjoint.

Given a combined bilinear form, compute the adjoint form by changing the ordering (count) of the test and trial functions, and taking the complex conjugate of the result.

By default, new Argument objects will be created with opposite ordering. However, if the adjoint form is to be added to other forms later, their arguments must match. In that case, the user must provide a tuple *reordered_arguments*=(u2,v2).

If the form is a baseform instance instead of a Form object, we return an Adjoint object instructing the adjoint to be computed at a later point.

When adjoint is being called multiple times on the same form, expanding derivatives become expensive -> derivatives_expanded enables to use caching mechanisms to avoid that.

ufl.as_cell(cell: AbstractCell | str | Tuple[AbstractCell, ...]) → AbstractCell[source]¶

Convert any valid object to a Cell or return cell if it is already a Cell.

Allows an already valid cell, a known cellname string, or a tuple of cells for a product cell.

ufl.as_matrix(expressions, indices=None)[source]¶: As as_tensor(), but limited to rank 2 tensors.

ufl.as_tensor(expressions, indices=None)[source]¶

Make a tensor valued expression.

This works in two different ways, by using indices or lists.

1) Returns \(A\) such that \(A\) [indices] = expressions. If indices are provided, expressions must be a scalar valued expression with all the provided indices among its free indices. This operator will then map each of these indices to a tensor axis, thereby making a tensor valued expression from a scalar valued expression with free indices.

2) Returns \(A\) such that \(A[k,...]\) = expressions*[k]. If no indices are provided, *expressions must be a list or tuple of expressions. The expressions can also consist of recursively nested lists to build higher rank tensors.

ufl.as_ufl(expression)[source]¶: Converts expression to an Expr if possible.

ufl.as_vector(expressions, index=None)[source]¶: As as_tensor(), but limited to rank 1 tensors.

ufl.asin(f)[source]¶: Take the inverse sine of f.

ufl.atan(f)[source]¶: Take the inverse tangent of f.

ufl.atan2(f1, f2)[source]¶: Take the inverse tangent with two the arguments f1 and f2.

ufl.avg(v)[source]¶: Take the average of v across a facet.

ufl.bessel_I(nu, f)[source]¶: Regular modified cylindrical Bessel function.

ufl.bessel_J(nu, f)[source]¶: Cylindrical Bessel function of the first kind.

ufl.bessel_K(nu, f)[source]¶: Irregular modified cylindrical Bessel function.

ufl.bessel_Y(nu, f)[source]¶: Cylindrical Bessel function of the second kind.

ufl.cell_avg(f)[source]¶: Take the average of v over a cell.

ufl.cofac(A)[source]¶: Take the cofactor of A.

ufl.conditional(condition, true_value, false_value)[source]¶

A conditional expression.

This takes the value of true_value when condition evaluates to true and false_value otherwise.

ufl.conj(f)[source]¶: The complex conjugate of f.

ufl.cos(f)[source]¶: Take the cosine of f.

ufl.cosh(f)[source]¶: Take the hyperbolic cosine of f.

ufl.cross(a, b)[source]¶: Take the cross product of a and b.

ufl.curl(f)[source]¶: Take the curl of f.

ufl.derivative(form, coefficient, argument=None, coefficient_derivatives=None)[source]¶

Compute the Gateaux derivative of form w.r.t. coefficient in direction of argument.

If the argument is omitted, a new Argument is created in the same space as the coefficient, with argument number one higher than the highest one in the form.

The resulting form has one additional Argument in the same finite element space as the coefficient.

A tuple of Coefficient s may be provided in place of a single Coefficient, in which case the new Argument argument is based on a MixedElement created from this tuple.

An indexed Coefficient from a mixed space may be provided, in which case the argument should be in the corresponding subspace of the coefficient space.

If provided, coefficient_derivatives should be a mapping from Coefficient instances to their derivatives w.r.t. coefficient.

ufl.det(A)[source]¶: Take the determinant of A.

ufl.dev(A)[source]¶: Take the deviatoric part of A.

ufl.diag(A)[source]¶

Diagonal ranl-2 tensor.

Take the diagonal part of rank 2 tensor A or make a diagonal rank 2 tensor from a rank 1 tensor.

Always returns a rank 2 tensor. See also diag_vector.

ufl.diag_vector(A)[source]¶

Take the diagonal part of rank 2 tensor A and return as a vector.