Cleanup, make shock_tube_fast work again.

dune/fem-dg/solver/dg.hh

@@ -199,7 +199,13 @@ namespace Fem
       }
     }
 
+    //! deprecated method
     void solve( DestinationType& dest ) const
+    {
+      step( dest );
+    }
+
+    void step( DestinationType& dest ) const
     {
       // check if initialization needs to be done
       checkInitialize( dest );

pydemo/euler/shock_tube_fast.py

@@ -4,7 +4,7 @@ from dune.fem import parameter
 import dune.create as create
 from dune.models.elliptic.formfiles import loadModels
 from llf import NumFlux
-from dune.femdg import createFemDGSolver
+from dune.femdg import femDGSolver
 from ufl import *
 
 gamma = 1.4
@@ -13,11 +13,19 @@ dim = 2
 from euler import sod as problem
 #from euler import radialSod3 as problem
 
-Model, initial, x0,x1,N, endTime, name = problem(dim,gamma)
+Model, initial, x0,x1,N, endTime, name, exact = problem(dim,gamma)
 
 parameter.append({"fem.verboserank": -1})
 parameter.append("parameter")
 
+parameters = {"fem.ode.odesolver": "EX",
+              "fem.timeprovider.factor": 0.45,
+              "dgadvectionflux.method": "EULER-HLLC",
+              "femdg.limiter.limiteps": 1,
+              "femdg.limiter.admissiblefunctions": 1,
+              "femdg.limiter.tolerance": 1}
+
+
 grid = structuredGrid(x0,x1,N)
 # grid = create.grid("ALUSimplex", cartesianDomain(x0,x1,N))
 dimR     = grid.dimension + 2
@@ -82,7 +90,7 @@ def useODESolver(polOrder=2, limiter='default'):
         space = create.space("dgonb", grid, order=polOrder, dimRange=dimR)
     u_h = initialize(space)
     # rho, v, p = Model.toPrim(u_h)
-    operator = createFemDGSolver( Model, space, limiter=limiter )
+    operator = femDGSolver( Model, space, limiter=limiter, parameters=parameters )
     # operator.setTimeStepSize(dt)
 
     operator.applyLimiter( u_h );
@@ -96,7 +104,7 @@ def useODESolver(polOrder=2, limiter='default'):
     start = time.time()
     tcount = 0
     while t < endTime:
-        operator.solve(target=u_h)
+        operator.step(target=u_h)
         # operator.applyLimiter( u_h );
         dt = operator.deltaT()
         t += dt

pydemo/rk/scheme.py

@@ -41,7 +41,7 @@ def run(Model, initial, x0,x1,N, endTime, name, exact,
     # create solution scheme, i.e. operator and ODE solver
     operator = femDGOperator( Model, space, limiter=limiter, threading=True, parameters=parameters )
     explOp = operator.explicitOperator()
-    #rksolver = createRungeKuttaSolver( space, operator )
+    rksolver = createRungeKuttaSolver( space, operator )
 
     # limit initial data if necessary
     operator.applyLimiter( u_h );
@@ -77,7 +77,7 @@ def run(Model, initial, x0,x1,N, endTime, name, exact,
         if dt is not None:
             operator.setTimeStepSize(dt)
         # solver time step
-        #rksolver.step(target=u_h)
+        rksolver.step(target=u_h)
         #operator.step(target=u_h)
         # obtain new time step size
         dt = operator.deltaT()

python/dune/femdg/_operators.py

@@ -434,10 +434,10 @@ def femDGSolver(Model, space,
     deltaT = Method('deltaT', '&DuneType::deltaT')
     # add method to set a fixed time step
     setTimeStepSize = Method('setTimeStepSize', '&DuneType::setTimeStepSize')
-    # add method to solve (not requiring u_h_n)
-    solve = Method('step', '&DuneType::solve', extra=['"target"_a'])
+    # add method to solve one step (not requiring u_h_n)
+    step = Method('step', '&DuneType::step', extra=['"target"_a'])
 
-    return load(includes, typeName, constructor, setTimeStepSize, deltaT, applyLimiter, solve,
+    return load(includes, typeName, constructor, setTimeStepSize, deltaT, applyLimiter, step,
               preamble=writer.writer.getvalue()).\
                     Operator( space, advModel, diffModel, parameters=parameters )