Provided by: python3-ffcx_0.6.0-2_all bug

NAME

       fenicsformcompilerx - FEniCS Form Compiler X Documentation

       The  is  an  experimental  version  of  the  FEniCS  Form  Compiler.   It  is developed at
       https://github.com/FEniCS/ffcx.

                    ┌────────────────────────────┬──────────────────────────────────┐
                    │ffcx                        │ FEniCS Form Compiler (FFCx).     │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.__main__               │                                  │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.analysis               │ Compiler stage 1: Analysis.      │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.compiler               │ Main interface  for  compilation │
                    │                            │ of forms.                        │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.element_interface      │ Finite element interface.        │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.formatting             │ Compiler     stage    5:    Code │
                    │                            │ formatting.                      │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.main                   │ Command-line interface to FFCx.  │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.naming                 │                                  │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.codegeneration         │                                  │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.options                │                                  │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.ir.representation      │ Compiler    stage    2:     Code │
                    │                            │ representation.                  │
                    ├────────────────────────────┼──────────────────────────────────┤
                    │ffcx.ir.representationutils │ Utility  functions for some code │
                    │                            │ shared between representations.  │
                    └────────────────────────────┴──────────────────────────────────┘

FFCX

       FEniCS Form Compiler (FFCx).

       FFCx compiles finite element variational forms into C code.

       ffcx.get_options(priority_options: Optional[dict] = None) -> dict
              Return (a copy of) the merged option values for FFCX.

   Options
                 priority_options:
                        take priority over all other option values (see notes)

              returns
                     dict

              rtype  merged option values

              Notes

              This function sets the log level from the merged option values prior to returning.

              The ffcx_options.json files are cached on the first call. Subsequent calls to  this
              function use this cache.

              Priority ordering of options from highest to lowest is:

              • priority_options (API and command line options)

              • $PWD/ffcx_options.json (local options)

              • $XDG_CONFIG_HOME/ffcx/ffcx_options.json (user options)

              • FFCX_DEFAULT_OPTIONS in ffcx.options

              XDG_CONFIG_HOME is ~/.config/ if the environment variable is not set.

              Example ffcx_options.json file:
                 { “assume_aligned”: 32, “epsilon”: 1e-7 }

FFCX.__MAIN__

       ffcx.__main__.main(args=None)

FFCX.ANALYSIS

       Compiler stage 1: Analysis.

       This   module  implements  the  analysis/preprocessing  of  variational  forms,  including
       automatic selection of elements, degrees and form representation type.

       Functions

                      ┌─────────────────────────────────┬────────────────────────┐
                      │analyze_ufl_objects(ufl_objects, │ Analyze ufl object(s). │
                      │options)                         │                        │
                      └─────────────────────────────────┴────────────────────────┘

       Classes

                       ┌──────────────────────┬──────────────────────────────────┐
                       │UFLData(form_data,    │ Create    new    instance     of │
                       │unique_elements, ...) │ UFLData(form_data,               │
                       │                      │ unique_elements,                 │
                       │                      │ element_numbers,                 │
                       │                      │ unique_coordinate_elements,      │
                       │                      │ expressions)                     │
                       └──────────────────────┴──────────────────────────────────┘

       class ffcx.analysis.QuadratureElement(cellname: str, value_shape: Tuple[int, ...], scheme:
       Optional[str]  =  None,  degree:  Optional[int]  =  None,  points:   Optional[ndarray[Any,
       dtype[float64]]]  = None, weights: Optional[ndarray[Any, dtype[float64]]] = None, mapname:
       str = 'identity')
              Bases: _BasixElementBase

              A quadrature element.

              Initialise the element.

              basix_sobolev_space()
                     Return the underlying Sobolev space.

              property cell_type: CellType
                     Basix cell type used to initialise the element.

              property dim: int
                     Number of DOFs the element has.

              property discontinuous: bool
                     True if the discontinuous version of the element is used.

              property dpc_variant: DPCVariant
                     Basix DPC variant used to initialise the element.

              property element_family: ElementFamily
                     Basix element family used to initialise the element.

              property entity_closure_dofs: List[List[List[int]]]
                     DOF numbers associated with the closure of each entity.

              property entity_dofs: List[List[List[int]]]
                     DOF numbers associated with each entity.

              property family_name: str
                     Family name of the element.

              get_component_element(flat_component: int) -> Tuple[_BasixElementBase, int, int]
                     Get element that represents a component of the element, and the  offset  and
                     stride of the component.

                     Parameters
                            flat_component – The component

                     Returns
                            component element, offset of the component, stride of the component

              property lagrange_variant: LagrangeVariant
                     Basix Lagrange variant used to initialise the element.

              property map_type: MapType
                     The Basix map type.

              property num_entity_closure_dofs: List[List[int]]
                     Number of DOFs associated with the closure of each entity.

              property num_entity_dofs: List[List[int]]
                     Number of DOFs associated with each entity.

              property num_global_support_dofs: int
                     Get the number of global support DOFs.

              property reference_geometry: ndarray[Any, dtype[float64]]
                     Geometry of the reference element.

              property reference_topology: List[List[List[int]]]
                     Topology of the reference element.

              tabulate(nderivs:   int,  points:  ndarray[Any,  dtype[float64]])  ->  ndarray[Any,
              dtype[float64]]
                     Tabulate the basis functions of the element.

                     Parametersnderivs – Number of derivatives to tabulate.

                            • points – Points to tabulate at

                     Returns
                            Tabulated basis functions

              property ufcx_element_type: str
                     Element type.

       class       ffcx.analysis.UFLData(form_data,       unique_elements,       element_numbers,
       unique_coordinate_elements, expressions)
              Bases: NamedTuple

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

              element_numbers: Dict[_BasixElementBase, int]
                     Alias for field number 2

              expressions: List[Tuple[Expr, ndarray[Any, dtype[float64]], Expr]]
                     Alias for field number 4

              form_data: Tuple[FormData, ...]
                     Alias for field number 0

              unique_coordinate_elements: List[_BasixElementBase]
                     Alias for field number 3

              unique_elements: List[_BasixElementBase]
                     Alias for field number 1

       ffcx.analysis.analyze_ufl_objects(ufl_objects: List, options: Dict) -> UFLData
              Analyze ufl object(s).

   Options
       ufl_objects options
                 FFCx options. These options take priority over all other set options.

   Returns a data structure holding
              form_datas
                     Form_data objects

              unique_elements
                     Unique elements across all forms and expressions

              element_numbers
                     Mapping to unique numbers for all elements

              unique_coordinate_elements
                     Unique coordinate elements across all forms and expressions

              expressions
                     List of all expressions after post-processing, with  its  evaluation  points
                     and the original expression

       ffcx.analysis.convert_element(element: FiniteElementBase) -> _BasixElementBase
              Convert and element to a FFCx element.

       ffcx.analysis.warn(message, category=None, stacklevel=1, source=None)
              Issue a warning, or maybe ignore it or raise an exception.

FFCX.COMPILER

       Main interface for compilation of forms.

       Breaks  the  compilation  into several sequential stages.  The output of each stage is the
       input of the next stage.

   Compiler stages
       0.  Language, parsing

           • Input:  Python code or .ufl file

           • Output: UFL form

           This stage consists of parsing and expressing a form in the UFL  form  language.  This
           stage is handled by UFL.

       1.  Analysis

           • Input:  UFL form

           • Output: Preprocessed UFL form and FormData (metadata)

           This  stage  preprocesses the UFL form and extracts form metadata. It may also perform
           simplifications on the form.

       2.  Code representation

           • Input:  Preprocessed UFL form and FormData (metadata)

           • Output: Intermediate Representation (IR)

           This stage examines the input and generates all data needed for code generation.  This
           includes  generation of finite element basis functions, extraction of data for mapping
           of degrees of freedom and possible precomputation of integrals. Most of the complexity
           of compilation is handled in this stage.

           The  IR  is  stored as a dictionary, mapping names of UFC functions to data needed for
           generation of the corresponding code.

       3.  Code generation

           • Input:  Intermediate Representation (IR)

           • Output: C code

           This stage examines the IR and generates the actual C code for the body  of  each  UFC
           function.

           The  code  is  stored  as  a  dictionary,  mapping  names  of UFC functions to strings
           containing the C code of the body of each function.

       4.  Code formatting

           • Input:  C code

           • Output: C code files

           This stage examines the generated C++ code and formats it according to the UFC format,
           generating as output one or more .h/.c files conforming to the UFC format.

       Functions

                 ┌──────────────────────────────────┬──────────────────────────────────┐
                 │compile_ufl_objects(ufl_objects[, │ Generate UFC code  for  a  given │
                 │...])                             │ UFL objects.                     │
                 └──────────────────────────────────┴──────────────────────────────────┘

       ffcx.compiler.analyze_ufl_objects(ufl_objects: List, options: Dict) -> UFLData
              Analyze ufl object(s).

   Options
       ufl_objects options
                 FFCx options. These options take priority over all other set options.

   Returns a data structure holding
              form_datas
                     Form_data objects

              unique_elements
                     Unique elements across all forms and expressions

              element_numbers
                     Mapping to unique numbers for all elements

              unique_coordinate_elements
                     Unique coordinate elements across all forms and expressions

              expressions
                     List  of  all  expressions after post-processing, with its evaluation points
                     and the original expression

       ffcx.compiler.compile_ufl_objects(ufl_objects: List[Any], object_names: Dict = {}, prefix:
       Optional[str] = None, options: Dict = {}, visualise: bool = False)
              Generate UFC code for a given UFL objects.

   Options
              @param ufl_objects:
                     Objects  to  be  compiled.  Accepts elements, forms, integrals or coordinate
                     mappings.

       ffcx.compiler.compute_ir(analysis: UFLData, object_names, prefix, options, visualise)
              Compute intermediate representation.

       ffcx.compiler.format_code(code, options: dict)
              Format given code in UFC format. Returns two strings with header  and  source  file
              contents.

       ffcx.compiler.generate_code(ir, options) -> CodeBlocks
              Generate code blocks from intermediate representation.

       ffcx.compiler.time() -> floating point number
              Return  the  current time in seconds since the Epoch.  Fractions of a second may be
              present if the system clock provides them.

FFCX.ELEMENT_INTERFACE

       Finite element interface.

       Functions

                 ┌──────────────────────────────────┬──────────────────────────────────┐
                 │basix_index(indices)              │ Get  the  Basix   index   of   a │
                 │                                  │ derivative.                      │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │convert_element(element)          │ Convert  and  element  to a FFCx │
                 │                                  │ element.                         │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │create_element(element)           │ Create an FFCx  element  from  a │
                 │                                  │ UFL element.                     │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │create_quadrature(cellname,       │ Create a quadrature rule.        │
                 │degree, rule)                     │                                  │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │map_facet_points(points,  facet,  │ Map   points  from  a  reference │
                 │cellname)                         │ facet to a physical facet.       │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │reference_cell_vertices(cellname) │ Get  the vertices of a reference │
                 │                                  │ cell.                            │
                 └──────────────────────────────────┴──────────────────────────────────┘

       Classes

                         ┌────────────────────────────┬───────────────────────┐
                         │QuadratureElement(cellname, │ A quadrature element. │
                         │value_shape[, ...])         │                       │
                         ├────────────────────────────┼───────────────────────┤
                         │RealElement(element)        │ A real element.       │
                         └────────────────────────────┴───────────────────────┘

       class   ffcx.element_interface.QuadratureElement(cellname:  str,  value_shape:  Tuple[int,
       ...],  scheme:   Optional[str]   =   None,   degree:   Optional[int]   =   None,   points:
       Optional[ndarray[Any,    dtype[float64]]]    =    None,   weights:   Optional[ndarray[Any,
       dtype[float64]]] = None, mapname: str = 'identity')
              Bases: _BasixElementBase

              A quadrature element.

              Initialise the element.

              basix_sobolev_space()
                     Return the underlying Sobolev space.

              property cell_type: CellType
                     Basix cell type used to initialise the element.

              property dim: int
                     Number of DOFs the element has.

              property discontinuous: bool
                     True if the discontinuous version of the element is used.

              property dpc_variant: DPCVariant
                     Basix DPC variant used to initialise the element.

              property element_family: ElementFamily
                     Basix element family used to initialise the element.

              property entity_closure_dofs: List[List[List[int]]]
                     DOF numbers associated with the closure of each entity.

              property entity_dofs: List[List[List[int]]]
                     DOF numbers associated with each entity.

              property family_name: str
                     Family name of the element.

              get_component_element(flat_component: int) -> Tuple[_BasixElementBase, int, int]
                     Get element that represents a component of the element, and the  offset  and
                     stride of the component.

                     Parameters
                            flat_component – The component

                     Returns
                            component element, offset of the component, stride of the component

              property lagrange_variant: LagrangeVariant
                     Basix Lagrange variant used to initialise the element.

              property map_type: MapType
                     The Basix map type.

              property num_entity_closure_dofs: List[List[int]]
                     Number of DOFs associated with the closure of each entity.

              property num_entity_dofs: List[List[int]]
                     Number of DOFs associated with each entity.

              property num_global_support_dofs: int
                     Get the number of global support DOFs.

              property reference_geometry: ndarray[Any, dtype[float64]]
                     Geometry of the reference element.

              property reference_topology: List[List[List[int]]]
                     Topology of the reference element.

              tabulate(nderivs:   int,  points:  ndarray[Any,  dtype[float64]])  ->  ndarray[Any,
              dtype[float64]]
                     Tabulate the basis functions of the element.

                     Parametersnderivs – Number of derivatives to tabulate.

                            • points – Points to tabulate at

                     Returns
                            Tabulated basis functions

              property ufcx_element_type: str
                     Element type.

       class ffcx.element_interface.RealElement(element: FiniteElementBase)
              Bases: _BasixElementBase

              A real element.

              Initialise the element.

              basix_sobolev_space()
                     Return the underlying Sobolev space.

              property cell_type: CellType
                     Basix cell type used to initialise the element.

              property dim: int
                     Number of DOFs the element has.

              property discontinuous: bool
                     True if the discontinuous version of the element is used.

              property dpc_variant: DPCVariant
                     Basix DPC variant used to initialise the element.

              property element_family: ElementFamily
                     Basix element family used to initialise the element.

              property entity_closure_dofs: List[List[List[int]]]
                     DOF numbers associated with the closure of each entity.

              property entity_dofs: List[List[List[int]]]
                     DOF numbers associated with each entity.

              property family_name: str
                     Family name of the element.

              get_component_element(flat_component: int) -> Tuple[_BasixElementBase, int, int]
                     Get element that represents a component of the element, and the  offset  and
                     stride of the component.

                     Parameters
                            flat_component – The component

                     Returns
                            component element, offset of the component, stride of the component

              property lagrange_variant: LagrangeVariant
                     Basix Lagrange variant used to initialise the element.

              property map_type: MapType
                     The Basix map type.

              property num_entity_closure_dofs: List[List[int]]
                     Number of DOFs associated with the closure of each entity.

              property num_entity_dofs: List[List[int]]
                     Number of DOFs associated with each entity.

              property num_global_support_dofs: int
                     Get the number of global support DOFs.

              property reference_geometry: ndarray[Any, dtype[float64]]
                     Geometry of the reference element.

              property reference_topology: List[List[List[int]]]
                     Topology of the reference element.

              tabulate(nderivs:   int,  points:  ndarray[Any,  dtype[float64]])  ->  ndarray[Any,
              dtype[float64]]
                     Tabulate the basis functions of the element.

                     Parametersnderivs – Number of derivatives to tabulate.

                            • points – Points to tabulate at

                     Returns
                            Tabulated basis functions

              property ufcx_element_type: str
                     Element type.

       ffcx.element_interface.basix_index(indices: Tuple[int]) -> int
              Get the Basix index of a derivative.

       ffcx.element_interface.convert_element(element: FiniteElementBase) -> _BasixElementBase
              Convert and element to a FFCx element.

       ffcx.element_interface.create_element(element: FiniteElementBase) -> _BasixElementBase
              Create an FFCx element from a UFL element.

              Parameters
                     element – A UFL finite element

              Returns
                     A Basix finite element

       ffcx.element_interface.create_quadrature(cellname,  degree,  rule)  ->  Tuple[ndarray[Any,
       dtype[float64]], ndarray[Any, dtype[float64]]]
              Create a quadrature rule.

       ffcx.element_interface.lru_cache(maxsize=128, typed=False)
              Least-recently-used cache decorator.

              If  maxsize  is  set  to None, the LRU features are disabled and the cache can grow
              without bound.

              If typed is True, arguments of different types  will  be  cached  separately.   For
              example, f(3.0) and f(3) will be treated as distinct calls with distinct results.

              Arguments to the cached function must be hashable.

              View  the  cache  statistics  named  tuple  (hits,  misses, maxsize, currsize) with
              f.cache_info().  Clear the cache and statistics with f.cache_clear().   Access  the
              underlying function with f.__wrapped__.

              See:
              https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)

       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

       Compiler stage 5: Code formatting.

       This module implements the formatting of UFC code from a given dictionary of generated C++
       code for the body of each UFC function.

       It relies on templates for UFC code available as part of the module ufcx_utils.

       Functions

                 ┌─────────────────────────────────┬──────────────────────────────────┐
                 │format_code(code, options)       │ Format given code in UFC format. │
                 ├─────────────────────────────────┼──────────────────────────────────┤
                 │write_code(code_h,       code_c, │                                  │
                 │prefix, output_dir)              │                                  │
                 └─────────────────────────────────┴──────────────────────────────────┘

       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)

FFCX.MAIN

       Command-line interface to FFCx.

       Parse command-line arguments and generate code from input UFL form files.

       Functions

                                           ┌─────────────┬───┐
                                           │main([args]) │   │
                                           └─────────────┴───┘

       ffcx.main.get_options(priority_options: Optional[dict] = None) -> dict
              Return (a copy of) the merged option values for FFCX.

   Options
                 priority_options:
                        take priority over all other option values (see notes)

              returns
                     dict

              rtype  merged option values

              Notes

              This function sets the log level from the merged option values prior to returning.

              The  ffcx_options.json files are cached on the first call. Subsequent calls to this
              function use this cache.

              Priority ordering of options from highest to lowest is:

              • priority_options (API and command line options)

              • $PWD/ffcx_options.json (local options)

              • $XDG_CONFIG_HOME/ffcx/ffcx_options.json (user options)

              • FFCX_DEFAULT_OPTIONS in ffcx.options

              XDG_CONFIG_HOME is ~/.config/ if the environment variable is not set.

              Example ffcx_options.json file:
                 { “assume_aligned”: 32, “epsilon”: 1e-7 }

       ffcx.main.main(args=None)

FFCX.NAMING

       Functions

                 ┌──────────────────────────────────┬──────────────────────────────────┐
                 │cdtype_to_numpy(cdtype)           │ Map a C data type  string  NumPy │
                 │                                  │ datatype string.                 │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │compute_signature(ufl_objects,    │ Compute the signature hash.      │
                 │tag)                              │                                  │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │dofmap_name(ufl_element, prefix)  │                                  │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │expression_name(expression,       │                                  │
                 │prefix)                           │                                  │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │finite_element_name(ufl_element,  │                                  │
                 │prefix)                           │                                  │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │form_name(original_form,          │                                  │
                 │form_id, prefix)                  │                                  │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │integral_name(original_form,      │                                  │
                 │integral_type, ...)               │                                  │
                 ├──────────────────────────────────┼──────────────────────────────────┤
                 │scalar_to_value_type(scalar_type) │ The C value type associated with │
                 │                                  │ a C scalar type.                 │
                 └──────────────────────────────────┴──────────────────────────────────┘

       ffcx.naming.cdtype_to_numpy(cdtype: str)
              Map a C data type string NumPy datatype string.

       ffcx.naming.compute_signature(ufl_objects: List[Union[Form, FiniteElementBase, 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.convert_element(element: FiniteElementBase) -> _BasixElementBase
              Convert and element to a FFCx element.

       ffcx.naming.dofmap_name(ufl_element, prefix)

       ffcx.naming.expression_name(expression, prefix)

       ffcx.naming.finite_element_name(ufl_element, prefix)

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

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

       ffcx.naming.scalar_to_value_type(scalar_type: str) -> str
              The C value type associated with a C scalar type.

              Parameters
                     scalar_type – A C type.

              Returns
                     The  value  type  associated with scalar_type. E.g., if scalar_type is float
                     _Complex the return value is ‘float’.

FFCX.CODEGENERATION

       Functions

                        ┌───────────────────┬──────────────────────────────────┐
                        │get_include_path() │ Return location  of  UFC  header │
                        │                   │ files.                           │
                        ├───────────────────┼──────────────────────────────────┤
                        │get_signature()    │ Return   SHA-1   hash   of   the │
                        │                   │ contents of ufcx.h.              │
                        └───────────────────┴──────────────────────────────────┘

       ffcx.codegeneration.get_include_path()
              Return location of UFC 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.

FFCX.OPTIONS

       Functions

                  ┌────────────────────────────────┬──────────────────────────────────┐
                  │get_options([priority_options]) │ Return (a copy  of)  the  merged │
                  │                                │ option values for FFCX.          │
                  └────────────────────────────────┴──────────────────────────────────┘

       class ffcx.options.Any(*args, **kwargs)
              Bases: object

              Special type indicating an unconstrained type.

              • Any is compatible with every type.

              • Any assumed to have all methods.

              • All values assumed to be instances of Any.

              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.

              absolute()
                     Return an absolute version of this path by prepending  the  current  working
                     directory. No normalization or symlink resolution is performed.

                     Use resolve() to get the canonical path to a file.

              chmod(mode, *, follow_symlinks=True)
                     Change the permissions of the path, like os.chmod().

              classmethod cwd()
                     Return  a new path pointing to the current working directory (as returned by
                     os.getcwd()).

              exists()
                     Whether this path exists.

              expanduser()
                     Return a new path with expanded ~  and  ~user  constructs  (as  returned  by
                     os.path.expanduser)

              glob(pattern)
                     Iterate  over  this  subtree  and  yield  all  existing  files (of any kind,
                     including directories) matching the given relative pattern.

              group()
                     Return the group name of the file gid.

              hardlink_to(target)
                     Make this path a hard link pointing to the same file as target.

                     Note the order of arguments (self, target) is the reverse of os.link’s.

              classmethod home()
                     Return a new path pointing to the user’s  home  directory  (as  returned  by
                     os.path.expanduser(‘~’)).

              is_block_device()
                     Whether this path is a block device.

              is_char_device()
                     Whether this path is a character device.

              is_dir()
                     Whether this path is a directory.

              is_fifo()
                     Whether this path is a FIFO.

              is_file()
                     Whether  this  path  is  a  regular file (also True for symlinks pointing to
                     regular files).

              is_mount()
                     Check if this path is a POSIX mount point

              is_socket()
                     Whether this path is a socket.

              is_symlink()
                     Whether this path is a symbolic link.

              iterdir()
                     Iterate over the files in this directory.  Does not yield any result for the
                     special paths ‘.’ and ‘..’.

              lchmod(mode)
                     Like  chmod(),  except  if  the  path  points  to  a  symlink, the symlink’s
                     permissions are changed, rather than its target’s.

              link_to(target)
                     Make the target path a hard link pointing to this path.

                     Note this function does not make this path a hard link  to  target,  despite
                     the  implication  of the function and argument names. The order of arguments
                     (target, link) is the  reverse  of  Path.symlink_to,  but  matches  that  of
                     os.link.

                     Deprecated  since Python 3.10 and scheduled for removal in Python 3.12.  Use
                     hardlink_to() instead.

              lstat()
                     Like stat(), except if the path points to a symlink,  the  symlink’s  status
                     information is returned, rather than its target’s.

              mkdir(mode=511, parents=False, exist_ok=False)
                     Create a new directory at this given path.

              open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)
                     Open the file pointed by this path and return a file object, as the built-in
                     open() function does.

              owner()
                     Return the login name of the file owner.

              read_bytes()
                     Open the file in bytes mode, read it, and close the file.

              read_text(encoding=None, errors=None)
                     Open the file in text mode, read it, and close the file.

              readlink()
                     Return the path to which the symbolic link points.

              rename(target)
                     Rename this path to the target path.

                     The target path may be absolute or relative. Relative paths are  interpreted
                     relative  to  the  current  working directory, not the directory of the Path
                     object.

                     Returns the new Path instance pointing to the target path.

              replace(target)
                     Rename this path to the target path, overwriting if that path exists.

                     The target path may be absolute or relative. Relative paths are  interpreted
                     relative  to  the  current  working directory, not the directory of the Path
                     object.

                     Returns the new Path instance pointing to the target path.

              resolve(strict=False)
                     Make the  path  absolute,  resolving  all  symlinks  on  the  way  and  also
                     normalizing it.

              rglob(pattern)
                     Recursively  yield  all  existing files (of any kind, including directories)
                     matching the given relative pattern, anywhere in this subtree.

              rmdir()
                     Remove this directory.  The directory must be empty.

              samefile(other_path)
                     Return whether other_path is the same or not as this file  (as  returned  by
                     os.path.samefile()).

              stat(*, follow_symlinks=True)
                     Return  the  result  of  the stat() system call on this path, like os.stat()
                     does.

              symlink_to(target, target_is_directory=False)
                     Make this path a symlink pointing to the target path.   Note  the  order  of
                     arguments (link, target) is the reverse of os.symlink.

              touch(mode=438, exist_ok=True)
                     Create this file with the given access mode, if it doesn’t exist.

              unlink(missing_ok=False)
                     Remove this file or link.  If the path is a directory, use rmdir() instead.

              write_bytes(data)
                     Open the file in bytes mode, write to it, and close the file.

              write_text(data, encoding=None, errors=None, newline=None)
                     Open the file in text mode, write to it, and close the file.

       ffcx.options.get_options(priority_options: Optional[dict] = None) -> dict
              Return (a copy of) the merged option values for FFCX.

   Options
                 priority_options:
                        take priority over all other option values (see notes)

              returns
                     dict

              rtype  merged option values

              Notes

              This function sets the log level from the merged option values prior to returning.

              The  ffcx_options.json files are cached on the first call. Subsequent calls to this
              function use this cache.

              Priority ordering of options from highest to lowest is:

              • priority_options (API and command line options)

              • $PWD/ffcx_options.json (local options)

              • $XDG_CONFIG_HOME/ffcx/ffcx_options.json (user options)

              • FFCX_DEFAULT_OPTIONS in ffcx.options

              XDG_CONFIG_HOME is ~/.config/ if the environment variable is not set.

              Example ffcx_options.json file:
                 { “assume_aligned”: 32, “epsilon”: 1e-7 }

FFCX.IR.REPRESENTATION

       Compiler stage 2: Code representation.

       Module computes intermediate representations of forms, elements and dofmaps. For each  UFC
       function, we extract the data needed for code generation at a later stage.

       The  representation  should  conform strictly to the naming and order of functions in UFC.
       Thus, for code generation of the function “foo”, one should only  need  to  use  the  data
       stored in the intermediate representation under the key “foo”.

       Functions

                    ┌───────────────────────────┬──────────────────────────────────┐
                    │compute_ir(analysis,       │ Compute             intermediate │
                    │object_names, prefix, ...) │ representation.                  │
                    └───────────────────────────┴──────────────────────────────────┘

       Classes

                 ┌─────────────────────────────────┬──────────────────────────────────┐
                 │CustomElementIR(cell_type,       │ Create    new    instance     of │
                 │value_shape, ...)                │ CustomElementIR(cell_type,       │
                 │                                 │ value_shape,  wcoeffs,   x,   M, │
                 │                                 │ map_type,         sobolev_space, │
                 │                                 │ interpolation_nderivs,           │
                 │                                 │ discontinuous,                   │
                 │                                 │ highest_complete_degree,         │
                 │                                 │ highest_degree)                  │
                 ├─────────────────────────────────┼──────────────────────────────────┤
                 │DataIR(elements,        dofmaps, │ Create    new    instance     of │
                 │integrals, forms, ...)           │ DataIR(elements,        dofmaps, │
                 │                                 │ integrals, forms, expressions)   │
                 ├─────────────────────────────────┼──────────────────────────────────┤
                 │DofMapIR(id,  name,   signature, │ Create     new    instance    of │
                 │...)                             │ DofMapIR(id,  name,   signature, │
                 │                                 │ num_global_support_dofs,         │
                 │                                 │ num_element_support_dofs,        │
                 │                                 │ entity_dofs,    num_entity_dofs, │
                 │                                 │ entity_closure_dofs,             │
                 │                                 │ num_entity_closure_dofs,         │
                 │                                 │ num_sub_dofmaps,    sub_dofmaps, │
                 │                                 │ block_size)                      │
                 ├─────────────────────────────────┼──────────────────────────────────┤
                 │ElementIR(id,  name,  signature, │ Create    new    instance     of │
                 │cell_shape, ...)                 │ ElementIR(id,  name,  signature, │
                 │                                 │ cell_shape,                      │
                 │                                 │ topological_dimension,           │
                 │                                 │ geometric_dimension,             │
                 │                                 │ space_dimension,    value_shape, │
                 │                                 │ reference_value_shape,   degree, │
                 │                                 │ family,        num_sub_elements, │
                 │                                 │ block_size,        sub_elements, │
                 │                                 │ element_type,       entity_dofs, │
                 │                                 │ lagrange_variant,   dpc_variant, │
                 │                                 │ basix_family,        basix_cell, │
                 │                                 │ discontinuous, custom_element)   │
                 └─────────────────────────────────┴──────────────────────────────────┘

                 │ExpressionIR(name,               │ Create     new    instance    of │
                 │element_dimensions, ...)         │ 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)  │
                 ├─────────────────────────────────┼──────────────────────────────────┤
                 │FormIR(id,   name,    signature, │ Create     new    instance    of │
                 │rank, ...)                       │ 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)                   │
                 ├─────────────────────────────────┼──────────────────────────────────┤
                 │IntegralIR(integral_type,        │ Create    new    instance     of │
                 │subdomain_id, ...)               │ 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,                 precision, │
                 │                                 │ needs_facet_permutations,        │
                 │                                 │ coordinate_element)              │
                 └─────────────────────────────────┴──────────────────────────────────┘

       class  ffcx.ir.representation.CustomElementIR(cell_type,  value_shape,  wcoeffs,   x,   M,
       map_type,  sobolev_space,  interpolation_nderivs,  discontinuous, highest_complete_degree,
       highest_degree)
              Bases: NamedTuple

              Create new instance  of  CustomElementIR(cell_type,  value_shape,  wcoeffs,  x,  M,
              map_type,        sobolev_space,        interpolation_nderivs,        discontinuous,
              highest_complete_degree, highest_degree)

              M: List[List[ndarray[Any, dtype[float64]]]]
                     Alias for field number 4

              cell_type: CellType
                     Alias for field number 0

              discontinuous: bool
                     Alias for field number 8

              highest_complete_degree: int
                     Alias for field number 9

              highest_degree: int
                     Alias for field number 10

              interpolation_nderivs: int
                     Alias for field number 7

              map_type: MapType
                     Alias for field number 5

              sobolev_space: SobolevSpace
                     Alias for field number 6

              value_shape: Tuple[int, ...]
                     Alias for field number 1

              wcoeffs: ndarray[Any, dtype[float64]]
                     Alias for field number 2

              x: List[List[ndarray[Any, dtype[float64]]]]
                     Alias for field number 3

       class ffcx.ir.representation.DataIR(elements, dofmaps, integrals, forms, expressions)
              Bases: NamedTuple

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

              dofmaps: List[DofMapIR]
                     Alias for field number 1

              elements: List[ElementIR]
                     Alias for field number 0

              expressions: List[ExpressionIR]
                     Alias for field number 4

              forms: List[FormIR]
                     Alias for field number 3

              integrals: List[IntegralIR]
                     Alias for field number 2

       class  ffcx.ir.representation.DofMapIR(id,   name,   signature,   num_global_support_dofs,
       num_element_support_dofs,      entity_dofs,      num_entity_dofs,     entity_closure_dofs,
       num_entity_closure_dofs, num_sub_dofmaps, sub_dofmaps, block_size)
              Bases: NamedTuple

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

              block_size: int
                     Alias for field number 11

              entity_closure_dofs: List[List[List[int]]]
                     Alias for field number 7

              entity_dofs: List[List[List[int]]]
                     Alias for field number 5

              id: int
                     Alias for field number 0

              name: str
                     Alias for field number 1

              num_element_support_dofs: int
                     Alias for field number 4

              num_entity_closure_dofs: List[List[int]]
                     Alias for field number 8

              num_entity_dofs: List[List[int]]
                     Alias for field number 6

              num_global_support_dofs: int
                     Alias for field number 3

              num_sub_dofmaps: int
                     Alias for field number 9

              signature: str
                     Alias for field number 2

              sub_dofmaps: List[str]
                     Alias for field number 10

       class     ffcx.ir.representation.ElementIR(id,      name,      signature,      cell_shape,
       topological_dimension,       geometric_dimension,       space_dimension,      value_shape,
       reference_value_shape,  degree,  family,   num_sub_elements,   block_size,   sub_elements,
       element_type,   entity_dofs,   lagrange_variant,  dpc_variant,  basix_family,  basix_cell,
       discontinuous, custom_element)
              Bases: NamedTuple

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

              basix_cell: CellType
                     Alias for field number 19

              basix_family: ElementFamily
                     Alias for field number 18

              block_size: int
                     Alias for field number 12

              cell_shape: str
                     Alias for field number 3

              custom_element: CustomElementIR
                     Alias for field number 21

              degree: int
                     Alias for field number 9

              discontinuous: bool
                     Alias for field number 20

              dpc_variant: DPCVariant
                     Alias for field number 17

              element_type: str
                     Alias for field number 14

              entity_dofs: List[List[List[int]]]
                     Alias for field number 15

              family: str
                     Alias for field number 10

              geometric_dimension: int
                     Alias for field number 5

              id: int
                     Alias for field number 0

              lagrange_variant: LagrangeVariant
                     Alias for field number 16

              name: str
                     Alias for field number 1

              num_sub_elements: int
                     Alias for field number 11

              reference_value_shape: Tuple[int, ...]
                     Alias for field number 8

              signature: str
                     Alias for field number 2

              space_dimension: int
                     Alias for field number 6

              sub_elements: List[str]
                     Alias for field number 13

              topological_dimension: int
                     Alias for field number 4

              value_shape: Tuple[int, ...]
                     Alias for field number 7

       class     ffcx.ir.representation.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)
              Bases: NamedTuple

              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)

              coefficient_names: List[str]
                     Alias for field number 14

              coefficient_numbering: Dict[Coefficient, int]
                     Alias for field number 6

              coefficient_offsets: Dict[Coefficient, int]
                     Alias for field number 7

              constant_names: List[str]
                     Alias for field number 15

              element_dimensions: Dict[FiniteElementBase, int]
                     Alias for field number 1

              entitytype: str
                     Alias for field number 9

              expression_shape: List[int]
                     Alias for field number 11

              function_spaces: Dict[str, Tuple[str, str, str, int, CellType, LagrangeVariant]]
                     Alias for field number 17

              integral_type: str
                     Alias for field number 8

              integrand: Dict[QuadratureRule, dict]
                     Alias for field number 5

              name: str
                     Alias for field number 0

              name_from_uflfile: str
                     Alias for field number 18

              needs_facet_permutations: bool
                     Alias for field number 16

              options: dict
                     Alias for field number 2

              original_coefficient_positions: List[int]
                     Alias for field number 19

              original_constant_offsets: Dict[Constant, int]
                     Alias for field number 12

              points: ndarray[Any, dtype[float64]]
                     Alias for field number 13

              tensor_shape: List[int]
                     Alias for field number 10

              unique_table_types: Dict[str, str]
                     Alias for field number 4

              unique_tables: Dict[str, ndarray[Any, dtype[float64]]]
                     Alias for field number 3

       class   ffcx.ir.representation.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)
              Bases: NamedTuple

              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)

              coefficient_names: List[str]
                     Alias for field number 9

              constant_names: List[str]
                     Alias for field number 10

              dofmaps: List[str]
                     Alias for field number 12

              finite_elements: List[str]
                     Alias for field number 11

              function_spaces: Dict[str, Tuple[str, str, str, int, CellType, LagrangeVariant]]
                     Alias for field number 7

              id: int
                     Alias for field number 0

              integral_names: Dict[str, List[str]]
                     Alias for field number 13

              name: str
                     Alias for field number 1

              name_from_uflfile: str
                     Alias for field number 6

              num_coefficients: int
                     Alias for field number 4

              num_constants: int
                     Alias for field number 5

              original_coefficient_position: List[int]
                     Alias for field number 8

              rank: int
                     Alias for field number 3

              signature: str
                     Alias for field number 2

              subdomain_ids: Dict[str, List[int]]
                     Alias for field number 14

       class   ffcx.ir.representation.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:
                 <a = Integral instance> b = a.reconstruct(expand_compounds(a.integrand()))  c  =
                 a.reconstruct(metadata={‘quadrature_degree’:2})

              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       ffcx.ir.representation.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,    precision,
       needs_facet_permutations, coordinate_element)
              Bases: NamedTuple

              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,   precision,
              needs_facet_permutations, coordinate_element)

              cell_shape: str
                     Alias for field number 16

              coefficient_numbering: Dict[Coefficient, int]
                     Alias for field number 12

              coefficient_offsets: Dict[Coefficient, int]
                     Alias for field number 13

              coordinate_element: str
                     Alias for field number 23

              element_dimensions: Dict[FiniteElementBase, int]
                     Alias for field number 9

              element_ids: Dict[FiniteElementBase, int]
                     Alias for field number 10

              enabled_coefficients: List[bool]
                     Alias for field number 8

              entitytype: str
                     Alias for field number 5

              geometric_dimension: int
                     Alias for field number 3

              integral_type: str
                     Alias for field number 0

              integrand: Dict[QuadratureRule, dict]
                     Alias for field number 19

              name: str
                     Alias for field number 20

              needs_facet_permutations: bool
                     Alias for field number 22

              num_facets: int
                     Alias for field number 6

              num_vertices: int
                     Alias for field number 7

              options: dict
                     Alias for field number 15

              original_constant_offsets: Dict[Constant, int]
                     Alias for field number 14

              precision: int
                     Alias for field number 21

              rank: int
                     Alias for field number 2

              subdomain_id: Union[str, Tuple[int, ...], int]
                     Alias for field number 1

              tensor_shape: List[int]
                     Alias for field number 11

              topological_dimension: int
                     Alias for field number 4

              unique_table_types: Dict[str, str]
                     Alias for field number 18

              unique_tables: Dict[str, ndarray[Any, dtype[float64]]]
                     Alias for field number 17

       class ffcx.ir.representation.QuadratureRule(points, weights)
              Bases: object

              id()   Return unique deterministic identifier.

                     NOTE:
                        This  identifier is used to provide unique names to tables and symbols in
                        generated code.

       class    ffcx.ir.representation.UFLData(form_data,    unique_elements,    element_numbers,
       unique_coordinate_elements, expressions)
              Bases: NamedTuple

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

              element_numbers: Dict[_BasixElementBase, int]
                     Alias for field number 2

              expressions: List[Tuple[Expr, ndarray[Any, dtype[float64]], Expr]]
                     Alias for field number 4

              form_data: Tuple[FormData, ...]
                     Alias for field number 0

              unique_coordinate_elements: List[_BasixElementBase]
                     Alias for field number 3

              unique_elements: List[_BasixElementBase]
                     Alias for field number 1

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

       ffcx.ir.representation.compute_ir(analysis:   UFLData,   object_names,   prefix,  options,
       visualise)
              Compute intermediate representation.

       ffcx.ir.representation.convert_element(element: FiniteElementBase) -> _BasixElementBase
              Convert and element to a FFCx element.

       ffcx.ir.representation.create_quadrature_points_and_weights(integral_type,  cell,  degree,
       rule)
              Create quadrature rule and return points and weights.

       ffcx.ir.representation.sorted_expr_sum(seq)

FFCX.IR.REPRESENTATIONUTILS

       Utility functions for some code shared between representations.

       Functions

            ┌───────────────────────────────────────────┬──────────────────────────────────┐
            │create_quadrature_points_and_weights(...)  │ Create   quadrature   rule   and │
            │                                           │ return points and weights.       │
            ├───────────────────────────────────────────┼──────────────────────────────────┤
            │integral_type_to_entity_dim(integral_type, │ Given integral_type  and  domain │
            │tdim)                                      │ tdim,  return  the  tdim  of the │
            │                                           │ integration entity.              │
            ├───────────────────────────────────────────┼──────────────────────────────────┤
            │map_integral_points(points, integral_type, │ Map points from reference entity │
            │...)                                       │ to its parent reference cell.    │
            └───────────────────────────────────────────┴──────────────────────────────────┘

       Classes

                                 ┌────────────────────────────────┬───┐
                                 │QuadratureRule(points, weights) │   │
                                 └────────────────────────────────┴───┘

       class ffcx.ir.representationutils.QuadratureRule(points, weights)
              Bases: object

              id()   Return unique deterministic identifier.

                     NOTE:
                        This identifier is used to provide unique names to tables and symbols  in
                        generated code.

       ffcx.ir.representationutils.create_quadrature(cellname,  degree,  rule) -> 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)
              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.

       • IndexModule IndexSearch Page

AUTHOR

       FEniCS Project

COPYRIGHT

       2023, FEniCS Project