Add shallow water test cases

python/dune/perftool/pdelab/driver/instationary.py

@@ -36,21 +36,11 @@ from dune.perftool.options import get_option
 
 
 def solve_instationary():
-    # Test if form is linear in ansatzfunction
-    linear = is_linear()
-
-    # Test wether we want to do matrix free operator evaluation
-    matrix_free = get_option('matrix_free')
-
     # Create time loop
-    if linear and matrix_free:
-        assert False
-    elif linear and not matrix_free:
+    if get_option('matrix_free'):
+        raise NotImplementedError("Instationary matrix free not implemented!")
+    else:
         time_loop()
-    if not linear and matrix_free:
-        assert False
-    elif not linear and not matrix_free:
-        assert False
 
     print_residual()
     print_matrix()

test/hyperbolic/CMakeLists.txt

@@ -7,3 +7,8 @@ dune_add_formcompiler_system_test(UFLFILE linearacoustics.ufl
                                   BASENAME linearacoustics
                                   INIFILE linearacoustics.mini
                                   )
+
+dune_add_formcompiler_system_test(UFLFILE shallowwater.ufl
+                                  BASENAME shallowwater
+                                  INIFILE shallowwater.mini
+                                  )

test/hyperbolic/shallowwater.mini

+__name = shallowwater_{__exec_suffix}
+__exec_suffix = {diff_suffix}
+
+diff_suffix = numdiff, symdiff | expand diff
+
+extension = 10.0 10.0
+upperright = 10.0 10.0
+cells = 20 20
+elementType = simplical
+elements = 20 20
+
+[instat]
+T = 0.5
+dt = 0.005
+
+[wrapper.vtkcompare]
+name = {__name}
+extension = vtu
+
+[formcompiler]
+numerical_jacobian = 1, 0 | expand diff
+explicit_time_stepping = 1

test/hyperbolic/shallowwater.ufl

+cell = quadrilateral
+x = SpatialCoordinate(cell)
+
+f = 0.2 * exp(-(pow((x[0] - 5), 2) / 2 + pow(x[1] - 5, 2) / 2)) + 1.
+
+V = FiniteElement("DG", cell, 1)
+MV = MixedElement(V, V, V)
+
+g = 10.0
+
+n = FacetNormal(cell)('+')
+
+u = TrialFunction(MV)
+v = TestFunction(MV)
+
+mass = inner(u, v)*dx
+
+h, q0, q1 = split(u)
+
+flux = as_matrix([[q0,                  q1],
+                  [h*q0*q0 + 0.5*g*h*h, h*q0*q1],
+                  [h*q0*q1,             h*q1*q1 + 0.5*g*h*h]])
+
+bflux = as_matrix([[-q0,                  -q1],
+                  [h*q0*q0 + 0.5*g*h*h, h*q0*q1],
+                  [h*q0*q1,             h*q1*q1 + 0.5*g*h*h]])
+
+
+# Define numerical fluxes to choose from
+llf_flux = dot(avg(flux), n) - 0.5*jump(u)
+boundary_flux = 0.5*dot(flux + bflux, n) + as_vector([0., q0, q1])
+numerical_flux = llf_flux
+
+r = -1. * inner(flux, grad(v))*dx \
+  - inner(numerical_flux, jump(v))*dS \
+  + inner(boundary_flux, v)*ds
+
+forms = [mass, r]
+dirichlet_expression = f, 0.0, 0.0

test/sumfact/hyperbolic/CMakeLists.txt

@@ -7,3 +7,8 @@ dune_add_formcompiler_system_test(UFLFILE linearacoustics.ufl
                                   BASENAME sumfact_linearacoustics
                                   INIFILE linearacoustics.mini
                                   )
+
+dune_add_formcompiler_system_test(UFLFILE shallowwater.ufl
+                                  BASENAME sumfact_shallowwater
+                                  INIFILE shallowwater.mini
+                                  )

test/sumfact/hyperbolic/shallowwater.mini

+__name = sumfact_shallowwater
+
+extension = 10.0 10.0
+cells = 20 20
+elementType = hexahedral
+
+[instat]
+T = 0.5
+dt = 0.005
+
+[wrapper.vtkcompare]
+name = {__name}
+extension = vtu
+
+[formcompiler]
+explicit_time_stepping = 1
+sumfact = 1

test/sumfact/hyperbolic/shallowwater.ufl

+cell = quadrilateral
+x = SpatialCoordinate(cell)
+
+f = 0.2 * exp(-(pow((x[0] - 5), 2) / 2 + pow(x[1] - 5, 2) / 2)) + 1.
+
+V = FiniteElement("DG", cell, 1)
+MV = MixedElement(V, V, V)
+
+g = 10.0
+
+n = FacetNormal(cell)('+')
+
+u = TrialFunction(MV)
+v = TestFunction(MV)
+
+mass = inner(u, v)*dx
+
+h, q0, q1 = split(u)
+
+flux = as_matrix([[q0,                  q1],
+                  [h*q0*q0 + 0.5*g*h*h, h*q0*q1],
+                  [h*q0*q1,             h*q1*q1 + 0.5*g*h*h]])
+
+bflux = as_matrix([[-q0,                  -q1],
+                  [h*q0*q0 + 0.5*g*h*h, h*q0*q1],
+                  [h*q0*q1,             h*q1*q1 + 0.5*g*h*h]])
+
+
+# Define numerical fluxes to choose from
+llf_flux = dot(avg(flux), n) - 0.5*jump(u)
+boundary_flux = 0.5*dot(flux + bflux, n) + as_vector([0., q0, q1])
+numerical_flux = llf_flux
+
+r = -1. * inner(flux, grad(v))*dx \
+  - inner(numerical_flux, jump(v))*dS \
+  + inner(boundary_flux, v)*ds
+
+forms = [mass, r]
+dirichlet_expression = f, 0.0, 0.0