Reuse Basix element instead of recreating from generated code

cpp/demo/biharmonic/main.cpp

@@ -128,6 +128,7 @@
 // convenience we also include the DOLFINx namespace.
 
 #include "biharmonic.h"
+#include <basix/finite-element.h>
 #include <cmath>
 #include <dolfinx.h>
 #include <dolfinx/common/types.h>
@@ -162,9 +163,14 @@ int main(int argc, char* argv[])
     //    A function space object, which is defined in the generated code,
     //    is created:
 
+    auto element = basix::create_element<U>(
+        basix::element::family::P, basix::cell::type::triangle, 2,
+        basix::element::lagrange_variant::unset,
+        basix::element::dpc_variant::unset, false);
+
     //  Create function space
     auto V = std::make_shared<fem::FunctionSpace<U>>(
-        fem::create_functionspace(functionspace_form_biharmonic_a, "u", mesh));
+        fem::create_functionspace(mesh, element));
 
     // The source function $f$ and the penalty term $\alpha$ are
     // declared:

cpp/demo/hyperelasticity/main.cpp

@@ -153,8 +153,13 @@ int main(int argc, char* argv[])
         mesh::CellType::tetrahedron,
         mesh::create_cell_partitioner(mesh::GhostMode::none)));
 
-    auto V = std::make_shared<fem::FunctionSpace<U>>(fem::create_functionspace(
-        functionspace_form_hyperelasticity_F_form, "u", mesh));
+    auto element = basix::create_element<U>(
+        basix::element::family::P, basix::cell::type::tetrahedron, 1,
+        basix::element::lagrange_variant::unset,
+        basix::element::dpc_variant::unset, false);
+
+    auto V = std::make_shared<fem::FunctionSpace<U>>(
+        fem::create_functionspace(mesh, element, {3}));
 
     auto B = std::make_shared<fem::Constant<T>>(std::vector<T>{0, 0, 0});
     auto traction = std::make_shared<fem::Constant<T>>(std::vector<T>{0, 0, 0});

cpp/demo/poisson/main.cpp

@@ -80,6 +80,7 @@
 // namespace.
 
 #include "poisson.h"
+#include <basix/finite-element.h>
 #include <cmath>
 #include <dolfinx.h>
 #include <dolfinx/fem/Constant.h>
@@ -114,8 +115,13 @@ int main(int argc, char* argv[])
         mesh::create_rectangle<U>(MPI_COMM_WORLD, {{{0.0, 0.0}, {2.0, 1.0}}},
                                   {32, 16}, mesh::CellType::triangle, part));
 
+    auto element = basix::create_element<U>(
+        basix::element::family::P, basix::cell::type::triangle, 1,
+        basix::element::lagrange_variant::unset,
+        basix::element::dpc_variant::unset, false);
+
     auto V = std::make_shared<fem::FunctionSpace<U>>(
-        fem::create_functionspace(functionspace_form_poisson_a, "u", mesh));
+        fem::create_functionspace(mesh, element, {}));
 
     //  Next, we define the variational formulation by initializing the
     //  bilinear and linear forms ($a$, $L$) using the previously

cpp/demo/poisson_matrix_free/main.cpp

@@ -42,6 +42,7 @@
 // ## C++ program
 
 #include "poisson.h"
+#include <basix/finite-element.h>
 #include <cmath>
 #include <complex>
 #include <concepts>
@@ -137,8 +138,12 @@ void solver(MPI_Comm comm)
   auto mesh = std::make_shared<mesh::Mesh<U>>(mesh::create_rectangle<U>(
       comm, {{{0.0, 0.0}, {1.0, 1.0}}}, {10, 10}, mesh::CellType::triangle,
       mesh::create_cell_partitioner(mesh::GhostMode::none)));
+  auto element = basix::create_element<U>(
+      basix::element::family::P, basix::cell::type::triangle, 2,
+      basix::element::lagrange_variant::unset,
+      basix::element::dpc_variant::unset, false);
   auto V = std::make_shared<fem::FunctionSpace<U>>(
-      fem::create_functionspace(functionspace_form_poisson_M, "ui", mesh));
+      fem::create_functionspace(mesh, element, {}));
 
   // Prepare and set Constants for the bilinear form
   auto f = std::make_shared<fem::Constant<T>>(-6.0);