don't compute liftings etc (now only works for Euler but much more

efficient there...)

dune/fem-dg/assemble/primalmatrix.hh

@@ -170,12 +170,10 @@ public:
     double maxspeedl, maxspeedr; // , maxspeed;
     double viscparal, viscparar, viscpara;
     
-    const DomainType xGlobal = intersection.geometry().global(x);
-
-    model_.maxSpeed( normal, time, xGlobal, 
-                     uLeft, viscparal, maxspeedl );
-    model_.maxSpeed( normal, time, xGlobal,
-                     uRight, viscparar, maxspeedr );
+    model_.maxSpeed( inside, time, faceQuadInner.point( quadPoint ),
+                     normal, uLeft, viscparal, maxspeedl );
+    model_.maxSpeed( outside, time, faceQuadOuter.point( quadPoint ),
+                     normal, uRight, viscparar, maxspeedr );
 
     //maxspeed = (maxspeedl > maxspeedr) ? maxspeedl : maxspeedr;
     viscpara = (viscparal > viscparar) ? viscparal : viscparar;
@@ -410,7 +408,7 @@ class DGPrimalMatrixAssembly
     std::vector< RangeType > phi( maxNumBasisFunctions );
     std::vector< JacobianRangeType > dphi( maxNumBasisFunctions );
 
-    flux_.initialize( dfSpace );
+    // flux_.initialize( dfSpace );
 
     const RangeType uZero(0);
     const JacobianRangeType uJacZero(0);
@@ -584,7 +582,7 @@ class DGPrimalMatrixAssembly
     const DiscreteFunctionSpaceType &dfSpace = rhs.space();
     const size_t maxNumBasisFunctions = maxNumScalarBasisFunctions( dfSpace );
 
-    flux_.initialize(dfSpace);
+    // flux_.initialize(dfSpace);
 
     const RangeType uZero(0);
     const JacobianRangeType uJacZero(0);
@@ -877,22 +875,27 @@ class DGPrimalMatrixAssembly
             RetType &retNb, DRetType &dretNb) const
   {
     RangeType gLeft,gRight;
+    /*
     flux_.initializeIntersection( intersectionStorage.intersection(), 
                                   intersectionStorage.inside(),
                                   intersectionStorage.outside(), time,
                                   //zero_, zero_,
                                   faceQuadInside, faceQuadOutside,
                                   valueEn, valueNb);
-
+    */
     const size_t numFaceQuadPoints = faceQuadInside.nop();
     for( size_t pt = 0; pt < numFaceQuadPoints; ++pt )
     {
+    /*
       flux_.numericalFlux( intersectionStorage.intersection(), 
                            intersectionStorage,
                            time, faceQuadInside, faceQuadOutside, pt, 
                            valueEn[ pt ], valueNb[ pt ], dvalueEn[ pt ], dvalueNb[ pt ],
                            retEn[ pt ], retNb[ pt ],
                            dretEn[ pt ], dretNb[ pt ]);
+     */
+      retEn[pt] = RangeType(0);
+      retNb[pt] = RangeType(0);
       advFlux_.numericalFlux(intersectionStorage.intersection(),
                              intersectionStorage.inside(),
                              intersectionStorage.outside(),
@@ -949,9 +952,11 @@ class DGPrimalMatrixAssembly
     const size_t numFaceQuadPoints = faceQuadInside.nop();
     for( size_t pt = 0; pt < numFaceQuadPoints; ++pt )
     {
+    /*
       flux_.evaluateLifting(faceQuadInside,faceQuadOutside,pt,time,
                             valueEn[pt],valueNb[pt],
                             liftEn[pt],liftNb[pt]);
+     */
     }
   }
   template <class FaceQuadrature,class Quadrature,class Value,class DValue,class RetType, class DRetType>
@@ -978,9 +983,11 @@ class DGPrimalMatrixAssembly
     const size_t numQuadPoints = quadInside.nop();
     for( size_t pt = 0; pt < numQuadPoints; ++pt )
     {
+    /*
       flux_.evaluateLifting(quadInside,quadOutside,pt,time,
                             valueEn[pt],valueNb[pt],
                             liftEn[pt],liftNb[pt]);
+     */
     }
   }
   template <class FaceQuadrature,class Value,class LiftingFunction>
@@ -992,11 +999,13 @@ class DGPrimalMatrixAssembly
                const Value &valueEn, const Value &valueNb,
                LiftingFunction &lifting) const
   {
+  /*
     flux_.initializeIntersection( intersection, entity, neighbor, time,
                                   // zero_, zero_, 
                                   faceQuadInside, faceQuadOutside,
                                   valueEn, valueNb, true );
     lifting += flux_.getInsideLifting();
+  */
   }
 
   template <class Quadrature,class RetType>
@@ -1024,21 +1033,26 @@ class DGPrimalMatrixAssembly
             RetType &retEn, DRetType &dretEn) const
   {
     RangeType gLeft,gRight;
+    /*
     flux_.initializeBoundary( intersection, entity, time, 
                               // zero_,
                               faceQuadInside, 
                               valueEn, valueNb );
+    */
     IntersectionStorage intersectionStorage( intersection, entity, entity, entity.geometry().volume(), entity.geometry().volume() );
     const size_t numFaceQuadPoints = faceQuadInside.nop();
     for( size_t pt = 0; pt < numFaceQuadPoints; ++pt )
     {
       if ( model_.hasBoundaryValue(intersection,time,faceQuadInside.localPoint(pt)) )
       {
+      /*
         flux_.boundaryFlux( intersection, intersectionStorage, 
                             time, faceQuadInside, pt, 
                             valueEn[ pt ], valueNb[ pt ],
                             dvalueEn[ pt ], 
                             retEn[ pt ], dretEn[ pt ]);
+        */
+        retEn[pt] = RangeType(0);
         advFlux_.numericalFlux(intersection,entity,entity,
                                time,faceQuadInside,faceQuadInside,pt,
                                valueEn[ pt ],valueNb[ pt ],