ffcx.get_options(priority_options: dict | None = None) -> dict

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[FormData, ...], unique_elements: list[_ElementBase], element_numbers: dict[_ElementBase, int], unique_coordinate_elements: list[_ElementBase], expressions: list[tuple[Expr, ndarray[Any, dtype[float64]], 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, options: dict) -> 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.

ffcx.formatting.format_code(code, options: dict)

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 | None = None) -> dict

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, prefix)

Get DOF map name.

ffcx.naming.expression_name(expression, prefix)

Get expression name.

ffcx.naming.finite_element_name(ufl_element, prefix)

Get finite element name.

ffcx.naming.form_name(original_form, form_id, prefix)

Get form name.

ffcx.naming.integral_name(original_form, integral_type, form_id, subdomain_id, prefix)

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.Any(*args, **kwargs)

Bases: object

Special type indicating an unconstrained type.

Note that all the above statements are true from the point of view of static type checkers. At runtime, Any should not be used with instance checks.

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 | None = None) -> dict

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

NOTE:

class ffcx.ir.representation.CustomElementIR(cell_type: CellType, value_shape: tuple[int, ...], wcoeffs: ndarray[Any, dtype[float64]], x: list[list[ndarray[Any, dtype[float64]]]], M: list[list[ndarray[Any, dtype[float64]]]], map_type: MapType, sobolev_space: SobolevSpace, interpolation_nderivs: int, discontinuous: bool, embedded_subdegree: int, embedded_superdegree: int, polyset_type: 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, num_sub_elements: int, block_size: int, sub_elements: list[str], element_type: str, entity_dofs: list[list[list[int]]], lagrange_variant: LagrangeVariant, dpc_variant: DPCVariant, basix_family: ElementFamily, basix_cell: 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, 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, element_dimensions: dict[_ElementBase, int], options: dict, unique_tables: dict[str, ndarray[Any, dtype[float64]]], unique_table_types: dict[str, str], integrand: dict[QuadratureRule, dict], coefficient_numbering: dict[Coefficient, int], coefficient_offsets: dict[Coefficient, int], integral_type: str, entitytype: str, tensor_shape: list[int], expression_shape: list[int], original_constant_offsets: dict[Constant, int], points: ndarray[Any, dtype[float64]], coefficient_names: list[str], constant_names: list[str], needs_facet_permutations: bool, function_spaces: dict[str, tuple[str, str, str, int, CellType, 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, element_dimensions, 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, CellType, 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, subdomain_id: str | tuple[int, ...] | int, rank: int, geometric_dimension: int, topological_dimension: int, entitytype: str, num_facets: int, num_vertices: int, enabled_coefficients: list[bool], element_dimensions: dict[_ElementBase, int], element_ids: dict[_ElementBase, int], tensor_shape: list[int], coefficient_numbering: dict[Coefficient, int], coefficient_offsets: dict[Coefficient, int], original_constant_offsets: dict[Constant, int], options: dict, cell_shape: str, unique_tables: dict[str, ndarray[Any, dtype[float64]]], unique_table_types: dict[str, str], integrand: dict[QuadratureRule, dict], name: str, needs_facet_permutations: bool, coordinate_element: str, sum_factorization: bool)

Bases: NamedTuple

Intermediate representation of an integral.

Create new instance of IntegralIR(integral_type, subdomain_id, rank, geometric_dimension, topological_dimension, entitytype, num_facets, num_vertices, enabled_coefficients, element_dimensions, element_ids, tensor_shape, coefficient_numbering, coefficient_offsets, original_constant_offsets, options, cell_shape, unique_tables, unique_table_types, integrand, name, needs_facet_permutations, coordinate_element, sum_factorization)

class ffcx.ir.representation.QuadratureIR(cell_shape: str, points: ndarray[Any, dtype[float64]], weights: ndarray[Any, dtype[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[FormData, ...], unique_elements: list[_ElementBase], element_numbers: dict[_ElementBase, int], unique_coordinate_elements: list[_ElementBase], expressions: list[tuple[Expr, ndarray[Any, dtype[float64]], 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, prefix, options, visualise)

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