Update UFL element (#614)

* remove convert_element

* update UFL interface

* branches

* update ufl interface, remove family string

* DOLFINx branch

* fix final test

* simplify

* flake

* update demos

* ufl branch (for demos)

* no UFL demos

* update pull back interface

* update CI name

* gdim

* AUTHORS

* pull_back -> pullback

* degree() -> degree

* add newline to readme

* Revert "add newline to readme"

This reverts commit 5c0224a.

* replace rank with shape

* shape not rank

* branches

Author: mscroggs

.github/workflows/pythonapp.yml

@@ -94,16 +94,8 @@ jobs:
         # when there are test failures
         if: always()
 
-      - name: Get UFL
-        uses: actions/checkout@v3
-        with:
-          path: ./ufl
-          repository: FEniCS/ufl
-          ref: main
-
-      - name: Run FFCx and UFL demos
+      - name: Run FFCx demos
         run: |
-          mv ufl/demo/* demo/
           pytest demo/test_demos.py
           rm -Rf ufl/
 

AUTHORS

@@ -60,6 +60,9 @@ Contributors:
     Ivan Yashchuk
     email: [email protected]
 
+    Matthew Scroggs
+    email: [email protected]
+    www:   https://mscroggs.co.uk
 
 Credits for UFC
 ===============

demo/BiharmonicHHJ.py

@@ -4,20 +4,23 @@
 # Biharmonic equation in Hellan-Herrmann-Johnson (HHJ)
 # formulation.
 import basix.ufl
-from ufl import (Coefficient, FacetNormal, TestFunctions, TrialFunctions, dot,
-                 dS, ds, dx, grad, inner, jump, triangle)
+from ufl import (Coefficient, FacetNormal, FunctionSpace, Mesh, TestFunctions,
+                 TrialFunctions, dot, dS, ds, dx, grad, inner, jump)
 
 HHJ = basix.ufl.element('HHJ', "triangle", 2)
 P = basix.ufl.element('P', "triangle", 3)
 mixed_element = basix.ufl.mixed_element([HHJ, P])
+domain = Mesh(basix.ufl.element("P", "triangle", 1, shape=(2, )))
+mixed_space = FunctionSpace(domain, mixed_element)
+p_space = FunctionSpace(domain, P)
 
-(sigma, u) = TrialFunctions(mixed_element)
-(tau, v) = TestFunctions(mixed_element)
-f = Coefficient(P)
+(sigma, u) = TrialFunctions(mixed_space)
+(tau, v) = TestFunctions(mixed_space)
+f = Coefficient(p_space)
 
 
 def b(sigma, v):
-    n = FacetNormal(triangle)
+    n = FacetNormal(domain)
     return inner(sigma, grad(grad(v))) * dx \
         - dot(dot(sigma('+'), n('+')), n('+')) * jump(grad(v), n) * dS \
         - dot(dot(sigma, n), n) * dot(grad(v), n) * ds

demo/BiharmonicRegge.py

@@ -3,25 +3,28 @@
 # The bilinear form a(u, v) and linear form L(v) for
 # Biharmonic equation in Regge formulation.
 import basix.ufl
-from ufl import (Coefficient, FacetNormal, Identity, TestFunctions,
-                 TrialFunctions, dot, dS, ds, dx, grad, inner, jump,
-                 tetrahedron, tr)
+from ufl import (Coefficient, FacetNormal, FunctionSpace, Identity, Mesh,
+                 TestFunctions, TrialFunctions, dot, dS, ds, dx, grad, inner,
+                 jump, tr)
 
 REG = basix.ufl.element("Regge", "tetrahedron", 1)
 P = basix.ufl.element("Lagrange", "tetrahedron", 2)
 mixed_element = basix.ufl.mixed_element([REG, P])
+domain = Mesh(basix.ufl.element("P", "tetrahedron", 1, shape=(3, )))
+mixed_space = FunctionSpace(domain, mixed_element)
+p_space = FunctionSpace(domain, P)
 
-(sigma, u) = TrialFunctions(mixed_element)
-(tau, v) = TestFunctions(mixed_element)
-f = Coefficient(P)
+(sigma, u) = TrialFunctions(mixed_space)
+(tau, v) = TestFunctions(mixed_space)
+f = Coefficient(p_space)
 
 
 def S(mu):
     return mu - Identity(3) * tr(mu)
 
 
 def b(mu, v):
-    n = FacetNormal(tetrahedron)
+    n = FacetNormal(domain)
     return inner(S(mu), grad(grad(v))) * dx \
         - dot(dot(S(mu('+')), n('+')), n('+')) * jump(grad(v), n) * dS \
         - dot(dot(S(mu), n), n) * dot(grad(v), n) * ds

demo/CellGeometry.py

@@ -3,23 +3,24 @@
 # A functional M involving a bunch of cell geometry quantities.
 import basix.ufl
 from ufl import (CellVolume, Circumradius, Coefficient, FacetArea, FacetNormal,
-                 SpatialCoordinate, ds, dx, tetrahedron, TrialFunction)
+                 FunctionSpace, Mesh, SpatialCoordinate, TrialFunction, ds, dx)
 from ufl.geometry import FacetEdgeVectors
 
-cell = tetrahedron
-V = basix.ufl.element("P", cell.cellname(), 1)
-u = Coefficient(V)
+V = basix.ufl.element("P", "tetrahedron", 1)
+domain = Mesh(basix.ufl.element("P", "tetrahedron", 1, shape=(3, )))
+space = FunctionSpace(domain, V)
+u = Coefficient(space)
 
 # TODO: Add all geometry for all cell types to this and other demo files, need for regression test.
-x = SpatialCoordinate(cell)
-n = FacetNormal(cell)
-vol = CellVolume(cell)
-rad = Circumradius(cell)
-area = FacetArea(cell)
+x = SpatialCoordinate(domain)
+n = FacetNormal(domain)
+vol = CellVolume(domain)
+rad = Circumradius(domain)
+area = FacetArea(domain)
 
 M = u * (x[0] * vol * rad) * dx + u * (x[0] * vol * rad * area) * ds  # + u*area*avg(n[0]*x[0]*vol*rad)*dS
 
 # Test some obscure functionality
-fev = FacetEdgeVectors(cell)
-v = TrialFunction(V)
+fev = FacetEdgeVectors(domain)
+v = TrialFunction(space)
 L = fev[0, 0] * v * ds

demo/Components.py

@@ -17,12 +17,15 @@
 #
 # This example demonstrates how to create vectors component-wise
 import basix.ufl
-from ufl import Coefficient, TestFunction, as_vector, dot, dx
+from ufl import (Coefficient, FunctionSpace, Mesh, TestFunction, as_vector,
+                 dot, dx)
 
 element = basix.ufl.element("Lagrange", "tetrahedron", 1, shape=(3, ))
+domain = Mesh(element)
+space = FunctionSpace(domain, element)
 
-v = TestFunction(element)
-f = Coefficient(element)
+v = TestFunction(space)
+f = Coefficient(space)
 
 # Create vector
 v0 = as_vector([v[0], v[1], 0.0])

demo/Conditional.py

@@ -17,15 +17,18 @@
 #
 # Illustration on how to use Conditional to define a source term
 import basix.ufl
-from ufl import (And, Constant, Not, Or, SpatialCoordinate, TestFunction,
-                 conditional, dx, ge, gt, le, lt, triangle)
+from ufl import (And, Constant, FunctionSpace, Mesh, Not, Or,
+                 SpatialCoordinate, TestFunction, conditional, dx, ge, gt, le,
+                 lt)
 
 element = basix.ufl.element("Lagrange", "triangle", 2)
+domain = Mesh(basix.ufl.element("Lagrange", "triangle", 1, shape=(2, )))
+space = FunctionSpace(domain, element)
 
-v = TestFunction(element)
-g = Constant(triangle)
+v = TestFunction(space)
+g = Constant(domain)
 
-x = SpatialCoordinate(triangle)
+x = SpatialCoordinate(domain)
 c0 = conditional(le((x[0] - 0.33)**2 + (x[1] - 0.67)**2, 0.015), -1.0, 5.0)
 c = conditional(le((x[0] - 0.33)**2 + (x[1] - 0.67)**2, 0.025), c0, 0.0)
 

demo/FacetIntegrals.py

@@ -20,15 +20,17 @@
 #
 # Simple example of a form defined over exterior and interior facets.
 import basix.ufl
-from ufl import (FacetNormal, TestFunction, TrialFunction, avg, ds, dS, grad,
-                 inner, jump, triangle)
+from ufl import (FacetNormal, FunctionSpace, Mesh, TestFunction, TrialFunction,
+                 avg, ds, dS, grad, inner, jump)
 
 element = basix.ufl.element("Discontinuous Lagrange", "triangle", 1)
+domain = Mesh(basix.ufl.element("Lagrange", "triangle", 1, shape=(2, )))
+space = FunctionSpace(domain, element)
 
-u = TrialFunction(element)
-v = TestFunction(element)
+u = TrialFunction(space)
+v = TestFunction(space)
 
-n = FacetNormal(triangle)
+n = FacetNormal(domain)
 
 a = u * v * ds \
     + u('+') * v('-') * dS \

demo/FacetRestrictionAD.py

@@ -15,14 +15,16 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with FFCx. If not, see <http://www.gnu.org/licenses/>.
 import basix.ufl
-from ufl import (Coefficient, TestFunction, TrialFunction, avg, derivative,
-                 dot, dS, dx, grad, inner)
+from ufl import (Coefficient, FunctionSpace, Mesh, TestFunction, TrialFunction,
+                 avg, derivative, dot, dS, dx, grad, inner)
 
 element = basix.ufl.element("Discontinuous Lagrange", "triangle", 1)
+domain = Mesh(basix.ufl.element("Lagrange", "triangle", 1, shape=(2, )))
+space = FunctionSpace(domain, element)
 
-v = TestFunction(element)
-w = Coefficient(element)
+v = TestFunction(space)
+w = Coefficient(space)
 L = inner(grad(w), grad(v)) * dx - dot(avg(grad(w)), avg(grad(v))) * dS
 
-u = TrialFunction(element)
+u = TrialFunction(space)
 a = derivative(L, w, u)

demo/HyperElasticity.py

@@ -5,47 +5,55 @@
 
 import basix.ufl
 # Modified by Garth N. Wells, 2009
-from ufl import (Coefficient, Constant, FacetNormal, Identity,
-                 SpatialCoordinate, TestFunction, TrialFunction, derivative,
-                 det, diff, dot, ds, dx, exp, grad, inner, inv, tetrahedron,
-                 tr, variable)
+from ufl import (Coefficient, Constant, FacetNormal, FunctionSpace, Identity,
+                 Mesh, SpatialCoordinate, TestFunction, TrialFunction,
+                 derivative, det, diff, dot, ds, dx, exp, grad, inner, inv,
+                 tetrahedron, tr, variable)
 
 # Cell and its properties
 cell = tetrahedron
 d = cell.geometric_dimension()
-N = FacetNormal(cell)
-x = SpatialCoordinate(cell)
 
 # Elements
 u_element = basix.ufl.element("P", cell.cellname(), 2, shape=(3, ))
 p_element = basix.ufl.element("P", cell.cellname(), 1)
 A_element = basix.ufl.element("P", cell.cellname(), 1, shape=(3, 3))
 
+# Spaces
+domain = Mesh(basix.ufl.element("Lagrange", cell.cellname(), 1, shape=(3, )))
+u_space = FunctionSpace(domain, u_element)
+p_space = FunctionSpace(domain, p_element)
+A_space = FunctionSpace(domain, A_element)
+
+# Cell properties
+N = FacetNormal(domain)
+x = SpatialCoordinate(domain)
+
 # Test and trial functions
-v = TestFunction(u_element)
-w = TrialFunction(u_element)
+v = TestFunction(u_space)
+w = TrialFunction(u_space)
 
 # Displacement at current and two previous timesteps
-u = Coefficient(u_element)
-up = Coefficient(u_element)
-upp = Coefficient(u_element)
+u = Coefficient(u_space)
+up = Coefficient(u_space)
+upp = Coefficient(u_space)
 
 # Time parameters
-dt = Constant(cell)
+dt = Constant(domain)
 
 # Fiber field
-A = Coefficient(A_element)
+A = Coefficient(A_space)
 
 # External forces
-T = Coefficient(u_element)
-p0 = Coefficient(p_element)
+T = Coefficient(u_space)
+p0 = Coefficient(p_space)
 
 # Material parameters FIXME
-rho = Constant(cell)
-K = Constant(cell)
-c00 = Constant(cell)
-c11 = Constant(cell)
-c22 = Constant(cell)
+rho = Constant(domain)
+K = Constant(domain)
+c00 = Constant(domain)
+c11 = Constant(domain)
+c22 = Constant(domain)
 
 # Deformation gradient
 I = Identity(d)

demo/MassDG0.py

@@ -17,11 +17,13 @@
 #
 # The bilinear form for a mass matrix.
 import basix.ufl
-from ufl import TestFunction, TrialFunction, dx, inner
+from ufl import FunctionSpace, Mesh, TestFunction, TrialFunction, dx, inner
 
 element = basix.ufl.element("DG", "tetrahedron", 0)
+domain = Mesh(basix.ufl.element("Lagrange", "tetrahedron", 1, shape=(3, )))
+space = FunctionSpace(domain, element)
 
-v = TestFunction(element)
-u = TrialFunction(element)
+v = TestFunction(space)
+u = TrialFunction(space)
 
 a = inner(u, v) * dx

demo/MassHcurl_2D_1.py

@@ -15,11 +15,13 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with FFCx. If not, see <http://www.gnu.org/licenses/>.
 import basix.ufl
-from ufl import TestFunction, TrialFunction, dx, inner
+from ufl import FunctionSpace, Mesh, TestFunction, TrialFunction, dx, inner
 
 element = basix.ufl.element("N1curl", "triangle", 1)
+domain = Mesh(basix.ufl.element("Lagrange", "triangle", 1, shape=(2, )))
+space = FunctionSpace(domain, element)
 
-v = TestFunction(element)
-u = TrialFunction(element)
+v = TestFunction(space)
+u = TrialFunction(space)
 
 a = inner(v, u) * dx

demo/MassHdiv_2D_1.py

@@ -15,11 +15,13 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with FFCx. If not, see <http://www.gnu.org/licenses/>.
 import basix.ufl
-from ufl import TestFunction, TrialFunction, dx, inner
+from ufl import FunctionSpace, Mesh, TestFunction, TrialFunction, dx, inner
 
 element = basix.ufl.element("BDM", "triangle", 1)
+domain = Mesh(basix.ufl.element("Lagrange", "triangle", 1, shape=(2, )))
+space = FunctionSpace(domain, element)
 
-v = TestFunction(element)
-u = TrialFunction(element)
+v = TestFunction(space)
+u = TrialFunction(space)
 
 a = inner(v, u) * dx

demo/MathFunctions.py

@@ -17,13 +17,15 @@
 #
 # Test all algebra operators on Coefficients.
 import basix.ufl
-from ufl import (Coefficient, acos, asin, atan, bessel_J, bessel_Y, cos, dx,
-                 erf, exp, ln, sin, sqrt, tan)
+from ufl import (Coefficient, FunctionSpace, Mesh, acos, asin, atan, bessel_J,
+                 bessel_Y, cos, dx, erf, exp, ln, sin, sqrt, tan)
 
 element = basix.ufl.element("Lagrange", "triangle", 1)
+domain = Mesh(basix.ufl.element("Lagrange", "triangle", 1, shape=(2, )))
+space = FunctionSpace(domain, element)
 
-c0 = Coefficient(element)
-c1 = Coefficient(element)
+c0 = Coefficient(space)
+c1 = Coefficient(space)
 
 s0 = 3 * c0 - c1
 p0 = c0 * c1

demo/MetaData.py

@@ -17,15 +17,18 @@
 #
 # Test form for metadata.
 import basix.ufl
-from ufl import Coefficient, TestFunction, TrialFunction, dx, grad, inner
+from ufl import (Coefficient, FunctionSpace, Mesh, TestFunction, TrialFunction,
+                 dx, grad, inner)
 
 element = basix.ufl.element("Lagrange", "triangle", 1)
 vector_element = basix.ufl.element("Lagrange", "triangle", 1, shape=(2, ))
+domain = Mesh(basix.ufl.element("Lagrange", "triangle", 1, shape=(2, )))
+space = FunctionSpace(domain, element)
+vector_space = FunctionSpace(domain, vector_element)
 
-
-u = TrialFunction(element)
-v = TestFunction(element)
-c = Coefficient(vector_element)
+u = TrialFunction(space)
+v = TestFunction(space)
+c = Coefficient(vector_space)
 
 # Terms on the same subdomain using different quadrature degree
 a = inner(grad(u), grad(v)) * dx(0, degree=8)\