# ufl package¶

## ufl.algebra module¶

Basic algebra operations.

class ufl.algebra.Abs(a)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.algebra.Division(a, b)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.algebra.Power(a, b)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.algebra.Product(a, b)

The product of two or more UFL objects.

evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.algebra.Sum(a, b)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape

## ufl.argument module¶

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

class ufl.argument.Argument(function_space, number, part=None)

UFL value: Representation of an argument to a form.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

number()

Return the Argument number.

part()
ufl_domain()

ufl_domains()

ufl_element()

ufl_function_space()

Get the function space of this Argument.

ufl_shape

Return the associated UFL shape.

ufl.argument.Arguments(function_space, number)

UFL value: Create an Argument in a mixed space, and return a tuple with the function components corresponding to the subelements.

ufl.argument.TestFunction(function_space, part=None)

UFL value: Create a test function argument to a form.

ufl.argument.TestFunctions(function_space)

UFL value: Create a TestFunction in a mixed space, and return a tuple with the function components corresponding to the subelements.

ufl.argument.TrialFunction(function_space, part=None)

UFL value: Create a trial function argument to a form.

ufl.argument.TrialFunctions(function_space)

UFL value: Create a TrialFunction in a mixed space, and return a tuple with the function components corresponding to the subelements.

## ufl.assertions module¶

This module provides assertion functions used by the UFL implementation.

ufl.assertions.expecting_expr(v)
ufl.assertions.expecting_instance(v, c)
ufl.assertions.expecting_python_scalar(v)
ufl.assertions.expecting_terminal(v)
ufl.assertions.expecting_true_ufl_scalar(v)
ufl.assertions.ufl_assert(condition, *message)

Assert that condition is true and otherwise issue an error with given message.

## ufl.cell module¶

Types for representing a cell.

class ufl.cell.AbstractCell(topological_dimension, geometric_dimension)

Bases: object

Representation of an abstract finite element cell with only the dimensions known.

geometric_dimension()

Return the dimension of the space this cell is embedded in.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

topological_dimension()

Return the dimension of the topology of this cell.

class ufl.cell.Cell(cellname, geometric_dimension=None)

Representation of a named finite element cell with known structure.

cellname()

Return the cellname of the cell.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

num_edges()

The number of cell edges.

num_facet_edges()

The number of facet edges.

num_facets()

The number of cell facets.

num_vertices()

The number of cell vertices.

reconstruct(geometric_dimension=None)
class ufl.cell.TensorProductCell(*cells, **kwargs)
cellname()

Return the cellname of the cell.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

num_edges()

The number of cell edges.

num_facets()

The number of cell facets.

num_vertices()

The number of cell vertices.

reconstruct(geometric_dimension=None)
sub_cells()

Return list of cell factors.

ufl.cell.as_cell(cell)

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, geometric_dimension=None)

Return a hypercube cell of given dimension.

ufl.cell.simplex(topological_dimension, geometric_dimension=None)

Return a simplex cell of given dimension.

## ufl.checks module¶

Utility functions for checking properties of expressions.

ufl.checks.is_cellwise_constant(expr)

Return whether expression is constant over a single cell.

ufl.checks.is_globally_constant(expr)

Check if an expression is globally constant, which includes spatially independent constant coefficients that are not known before assembly time.

ufl.checks.is_python_scalar(expression)

Return True iff expression is of a Python scalar type.

ufl.checks.is_scalar_constant_expression(expr)

Check if an expression is a globally constant scalar expression.

ufl.checks.is_true_ufl_scalar(expression)

Return True iff expression is scalar-valued, with no free indices.

ufl.checks.is_ufl_scalar(expression)

Return True iff expression is scalar-valued, but possibly containing free indices.

## ufl.classes module¶

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.Expr

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.

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)

Evaluate expression at given coordinate with given values for terminals.

geometric_dimension()

Return the geometric dimension this expression lives in.

static ufl_disable_profiling()

Turn off the object counting mechanism. Return object init and del counts.

ufl_domain()

Return the single unique domain this expression is defined on, or throw an error.

ufl_domains()

Return all domains this expression is defined on.

static ufl_enable_profiling()

Turn on the object counting mechanism and reset counts to zero.

class ufl.classes.Terminal

A terminal node in the UFL expression tree.

evaluate(x, mapping, component, index_values, derivatives=())

Get self from mapping and return the component asked for.

ufl_domains()

Return tuple of domains related to this terminal object.

ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_operands = ()
class ufl.classes.FormArgument

An abstract class for a form argument.

class ufl.classes.GeometricQuantity(domain)
is_cellwise_constant()

Return whether this expression is spatially constant over each cell (or over each facet for facet quantities).

ufl_domains()
ufl_shape = ()
class ufl.classes.GeometricCellQuantity(domain)
class ufl.classes.GeometricFacetQuantity(domain)
class ufl.classes.SpatialCoordinate(domain)

UFL geometry representation: 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.

evaluate(x, mapping, component, index_values)

Return the value of the coordinate.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'x'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.CellCoordinate(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'X'
ufl_shape
class ufl.classes.FacetCoordinate(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'Xf'
ufl_shape
class ufl.classes.CellOrigin(domain)

UFL geometry representation: The spatial coordinate corresponding to origin of a reference cell.

is_cellwise_constant()
name = 'x0'
ufl_shape
class ufl.classes.FacetOrigin(domain)

UFL geometry representation: The spatial coordinate corresponding to origin of a reference facet.

name = 'x0f'
ufl_shape
class ufl.classes.CellFacetOrigin(domain)

UFL geometry representation: The reference cell coordinate corresponding to origin of a reference facet.

name = 'X0f'
ufl_shape
class ufl.classes.Jacobian(domain)

UFL geometry representation: The Jacobian of the mapping from reference cell to spatial coordinates.

$J_{ij} = \frac{dx_i}{dX_j}$
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'J'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.FacetJacobian(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'FJ'
ufl_shape
class ufl.classes.CellFacetJacobian(domain)

UFL geometry representation: The Jacobian of the mapping from reference facet to reference cell coordinates.

CFJ_ij = dX_i/dXf_j

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CFJ'
ufl_shape
class ufl.classes.ReferenceCellEdgeVectors(domain)

UFL geometry representation: The vectors between reference cell vertices for each edge in cell.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'RCEV'
ufl_shape
class ufl.classes.ReferenceFacetEdgeVectors(domain)

UFL geometry representation: The vectors between reference cell vertices for each edge in current facet.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'RFEV'
ufl_shape
class ufl.classes.CellVertices(domain)

UFL geometry representation: Physical cell vertices.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CV'
ufl_shape
class ufl.classes.CellEdgeVectors(domain)

UFL geometry representation: The vectors between physical cell vertices for each edge in cell.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CEV'
ufl_shape
class ufl.classes.FacetEdgeVectors(domain)

UFL geometry representation: The vectors between physical cell vertices for each edge in current facet.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'FEV'
ufl_shape
class ufl.classes.JacobianDeterminant(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'detJ'
class ufl.classes.FacetJacobianDeterminant(domain)

UFL geometry representation: The pseudo-determinant of the FacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'detFJ'
class ufl.classes.CellFacetJacobianDeterminant(domain)

UFL geometry representation: The pseudo-determinant of the CellFacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'detCFJ'
class ufl.classes.JacobianInverse(domain)

UFL geometry representation: The inverse of the Jacobian.

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

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'K'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.FacetJacobianInverse(domain)

UFL geometry representation: The pseudo-inverse of the FacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'FK'
ufl_shape
class ufl.classes.CellFacetJacobianInverse(domain)

UFL geometry representation: The pseudo-inverse of the CellFacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CFK'
ufl_shape
class ufl.classes.FacetNormal(domain)

UFL geometry representation: The outwards pointing normal vector of the current facet.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'n'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.CellNormal(domain)

UFL geometry representation: The upwards pointing normal vector of the current manifold cell.

name = 'cell_normal'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.classes.ReferenceNormal(domain)

UFL geometry representation: The outwards pointing normal vector of the current facet on the reference cell

name = 'reference_normal'
ufl_shape
class ufl.classes.ReferenceCellVolume(domain)

UFL geometry representation: The volume of the reference cell.

name = 'reference_cell_volume'
class ufl.classes.ReferenceFacetVolume(domain)

UFL geometry representation: The volume of the reference cell of the current facet.

name = 'reference_facet_volume'
class ufl.classes.CellVolume(domain)

UFL geometry representation: The volume of the cell.

name = 'volume'
class ufl.classes.Circumradius(domain)

UFL geometry representation: The circumradius of the cell.

name = 'circumradius'
class ufl.classes.CellDiameter(domain)

UFL geometry representation: The diameter of the cell, i.e., maximal distance of two points in the cell.

name = 'diameter'
class ufl.classes.FacetArea(domain)

UFL geometry representation: The area of the facet.

name = 'facetarea'
class ufl.classes.MinCellEdgeLength(domain)

UFL geometry representation: The minimum edge length of the cell.

name = 'mincelledgelength'
class ufl.classes.MaxCellEdgeLength(domain)

UFL geometry representation: The maximum edge length of the cell.

name = 'maxcelledgelength'
class ufl.classes.MinFacetEdgeLength(domain)

UFL geometry representation: The minimum edge length of the facet.

name = 'minfacetedgelength'
class ufl.classes.MaxFacetEdgeLength(domain)

UFL geometry representation: The maximum edge length of the facet.

name = 'maxfacetedgelength'
class ufl.classes.CellOrientation(domain)

UFL geometry representation: 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.FacetOrientation(domain)

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

name = 'facet_orientation'
class ufl.classes.QuadratureWeight(domain)

UFL geometry representation: The current quadrature weight.

Only used inside a quadrature context.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'weight'
class ufl.classes.Operator(operands=None)

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

ufl_operands
class ufl.classes.MultiIndex(indices)

Represents a sequence of indices, either fixed or free.

evaluate(x, mapping, component, index_values)

Evaluate index.

indices()

Return tuple of indices.

is_cellwise_constant()

Always True.

ufl_domains()

Return tuple of domains related to this terminal object.

ufl_free_indices

This shall not be used.

ufl_index_dimensions

This shall not be used.

ufl_shape

This shall not be used.

class ufl.classes.ConstantValue
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

ufl_domains()

Return tuple of domains related to this terminal object.

class ufl.classes.Zero(shape=(), free_indices=(), index_dimensions=None)

UFL literal type: Representation of a zero valued expression.

evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.ScalarValue(value)

A constant scalar value.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
value()
class ufl.classes.FloatValue(value)

UFL literal type: Representation of a constant scalar floating point value.

class ufl.classes.IntValue(value)

UFL literal type: Representation of a constant scalar integer value.

class ufl.classes.Identity(dim)

UFL literal type: Representation of an identity matrix.

evaluate(x, mapping, component, index_values)

Evaluates the identity matrix on the given components.

ufl_shape
class ufl.classes.PermutationSymbol(dim)

UFL literal type: 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)

Evaluates the permutation symbol.

ufl_shape
class ufl.classes.Indexed(expression, multiindex)
evaluate(x, mapping, component, index_values, derivatives=())
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.classes.ListTensor(*expressions)

UFL operator type: Wraps a list of expressions into a tensor valued expression of one higher rank.

evaluate(x, mapping, component, index_values, derivatives=())
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.ComponentTensor(expression, indices)

UFL operator type: Maps the free indices of a scalar valued expression to tensor axes.

evaluate(x, mapping, component, index_values)
indices()
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Argument(function_space, number, part=None)

UFL value: Representation of an argument to a form.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

number()

Return the Argument number.

part()
ufl_domain()

ufl_domains()

ufl_element()

ufl_function_space()

Get the function space of this Argument.

ufl_shape

Return the associated UFL shape.

class ufl.classes.Coefficient(function_space, count=None)

UFL form argument type: Representation of a form coefficient.

count()
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

ufl_domain()

Shortcut to get the domain of the function space of this coefficient.

ufl_domains()

Return tuple of domains related to this terminal object.

ufl_element()

Shortcut to get the finite element of the function space of this coefficient.

ufl_function_space()

Get the function space of this coefficient.

ufl_shape

Return the associated UFL shape.

class ufl.classes.Label(count=None)
count()
is_cellwise_constant()
ufl_domains()

Return tuple of domains related to this terminal object.

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Variable(expression, label=None)

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)
expression()
label()
ufl_domains()
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.classes.Sum(a, b)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Product(a, b)

The product of two or more UFL objects.

evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.classes.Division(a, b)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.classes.Power(a, b)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.classes.Abs(a)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.CompoundTensorOperator(operands)
class ufl.classes.Transposed(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Outer(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Inner(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.classes.Dot(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Cross(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape = (3,)
class ufl.classes.Trace(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.classes.Determinant(A)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.classes.Inverse(A)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.classes.Cofactor(A)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.classes.Deviatoric(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Skew(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Sym(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.IndexSum(summand, index)
dimension()
evaluate(x, mapping, component, index_values)
index()
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Restricted(f)
evaluate(x, mapping, component, index_values)
side()
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.PositiveRestricted(f)
class ufl.classes.NegativeRestricted(f)
class ufl.classes.CellAvg(f)
evaluate(x, mapping, component, index_values)

Performs an approximate symbolic evaluation, since we dont have a cell.

ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.classes.FacetAvg(f)
evaluate(x, mapping, component, index_values)

Performs an approximate symbolic evaluation, since we dont have a cell.

ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.classes.ExprList(*operands)

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

free_indices()
index_dimensions()
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.ExprMapping(*operands)

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

free_indices()
index_dimensions()
ufl_domains()
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Derivative(operands)

Base class for all derivative types.

class ufl.classes.CoefficientDerivative(integrand, coefficients, arguments, coefficient_derivatives)

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

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.VariableDerivative(f, v)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.CompoundDerivative(operands)

Base class for all compound derivative types.

class ufl.classes.Grad(f)
evaluate(x, mapping, component, index_values, derivatives=())

Get child from mapping and return the component asked for.

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.ReferenceGrad(f)
evaluate(x, mapping, component, index_values, derivatives=())

Get child from mapping and return the component asked for.

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Div(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.ReferenceDiv(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.NablaGrad(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.NablaDiv(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Curl(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.ReferenceCurl(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.Condition(operands)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.classes.BinaryCondition(name, left, right)
class ufl.classes.EQ(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.NE(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.LE(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.GE(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.LT(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.GT(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.AndCondition(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.OrCondition(left, right)
evaluate(x, mapping, component, index_values)
class ufl.classes.NotCondition(condition)
evaluate(x, mapping, component, index_values)
class ufl.classes.Conditional(condition, true_value, false_value)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.classes.MinValue(left, right)

UFL operator: Take the minimum of two values.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.classes.MaxValue(left, right)

UFL operator: Take the maximum of two values.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.classes.MathFunction(name, argument)

Base class for all unary scalar math functions.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.classes.Sqrt(argument)
class ufl.classes.Exp(argument)
class ufl.classes.Ln(argument)
evaluate(x, mapping, component, index_values)
class ufl.classes.Cos(argument)
class ufl.classes.Sin(argument)
class ufl.classes.Tan(argument)
class ufl.classes.Cosh(argument)
class ufl.classes.Sinh(argument)
class ufl.classes.Tanh(argument)
class ufl.classes.Acos(argument)
class ufl.classes.Asin(argument)
class ufl.classes.Atan(argument)
class ufl.classes.Atan2(arg1, arg2)
evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.classes.Erf(argument)
evaluate(x, mapping, component, index_values)
class ufl.classes.BesselFunction(name, classname, nu, argument)

Base class for all bessel functions

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.classes.BesselJ(nu, argument)
class ufl.classes.BesselY(nu, argument)
class ufl.classes.BesselI(nu, argument)
class ufl.classes.BesselK(nu, argument)
class ufl.classes.ReferenceValue(f)

Representation of the reference cell value of a form argument.

evaluate(x, mapping, component, index_values, derivatives=())

Get child from mapping and return the component asked for.

ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.classes.AbstractCell(topological_dimension, geometric_dimension)

Bases: object

Representation of an abstract finite element cell with only the dimensions known.

geometric_dimension()

Return the dimension of the space this cell is embedded in.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

topological_dimension()

Return the dimension of the topology of this cell.

class ufl.classes.Cell(cellname, geometric_dimension=None)

Representation of a named finite element cell with known structure.

cellname()

Return the cellname of the cell.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

num_edges()

The number of cell edges.

num_facet_edges()

The number of facet edges.

num_facets()

The number of cell facets.

num_vertices()

The number of cell vertices.

reconstruct(geometric_dimension=None)
class ufl.classes.TensorProductCell(*cells, **kwargs)
cellname()

Return the cellname of the cell.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

num_edges()

The number of cell edges.

num_facets()

The number of cell facets.

num_vertices()

The number of cell vertices.

reconstruct(geometric_dimension=None)
sub_cells()

Return list of cell factors.

class ufl.classes.FiniteElementBase(family, cell, degree, quad_scheme, value_shape, reference_value_shape)

Bases: object

Base class for all finite elements.

cell()

Return cell of finite element.

degree(component=None)

Return polynomial degree of finite element.

extract_component(i)

Recursively extract component index relative to a (simple) element and that element for given value component index.

extract_reference_component(i)

Recursively extract reference component index relative to a (simple) element and that element for given reference value component index.

extract_subelement_component(i)

Extract direct subelement index and subelement relative component index for a given component index.

extract_subelement_reference_component(i)

Extract direct subelement index and subelement relative reference component index for a given reference component index.

family()

Return finite element family.

is_cellwise_constant(component=None)

Return whether the basis functions of this element is spatially constant over each cell.

mapping()

Not implemented.

num_sub_elements()

Return number of sub-elements.

quadrature_scheme()

Return quadrature scheme of finite element.

reference_value_shape()

Return the shape of the value space on the reference cell.

reference_value_size()

Return the integer product of the reference value shape.

sub_elements()

Return list of sub-elements.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

value_shape()

Return the shape of the value space on the global domain.

value_size()

Return the integer product of the value shape.

class ufl.classes.FiniteElement(family, cell=None, degree=None, form_degree=None, quad_scheme=None, variant=None)

The basic finite element class for all simple finite elements.

mapping()
reconstruct(family=None, cell=None, degree=None)

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

shortstr()

Format as string for pretty printing.

sobolev_space()

Return the underlying Sobolev space.

variant()
class ufl.classes.MixedElement(*elements, **kwargs)

A finite element composed of a nested hierarchy of mixed or simple elements.

degree(component=None)

Return polynomial degree of finite element.

extract_component(i)

Recursively extract component index relative to a (simple) element and that element for given value component index.

extract_reference_component(i)

Recursively extract reference_component index relative to a (simple) element and that element for given value reference_component index.

extract_subelement_component(i)

Extract direct subelement index and subelement relative component index for a given component index.

extract_subelement_reference_component(i)

Extract direct subelement index and subelement relative reference_component index for a given reference_component index.

is_cellwise_constant(component=None)

Return whether the basis functions of this element is spatially constant over each cell.

mapping()
num_sub_elements()

Return number of sub elements.

reconstruct(**kwargs)
reconstruct_from_elements(*elements)

Reconstruct a mixed element from new subelements.

shortstr()

Format as string for pretty printing.

sub_elements()

Return list of sub elements.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

class ufl.classes.VectorElement(family, cell=None, degree=None, dim=None, form_degree=None, quad_scheme=None)

A special case of a mixed finite element where all elements are equal.

reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

class ufl.classes.TensorElement(family, cell=None, degree=None, shape=None, symmetry=None, quad_scheme=None)

A special case of a mixed finite element where all elements are equal.

extract_subelement_component(i)

Extract direct subelement index and subelement relative component index for a given component index.

flattened_sub_element_mapping()
mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

class ufl.classes.EnrichedElement(*elements)

The vector sum of several finite element spaces:

$\textrm{EnrichedElement}(V, Q) = \{v + q | v \in V, q \in Q\}.$

Dual basis is a concatenation of subelements dual bases; primal basis is a concatenation of subelements primal bases; resulting element is not nodal even when subelements are. Structured basis may be exploited in form compilers.

is_cellwise_constant()

Return whether the basis functions of this element is spatially constant over each cell.

shortstr()

Format as string for pretty printing.

class ufl.classes.NodalEnrichedElement(*elements)

The vector sum of several finite element spaces:

$\textrm{EnrichedElement}(V, Q) = \{v + q | v \in V, q \in Q\}.$

Primal basis is reorthogonalized to dual basis which is a concatenation of subelements dual bases; resulting element is nodal.

is_cellwise_constant()

Return whether the basis functions of this element is spatially constant over each cell.

shortstr()

Format as string for pretty printing.

class ufl.classes.RestrictedElement(element, restriction_domain)

Represents the restriction of a finite element to a type of cell entity.

is_cellwise_constant()

Return whether the basis functions of this element is spatially constant over each cell.

mapping()
num_restricted_sub_elements()

Return number of restricted sub elements.

num_sub_elements()

Return number of sub elements.

reconstruct(**kwargs)
restricted_sub_elements()

Return list of restricted sub elements.

restriction_domain()

Return the domain onto which the element is restricted.

shortstr()

Format as string for pretty printing.

sub_element()

Return the element which is restricted.

sub_elements()

Return list of sub elements.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

class ufl.classes.TensorProductElement(*elements, **kwargs)

The tensor product of $$d$$ element spaces:

$V = V_1 \otimes V_2 \otimes ... \otimes V_d$

Given bases $$\{\phi_{j_i}\}$$ of the spaces $$V_i$$ for $$i = 1, ...., d$$, $$\{ \phi_{j_1} \otimes \phi_{j_2} \otimes \cdots \otimes \phi_{j_d} \}$$ forms a basis for $$V$$.

mapping()
num_sub_elements()

Return number of subelements.

reconstruct(cell=None)
shortstr()

Short pretty-print.

sobolev_space()

Return the underlying Sobolev space of the TensorProductElement.

sub_elements()

Return subelements (factors).

class ufl.classes.HDivElement(element)

A div-conforming version of an outer product element, assuming this makes mathematical sense.

mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

sobolev_space()

Return the underlying Sobolev space.

class ufl.classes.HCurlElement(element)

A curl-conforming version of an outer product element, assuming this makes mathematical sense.

mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

sobolev_space()

Return the underlying Sobolev space.

class ufl.classes.BrokenElement(element)

The discontinuous version of an existing Finite Element space.

mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

ufl.classes.FacetElement(element)

Constructs the restriction of a finite element to the facets of the cell.

ufl.classes.InteriorElement(element)

Constructs the restriction of a finite element to the interior of the cell.

class ufl.classes.AbstractDomain(topological_dimension, geometric_dimension)

Bases: object

Symbolic representation of a geometric domain with only a geometric and topological dimension.

geometric_dimension()

Return the dimension of the space this domain is embedded in.

topological_dimension()

Return the dimension of the topology of this domain.

class ufl.classes.Mesh(coordinate_element, ufl_id=None, cargo=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cargo()

Return carried object that will not be used by UFL.

ufl_cell()
ufl_coordinate_element()
ufl_id()

Return the ufl_id of this object.

class ufl.classes.MeshView(mesh, topological_dimension, ufl_id=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cell()
ufl_id()

Return the ufl_id of this object.

ufl_mesh()
class ufl.classes.TensorProductMesh(meshes, ufl_id=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cell()
ufl_coordinate_element()
ufl_id()

Return the ufl_id of this object.

class ufl.classes.AbstractFunctionSpace

Bases: object

ufl_sub_spaces()
class ufl.classes.FunctionSpace(domain, element)
ufl_domain()

Return ufl domain.

ufl_domains()

Return ufl domains.

ufl_element()

Return ufl element.

ufl_sub_spaces()

Return ufl sub spaces.

class ufl.classes.MixedFunctionSpace(*function_spaces)
ufl_domain()

Return ufl domain.

ufl_domains()

Return ufl domains.

ufl_element()

Return ufl element.

ufl_sub_spaces()

Return ufl sub spaces.

class ufl.classes.TensorProductFunctionSpace(*function_spaces)
ufl_sub_spaces()
class ufl.classes.IndexBase

Bases: object

Base class for all indices.

class ufl.classes.FixedIndex(value)

UFL value: An index with a specific value assigned.

class ufl.classes.Index(count=None)

UFL value: An index with no value assigned.

Used to represent free indices in Einstein indexing notation.

count()
ufl.classes.TestFunction(function_space, part=None)

UFL value: Create a test function argument to a form.

ufl.classes.TrialFunction(function_space, part=None)

UFL value: Create a trial function argument to a form.

ufl.classes.TestFunctions(function_space)

UFL value: Create a TestFunction in a mixed space, and return a tuple with the function components corresponding to the subelements.

ufl.classes.TrialFunctions(function_space)

UFL value: Create a TrialFunction in a mixed space, and return a tuple with the function components corresponding to the subelements.

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

Bases: object

integral_type()

Return the domain type.

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

metadata()

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)

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()

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()

Return the domain id of this measure (integer).

ufl_domain()

Return the domain associated with this measure.

This may be None or a Domain object.

class ufl.classes.MeasureSum(*measures)

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.MeasureProduct(*measures)

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()

Return submeasures.

class ufl.classes.Integral(integrand, integral_type, domain, subdomain_id, metadata, subdomain_data)

Bases: object

An integral over a single domain.

integral_type()

Return the domain type of this integral.

integrand()

Return the integrand expression, which is an Expr instance.

metadata()

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)

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

Example:
subdomain_data()

Return the domain data of this integral.

subdomain_id()

Return the subdomain id of this integral.

ufl_domain()

Return the integration domain of this integral.

class ufl.classes.Form(integrals)

Bases: object

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

arguments()

Return all Argument objects found in form.

coefficient_numbering()

Return a contiguous numbering of coefficients in a mapping {coefficient:number}.

coefficients()

Return all Coefficient objects found in form.

domain_numbering()

Return a contiguous numbering of domains in a mapping {domain:number}.

empty()

Returns whether the form has no integrals.

equals(other)

Evaluate bool(lhs_form == rhs_form).

geometric_dimension()

Return the geometric dimension shared by all domains and functions in this form.

integrals()

Return a sequence of all integrals in form.

integrals_by_type(integral_type)

Return a sequence of all integrals with a particular domain type.

max_subdomain_ids()

Returns a mapping on the form {domain:{integral_type:max_subdomain_id}}.

signature()

Signature for use with jit cache (independent of incidental numbering of indices etc.)

subdomain_data()

Returns a mapping on the form {domain:{integral_type: subdomain_data}}.

ufl_cell()

Return the single cell this form is defined on, fails if multiple cells are found.

ufl_domain()

Return the single geometric integration domain occuring in the form.

Fails if multiple domains are found.

NB! This does not include domains of coefficients defined on other meshes, look at form data for that additional information.

ufl_domains()

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.

x_repr_latex_()
x_repr_png_()
class ufl.classes.Equation(lhs, rhs)

Bases: object

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.coefficient module¶

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

class ufl.coefficient.Coefficient(function_space, count=None)

UFL form argument type: Representation of a form coefficient.

count()
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

ufl_domain()

Shortcut to get the domain of the function space of this coefficient.

ufl_domains()

Return tuple of domains related to this terminal object.

ufl_element()

Shortcut to get the finite element of the function space of this coefficient.

ufl_function_space()

Get the function space of this coefficient.

ufl_shape

Return the associated UFL shape.

ufl.coefficient.Coefficients(function_space)

UFL value: Create a Coefficient in a mixed space, and return a tuple with the function components corresponding to the subelements.

ufl.coefficient.Constant(domain, count=None)

UFL value: Represents a globally constant scalar valued coefficient.

ufl.coefficient.TensorConstant(domain, shape=None, symmetry=None, count=None)

UFL value: Represents a globally constant tensor valued coefficient.

ufl.coefficient.VectorConstant(domain, dim=None, count=None)

UFL value: Represents a globally constant vector valued coefficient.

## ufl.compound_expressions module¶

Functions implementing compound expressions as equivalent representations using basic operators.

ufl.compound_expressions.adj_expr(A)
ufl.compound_expressions.adj_expr_2x2(A)
ufl.compound_expressions.adj_expr_3x3(A)
ufl.compound_expressions.adj_expr_4x4(A)
ufl.compound_expressions.codeterminant_expr_nxn(A, rows, cols)
ufl.compound_expressions.cofactor_expr(A)
ufl.compound_expressions.cofactor_expr_2x2(A)
ufl.compound_expressions.cofactor_expr_3x3(A)
ufl.compound_expressions.cofactor_expr_4x4(A)
ufl.compound_expressions.cross_expr(a, b)
ufl.compound_expressions.determinant_expr(A)

Compute the (pseudo-)determinant of A.

ufl.compound_expressions.determinant_expr_2x2(B)
ufl.compound_expressions.determinant_expr_3x3(A)
ufl.compound_expressions.deviatoric_expr(A)
ufl.compound_expressions.deviatoric_expr_2x2(A)
ufl.compound_expressions.deviatoric_expr_3x3(A)
ufl.compound_expressions.generic_pseudo_determinant_expr(A)

Compute the pseudo-determinant of A: sqrt(det(A.T*A)).

ufl.compound_expressions.generic_pseudo_inverse_expr(A)

Compute the Penrose-Moore pseudo-inverse of A: (A.T*A)^-1 * A.T.

ufl.compound_expressions.inverse_expr(A)

Compute the inverse of A.

ufl.compound_expressions.old_determinant_expr_3x3(A)
ufl.compound_expressions.pseudo_determinant_expr(A)

Compute the pseudo-determinant of A.

ufl.compound_expressions.pseudo_inverse_expr(A)

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)
evaluate(x, mapping, component, index_values)
class ufl.conditional.BinaryCondition(name, left, right)
class ufl.conditional.Condition(operands)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.conditional.Conditional(condition, true_value, false_value)
evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.conditional.EQ(left, right)
evaluate(x, mapping, component, index_values)
class ufl.conditional.GE(left, right)
evaluate(x, mapping, component, index_values)
class ufl.conditional.GT(left, right)
evaluate(x, mapping, component, index_values)
class ufl.conditional.LE(left, right)
evaluate(x, mapping, component, index_values)
class ufl.conditional.LT(left, right)
evaluate(x, mapping, component, index_values)
class ufl.conditional.MaxValue(left, right)

UFL operator: Take the maximum of two values.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.conditional.MinValue(left, right)

UFL operator: Take the minimum of two values.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.conditional.NE(left, right)
evaluate(x, mapping, component, index_values)
class ufl.conditional.NotCondition(condition)
evaluate(x, mapping, component, index_values)
class ufl.conditional.OrCondition(left, right)
evaluate(x, mapping, component, index_values)

## ufl.constantvalue module¶

This module defines classes representing constant values.

class ufl.constantvalue.ConstantValue
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

ufl_domains()

Return tuple of domains related to this terminal object.

class ufl.constantvalue.FloatValue(value)

UFL literal type: Representation of a constant scalar floating point value.

class ufl.constantvalue.Identity(dim)

UFL literal type: Representation of an identity matrix.

evaluate(x, mapping, component, index_values)

Evaluates the identity matrix on the given components.

ufl_shape
class ufl.constantvalue.IntValue(value)

UFL literal type: Representation of a constant scalar integer value.

class ufl.constantvalue.PermutationSymbol(dim)

UFL literal type: 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)

Evaluates the permutation symbol.

ufl_shape
class ufl.constantvalue.ScalarValue(value)

A constant scalar value.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
value()
class ufl.constantvalue.Zero(shape=(), free_indices=(), index_dimensions=None)

UFL literal type: Representation of a zero valued expression.

evaluate(x, mapping, component, index_values)
ufl_free_indices
ufl_index_dimensions
ufl_shape
ufl.constantvalue.as_ufl(expression)

Converts expression to an Expr if possible.

ufl.constantvalue.format_float(x)

Format float value based on global UFL precision.

ufl.constantvalue.zero(*shape)

UFL literal constant: Return a zero tensor with the given shape.

## ufl.differentiation module¶

Differential operators.

class ufl.differentiation.CoefficientDerivative(integrand, coefficients, arguments, coefficient_derivatives)

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

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.CompoundDerivative(operands)

Base class for all compound derivative types.

class ufl.differentiation.Curl(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.Derivative(operands)

Base class for all derivative types.

class ufl.differentiation.Div(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.Grad(f)
evaluate(x, mapping, component, index_values, derivatives=())

Get child from mapping and return the component asked for.

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.NablaDiv(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.NablaGrad(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.ReferenceCurl(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.ReferenceDiv(f)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.ReferenceGrad(f)
evaluate(x, mapping, component, index_values, derivatives=())

Get child from mapping and return the component asked for.

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.differentiation.VariableDerivative(f, v)
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)

Bases: object

Symbolic representation of a geometric domain with only a geometric and topological dimension.

geometric_dimension()

Return the dimension of the space this domain is embedded in.

topological_dimension()

Return the dimension of the topology of this domain.

class ufl.domain.Mesh(coordinate_element, ufl_id=None, cargo=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cargo()

Return carried object that will not be used by UFL.

ufl_cell()
ufl_coordinate_element()
ufl_id()

Return the ufl_id of this object.

class ufl.domain.MeshView(mesh, topological_dimension, ufl_id=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cell()
ufl_id()

Return the ufl_id of this object.

ufl_mesh()
class ufl.domain.TensorProductMesh(meshes, ufl_id=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cell()
ufl_coordinate_element()
ufl_id()

Return the ufl_id of this object.

ufl.domain.affine_mesh(cell, ufl_id=None)

Create a Mesh over a given cell type with an affine geometric parameterization.

ufl.domain.as_domain(domain)

Convert any valid object to an AbstractDomain type.

ufl.domain.default_domain(cell)

Create a singular default Mesh from a cell, always returning the same Mesh object for the same cell.

ufl.domain.extract_domains(expr)

Return all domains expression is defined on.

ufl.domain.extract_unique_domain(expr)

Return the single unique domain expression is defined on or throw an error.

ufl.domain.find_geometric_dimension(expr)

Find the geometric dimension of an expression.

ufl.domain.join_domains(domains)

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)

Sort domains in a canonical ordering.

## ufl.equation module¶

The Equation class, used to express equations like a == L.

class ufl.equation.Equation(lhs, rhs)

Bases: object

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)

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

free_indices()
index_dimensions()
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.exprcontainers.ExprMapping(*operands)

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

free_indices()
index_dimensions()
ufl_domains()
ufl_free_indices
ufl_index_dimensions
ufl_shape

## ufl.exprequals module¶

ufl.exprequals.expr_equals(self, other)

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.exprequals.measure_collisions(equals_func)
ufl.exprequals.nonrecursive_expr_equals(self, other)

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.exprequals.print_collisions()
ufl.exprequals.recursive_expr_equals(self, other)

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¶

This module attaches special functions to Expr. This way we avoid circular dependencies between e.g. Sum and its superclass Expr.

ufl.exproperators.analyse_key(ii, rank)

Takes something the user might input as an index tuple inside [], which could include complete slices (:) and ellipsis (…), and returns tuples of actual UFL index objects.

The return value is a tuple (indices, axis_indices), each being a tuple of IndexBase instances.

The return value ‘indices’ corresponds to all input objects of these types: - Index - FixedIndex - int => Wrapped in FixedIndex

The return value ‘axis_indices’ corresponds to all input objects of these types: - Complete slice (:) => Replaced by a single new index - Ellipsis (…) => Replaced by multiple new indices

## ufl.form module¶

The Form class.

class ufl.form.Form(integrals)

Bases: object

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

arguments()

Return all Argument objects found in form.

coefficient_numbering()

Return a contiguous numbering of coefficients in a mapping {coefficient:number}.

coefficients()

Return all Coefficient objects found in form.

domain_numbering()

Return a contiguous numbering of domains in a mapping {domain:number}.

empty()

Returns whether the form has no integrals.

equals(other)

Evaluate bool(lhs_form == rhs_form).

geometric_dimension()

Return the geometric dimension shared by all domains and functions in this form.

integrals()

Return a sequence of all integrals in form.

integrals_by_type(integral_type)

Return a sequence of all integrals with a particular domain type.

max_subdomain_ids()

Returns a mapping on the form {domain:{integral_type:max_subdomain_id}}.

signature()

Signature for use with jit cache (independent of incidental numbering of indices etc.)

subdomain_data()

Returns a mapping on the form {domain:{integral_type: subdomain_data}}.

ufl_cell()

Return the single cell this form is defined on, fails if multiple cells are found.

ufl_domain()

Return the single geometric integration domain occuring in the form.

Fails if multiple domains are found.

NB! This does not include domains of coefficients defined on other meshes, look at form data for that additional information.

ufl_domains()

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.

x_repr_latex_()
x_repr_png_()
ufl.form.as_form(form)

Convert to form if not a form, otherwise return form.

ufl.form.replace_integral_domains(form, common_domain)

Given a form and a domain, assign a common integration domain to all integrals.

Does not modify the input form (Form should always be immutable). This is to support ill formed forms with no domain specified, sometimes occurring in pydolfin, e.g. assemble(1*dx, mesh=mesh).

## ufl.formoperators module¶

Various high level ways to transform a complete Form into a new Form.

ufl.formoperators.action(form, coefficient=None)

UFL form operator: 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.

ufl.formoperators.adjoint(form, reordered_arguments=None)

UFL form operator: Given a combined bilinear form, compute the adjoint form by changing the ordering (count) of the test and trial functions.

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).

ufl.formoperators.block_split(form, ix, iy=0)

UFL form operator: Given a linear or bilinear form on a mixed space, extract the block correspoinding to the indices ix, iy.

Example:

ufl.formoperators.derivative(form, coefficient, argument=None, coefficient_derivatives=None)

UFL form operator: 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)

UFL form operator: Given a bilinear form a and a coefficient f, return the functional $$a(f,f)$$.

ufl.formoperators.functional(form)

UFL form operator: Extract the functional part of form.

ufl.formoperators.lhs(form)

UFL form operator: 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)

UFL form operator: 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)

UFL form operator: 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}0 = \frac{d}{dv}(Ax-b) = \frac{dA}{dv} x + A \frac{dx}{dv} - \frac{db}{dv},\\A \frac{dx}{dv} = \frac{db}{dv} - \frac{dA}{dv} x,\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)
ufl.formoperators.system(form)

UFL form operator: Split a form into the left hand side and right hand side, see lhs and rhs.

ufl.formoperators.zero_lists(shape)

## ufl.functionspace module¶

Types for representing function spaces.

class ufl.functionspace.AbstractFunctionSpace

Bases: object

ufl_sub_spaces()
class ufl.functionspace.FunctionSpace(domain, element)
ufl_domain()

Return ufl domain.

ufl_domains()

Return ufl domains.

ufl_element()

Return ufl element.

ufl_sub_spaces()

Return ufl sub spaces.

class ufl.functionspace.MixedFunctionSpace(*function_spaces)
ufl_domain()

Return ufl domain.

ufl_domains()

Return ufl domains.

ufl_element()

Return ufl element.

ufl_sub_spaces()

Return ufl sub spaces.

class ufl.functionspace.TensorProductFunctionSpace(*function_spaces)
ufl_sub_spaces()

## ufl.geometry module¶

Types for representing symbolic expressions for geometric quantities.

class ufl.geometry.CellCoordinate(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'X'
ufl_shape
class ufl.geometry.CellDiameter(domain)

UFL geometry representation: The diameter of the cell, i.e., maximal distance of two points in the cell.

name = 'diameter'
class ufl.geometry.CellEdgeVectors(domain)

UFL geometry representation: The vectors between physical cell vertices for each edge in cell.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CEV'
ufl_shape
class ufl.geometry.CellFacetJacobian(domain)

UFL geometry representation: The Jacobian of the mapping from reference facet to reference cell coordinates.

CFJ_ij = dX_i/dXf_j

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CFJ'
ufl_shape
class ufl.geometry.CellFacetJacobianDeterminant(domain)

UFL geometry representation: The pseudo-determinant of the CellFacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'detCFJ'
class ufl.geometry.CellFacetJacobianInverse(domain)

UFL geometry representation: The pseudo-inverse of the CellFacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CFK'
ufl_shape
class ufl.geometry.CellFacetOrigin(domain)

UFL geometry representation: The reference cell coordinate corresponding to origin of a reference facet.

name = 'X0f'
ufl_shape
class ufl.geometry.CellNormal(domain)

UFL geometry representation: The upwards pointing normal vector of the current manifold cell.

name = 'cell_normal'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.CellOrientation(domain)

UFL geometry representation: 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)

UFL geometry representation: The spatial coordinate corresponding to origin of a reference cell.

is_cellwise_constant()
name = 'x0'
ufl_shape
class ufl.geometry.CellVertices(domain)

UFL geometry representation: Physical cell vertices.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'CV'
ufl_shape
class ufl.geometry.CellVolume(domain)

UFL geometry representation: The volume of the cell.

name = 'volume'
class ufl.geometry.Circumradius(domain)

UFL geometry representation: The circumradius of the cell.

name = 'circumradius'
class ufl.geometry.FacetArea(domain)

UFL geometry representation: The area of the facet.

name = 'facetarea'
class ufl.geometry.FacetCoordinate(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'Xf'
ufl_shape
class ufl.geometry.FacetEdgeVectors(domain)

UFL geometry representation: The vectors between physical cell vertices for each edge in current facet.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'FEV'
ufl_shape
class ufl.geometry.FacetJacobian(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'FJ'
ufl_shape
class ufl.geometry.FacetJacobianDeterminant(domain)

UFL geometry representation: The pseudo-determinant of the FacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'detFJ'
class ufl.geometry.FacetJacobianInverse(domain)

UFL geometry representation: The pseudo-inverse of the FacetJacobian.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'FK'
ufl_shape
class ufl.geometry.FacetNormal(domain)

UFL geometry representation: The outwards pointing normal vector of the current facet.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'n'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.FacetOrientation(domain)

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

name = 'facet_orientation'
class ufl.geometry.FacetOrigin(domain)

UFL geometry representation: The spatial coordinate corresponding to origin of a reference facet.

name = 'x0f'
ufl_shape
class ufl.geometry.GeometricCellQuantity(domain)
class ufl.geometry.GeometricFacetQuantity(domain)
class ufl.geometry.GeometricQuantity(domain)
is_cellwise_constant()

Return whether this expression is spatially constant over each cell (or over each facet for facet quantities).

ufl_domains()
ufl_shape = ()
class ufl.geometry.Jacobian(domain)

UFL geometry representation: The Jacobian of the mapping from reference cell to spatial coordinates.

$J_{ij} = \frac{dx_i}{dX_j}$
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'J'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.JacobianDeterminant(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'detJ'
class ufl.geometry.JacobianInverse(domain)

UFL geometry representation: The inverse of the Jacobian.

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

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'K'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.geometry.MaxCellEdgeLength(domain)

UFL geometry representation: The maximum edge length of the cell.

name = 'maxcelledgelength'
class ufl.geometry.MaxFacetEdgeLength(domain)

UFL geometry representation: The maximum edge length of the facet.

name = 'maxfacetedgelength'
class ufl.geometry.MinCellEdgeLength(domain)

UFL geometry representation: The minimum edge length of the cell.

name = 'mincelledgelength'
class ufl.geometry.MinFacetEdgeLength(domain)

UFL geometry representation: The minimum edge length of the facet.

name = 'minfacetedgelength'
class ufl.geometry.QuadratureWeight(domain)

UFL geometry representation: The current quadrature weight.

Only used inside a quadrature context.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'weight'
class ufl.geometry.ReferenceCellEdgeVectors(domain)

UFL geometry representation: The vectors between reference cell vertices for each edge in cell.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'RCEV'
ufl_shape
class ufl.geometry.ReferenceCellVolume(domain)

UFL geometry representation: The volume of the reference cell.

name = 'reference_cell_volume'
class ufl.geometry.ReferenceFacetEdgeVectors(domain)

UFL geometry representation: The vectors between reference cell vertices for each edge in current facet.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'RFEV'
ufl_shape
class ufl.geometry.ReferenceFacetVolume(domain)

UFL geometry representation: The volume of the reference cell of the current facet.

name = 'reference_facet_volume'
class ufl.geometry.ReferenceNormal(domain)

UFL geometry representation: The outwards pointing normal vector of the current facet on the reference cell

name = 'reference_normal'
ufl_shape
class ufl.geometry.SpatialCoordinate(domain)

UFL geometry representation: 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.

evaluate(x, mapping, component, index_values)

Return the value of the coordinate.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'x'
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)
ufl.index_combination_utils.merge_nonoverlapping_indices(a, b)

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)

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)

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)
ufl.index_combination_utils.unique_sorted_indices(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)
evaluate(x, mapping, component, index_values, derivatives=())
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()

## ufl.indexsum module¶

This module defines the IndexSum class.

class ufl.indexsum.IndexSum(summand, index)
dimension()
evaluate(x, mapping, component, index_values)
index()
ufl_free_indices
ufl_index_dimensions
ufl_shape

## ufl.integral module¶

The Integral class.

class ufl.integral.Integral(integrand, integral_type, domain, subdomain_id, metadata, subdomain_data)

Bases: object

An integral over a single domain.

integral_type()

Return the domain type of this integral.

integrand()

Return the integrand expression, which is an Expr instance.

metadata()

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)

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

Example:
subdomain_data()

Return the domain data of this integral.

subdomain_id()

Return the subdomain id of this integral.

ufl_domain()

Return the integration domain of this integral.

## ufl.log module¶

This module provides functions used by the UFL implementation to output messages. These may be redirected by the user of UFL.

class ufl.log.Logger(name, exception_type=<class 'Exception'>)

Bases: object

add_indent(increment=1)

add_logfile(filename=None, mode='a', level=10)

begin(*message)

Begin task: write message and increase indentation level.

debug(*message)

Write debug message.

deprecate(*message)

Write deprecation message.

end()

End task: write a newline and decrease indentation level.

error(*message)

Write error message and raise an exception.

get_handler()

Get handler for logging.

get_logfile_handler(filename)

Gets the handler to the file identified by the given file name.

get_logger()

Return message logger.

info(*message)

Write info message.

info_blue(*message)

Write info message in blue.

info_green(*message)

Write info message in green.

info_red(*message)

Write info message in red.

log(level, *message)

Write a log message on given log level.

pop_level()

Pop log level from the level stack, reverting to before the last push_level.

push_level(level)

Push a log level on the level stack.

set_handler(handler)

Replace handler for logging. To add additional handlers instead of replacing the existing one, use log.get_logger().addHandler(myhandler). See the logging module for more details.

set_indent(level)

Set indentation level.

set_level(level)

Set log level.

set_prefix(prefix)

Set prefix for log messages.

warning(*message)

Write warning message.

warning_blue(*message)

Write warning message in blue.

warning_green(*message)

Write warning message in green.

warning_red(*message)

Write warning message in red.

## ufl.mathfunctions module¶

This module provides basic mathematical functions.

class ufl.mathfunctions.Acos(argument)
class ufl.mathfunctions.Asin(argument)
class ufl.mathfunctions.Atan(argument)
class ufl.mathfunctions.Atan2(arg1, arg2)
evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.mathfunctions.BesselFunction(name, classname, nu, argument)

Base class for all bessel functions

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.mathfunctions.BesselI(nu, argument)
class ufl.mathfunctions.BesselJ(nu, argument)
class ufl.mathfunctions.BesselK(nu, argument)
class ufl.mathfunctions.BesselY(nu, argument)
class ufl.mathfunctions.Cos(argument)
class ufl.mathfunctions.Cosh(argument)
class ufl.mathfunctions.Erf(argument)
evaluate(x, mapping, component, index_values)
class ufl.mathfunctions.Exp(argument)
class ufl.mathfunctions.Ln(argument)
evaluate(x, mapping, component, index_values)
class ufl.mathfunctions.MathFunction(name, argument)

Base class for all unary scalar math functions.

evaluate(x, mapping, component, index_values)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.mathfunctions.Sin(argument)
class ufl.mathfunctions.Sinh(argument)
class ufl.mathfunctions.Sqrt(argument)
class ufl.mathfunctions.Tan(argument)
class ufl.mathfunctions.Tanh(argument)

## ufl.measure module¶

The Measure class.

class ufl.measure.Measure(integral_type, domain=None, subdomain_id='everywhere', metadata=None, subdomain_data=None)

Bases: object

integral_type()

Return the domain type.

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

metadata()

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)

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()

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()

Return the domain id of this measure (integer).

ufl_domain()

Return the domain associated with this measure.

This may be None or a Domain object.

class ufl.measure.MeasureProduct(*measures)

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()

Return submeasures.

class ufl.measure.MeasureSum(*measures)

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)

Map short name to long name and require a valid one.

ufl.measure.integral_types()

Return a tuple of all domain type strings.

ufl.measure.measure_names()

Return a tuple of all measure name strings.

ufl.measure.register_integral_type(integral_type, measure_name)

## ufl.objects module¶

Utility objects for pretty syntax in user code.

## ufl.operators module¶

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)

UFL operator: A boolean expression (left and right) for use with conditional.

ufl.operators.Dn(f)

UFL operator: Take the directional derivative of f in the facet normal direction, Dn(f) := dot(grad(f), n).

ufl.operators.Dt(f)

UFL operator: <Not implemented yet!> The partial derivative of f with respect to time.

ufl.operators.Dx(f, *i)

UFL operator: Take the partial derivative of f with respect to spatial variable number i. Equivalent to f.dx(*i).

ufl.operators.Max(x, y)

UFL operator: Take the maximum of x and y.

ufl.operators.Min(x, y)

UFL operator: Take the minimum of x and y.

ufl.operators.Not(condition)

UFL operator: A boolean expression (not condition) for use with conditional.

ufl.operators.Or(left, right)

UFL operator: A boolean expression (left or right) for use with conditional.

ufl.operators.acos(f)

UFL operator: Take the inverse cosine of f.

ufl.operators.asin(f)

UFL operator: Take the inverse sine of f.

ufl.operators.atan(f)

UFL operator: Take the inverse tangent of f.

ufl.operators.atan_2(f1, f2)

UFL operator: Take the inverse tangent with two the arguments f1 and f2.

ufl.operators.avg(v)

UFL operator: Take the average of v across a facet.

ufl.operators.bessel_I(nu, f)

UFL operator: regular modified cylindrical Bessel function.

ufl.operators.bessel_J(nu, f)

UFL operator: cylindrical Bessel function of the first kind.

ufl.operators.bessel_K(nu, f)

UFL operator: irregular modified cylindrical Bessel function.

ufl.operators.bessel_Y(nu, f)

UFL operator: cylindrical Bessel function of the second kind.

ufl.operators.cell_avg(f)

UFL operator: Take the average of v over a cell.

ufl.operators.cofac(A)

UFL operator: Take the cofactor of A.

ufl.operators.conditional(condition, true_value, false_value)

UFL operator: A conditional expression, taking the value of true_value when condition evaluates to true and false_value otherwise.

ufl.operators.contraction(a, a_axes, b, b_axes)

UFL operator: Take the contraction of a and b over given axes.

ufl.operators.cos(f)

UFL operator: Take the cosine of f.

ufl.operators.cosh(f)

UFL operator: Take the hyperbolic cosine of f.

ufl.operators.cross(a, b)

UFL operator: Take the cross product of a and b.

ufl.operators.curl(f)

UFL operator: Take the curl of f.

ufl.operators.det(A)

UFL operator: Take the determinant of A.

ufl.operators.dev(A)

UFL operator: Take the deviatoric part of A.

ufl.operators.diag(A)

UFL operator: 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)

UFL operator: Take the diagonal part of rank 2 tensor A and return as a vector.

See also diag.

ufl.operators.diff(f, v)

UFL operator: Take the derivative of f with respect to the variable v.

If f is a form, diff is applied to each integrand.

ufl.operators.div(f)

UFL operator: Take the divergence of f.

This operator follows the div convention where

div(v) = v[i].dx(i)

div(T)[:] = T[:,i].dx(i)

for vector expressions v, and arbitrary rank tensor expressions T.

See also: nabla_div()

ufl.operators.dot(a, b)

UFL operator: Take the dot product of a and b.

ufl.operators.elem_div(A, B)

UFL operator: Take the elementwise division of tensors A and B with the same shape.

ufl.operators.elem_mult(A, B)

UFL operator: Take the elementwise multiplication of tensors A and B with the same shape.

ufl.operators.elem_op(op, *args)

UFL operator: Take the elementwise application of operator op on scalar values from one or more tensor arguments.

ufl.operators.elem_op_items(op_ind, indices, *args)
ufl.operators.elem_pow(A, B)

UFL operator: Take the elementwise power of tensors A and B with the same shape.

ufl.operators.eq(left, right)

UFL operator: A boolean expression (left == right) for use with conditional.

ufl.operators.erf(f)

UFL operator: Take the error function of f.

ufl.operators.exp(f)

UFL operator: Take the exponential of f.

ufl.operators.exterior_derivative(f)

UFL operator: Take the exterior derivative of f.

The exterior derivative uses the element family to determine whether id, grad, curl or div should be used.

Note that this uses the grad and div operators, as opposed to nabla_grad and nabla_div.

ufl.operators.facet_avg(f)

UFL operator: Take the average of v over a facet.

ufl.operators.ge(left, right)

UFL operator: A boolean expression (left >= right) for use with conditional.

ufl.operators.grad(f)

UFL operator: Take the gradient of f.

This operator follows the grad convention where

for scalar expressions s, vector expressions v, and arbitrary rank tensor expressions T.

See also: nabla_grad()

ufl.operators.gt(left, right)

UFL operator: A boolean expression (left > right) for use with conditional.

ufl.operators.inner(a, b)

UFL operator: Take the inner product of a and b.

ufl.operators.inv(A)

UFL operator: Take the inverse of A.

ufl.operators.jump(v, n=None)

UFL operator: Take the jump of v across a facet.

ufl.operators.le(left, right)

UFL operator: A boolean expression (left <= right) for use with conditional.

ufl.operators.ln(f)

UFL operator: Take the natural logarithm of f.

ufl.operators.lt(left, right)

UFL operator: A boolean expression (left < right) for use with conditional.

ufl.operators.max_value(x, y)

UFL operator: Take the maximum of x and y.

ufl.operators.min_value(x, y)

UFL operator: Take the minimum of x and y.

ufl.operators.nabla_div(f)

UFL operator: Take the divergence of f.

This operator follows the div convention where

nabla_div(v) = v[i].dx(i)

nabla_div(T)[:] = T[i,:].dx(i)

for vector expressions v, and arbitrary rank tensor expressions T.

See also: div()

ufl.operators.nabla_grad(f)

UFL operator: Take the gradient of f.

This operator follows the grad convention where

for scalar expressions s, vector expressions v, and arbitrary rank tensor expressions T.

See also: grad()

ufl.operators.ne(left, right)

UFL operator: A boolean expression (left != right) for use with conditional.

ufl.operators.outer(*operands)

UFL operator: Take the outer product of two or more operands.

ufl.operators.perp(v)

UFL operator: Take the perp of v, i.e. $$(-v_1, +v_0)$$.

ufl.operators.rank(f)

UFL operator: The rank of f.

ufl.operators.rot(f)

UFL operator: Take the curl of f.

ufl.operators.shape(f)

UFL operator: The shape of f.

ufl.operators.sign(x)

UFL operator: Take the sign (+1 or -1) of x.

ufl.operators.sin(f)

UFL operator: Take the sine of f.

ufl.operators.sinh(f)

UFL operator: Take the hyperbolic sine of f.

ufl.operators.skew(A)

UFL operator: Take the skew symmetric part of A.

ufl.operators.sqrt(f)

UFL operator: Take the square root of f.

ufl.operators.sym(A)

UFL operator: Take the symmetric part of A.

ufl.operators.tan(f)

UFL operator: Take the tangent of f.

ufl.operators.tanh(f)

UFL operator: Take the hyperbolic tangent of f.

ufl.operators.tr(A)

UFL operator: Take the trace of A.

ufl.operators.transpose(A)

UFL operator: Take the transposed of tensor A.

ufl.operators.variable(e)

UFL operator: Define a variable representing the given expression, see also diff().

## ufl.permutation module¶

This module provides utility functions for computing permutations and generating index lists.

ufl.permutation.build_component_numbering(shape, symmetry)

Build a numbering of components within the given value shape, taking 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)

Compute all index combinations for given shape

ufl.permutation.compute_indices2(shape)

Compute all index combinations for given shape

ufl.permutation.compute_order_tuples(k, n)

Compute all tuples of n integers such that the sum is k

ufl.permutation.compute_permutation_pairs(j, k)

Compute all permutations of j + k elements from (0, j + k) in rising order within (0, j) and (j, j + k) respectively.

ufl.permutation.compute_permutations(k, n, skip=None)

Compute all permutations of k elements from (0, n) in rising order. Any elements that are contained in the list skip are not included.

ufl.permutation.compute_sign(permutation)

Compute sign by sorting.

## ufl.precedence module¶

Precedence handling.

ufl.precedence.assign_precedences(precedence_list)

ufl.precedence.build_precedence_list()
ufl.precedence.build_precedence_mapping(precedence_list)

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'>)

## ufl.protocols module¶

ufl.protocols.id_or_none(obj)

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.protocols.metadata_equal(a, b)
ufl.protocols.metadata_hashdata(md)

## ufl.referencevalue module¶

Representation of the reference value of a function.

class ufl.referencevalue.ReferenceValue(f)

Representation of the reference cell value of a form argument.

evaluate(x, mapping, component, index_values, derivatives=())

Get child from mapping and return the component asked for.

ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape

## ufl.restriction module¶

Restriction operations.

class ufl.restriction.CellAvg(f)
evaluate(x, mapping, component, index_values)

Performs an approximate symbolic evaluation, since we dont have a cell.

ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.restriction.FacetAvg(f)
evaluate(x, mapping, component, index_values)

Performs an approximate symbolic evaluation, since we dont have a cell.

ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.restriction.NegativeRestricted(f)
class ufl.restriction.PositiveRestricted(f)
class ufl.restriction.Restricted(f)
evaluate(x, mapping, component, index_values)
side()
ufl_free_indices
ufl_index_dimensions
ufl_shape

## ufl.sobolevspace module¶

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)

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

class ufl.sobolevspace.SobolevSpace(name, parents=None)

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¶

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)

Replacement for cmp(a, b), removed in Python 3, for Expr objects.

ufl.sorting.sorted_expr(sequence)

Return a canonically sorted list of Expr objects in sequence.

ufl.sorting.sorted_expr_sum(seq)

## ufl.split_functions module¶

Algorithm for splitting a Coefficient or Argument into subfunctions.

ufl.split_functions.split(v)

UFL operator: 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)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.tensoralgebra.CompoundTensorOperator(operands)
class ufl.tensoralgebra.Cross(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape = (3,)
class ufl.tensoralgebra.Determinant(A)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape = ()
class ufl.tensoralgebra.Deviatoric(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.tensoralgebra.Dot(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.tensoralgebra.Inner(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.tensoralgebra.Inverse(A)
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape
class ufl.tensoralgebra.Outer(a, b)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.tensoralgebra.Skew(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.tensoralgebra.Sym(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.tensoralgebra.Trace(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape = ()
class ufl.tensoralgebra.Transposed(A)
ufl_free_indices
ufl_index_dimensions
ufl_shape

## ufl.tensors module¶

Classes used to group scalar expressions into expressions with rank > 0.

class ufl.tensors.ComponentTensor(expression, indices)

UFL operator type: Maps the free indices of a scalar valued expression to tensor axes.

evaluate(x, mapping, component, index_values)
indices()
ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.tensors.ListTensor(*expressions)

UFL operator type: Wraps a list of expressions into a tensor valued expression of one higher rank.

evaluate(x, mapping, component, index_values, derivatives=())
ufl_free_indices
ufl_index_dimensions
ufl_shape
ufl.tensors.as_matrix(expressions, indices=None)

UFL operator: As as_tensor(), but limited to rank 2 tensors.

ufl.tensors.as_scalar(expression)

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)

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)

UFL operator: 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)

UFL operator: As as_tensor(), but limited to rank 1 tensors.

ufl.tensors.dyad(d, *iota)

TODO: Develop this concept, can e.g. write A[i,j]*dyad(j,i) for the transpose.

ufl.tensors.from_numpy_to_lists(expressions)
ufl.tensors.numpy2nestedlists(arr)
ufl.tensors.relabel(A, indexmap)

UFL operator: Relabel free indices of $$A$$ with new indices, using the given mapping.

ufl.tensors.unit_indexed_tensor(shape, component)
ufl.tensors.unit_list(i, n)
ufl.tensors.unit_list2(i, j, n)
ufl.tensors.unit_matrices(d)

UFL value: A tuple of constant unit matrices in all directions with dimension d.

ufl.tensors.unit_matrix(i, j, d)

UFL value: A constant unit matrix in direction i,*j* with dimension d.

ufl.tensors.unit_vector(i, d)

UFL value: A constant unit vector in direction i with dimension d.

ufl.tensors.unit_vectors(d)

UFL value: A tuple of constant unit vectors in all directions with dimension d.

ufl.tensors.unwrap_list_tensor(lt)

## ufl.variable module¶

Defines the Variable and Label classes, used to label expressions as variables for differentiation.

class ufl.variable.Label(count=None)
count()
is_cellwise_constant()
ufl_domains()

Return tuple of domains related to this terminal object.

ufl_free_indices
ufl_index_dimensions
ufl_shape
class ufl.variable.Variable(expression, label=None)

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)
expression()
label()
ufl_domains()
ufl_free_indices = ()
ufl_index_dimensions = ()
ufl_shape

## Module contents¶

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:

from ufl import *

• To import the underlying classes an UFL expression tree is built from, type

from ufl.classes import *

• Various algorithms for working with UFL expression trees can be accessed by

from ufl.algorithms import *


Classes and algorithms are considered implementation details and should not be used in form definitions.

For more details on the language, see

and

The development version can be found in the repository at

A very brief overview of the language contents follows:

• Cells:

- AbstractCell
- Cell
- TensorProductCell
- vertex
- interval
- triangle
- tetrahedron
- hexahedron

• Domains:

- AbstractDomain
- Mesh
- MeshView
- TensorProductMesh

• Sobolev spaces:

- L2
- H1
- H2
- HDiv
- HCurl

• Elements:

- FiniteElement
- MixedElement
- VectorElement
- TensorElement
- EnrichedElement
- NodalEnrichedElement
- RestrictedElement
- TensorProductElement
- HDivElement
- HCurlElement
- BrokenElement
- FacetElement
- InteriorElement

• Function spaces:

- FunctionSpace

• 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
- 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,
- 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, atan_2
- cosh, sinh, tanh
- bessel_J, bessel_Y, bessel_I, bessel_K

• 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, replace_integral_domains
- action
- energy_norm,
- sensitivity_rhs
- derivative

ufl.product(sequence)

Return the product of all elements in a sequence.

exception ufl.UFLException

Bases: Exception

Base class for UFL exceptions.

ufl.as_cell(cell)

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.

class ufl.AbstractCell(topological_dimension, geometric_dimension)

Bases: object

Representation of an abstract finite element cell with only the dimensions known.

geometric_dimension()

Return the dimension of the space this cell is embedded in.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

topological_dimension()

Return the dimension of the topology of this cell.

class ufl.Cell(cellname, geometric_dimension=None)

Representation of a named finite element cell with known structure.

cellname()

Return the cellname of the cell.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

num_edges()

The number of cell edges.

num_facet_edges()

The number of facet edges.

num_facets()

The number of cell facets.

num_vertices()

The number of cell vertices.

reconstruct(geometric_dimension=None)
class ufl.TensorProductCell(*cells, **kwargs)
cellname()

Return the cellname of the cell.

has_simplex_facets()

Return True if all the facets of this cell are simplex cells.

is_simplex()

Return True if this is a simplex cell.

num_edges()

The number of cell edges.

num_facets()

The number of cell facets.

num_vertices()

The number of cell vertices.

reconstruct(geometric_dimension=None)
sub_cells()

Return list of cell factors.

ufl.as_domain(domain)

Convert any valid object to an AbstractDomain type.

class ufl.AbstractDomain(topological_dimension, geometric_dimension)

Bases: object

Symbolic representation of a geometric domain with only a geometric and topological dimension.

geometric_dimension()

Return the dimension of the space this domain is embedded in.

topological_dimension()

Return the dimension of the topology of this domain.

class ufl.Mesh(coordinate_element, ufl_id=None, cargo=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cargo()

Return carried object that will not be used by UFL.

ufl_cell()
ufl_coordinate_element()
ufl_id()

Return the ufl_id of this object.

class ufl.MeshView(mesh, topological_dimension, ufl_id=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cell()
ufl_id()

Return the ufl_id of this object.

ufl_mesh()
class ufl.TensorProductMesh(meshes, ufl_id=None)

Symbolic representation of a mesh.

is_piecewise_linear_simplex_domain()
ufl_cell()
ufl_coordinate_element()
ufl_id()

Return the ufl_id of this object.

class ufl.SpatialCoordinate(domain)

UFL geometry representation: 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.

evaluate(x, mapping, component, index_values)

Return the value of the coordinate.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'x'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.CellVolume(domain)

UFL geometry representation: The volume of the cell.

name = 'volume'
class ufl.CellDiameter(domain)

UFL geometry representation: The diameter of the cell, i.e., maximal distance of two points in the cell.

name = 'diameter'
class ufl.Circumradius(domain)

UFL geometry representation: The circumradius of the cell.

name = 'circumradius'
class ufl.MinCellEdgeLength(domain)

UFL geometry representation: The minimum edge length of the cell.

name = 'mincelledgelength'
class ufl.MaxCellEdgeLength(domain)

UFL geometry representation: The maximum edge length of the cell.

name = 'maxcelledgelength'
class ufl.FacetArea(domain)

UFL geometry representation: The area of the facet.

name = 'facetarea'
class ufl.MinFacetEdgeLength(domain)

UFL geometry representation: The minimum edge length of the facet.

name = 'minfacetedgelength'
class ufl.MaxFacetEdgeLength(domain)

UFL geometry representation: The maximum edge length of the facet.

name = 'maxfacetedgelength'
class ufl.FacetNormal(domain)

UFL geometry representation: The outwards pointing normal vector of the current facet.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'n'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.CellNormal(domain)

UFL geometry representation: The upwards pointing normal vector of the current manifold cell.

name = 'cell_normal'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.Jacobian(domain)

UFL geometry representation: The Jacobian of the mapping from reference cell to spatial coordinates.

$J_{ij} = \frac{dx_i}{dX_j}$
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'J'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.JacobianDeterminant(domain)

UFL geometry representation: 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()

Return whether this expression is spatially constant over each cell.

name = 'detJ'
class ufl.JacobianInverse(domain)

UFL geometry representation: The inverse of the Jacobian.

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

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

name = 'K'
ufl_shape

Return the number of coordinates defined (i.e. the geometric dimension of the domain).

class ufl.FiniteElementBase(family, cell, degree, quad_scheme, value_shape, reference_value_shape)

Bases: object

Base class for all finite elements.

cell()

Return cell of finite element.

degree(component=None)

Return polynomial degree of finite element.

extract_component(i)

Recursively extract component index relative to a (simple) element and that element for given value component index.

extract_reference_component(i)

Recursively extract reference component index relative to a (simple) element and that element for given reference value component index.

extract_subelement_component(i)

Extract direct subelement index and subelement relative component index for a given component index.

extract_subelement_reference_component(i)

Extract direct subelement index and subelement relative reference component index for a given reference component index.

family()

Return finite element family.

is_cellwise_constant(component=None)

Return whether the basis functions of this element is spatially constant over each cell.

mapping()

Not implemented.

num_sub_elements()

Return number of sub-elements.

quadrature_scheme()

Return quadrature scheme of finite element.

reference_value_shape()

Return the shape of the value space on the reference cell.

reference_value_size()

Return the integer product of the reference value shape.

sub_elements()

Return list of sub-elements.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

value_shape()

Return the shape of the value space on the global domain.

value_size()

Return the integer product of the value shape.

class ufl.FiniteElement(family, cell=None, degree=None, form_degree=None, quad_scheme=None, variant=None)

The basic finite element class for all simple finite elements.

mapping()
reconstruct(family=None, cell=None, degree=None)

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

shortstr()

Format as string for pretty printing.

sobolev_space()

Return the underlying Sobolev space.

variant()
class ufl.MixedElement(*elements, **kwargs)

A finite element composed of a nested hierarchy of mixed or simple elements.

degree(component=None)

Return polynomial degree of finite element.

extract_component(i)

Recursively extract component index relative to a (simple) element and that element for given value component index.

extract_reference_component(i)

Recursively extract reference_component index relative to a (simple) element and that element for given value reference_component index.

extract_subelement_component(i)

Extract direct subelement index and subelement relative component index for a given component index.

extract_subelement_reference_component(i)

Extract direct subelement index and subelement relative reference_component index for a given reference_component index.

is_cellwise_constant(component=None)

Return whether the basis functions of this element is spatially constant over each cell.

mapping()
num_sub_elements()

Return number of sub elements.

reconstruct(**kwargs)
reconstruct_from_elements(*elements)

Reconstruct a mixed element from new subelements.

shortstr()

Format as string for pretty printing.

sub_elements()

Return list of sub elements.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

class ufl.VectorElement(family, cell=None, degree=None, dim=None, form_degree=None, quad_scheme=None)

A special case of a mixed finite element where all elements are equal.

reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

class ufl.TensorElement(family, cell=None, degree=None, shape=None, symmetry=None, quad_scheme=None)

A special case of a mixed finite element where all elements are equal.

extract_subelement_component(i)

Extract direct subelement index and subelement relative component index for a given component index.

flattened_sub_element_mapping()
mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

class ufl.EnrichedElement(*elements)

The vector sum of several finite element spaces:

$\textrm{EnrichedElement}(V, Q) = \{v + q | v \in V, q \in Q\}.$

Dual basis is a concatenation of subelements dual bases; primal basis is a concatenation of subelements primal bases; resulting element is not nodal even when subelements are. Structured basis may be exploited in form compilers.

is_cellwise_constant()

Return whether the basis functions of this element is spatially constant over each cell.

shortstr()

Format as string for pretty printing.

class ufl.NodalEnrichedElement(*elements)

The vector sum of several finite element spaces:

$\textrm{EnrichedElement}(V, Q) = \{v + q | v \in V, q \in Q\}.$

Primal basis is reorthogonalized to dual basis which is a concatenation of subelements dual bases; resulting element is nodal.

is_cellwise_constant()

Return whether the basis functions of this element is spatially constant over each cell.

shortstr()

Format as string for pretty printing.

class ufl.RestrictedElement(element, restriction_domain)

Represents the restriction of a finite element to a type of cell entity.

is_cellwise_constant()

Return whether the basis functions of this element is spatially constant over each cell.

mapping()
num_restricted_sub_elements()

Return number of restricted sub elements.

num_sub_elements()

Return number of sub elements.

reconstruct(**kwargs)
restricted_sub_elements()

Return list of restricted sub elements.

restriction_domain()

Return the domain onto which the element is restricted.

shortstr()

Format as string for pretty printing.

sub_element()

Return the element which is restricted.

sub_elements()

Return list of sub elements.

symmetry()

Return the symmetry dict, which is a mapping $$c_0 \to c_1$$ meaning that component $$c_0$$ is represented by component $$c_1$$. A component is a tuple of one or more ints.

class ufl.TensorProductElement(*elements, **kwargs)

The tensor product of $$d$$ element spaces:

$V = V_1 \otimes V_2 \otimes ... \otimes V_d$

Given bases $$\{\phi_{j_i}\}$$ of the spaces $$V_i$$ for $$i = 1, ...., d$$, $$\{ \phi_{j_1} \otimes \phi_{j_2} \otimes \cdots \otimes \phi_{j_d} \}$$ forms a basis for $$V$$.

mapping()
num_sub_elements()

Return number of subelements.

reconstruct(cell=None)
shortstr()

Short pretty-print.

sobolev_space()

Return the underlying Sobolev space of the TensorProductElement.

sub_elements()

Return subelements (factors).

class ufl.HDivElement(element)

A div-conforming version of an outer product element, assuming this makes mathematical sense.

mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

sobolev_space()

Return the underlying Sobolev space.

class ufl.HCurlElement(element)

A curl-conforming version of an outer product element, assuming this makes mathematical sense.

mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

sobolev_space()

Return the underlying Sobolev space.

class ufl.BrokenElement(element)

The discontinuous version of an existing Finite Element space.

mapping()
reconstruct(**kwargs)
shortstr()

Format as string for pretty printing.

ufl.FacetElement(element)

Constructs the restriction of a finite element to the facets of the cell.

ufl.InteriorElement(element)

Constructs the restriction of a finite element to the interior of the cell.

ufl.register_element(family, short_name, value_rank, sobolev_space, mapping, degree_range, cellnames)

Register new finite element family.

ufl.show_elements()

Shows all registered elements.

class ufl.FunctionSpace(domain, element)
ufl_domain()

Return ufl domain.

ufl_domains()

Return ufl domains.

ufl_element()

Return ufl element.

ufl_sub_spaces()

Return ufl sub spaces.

class ufl.Argument(function_space, number, part=None)

UFL value: Representation of an argument to a form.

is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

number()

Return the Argument number.

part()
ufl_domain()

ufl_domains()

ufl_element()

ufl_function_space()

Get the function space of this Argument.

ufl_shape

Return the associated UFL shape.

ufl.TestFunction(function_space, part=None)

UFL value: Create a test function argument to a form.

ufl.TrialFunction(function_space, part=None)

UFL value: Create a trial function argument to a form.

ufl.Arguments(function_space, number)

UFL value: Create an Argument in a mixed space, and return a tuple with the function components corresponding to the subelements.

ufl.TestFunctions(function_space)

UFL value: Create a TestFunction in a mixed space, and return a tuple with the function components corresponding to the subelements.

ufl.TrialFunctions(function_space)

UFL value: Create a TrialFunction in a mixed space, and return a tuple with the function components corresponding to the subelements.

class ufl.Coefficient(function_space, count=None)

UFL form argument type: Representation of a form coefficient.

count()
is_cellwise_constant()

Return whether this expression is spatially constant over each cell.

ufl_domain()

Shortcut to get the domain of the function space of this coefficient.

ufl_domains()

Return tuple of domains related to this terminal object.

ufl_element()

Shortcut to get the finite element of the function space of this coefficient.

ufl_function_space()

Get the function space of this coefficient.

ufl_shape

Return the associated UFL shape.

ufl.Coefficients(function_space)

UFL value: Create a Coefficient in a mixed space, and return a tuple with the function components corresponding to the subelements.

ufl.Constant(domain, count=None)

UFL value: Represents a globally constant scalar valued coefficient.

ufl.VectorConstant(domain, dim=None, count=None)

UFL value: Represents a globally constant vector valued coefficient.

ufl.TensorConstant(domain, shape=None, symmetry=None, count=None)

UFL value: Represents a globally constant tensor valued coefficient.

ufl.split(v)

UFL operator: If v is a Coefficient or Argument in a mixed space, returns a tuple with the function components corresponding to the subelements.

class ufl.PermutationSymbol(dim)

UFL literal type: 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)

Evaluates the permutation symbol.

ufl_shape
class ufl.Identity(dim)

UFL literal type: Representation of an identity matrix.

evaluate(x, mapping, component, index_values)

Evaluates the identity matrix on the given components.

ufl_shape
ufl.zero(*shape)

UFL literal constant: Return a zero tensor with the given shape.

ufl.as_ufl(expression)

Converts expression to an Expr if possible.

class ufl.Index(count=None)

UFL value: An index with no value assigned.

Used to represent free indices in Einstein indexing notation.

count()
ufl.indices(n)

UFL value: Return a tuple of $$n$$ new Index objects.

ufl.as_tensor(expressions, indices=None)

UFL operator: 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_vector(expressions, index=None)

UFL operator: As as_tensor(), but limited to rank 1 tensors.

ufl.as_matrix(expressions, indices=None)

UFL operator: As as_tensor(), but limited to rank 2 tensors.

ufl.relabel(A, indexmap)

UFL operator: Relabel free indices of $$A$$ with new indices, using the given mapping.

ufl.unit_vector(i, d)

UFL value: A constant unit vector in direction i with dimension d.

ufl.unit_vectors(d)

UFL value: A tuple of constant unit vectors in all directions with dimension d.

ufl.unit_matrix(i, j, d)

UFL value: A constant unit matrix in direction i,*j* with dimension d.

ufl.unit_matrices(d)

UFL value: A tuple of constant unit matrices in all directions with dimension d.

ufl.rank(f)

UFL operator: The rank of f.

ufl.shape(f)

UFL operator: The shape of f.

ufl.outer(*operands)

UFL operator: Take the outer product of two or more operands.

ufl.inner(a, b)

UFL operator: Take the inner product of a and b.

ufl.dot(a, b)

UFL operator: Take the dot product of a and b.

ufl.cross(a, b)

UFL operator: Take the cross product of a and b.

ufl.perp(v)

UFL operator: Take the perp of v, i.e. $$(-v_1, +v_0)$$.

ufl.det(A)

UFL operator: Take the determinant of A.

ufl.inv(A)

UFL operator: Take the inverse of A.

ufl.cofac(A)

UFL operator: Take the cofactor of A.

ufl.transpose(A)

UFL operator: Take the transposed of tensor A.

ufl.tr(A)

UFL operator: Take the trace of A.

ufl.diag(A)

UFL operator: 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)

UFL operator: Take the diagonal part of rank 2 tensor A and return as a vector.

See also diag.

ufl.dev(A)

UFL operator: Take the deviatoric part of A.

ufl.skew(A)

UFL operator: Take the skew symmetric part of A.

ufl.sym(A)

UFL operator: Take the symmetric part of A.

ufl.sqrt(f)

UFL operator: Take the square root of f.

ufl.exp(f)

UFL operator: Take the exponential of f.

ufl.ln(f)

UFL operator: Take the natural logarithm of f.

ufl.erf(f)

UFL operator: Take the error function of f.

ufl.cos(f)

UFL operator: Take the cosine of f.

ufl.sin(f)

UFL operator: Take the sine of f.

ufl.tan(f)

UFL operator: Take the tangent of f.

ufl.acos(f)

UFL operator: Take the inverse cosine of f.

ufl.asin(f)

UFL operator: Take the inverse sine of f.

ufl.atan(f)

UFL operator: Take the inverse tangent of f.

ufl.atan_2(f1, f2)

UFL operator: Take the inverse tangent with two the arguments f1 and f2.

ufl.cosh(f)

UFL operator: Take the hyperbolic cosine of f.

ufl.sinh(f)

UFL operator: Take the hyperbolic sine of f.

ufl.tanh(f)

UFL operator: Take the hyperbolic tangent of f.

ufl.bessel_J(nu, f)

UFL operator: cylindrical Bessel function of the first kind.

ufl.bessel_Y(nu, f)

UFL operator: cylindrical Bessel function of the second kind.

ufl.bessel_I(nu, f)

UFL operator: regular modified cylindrical Bessel function.

ufl.bessel_K(nu, f)

UFL operator: irregular modified cylindrical Bessel function.

ufl.eq(left, right)

UFL operator: A boolean expression (left == right) for use with conditional.

ufl.ne(left, right)

UFL operator: A boolean expression (left != right) for use with conditional.

ufl.le(left, right)

UFL operator: A boolean expression (left <= right) for use with conditional.

ufl.ge(left, right)

UFL operator: A boolean expression (left >= right) for use with conditional.

ufl.lt(left, right)

UFL operator: A boolean expression (left < right) for use with conditional.

ufl.gt(left, right)

UFL operator: A boolean expression (left > right) for use with conditional.

ufl.And(left, right)

UFL operator: A boolean expression (left and right) for use with conditional.

ufl.Or(left, right)

UFL operator: A boolean expression (left or right) for use with conditional.

ufl.Not(condition)

UFL operator: A boolean expression (not condition) for use with conditional.

ufl.conditional(condition, true_value, false_value)

UFL operator: A conditional expression, taking the value of true_value when condition evaluates to true and false_value otherwise.

ufl.sign(x)

UFL operator: Take the sign (+1 or -1) of x.

ufl.max_value(x, y)

UFL operator: Take the maximum of x and y.

ufl.min_value(x, y)

UFL operator: Take the minimum of x and y.

ufl.Max(x, y)

UFL operator: Take the maximum of x and y.

ufl.Min(x, y)

UFL operator: Take the minimum of x and y.

ufl.variable(e)

UFL operator: Define a variable representing the given expression, see also diff().

ufl.diff(f, v)

UFL operator: Take the derivative of f with respect to the variable v.

If f is a form, diff is applied to each integrand.

ufl.Dx(f, *i)

UFL operator: Take the partial derivative of f with respect to spatial variable number i. Equivalent to f.dx(*i).

ufl.grad(f)

UFL operator: Take the gradient of f.

This operator follows the grad convention where

for scalar expressions s, vector expressions v, and arbitrary rank tensor expressions T.

See also: nabla_grad()

ufl.div(f)

UFL operator: Take the divergence of f.

This operator follows the div convention where

div(v) = v[i].dx(i)

div(T)[:] = T[:,i].dx(i)

for vector expressions v, and arbitrary rank tensor expressions T.

See also: nabla_div()

ufl.curl(f)

UFL operator: Take the curl of f.

ufl.rot(f)

UFL operator: Take the curl of f.

ufl.nabla_grad(f)

UFL operator: Take the gradient of f.

This operator follows the grad convention where

for scalar expressions s, vector expressions v, and arbitrary rank tensor expressions T.

See also: grad()

ufl.nabla_div(f)

UFL operator: Take the divergence of f.

This operator follows the div convention where

nabla_div(v) = v[i].dx(i)

nabla_div(T)[:] = T[i,:].dx(i)

for vector expressions v, and arbitrary rank tensor expressions T.

See also: div()

ufl.Dn(f)

UFL operator: Take the directional derivative of f in the facet normal direction, Dn(f) := dot(grad(f), n).

ufl.exterior_derivative(f)

UFL operator: Take the exterior derivative of f.

The exterior derivative uses the element family to determine whether id, grad, curl or div should be used.

Note that this uses the grad and div operators, as opposed to nabla_grad and nabla_div.

ufl.jump(v, n=None)

UFL operator: Take the jump of v across a facet.

ufl.avg(v)

UFL operator: Take the average of v across a facet.

ufl.cell_avg(f)

UFL operator: Take the average of v over a cell.

ufl.facet_avg(f)

UFL operator: Take the average of v over a facet.

ufl.elem_mult(A, B)

UFL operator: Take the elementwise multiplication of tensors A and B with the same shape.

ufl.elem_div(A, B)

UFL operator: Take the elementwise division of tensors A and B with the same shape.

ufl.elem_pow(A, B)

UFL operator: Take the elementwise power of tensors A and B with the same shape.

ufl.elem_op(op, *args)

UFL operator: Take the elementwise application of operator op on scalar values from one or more tensor arguments.

class ufl.Form(integrals)

Bases: object

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

arguments()

Return all Argument objects found in form.

coefficient_numbering()

Return a contiguous numbering of coefficients in a mapping {coefficient:number}.

coefficients()

Return all Coefficient objects found in form.

domain_numbering()

Return a contiguous numbering of domains in a mapping {domain:number}.

empty()

Returns whether the form has no integrals.

equals(other)

Evaluate bool(lhs_form == rhs_form).

geometric_dimension()

Return the geometric dimension shared by all domains and functions in this form.

integrals()

Return a sequence of all integrals in form.

integrals_by_type(integral_type)

Return a sequence of all integrals with a particular domain type.

max_subdomain_ids()

Returns a mapping on the form {domain:{integral_type:max_subdomain_id}}.

signature()

Signature for use with jit cache (independent of incidental numbering of indices etc.)

subdomain_data()

Returns a mapping on the form {domain:{integral_type: subdomain_data}}.

ufl_cell()

Return the single cell this form is defined on, fails if multiple cells are found.

ufl_domain()

Return the single geometric integration domain occuring in the form.

Fails if multiple domains are found.

NB! This does not include domains of coefficients defined on other meshes, look at form data for that additional information.

ufl_domains()

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.

x_repr_latex_()
x_repr_png_()
class ufl.Integral(integrand, integral_type, domain, subdomain_id, metadata, subdomain_data)

Bases: object

An integral over a single domain.

integral_type()

Return the domain type of this integral.

integrand()

Return the integrand expression, which is an Expr instance.

metadata()

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)

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

Example:
subdomain_data()

Return the domain data of this integral.

subdomain_id()

Return the subdomain id of this integral.

ufl_domain()

Return the integration domain of this integral.

class ufl.Measure(integral_type, domain=None, subdomain_id='everywhere', metadata=None, subdomain_data=None)

Bases: object

integral_type()

Return the domain type.

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

metadata()

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)

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()

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()

Return the domain id of this measure (integer).

ufl_domain()

Return the domain associated with this measure.

This may be None or a Domain object.

ufl.register_integral_type(integral_type, measure_name)
ufl.integral_types()

Return a tuple of all domain type strings.

ufl.replace(e, mapping)

Replace terminal objects in expression.

@param e:
An Expr or Form.
@param mapping:
A dict with from:to replacements to perform.
ufl.replace_integral_domains(form, common_domain)

Given a form and a domain, assign a common integration domain to all integrals.

Does not modify the input form (Form should always be immutable). This is to support ill formed forms with no domain specified, sometimes occurring in pydolfin, e.g. assemble(1*dx, mesh=mesh).

ufl.derivative(form, coefficient, argument=None, coefficient_derivatives=None)

UFL form operator: 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.action(form, coefficient=None)

UFL form operator: 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.

ufl.energy_norm(form, coefficient=None)

UFL form operator: Given a bilinear form a and a coefficient f, return the functional $$a(f,f)$$.

ufl.rhs(form)

UFL form operator: 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.lhs(form)

UFL form operator: 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.block_split(form, ix, iy=0)

UFL form operator: Given a linear or bilinear form on a mixed space, extract the block correspoinding to the indices ix, iy.

Example:

ufl.system(form)

UFL form operator: Split a form into the left hand side and right hand side, see lhs and rhs.

ufl.functional(form)

UFL form operator: Extract the functional part of form.

ufl.adjoint(form, reordered_arguments=None)

UFL form operator: Given a combined bilinear form, compute the adjoint form by changing the ordering (count) of the test and trial functions.

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).

ufl.sensitivity_rhs(a, u, L, v)

UFL form operator: 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}0 = \frac{d}{dv}(Ax-b) = \frac{dA}{dv} x + A \frac{dx}{dv} - \frac{db}{dv},\\A \frac{dx}{dv} = \frac{db}{dv} - \frac{dA}{dv} x,\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)