[feature][femDGOperator] Allow to set quadrature orders when creating

femDGOperator.

dune/fem-dg/operator/dg/operatorbase.hh

@@ -157,7 +157,7 @@ namespace Fem
       , space_( gridPart_ )
       , discreteModel_( model_, numFlux_, DiffusionFluxType( gridPart_, model_, parameter ) )
       , previousPass_( InsertFunctionsType::createPass( tuple ) )
-      , pass1_( discreteModel_, *previousPass_, space_ )
+      , pass1_( discreteModel_, *previousPass_, space_, parameter )
       , counter_(0)
     {}
 

dune/fem-dg/pass/dgpass.hh

@@ -156,7 +156,7 @@ namespace Fem
     LocalCDGPass( DiscreteModelType& discreteModel,
                   PreviousPassType& pass,
                   const DiscreteFunctionSpaceType& spc,
-                  const Dune::Fem::ParameterReader& /* parameter */,
+                  const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container(),
                   const int volumeQuadOrd = -1,
                   const int faceQuadOrd = -1,
                   const bool verbose = Dune::Fem::Parameter::verbose() )
@@ -178,8 +178,8 @@ namespace Fem
         valJacNb_( 20 ),
         dtMin_(std::numeric_limits<double>::max()),
         minLimit_(2.0*std::numeric_limits<double>::min()),
-        volumeQuadOrd_( volumeQuadOrd ),
-        faceQuadOrd_( faceQuadOrd ),
+        volumeQuadOrd_( parameter.getValue< int >("femdg.dgpass.volumequadratureorder", volumeQuadOrd )),
+        faceQuadOrd_( parameter.getValue< int >("femdg.dgpass.surfacequadratureorder", faceQuadOrd )),
 #ifdef USE_CACHED_INVERSE_MASSMATRIX
         localMassMatrix_( InverseMassProviderType :: getObject( MassKeyType( gridPart_ ) ) ),
 #else
@@ -197,6 +197,13 @@ namespace Fem
         }
       }
 
+      if( verbose && (volumeQuadOrd_ >= 0 || faceQuadOrd_ >=0) )
+      {
+        const int vo = volumeQuadOrd_ < 0 ? DefaultQuadratureType::volumeOrder(spc_.order()) : volumeQuadOrd_;
+        const int so = faceQuadOrd_ < 0 ? DefaultQuadratureType::surfaceOrder(spc_.order()) : faceQuadOrd_;
+        std::cout << "LocalCDGPass: quadrature orders = (" << vo << "," << so << ")" << std::endl;
+      }
+
       valEnVec_.setMemoryFactor( 1.1 );
       valNbVec_.setMemoryFactor( 1.1 );
       valJacEn_.setMemoryFactor( 1.1 );

python/dune/femdg/_operators.py

@@ -152,6 +152,7 @@ def femDGOperator(Model, space,
         diffusionScheme = "cdg2",
         threading="default",
         defaultQuadrature=True,
+        quadratureOrders=None,
         codegen=True,
         initialTime=0.0, parameters=None):
     """ create DG operator + ODE solver
@@ -168,6 +169,7 @@ def femDGOperator(Model, space,
         threading: enable shared memory parallelization - default is that
                 threading is turned on if `dune.fem.threading.use>1`
         defaultQuadrature: use quadratures that generically fit to the space
+        quadratureOrders: tuple with (volume,surface) quadrature orders, otherwise default is used (depends on space and quadrature)
         codegen: enable optimized code for evaluation and interpolation
         initialTime: T_0, default is 0.0
         parameters: Additional parameter passed to the DG operator, limiter and ODE solvers
@@ -250,6 +252,15 @@ def femDGOperator(Model, space,
         limiterstr = "default(" + limiterstr + ")" if defaultLimiter else limiterstr
         print("femDGOperator: Limiter =",limiterstr)
 
+    # if quadrature orders were provide store those in parameters
+    if isinstance(quadratureOrders, tuple):
+        if parameters is None:
+            parameterReader.append({"femdg.dgpass.volumequadratureorder": quadratureOrders[0],
+                                    "femdg.dgpass.surfacequadratureorder": quadratureOrders[1] })
+        else:
+            parameters["femdg.dgpass.volumequadratureorder"] = quadratureOrders[0]
+            parameters["femdg.dgpass.surfacequadratureorder"] = quadratureOrders[1]
+
     # TODO: does this make sense - if there is no diffusion then it doesn't
     # matter and with diffusion using 'none' seems a bad idea?
     if diffusionScheme is None or diffusionScheme is False: