>   ???

petsc4py/PETSc/PETSc.pyx:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
petsc4py/PETSc/PETSc.pyx:348: in petsc4py.PETSc.PetscPythonErrorHandler
    ???
petsc4py/PETSc/PETSc.pyx:348: in petsc4py.PETSc.PetscPythonErrorHandler
    ???
petsc4py/PETSc/petscsnes.pxi:334: in petsc4py.PETSc.SNES_Function
    ???
firedrake/solving_utils.py:401: in form_function
    ctx._assemble_residual(tensor=ctx._F)
firedrake/assemble.py:983: in assemble
    self.execute_parloops(tensor)
firedrake/assemble.py:1219: in execute_parloops
    for parloop in self.parloops(tensor):
firedrake/assemble.py:1016: in parloops
    for local_kernel, subdomain_id in self.local_kernels:
/usr/lib/python3.12/functools.py:995: in __get__
    val = self.func(instance)
firedrake/assemble.py:1054: in local_kernels
    kernels = tsfc_interface.compile_form(
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
pyop2/caching.py:550: in wrapper
    value = func(*args, **kwargs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
pyop2/caching.py:550: in wrapper
    value = func(*args, **kwargs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/tsfc_interface.py:220: in compile_form
    tsfc_kernel = TSFCKernel(
firedrake/tsfc_interface.py:95: in __init__
    tree = tsfc_compile_form(form, prefix=name, parameters=parameters,
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
pyop2/caching.py:550: in wrapper
    value = func(*args, **kwargs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
pyop2/caching.py:550: in wrapper
    value = func(*args, **kwargs)
tsfc/driver.py:74: in compile_form
    kernel = compile_integral(integral_data, fd, prefix, parameters, interface=interface, diagonal=diagonal, log=log)
tsfc/driver.py:137: in compile_integral
    integrand_exprs = builder.compile_integrand(integrand, params, ctx)
tsfc/kernel_interface/common.py:140: in compile_integrand
    set_quad_rule(params, info.domain.ufl_cell(), info.integral_type, functions)
tsfc/kernel_interface/common.py:316: in set_quad_rule
    finat_elements = set(create_element(f.ufl_element()) for f in functions
tsfc/kernel_interface/common.py:316: in <genexpr>
    finat_elements = set(create_element(f.ufl_element()) for f in functions
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
tsfc/finatinterface.py:184: in convert_mixedelement
    elements, deps = zip(*[_create_element(elem, **kwargs)
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', interval, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCInterval object at 0x7f638c3baf90>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

The above exception was the direct cause of the following exception:

    def test_moore_spence():
    
        try:
            from slepc4py import SLEPc
        except ImportError:
            pytest.skip(reason="SLEPc unavailable, skipping eigenvalue test")
    
        msh = IntervalMesh(1000, 1)
        V = FunctionSpace(msh, "CG", 1)
        R = FunctionSpace(msh, "R", 0)
    
        # elastica residual
        def residual(theta, lmbda, ttheta):
            return inner(grad(theta), grad(ttheta))*dx - inner(lmbda**2*sin(theta), ttheta) * dx
    
        th = Function(V)
        x = SpatialCoordinate(msh)[0]
        tth = TestFunction(V)
        lm = Constant(3.142)
    
        # Using guess for parameter lm, solve for state theta (th)
        A = residual(th, lm, tth)
        bcs = [DirichletBC(V, 0.0, "on_boundary")]
        solve(A == 0, th, bcs=bcs)
    
        # Now solve eigenvalue problem for $F_u(u, \lambda)\phi = r\phi$
        # Want eigenmode phi with minimal eigenvalue r
        B = derivative(residual(th, lm, TestFunction(V)), th, TrialFunction(V))
    
        petsc_M = assemble(inner(TrialFunction(V), TestFunction(V))*dx, bcs=bcs).petscmat
        petsc_B = assemble(B, bcs=bcs).petscmat
    
        num_eigenvalues = 1
    
        opts = PETSc.Options()
        opts.setValue("eps_target_magnitude", None)
        opts.setValue("eps_target", 0)
        opts.setValue("st_type", "sinvert")
    
        es = SLEPc.EPS().create(comm=COMM_WORLD)
        es.setDimensions(num_eigenvalues)
        es.setOperators(petsc_B, petsc_M)
        es.setProblemType(SLEPc.EPS.ProblemType.GHEP)
        es.setFromOptions()
        es.solve()
    
        ev_re, ev_im = petsc_B.getVecs()
        es.getEigenpair(0, ev_re, ev_im)
        eigenmode = Function(V)
        eigenmode.vector().set_local(ev_re)
    
        Z = MixedFunctionSpace([V, R, V])
    
        # Set initial guesses for state, parameter, null eigenmode
        z = Function(Z)
        z.subfunctions[0].assign(th)
        z.subfunctions[1].assign(lm)
        z.subfunctions[2].assign(eigenmode)
    
        # Write Moore-Spence system of equations
        theta, lmbda, phi = split(z)
        ttheta, tlmbda, tphi = TestFunctions(Z)
        F1 = residual(theta, lmbda, ttheta)
        F2 = derivative(residual(theta, lmbda, tphi), z, as_vector([phi, 0, 0]))
        F3 = inner(dot(phi, phi) - 1, tlmbda)*dx
    
        F = F1 + F2 + F3
    
        bcs = [DirichletBC(Z.sub(0), 0.0, "on_boundary"), DirichletBC(Z.sub(2), 0.0, "on_boundary")]
    
>       solve(F == 0, z, bcs=bcs)

tests/firedrake/regression/test_moore_spence.py:76: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/adjoint_utils/solving.py:57: in wrapper
    output = solve(*args, **kwargs)
firedrake/solving.py:141: in solve
    _solve_varproblem(*args, **kwargs)
firedrake/solving.py:195: in _solve_varproblem
    solver.solve()
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/adjoint_utils/variational_solver.py:101: in wrapper
    out = solve(self, **kwargs)
firedrake/variational_solver.py:321: in solve
    self.snes.solve(None, work)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

>   ???
E   petsc4py.PETSc.Error: error code -1
E   [0] SNESSolve() at /home/firedrake/petsc/src/snes/interface/snes.c:4839
E   [0] SNESSolve_NEWTONLS() at /home/firedrake/petsc/src/snes/impls/ls/ls.c:169
E   [0] SNESComputeFunction() at /home/firedrake/petsc/src/snes/interface/snes.c:2490

petsc4py/PETSc/SNES.pyx:1724: Error

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e20723c0>, FiniteElement('Real', interval, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4564))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4570')
expr = Constant([1.+0.j], name='constant_3362', count=3362), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', interval, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCInterval object at 0x7fc0e1dba990>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4564)
vertexcoords = array([], shape=(0, 1), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e20723c0>, FiniteElement('Real', interval, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4564))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4570')
expr = Constant([1.+0.j], name='constant_3362', count=3362), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a interval>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2a04740>, FiniteElement('Real', interval, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4571))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4577')
expr = Constant([1.+0.j], name='constant_3366', count=3366), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', interval, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCInterval object at 0x7fc0e1db8bc0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4571)
vertexcoords = array([[0.59762701]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2a04740>, FiniteElement('Real', interval, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4571))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4577')
expr = Constant([1.+0.j], name='constant_3366', count=3366), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a interval>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e1f30ef0>, FiniteElement('Real', interval, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4578))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4584')
expr = Constant([1.+0.j], name='constant_3370', count=3370), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', interval, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCInterval object at 0x7fc0e2a06570>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4578)
vertexcoords = array([[ 0.59762701],
       [ 0.93037873],
       [ 0.70552675],
       [ 0.58976637],
       [ 0.3473096 ],
       [...881219],
       [-0.13361728],
       [ 0.67302587],
       [-0.45978491],
       [ 1.15788006],
       [-0.49060905]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e1f30ef0>, FiniteElement('Real', interval, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', interval, 1), dim=1), 4578))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4584')
expr = Constant([1.+0.j], name='constant_3370', count=3370), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a interval>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2481a60>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4585))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4594')
expr = Constant([1.+0.j], name='constant_3374', count=3374), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', triangle, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTriangle object at 0x7fc0e18f14c0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4585)
vertexcoords = array([], shape=(0, 2), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2481a60>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4585))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4594')
expr = Constant([1.+0.j], name='constant_3374', count=3374), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a triangle>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e24dd910>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4595))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4604')
expr = Constant([1.+0.j], name='constant_3378', count=3378), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', triangle, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTriangle object at 0x7fc0e24d6e70>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4595)
vertexcoords = array([[0.59762701, 0.93037873]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e24dd910>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4595))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4604')
expr = Constant([1.+0.j], name='constant_3378', count=3378), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a triangle>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e19fb110>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4605))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4614')
expr = Constant([1.+0.j], name='constant_3382', count=3382), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', triangle, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTriangle object at 0x7fc0e3654c50>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4605)
vertexcoords = array([[ 0.59762701,  0.93037873],
       [ 0.70552675,  0.58976637],
       [ 0.3473096 ,  0.79178823],
       [ 0.37... 1.38874478],
       [ 0.97910159,  0.48091762],
       [-0.04517074,  0.00871296],
       [-0.38394168,  0.36883325]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e19fb110>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=2), 4605))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4614')
expr = Constant([1.+0.j], name='constant_3382', count=3382), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a triangle>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e19dd2b0>, FiniteElement('Real', quadrilateral, 0), name=None), Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4615))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4624')
expr = Constant([1.+0.j], name='constant_3386', count=3386), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', quadrilateral, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCQuadrilateral object at 0x7fc0e19f91c0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4615)
vertexcoords = array([], shape=(0, 2), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e19dd2b0>, FiniteElement('Real', quadrilateral, 0), name=None), Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4615))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4624')
expr = Constant([1.+0.j], name='constant_3386', count=3386), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a quadrilateral>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e3054c20>, FiniteElement('Real', quadrilateral, 0), name=None), Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4625))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4634')
expr = Constant([1.+0.j], name='constant_3390', count=3390), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', quadrilateral, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCQuadrilateral object at 0x7fc0e3654b00>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4625)
vertexcoords = array([[0.59762701, 0.93037873]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e3054c20>, FiniteElement('Real', quadrilateral, 0), name=None), Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4625))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4634')
expr = Constant([1.+0.j], name='constant_3390', count=3390), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a quadrilateral>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e3cea3c0>, FiniteElement('Real', quadrilateral, 0), name=None), Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4635))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4644')
expr = Constant([1.+0.j], name='constant_3394', count=3394), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', quadrilateral, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCQuadrilateral object at 0x7fc0e2e2cdd0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4635)
vertexcoords = array([[ 0.59762701,  0.93037873],
       [ 0.70552675,  0.58976637],
       [ 0.3473096 ,  0.79178823],
       [ 0.37... 1.38874478],
       [ 0.97910159,  0.48091762],
       [-0.04517074,  0.00871296],
       [-0.38394168,  0.36883325]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e3cea3c0>, FiniteElement('Real', quadrilateral, 0), name=None), Mesh(VectorElement(FiniteElement('Q', quadrilateral, 1), dim=2), 4635))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4644')
expr = Constant([1.+0.j], name='constant_3394', count=3394), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a quadrilateral>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e2cc1220>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4648))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4656')
expr = Constant([1.+0.j], name='constant_3398', count=3398), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', TensorProductCell(triangle, interval), 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.TensorProductCell object at 0x7fc0e1da7590>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(TensorProductElement(FiniteElement('Lagrange', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4648)
vertexcoords = array([], shape=(0, 3), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
>               assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:346: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e2cc1220>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4648))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4656')
expr = Constant([1.+0.j], name='constant_3398', count=3398), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a TensorProductCell(triangle, interval)>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e2506b70>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4660))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4668')
expr = Constant([1.+0.j], name='constant_3402', count=3402), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', TensorProductCell(triangle, interval), 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.TensorProductCell object at 0x7fc0e2a09160>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(TensorProductElement(FiniteElement('Lagrange', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4660)
vertexcoords = array([[0.59762701, 0.93037873, 0.70552675]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
>               assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:346: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e2506b70>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4660))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4668')
expr = Constant([1.+0.j], name='constant_3402', count=3402), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a TensorProductCell(triangle, interval)>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e29ed7c0>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4672))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4680')
expr = Constant([1.+0.j], name='constant_3406', count=3406), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', TensorProductCell(triangle, interval), 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.TensorProductCell object at 0x7fc0e2dc67b0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(TensorProductElement(FiniteElement('Lagrange', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4672)
vertexcoords = array([[ 0.59762701,  0.93037873,  0.70552675],
       [ 0.58976637,  0.3473096 ,  0.79178823],
       [ 0.37517442,  ...4423547, -0.12030418],
       [ 0.52263797, -0.05136594, -0.30431103],
       [ 1.22438303,  1.44583898,  1.42166932]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
>               assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:346: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e29ed7c0>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4672))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4680')
expr = Constant([1.+0.j], name='constant_3406', count=3406), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a TensorProductCell(triangle, interval)>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e232b8c0>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4681))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4690')
expr = Constant([1.+0.j], name='constant_3410', count=3410), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', tetrahedron, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTetrahedron object at 0x7fc0e2e44800>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4681)
vertexcoords = array([], shape=(0, 3), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e232b8c0>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4681))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4690')
expr = Constant([1.+0.j], name='constant_3410', count=3410), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a tetrahedron>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2e5dc70>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4691))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4700')
expr = Constant([1.+0.j], name='constant_3414', count=3414), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', tetrahedron, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTetrahedron object at 0x7fc0e29647d0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4691)
vertexcoords = array([[0.59762701, 0.93037873, 0.70552675]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2e5dc70>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4691))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4700')
expr = Constant([1.+0.j], name='constant_3414', count=3414), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a tetrahedron>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2243f80>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4701))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4710')
expr = Constant([1.+0.j], name='constant_3418', count=3418), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', tetrahedron, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTetrahedron object at 0x7fc0e2b111f0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4701)
vertexcoords = array([[ 0.59762701,  0.93037873,  0.70552675],
       [ 0.58976637,  0.3473096 ,  0.79178823],
       [ 0.37517442,  ...4423547, -0.12030418],
       [ 0.52263797, -0.05136594, -0.30431103],
       [ 1.22438303,  1.44583898,  1.42166932]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2243f80>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4701))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4710')
expr = Constant([1.+0.j], name='constant_3418', count=3418), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a tetrahedron>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e22435f0>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4711))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4720')
expr = Constant([1.+0.j], name='constant_3422', count=3422), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', tetrahedron, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTetrahedron object at 0x7fc0e1d76810>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4711)
vertexcoords = array([], shape=(0, 3), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e22435f0>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4711))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4720')
expr = Constant([1.+0.j], name='constant_3422', count=3422), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a tetrahedron>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e21b64b0>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4721))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4730')
expr = Constant([1.+0.j], name='constant_3426', count=3426), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', tetrahedron, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTetrahedron object at 0x7fc0e2e15dc0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4721)
vertexcoords = array([[0.59762701, 0.93037873, 0.70552675]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e21b64b0>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4721))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4730')
expr = Constant([1.+0.j], name='constant_3426', count=3426), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a tetrahedron>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e24ed160>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4731))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4740')
expr = Constant([1.+0.j], name='constant_3430', count=3430), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', tetrahedron, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTetrahedron object at 0x7fc0e2078890>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4731)
vertexcoords = array([[ 0.59762701,  0.93037873,  0.70552675],
       [ 0.58976637,  0.3473096 ,  0.79178823],
       [ 0.37517442,  ...4423547, -0.12030418],
       [ 0.52263797, -0.05136594, -0.30431103],
       [ 1.22438303,  1.44583898,  1.42166932]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e24ed160>, FiniteElement('Real', tetrahedron, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', tetrahedron, 1), dim=3), 4731))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4740')
expr = Constant([1.+0.j], name='constant_3430', count=3430), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a tetrahedron>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e20872c0>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4741))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4753')
expr = Constant([1.+0.j], name='constant_3438', count=3438), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', triangle, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTriangle object at 0x7fc0e2aeafc0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4741)
vertexcoords = array([], shape=(0, 3), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e20872c0>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4741))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4753')
expr = Constant([1.+0.j], name='constant_3438', count=3438), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a triangle>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2548980>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4754))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4766')
expr = Constant([1.+0.j], name='constant_3446', count=3446), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', triangle, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTriangle object at 0x7fc0e1df6420>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4754)
vertexcoords = array([[0.59762701, 0.93037873, 0.70552675]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2548980>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4754))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4766')
expr = Constant([1.+0.j], name='constant_3446', count=3446), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a triangle>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2541ca0>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4767))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4779')
expr = Constant([1.+0.j], name='constant_3454', count=3454), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', triangle, 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.UFCTriangle object at 0x7fc0e20788f0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4767)
vertexcoords = array([[ 0.59762701,  0.93037873,  0.70552675],
       [ 0.58976637,  0.3473096 ,  0.79178823],
       [ 0.37517442,  ...4423547, -0.12030418],
       [ 0.52263797, -0.05136594, -0.30431103],
       [ 1.22438303,  1.44583898,  1.42166932]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
                assemble(interpolate(Constant(1), V))
            return
>       v = assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:348: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.MeshTopology object at 0x7fc0e2541ca0>, FiniteElement('Real', triangle, 0), name=None), Mesh(VectorElement(FiniteElement('Lagrange', triangle, 1), dim=3), 4767))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4779')
expr = Constant([1.+0.j], name='constant_3454', count=3454), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a triangle>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e1ed43e0>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4786))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4794')
expr = Constant([1.+0.j], name='constant_3462', count=3462), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', TensorProductCell(triangle, interval), 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.TensorProductCell object at 0x7fc0e21f1460>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(TensorProductElement(FiniteElement('Lagrange', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4786)
vertexcoords = array([], shape=(0, 3), dtype=float64)

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
>               assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:346: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e1ed43e0>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4786))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4794')
expr = Constant([1.+0.j], name='constant_3462', count=3462), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a TensorProductCell(triangle, interval)>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e24ecb30>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4801))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4809')
expr = Constant([1.+0.j], name='constant_3470', count=3470), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', TensorProductCell(triangle, interval), 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.TensorProductCell object at 0x7fc0e2d9cdd0>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(TensorProductElement(FiniteElement('Lagrange', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4801)
vertexcoords = array([[0.59762701, 0.93037873, 0.70552675]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
>               assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:346: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e24ecb30>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4801))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4809')
expr = Constant([1.+0.j], name='constant_3470', count=3470), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a TensorProductCell(triangle, interval)>

firedrake/interpolation.py:1041: NotImplementedError

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e2071b20>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4816))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4824')
expr = Constant([1.+0.j], name='constant_3478', count=3478), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
>           to_element = create_element(V.ufl_element())

firedrake/interpolation.py:1038: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tsfc/finatinterface.py:254: in create_element
    finat_element, deps = _create_element(ufl_element,
tsfc/finatinterface.py:284: in _create_element
    finat_element, deps = convert(ufl_element, **kwargs)
/usr/lib/python3.12/functools.py:909: in wrapper
    return dispatch(args[0].__class__)(*args, **kw)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

element = FiniteElement('Real', TensorProductCell(triangle, interval), 0)
kwargs = {'restriction': None, 'shape_innermost': True, 'shift_axes': 0}
cell = <FIAT.reference_element.TensorProductCell object at 0x7fc0e19fe360>

    @convert.register(finat.ufl.FiniteElement)
    def convert_finiteelement(element, **kwargs):
        cell = as_fiat_cell(element.cell)
        if element.family() == "Quadrature":
            degree = element.degree()
            scheme = element.quadrature_scheme()
            if degree is None or scheme is None:
                raise ValueError("Quadrature scheme and degree must be specified!")
    
            return finat.make_quadrature_element(cell, degree, scheme), set()
>       lmbda = supported_elements[element.family()]
E       KeyError: 'Real'

tsfc/finatinterface.py:95: KeyError

During handling of the above exception, another exception occurred:

parentmesh = Mesh(VectorElement(TensorProductElement(FiniteElement('Lagrange', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4816)
vertexcoords = array([[ 0.59762701,  0.93037873,  0.70552675],
       [ 0.58976637,  0.3473096 ,  0.79178823],
       [ 0.37517442,  ...4423547, -0.12030418],
       [ 0.52263797, -0.05136594, -0.30431103],
       [ 1.22438303,  1.44583898,  1.42166932]])

    def test_scalar_real_interpolation(parentmesh, vertexcoords):
        vm = VertexOnlyMesh(parentmesh, vertexcoords, missing_points_behaviour=None)
        W = FunctionSpace(vm, "DG", 0)
        V = FunctionSpace(parentmesh, "Real", 0)
        # Remove below when interpolating constant onto Real works for extruded
        if type(parentmesh.topology) is mesh.ExtrudedMeshTopology:
            with pytest.raises(ValueError):
>               assemble(interpolate(Constant(1), V))

tests/firedrake/vertexonly/test_interpolation_from_parent.py:346: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
firedrake/__future__.py:46: in interpolate
    return Interpolator(expr, V, *args, **kwargs).interpolate(default_missing_val=default_missing_val)
/usr/lib/python3.12/contextlib.py:81: in inner
    return func(*args, **kwds)
firedrake/interpolation.py:819: in __init__
    self.callable, arguments = make_interpolator(expr, V, subset, access, bcs=bcs)
petsc4py/PETSc/Log.pyx:188: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
petsc4py/PETSc/Log.pyx:189: in petsc4py.PETSc.Log.EventDecorator.decorator.wrapped_func
    ???
firedrake/interpolation.py:999: in make_interpolator
    loops.extend(_interpolator(V, tensor, expr, subset, arguments, access, bcs=bcs))
<decorator-gen-31>:2: in _interpolator
    ???
firedrake/utils.py:90: in wrapper
    return f(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

V = WithGeometry(FunctionSpace(<firedrake.mesh.ExtrudedMeshTopology object at 0x7fc0e2071b20>, FiniteElement('Real', Tenso...nge', triangle, 1), FiniteElement('Lagrange', interval, 1), cell=TensorProductCell(triangle, interval)), dim=3), 4816))
tensor = Global((1,), array([0.+0.j]), dtype('complex128'), 'function_4824')
expr = Constant([1.+0.j], name='constant_3478', count=3478), subset = None
arguments = [], access = <Access.WRITE: 2>, bcs = None

    @utils.known_pyop2_safe
    def _interpolator(V, tensor, expr, subset, arguments, access, bcs=None):
        try:
            expr = ufl.as_ufl(expr)
        except ValueError:
            raise ValueError("Expecting to interpolate a UFL expression")
        try:
            to_element = create_element(V.ufl_element())
        except KeyError:
            # FInAT only elements
>           raise NotImplementedError("Don't know how to create FIAT element for %s" % V.ufl_element())
E           NotImplementedError: Don't know how to create FIAT element for <R0 on a TensorProductCell(triangle, interval)>

firedrake/interpolation.py:1041: NotImplementedError