ffcx.get_options(priority_options: dict[str, dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any] | int | float] | None = None) -> dict[str, int | float | dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any]]

Return (a copy of) the merged option values for FFCX.

NOTE:

ffcx.__main__.main(args=None)

Run ffcx on a UFL file.

class ffcx.analysis.UFLData(form_data: tuple[ufl.algorithms.formdata.FormData, ...], unique_elements: list[basix.ufl._ElementBase], element_numbers: dict[basix.ufl._ElementBase, int], unique_coordinate_elements: list[basix.ufl._ElementBase], expressions: list[tuple[ufl.core.expr.Expr, npt.NDArray[np.float64], ufl.core.expr.Expr]])

Bases: NamedTuple

UFL data.

Create new instance of UFLData(form_data, unique_elements, element_numbers, unique_coordinate_elements, expressions)

ffcx.analysis.analyze_ufl_objects(ufl_objects: list[Form | AbstractFiniteElement | Mesh | tuple[Expr, ndarray[Any, dtype[floating]]]], scalar_type: dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any]) -> UFLData

Analyze ufl object(s).

ffcx.element_interface.basix_index(indices: tuple[int]) -> int

Get the Basix index of a derivative.

ffcx.element_interface.create_quadrature(cellname: str, degree: int, rule: str, elements: list[_ElementBase]) -> tuple[ndarray[Any, dtype[float64]], ndarray[Any, dtype[float64]]]

Create a quadrature rule.

ffcx.element_interface.map_facet_points(points: ndarray[Any, dtype[float64]], facet: int, cellname: str) -> ndarray[Any, dtype[float64]]

Map points from a reference facet to a physical facet.

ffcx.element_interface.reference_cell_vertices(cellname: str) -> ndarray[Any, dtype[float64]]

Get the vertices of a reference cell.

class ffcx.formatting.CodeBlocks(file_pre: list[tuple[str, str]], elements: list[tuple[str, str]], dofmaps: list[tuple[str, str]], integrals: list[tuple[str, str]], forms: list[tuple[str, str]], expressions: list[tuple[str, str]], file_post: list[tuple[str, str]])

Bases: NamedTuple

Storage of code blocks of the form (declaration, implementation).

Blocks for elements, dofmaps, integrals, forms and expressions, and start and end of file output

Create new instance of CodeBlocks(file_pre, elements, dofmaps, integrals, forms, expressions, file_post)

ffcx.formatting.format_code(code: CodeBlocks) -> tuple[str, str]

Format given code in UFC format. Returns two strings with header and source file contents.

ffcx.formatting.write_code(code_h, code_c, prefix, output_dir)

Write code to files.

ffcx.main.arg_type

alias of int

ffcx.main.get_options(priority_options: dict[str, dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any] | int | float] | None = None) -> dict[str, int | float | dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any]]

Return (a copy of) the merged option values for FFCX.

NOTE:

ffcx.main.main(args=None)

Run ffcx on a UFL file.

ffcx.naming.compute_signature(ufl_objects: list[Form | _ElementBase | tuple[Expr, ndarray[Any, dtype[float64]]]], tag: str) -> str

Compute the signature hash.

Based on the UFL type of the objects and an additional optional ‘tag’.

ffcx.naming.dofmap_name(ufl_element: _ElementBase, prefix: str) -> str

Get DOF map name.

ffcx.naming.expression_name(expression: tuple[Expr, ndarray[Any, dtype[floating]]], prefix: str) -> str

Get expression name.

ffcx.naming.finite_element_name(ufl_element: _ElementBase, prefix: str) -> str

Get finite element name.

ffcx.naming.form_name(original_form: Form, form_id: int, prefix: str) -> str

Get form name.

ffcx.naming.integral_name(original_form: Form, integral_type: str, form_id: int, subdomain_id: tuple[int, ...] | tuple[str], prefix: str) -> str

Get integral name.

ffcx.codegeneration.get_include_path()

Return location of UFCx header files.

ffcx.codegeneration.get_signature()

Return SHA-1 hash of the contents of ufcx.h.

In this implementation, the value is computed on import.

class ffcx.options.Path(*args, **kwargs)

Bases: PurePath

PurePath subclass that can make system calls.

Path represents a filesystem path but unlike PurePath, also offers methods to do system calls on path objects. Depending on your system, instantiating a Path will return either a PosixPath or a WindowsPath object. You can also instantiate a PosixPath or WindowsPath directly, but cannot instantiate a WindowsPath on a POSIX system or vice versa.

Construct a PurePath from one or several strings and or existing PurePath objects. The strings and path objects are combined so as to yield a canonicalized path, which is incorporated into the new PurePath object.

ffcx.options.get_options(priority_options: dict[str, dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any] | int | float] | None = None) -> dict[str, int | float | dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any]]

Return (a copy of) the merged option values for FFCX.

NOTE:

class ffcx.ir.representation.CustomElementIR(cell_type: basix.CellType, value_shape: tuple[int, ...], wcoeffs: npt.NDArray[np.float64], x: list[list[npt.NDArray[np.float64]]], M: list[list[npt.NDArray[np.float64]]], map_type: basix.MapType, sobolev_space: basix.SobolevSpace, interpolation_nderivs: int, discontinuous: bool, embedded_subdegree: int, embedded_superdegree: int, polyset_type: basix.PolysetType)

Bases: NamedTuple

Intermediate representation of a custom element.

Create new instance of CustomElementIR(cell_type, value_shape, wcoeffs, x, M, map_type, sobolev_space, interpolation_nderivs, discontinuous, embedded_subdegree, embedded_superdegree, polyset_type)

class ffcx.ir.representation.DataIR(elements: list[ElementIR], dofmaps: list[DofMapIR], integrals: list[IntegralIR], forms: list[FormIR], expressions: list[ExpressionIR])

Bases: NamedTuple

Intermediate representation of data.

Create new instance of DataIR(elements, dofmaps, integrals, forms, expressions)

class ffcx.ir.representation.DofMapIR(id: int, name: str, signature: str, num_global_support_dofs: int, num_element_support_dofs: int, entity_dofs: list[list[list[int]]], entity_closure_dofs: list[list[list[int]]], num_entity_closure_dofs: list[list[int]], num_sub_dofmaps: int, sub_dofmaps: list[str], block_size: int)

Bases: NamedTuple

Intermediate representation of a DOF map.

Create new instance of DofMapIR(id, name, signature, num_global_support_dofs, num_element_support_dofs, entity_dofs, entity_closure_dofs, num_entity_closure_dofs, num_sub_dofmaps, sub_dofmaps, block_size)

class ffcx.ir.representation.ElementIR(id: int, name: str, signature: str, cell_shape: str, topological_dimension: int, space_dimension: int, reference_value_shape: tuple[int, ...], degree: int, symmetric: bool, num_sub_elements: int, block_size: int, sub_elements: list[str], element_type: str, entity_dofs: list[list[list[int]]], lagrange_variant: basix.LagrangeVariant, dpc_variant: basix.DPCVariant, basix_family: basix.ElementFamily, basix_cell: basix.CellType, discontinuous: bool, custom_element: CustomElementIR, custom_quadrature: QuadratureIR)

Bases: NamedTuple

Intermediate representation of an element.

Create new instance of ElementIR(id, name, signature, cell_shape, topological_dimension, space_dimension, reference_value_shape, degree, symmetric, num_sub_elements, block_size, sub_elements, element_type, entity_dofs, lagrange_variant, dpc_variant, basix_family, basix_cell, discontinuous, custom_element, custom_quadrature)

class ffcx.ir.representation.ExpressionIR(name: str, options: dict, unique_tables: dict[str, npt.NDArray[np.float64]], unique_table_types: dict[str, str], integrand: dict[QuadratureRule, dict], coefficient_numbering: dict[ufl.Coefficient, int], coefficient_offsets: dict[ufl.Coefficient, int], integral_type: str, entitytype: str, tensor_shape: list[int], expression_shape: list[int], original_constant_offsets: dict[ufl.Constant, int], points: npt.NDArray[np.float64], coefficient_names: list[str], constant_names: list[str], needs_facet_permutations: bool, function_spaces: dict[str, tuple[str, str, str, int, basix.CellType, basix.LagrangeVariant, tuple[int]]], name_from_uflfile: str, original_coefficient_positions: list[int])

Bases: NamedTuple

Intermediate representation of an expression.

Create new instance of ExpressionIR(name, options, unique_tables, unique_table_types, integrand, coefficient_numbering, coefficient_offsets, integral_type, entitytype, tensor_shape, expression_shape, original_constant_offsets, points, coefficient_names, constant_names, needs_facet_permutations, function_spaces, name_from_uflfile, original_coefficient_positions)

class ffcx.ir.representation.FormIR(id: int, name: str, signature: str, rank: int, num_coefficients: int, num_constants: int, name_from_uflfile: str, function_spaces: dict[str, tuple[str, str, str, int, basix.CellType, basix.LagrangeVariant, tuple[int]]], original_coefficient_position: list[int], coefficient_names: list[str], constant_names: list[str], finite_elements: list[str], dofmaps: list[str], integral_names: dict[str, list[str]], subdomain_ids: dict[str, list[int]])

Bases: NamedTuple

Intermediate representation of a form.

Create new instance of FormIR(id, name, signature, rank, num_coefficients, num_constants, name_from_uflfile, function_spaces, original_coefficient_position, coefficient_names, constant_names, finite_elements, dofmaps, integral_names, subdomain_ids)

class ffcx.ir.representation.Integral(integrand, integral_type, domain, subdomain_id, metadata, subdomain_data)

Bases: object

An integral over a single domain.

Initialise.

class ffcx.ir.representation.IntegralIR(integral_type: str, rank: int, entitytype: str, enabled_coefficients: list[bool], tensor_shape: list[int], coefficient_numbering: dict[ufl.Coefficient, int], coefficient_offsets: dict[ufl.Coefficient, int], original_constant_offsets: dict[ufl.Constant, int], unique_tables: dict[str, npt.NDArray[np.float64]], unique_table_types: dict[str, str], integrand: dict[QuadratureRule, dict], name: str, needs_facet_permutations: bool, coordinate_element: str)

Bases: NamedTuple

Intermediate representation of an integral.

Create new instance of IntegralIR(integral_type, rank, entitytype, enabled_coefficients, tensor_shape, coefficient_numbering, coefficient_offsets, original_constant_offsets, unique_tables, unique_table_types, integrand, name, needs_facet_permutations, coordinate_element)

class ffcx.ir.representation.QuadratureIR(cell_shape: str, points: npt.NDArray[np.float64], weights: npt.NDArray[np.float64])

Bases: NamedTuple

Intermediate representation of a quadrature rule.

Create new instance of QuadratureIR(cell_shape, points, weights)

class ffcx.ir.representation.QuadratureRule(points, weights, tensor_factors=None)

Bases: object

A quadrature rule.

Initialise.

class ffcx.ir.representation.UFLData(form_data: tuple[ufl.algorithms.formdata.FormData, ...], unique_elements: list[basix.ufl._ElementBase], element_numbers: dict[basix.ufl._ElementBase, int], unique_coordinate_elements: list[basix.ufl._ElementBase], expressions: list[tuple[ufl.core.expr.Expr, npt.NDArray[np.float64], ufl.core.expr.Expr]])

Bases: NamedTuple

UFL data.

Create new instance of UFLData(form_data, unique_elements, element_numbers, unique_coordinate_elements, expressions)

ffcx.ir.representation.compute_integral_ir(cell, integral_type, entitytype, integrands, argument_shape, p, visualise)

Compute intermediate representation for an integral.

ffcx.ir.representation.compute_ir(analysis: UFLData, object_names: dict[int, str], prefix: str, options: dict[str, dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any] | int | float], visualise: bool) -> DataIR

Compute intermediate representation.

ffcx.ir.representation.create_quadrature_points_and_weights(integral_type, cell, degree, rule, elements, use_tensor_product=False)

Create quadrature rule and return points and weights.

ffcx.ir.representation.sorted_expr_sum(seq)

Sorted expr sum.

class ffcx.ir.representationutils.QuadratureRule(points, weights, tensor_factors=None)

Bases: object

A quadrature rule.

Initialise.

ffcx.ir.representationutils.create_quadrature(cellname: str, degree: int, rule: str, elements: list[_ElementBase]) -> tuple[ndarray[Any, dtype[float64]], ndarray[Any, dtype[float64]]]

Create a quadrature rule.

ffcx.ir.representationutils.create_quadrature_points_and_weights(integral_type, cell, degree, rule, elements, use_tensor_product=False)

Create quadrature rule and return points and weights.

ffcx.ir.representationutils.integral_type_to_entity_dim(integral_type, tdim)

Given integral_type and domain tdim, return the tdim of the integration entity.

ffcx.ir.representationutils.map_facet_points(points: ndarray[Any, dtype[float64]], facet: int, cellname: str) -> ndarray[Any, dtype[float64]]

Map points from a reference facet to a physical facet.

ffcx.ir.representationutils.map_integral_points(points, integral_type, cell, entity)

Map points from reference entity to its parent reference cell.

ffcx.ir.representationutils.reference_cell_vertices(cellname: str) -> ndarray[Any, dtype[float64]]

Get the vertices of a reference cell.

• Index
• Module Index
• Search Page