improve parameter handling. Most (if not all?) parameters can now be passed

in as dictionary on the python side

dune/fem-dg/algorithm/evolution.hh

@@ -51,6 +51,7 @@ namespace Fem
   {
     protected:
     const std::string keyPrefix_;
+    const Dune::Fem::ParameterReader parameter_;
 
     public:
     /**
@@ -58,8 +59,10 @@ namespace Fem
      *
      * \param keyPrefix the key prefix for the parameter file.
      */
-    TimeSteppingParameters( const std::string keyPrefix = "femdg.stepper." )
-      : keyPrefix_( keyPrefix )
+    TimeSteppingParameters( const std::string keyPrefix = "femdg.stepper.",
+                            const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : keyPrefix_( keyPrefix ),
+        parameter_( parameter )
     {}
 
     /**
@@ -70,7 +73,7 @@ namespace Fem
      */
     virtual double fixedTimeStep() const
     {
-      return Dune::Fem::Parameter::getValue< double >( keyPrefix_ + "fixedtimestep" , 0.0 );
+      return parameter_.getValue< double >( keyPrefix_ + "fixedtimestep" , 0.0 );
     }
 
     /**
@@ -81,7 +84,7 @@ namespace Fem
      */
     virtual double fixedTimeStepEocLoopFactor() const
     {
-      return Dune::Fem::Parameter::getValue< double >( keyPrefix_ + "fixedtimestepeocloopfactor" , 1.0 );
+      return parameter_.getValue< double >( keyPrefix_ + "fixedtimestepeocloopfactor" , 1.0 );
     }
 
     /**
@@ -89,7 +92,7 @@ namespace Fem
      */
     virtual double startTime() const
     {
-      return Dune::Fem::Parameter::getValue< double >( keyPrefix_ + "starttime" , 0.0 );
+      return parameter_.getValue< double >( keyPrefix_ + "starttime" , 0.0 );
     }
 
     /**
@@ -97,7 +100,7 @@ namespace Fem
      */
     virtual double endTime() const
     {
-      return Dune::Fem::Parameter::getValue< double >( keyPrefix_ + "endtime"/*, 1.0 */);
+      return parameter_.getValue< double >( keyPrefix_ + "endtime"/*, 1.0 */);
     }
 
     /**
@@ -109,7 +112,7 @@ namespace Fem
      */
     virtual int printCount() const
     {
-      return Dune::Fem::Parameter::getValue< int >( keyPrefix_ + "printcount" , -1 );
+      return parameter_.getValue< int >( keyPrefix_ + "printcount" , -1 );
     }
 
     /**
@@ -118,7 +121,7 @@ namespace Fem
      */
     virtual double maxTimeStep() const
     {
-      return Dune::Fem::Parameter::getValue< double >( keyPrefix_ + "maxtimestep", std::numeric_limits<double>::max());
+      return parameter_.getValue< double >( keyPrefix_ + "maxtimestep", std::numeric_limits<double>::max());
     }
 
     /**
@@ -126,7 +129,7 @@ namespace Fem
      */
     virtual int maximalTimeSteps () const
     {
-      return Dune::Fem::Parameter::getValue< int >(  keyPrefix_ + "maximaltimesteps", std::numeric_limits<int>::max());
+      return parameter_.getValue< int >(  keyPrefix_ + "maximaltimesteps", std::numeric_limits<int>::max());
     }
 
     /**
@@ -142,7 +145,7 @@ namespace Fem
      */
     virtual bool stopAtEndTime() const
     {
-      return Dune::Fem::Parameter::getValue< bool >( keyPrefix_ + "stopatendtime", bool(false) );
+      return parameter_.getValue< bool >( keyPrefix_ + "stopatendtime", bool(false) );
     }
 
   };

dune/fem-dg/operator/adaptation/utility.hh

@@ -24,14 +24,20 @@ namespace Fem
     protected:
     const std::string keyPrefix_;
     int markStrategy_;
-
-
+    const Dune::Fem::ParameterReader parameter_;
 
     public:
     //! constructor
-    AdaptationParameters( const std::string keyPrefix = "fem.adaptation." )
+    AdaptationParameters( const std::string keyPrefix = "fem.adaptation.",
+                          const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
       : keyPrefix_( keyPrefix ),
-        markStrategy_( getStrategy() )
+        markStrategy_( getStrategy() ),
+        parameter_(parameter)
+    {}
+    AdaptationParameters( const Dune::Fem::ParameterReader &parameter )
+      : keyPrefix_( "fem.adaptation" ),
+        markStrategy_( getStrategy() ),
+        parameter_(parameter)
     {}
 
     ////TODO:

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

@@ -142,9 +142,10 @@ namespace Fem
     template< class ExtraParameterTupleImp >
     DGAdvectionDiffusionOperatorBase( GridPartType& gridPart, const ModelType& model,
                                       ExtraParameterTupleImp& tuple,
-                                      const std::string name = "" )
+                                      const std::string name = "",
+                                      const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
       : model_( model )
-      , numflux_( model_ )
+      , numflux_( model_, parameter )
       , gridPart_( gridPart )
       , space_( gridPart_ )
       , discreteModel_( model_, numflux_,

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

@@ -364,18 +364,19 @@ namespace Fem
     DGLimitedAdvectionOperator( GridPartType& gridPart,
                                 const ModelType& model,
                                 ExtraParameterTupleImp tuple,
-                                const std::string name = "" )
+                                const std::string name = "",
+                                const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
       : model_( model )
-      , advflux_( model_ )
+      , advflux_( model_, parameter )
       , gridPart_( gridPart )
       , space_( gridPart_ )
       , limiterSpace_( gridPart_ )
       , uTmp_()
       , fvSpc_()
       , indicator_()
-      , diffFlux_( gridPart_, model_, DGPrimalDiffusionFluxParameters( ParameterKey::generate( name, "dgdiffusionflux." ) ) )
+      , diffFlux_( gridPart_, model_, DGPrimalDiffusionFluxParameters( ParameterKey::generate( name, "dgdiffusionflux." ), parameter ) )
       , discreteModel1_( model_, advflux_, diffFlux_ )
-      , limitDiscreteModel_( model_ , space_.order() )
+      , limitDiscreteModel_( model_ , space_.order(), parameter )
       , pass0_()
       , pass1_( limitDiscreteModel_, pass0_, limiterSpace_ )
       , pass2_( discreteModel1_, pass1_, space_ )

dune/fem-dg/operator/fluxes/advection/parameters.hh

@@ -70,8 +70,14 @@ namespace Fem
      *
      * \param[in] keyPrefix key prefix for parameter file.
      */
-    AdvectionFluxParameters( const std::string keyPrefix = "dgadvectionflux." )
-      : keyPrefix_( keyPrefix )
+    AdvectionFluxParameters( const std::string keyPrefix = "dgadvectionflux.",
+                             const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : keyPrefix_( keyPrefix ),
+        parameter_( parameter )
+    {}
+    AdvectionFluxParameters( const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : keyPrefix_( "dgadvectionflux." ),
+        parameter_( parameter )
     {}
 
     /**
@@ -94,12 +100,13 @@ namespace Fem
      */
     virtual IdEnum getMethod() const
     {
-      const int i = Fem::Parameter::getEnum( keyPrefix_ + "method", AdvectionFlux::_strings );
+      const int i = parameter_.getEnum( keyPrefix_ + "method", AdvectionFlux::_strings );
       return AdvectionFlux::_enums[i];
     }
 
   private:
     const std::string keyPrefix_;
+    const Dune::Fem::ParameterReader parameter_;
   };
 
 

dune/fem-dg/operator/fluxes/diffusion/parameters.hh

@@ -139,8 +139,10 @@ namespace Fem
      *
      * \param[in] keyPrefix key prefix for parameter file.
      */
-    DGPrimalDiffusionFluxParameters( const std::string keyPrefix = "dgdiffusionflux." )
-      : keyPrefix_( keyPrefix )
+    DGPrimalDiffusionFluxParameters( const std::string keyPrefix = "dgdiffusionflux.",
+                                     const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : keyPrefix_( keyPrefix ),
+        parameter_( parameter )
     {}
 
     /**
@@ -163,7 +165,7 @@ namespace Fem
      */
     virtual IdEnum getMethod() const
     {
-      const int i = Fem::Parameter::getEnum( keyPrefix_ + "method", PrimalDiffusionFlux::_strings, 0 );
+      const int i = parameter_.getEnum( keyPrefix_ + "method", PrimalDiffusionFlux::_strings, 0 );
       return PrimalDiffusionFlux::_enums[i];
     }
 
@@ -187,20 +189,20 @@ namespace Fem
      */
     virtual LiftingEnum getLifting() const
     {
-      const int i = Fem::Parameter::getEnum( keyPrefix_ + "lifting", PrimalDiffusionLifting::_strings, 0 );
+      const int i = parameter_.getEnum( keyPrefix_ + "lifting", PrimalDiffusionLifting::_strings, 0 );
       return PrimalDiffusionLifting::_enums[i];
     }
 
     //! todo please doc me
     virtual double penalty() const
     {
-      return Fem::Parameter::getValue<double>( keyPrefix_ + "penalty", 1.0 );
+      return parameter_.getValue<double>( keyPrefix_ + "penalty", 1.0 );
     }
 
     //! todo please doc me
     virtual double liftfactor() const
     {
-      return Fem::Parameter::getValue<double>( keyPrefix_ + "liftfactor", 1.0 );
+      return parameter_.getValue<double>( keyPrefix_ + "liftfactor", 1.0 );
     }
 
     /**
@@ -208,19 +210,19 @@ namespace Fem
      */
     virtual double theoryparameters() const
     {
-      return Fem::Parameter::getValue<double>( keyPrefix_ + "theoryparameters", 0. );
+      return parameter_.getValue<double>( keyPrefix_ + "theoryparameters", 0. );
     }
 
     //! todo please doc me
     template <class DomainType>
     void upwind( DomainType& upwd ) const
     {
-      Fem::Parameter::get(keyPrefix_ + "upwind", upwd, upwd);
+      parameter_.get(keyPrefix_ + "upwind", upwd, upwd);
     }
   private:
 
     const std::string keyPrefix_;
-
+    const Dune::Fem::ParameterReader parameter_;
   };
 
   /**

dune/fem-dg/operator/limiter/limiterdiscretemodel.hh

@@ -72,6 +72,7 @@ namespace Fem
     double crsTol_;
     int finLevel_;
     int crsLevel_;
+    const AdaptationParameters param;
     const bool shockIndicatorAdaptivty_;
 
   public:
@@ -81,13 +82,14 @@ namespace Fem
     //! constructor
     StandardLimiterDiscreteModel(const Model& mod,
                                  const int polOrd,
-                                 const AdaptationParameters& param = AdaptationParameters() )
-      : BaseType(mod),
+                                 const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : BaseType(mod, 1e-8, parameter),
         indicator_( 0 ),
         refTol_( -1 ),
         crsTol_( -1 ),
         finLevel_( 0 ),
         crsLevel_( 0 ),
+        param(parameter),
         shockIndicatorAdaptivty_( param.shockIndicator() )
     {
       if( shockIndicatorAdaptivty_ )

dune/fem-dg/operator/limiter/limiterutility.hh

@@ -909,16 +909,16 @@ namespace Fem
   struct LimiterFunctionBase
   {
     const double limitEps_;
-    LimiterFunctionBase()
-      : limitEps_( getEpsilon() )
+    LimiterFunctionBase( const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : limitEps_( getEpsilon(parameter) )
     {
     }
 
     //! get tolerance for shock detector
-    static double getEpsilon()
+    static double getEpsilon( const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
     {
       // default value is 1e-8
-      return Parameter::getValue("femdg.limiter.limiteps", double(1e-8) );
+      return parameter.getValue("femdg.limiter.limiteps", double(1e-8) );
     }
 
     //! return epsilon for limiting
@@ -955,7 +955,8 @@ namespace Fem
     using LimiterFunctionBase :: limitEps_ ;
     typedef Field FieldType;
 
-    MinModLimiter() : LimiterFunctionBase()
+    MinModLimiter( const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+    : LimiterFunctionBase(parameter)
     {
       printInfo( "minmod" );
     }
@@ -983,7 +984,8 @@ namespace Fem
     using LimiterFunctionBase :: limitEps_ ;
     typedef Field FieldType;
 
-    SuperBeeLimiter() : LimiterFunctionBase()
+    SuperBeeLimiter( const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+    : LimiterFunctionBase(parameter)
     {
       printInfo( "superbee" );
     }
@@ -1012,7 +1014,8 @@ namespace Fem
     using LimiterFunctionBase :: limitEps_ ;
     typedef Field FieldType;
 
-    VanLeerLimiter() : LimiterFunctionBase()
+    VanLeerLimiter( const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+    : LimiterFunctionBase(parameter)
     {
       printInfo( "vanLeer" );
     }

dune/fem-dg/operator/limiter/limitpass.hh

@@ -211,9 +211,10 @@ namespace Fem
 
     /** \brief default limiter discrete model */
     LimiterDefaultDiscreteModel(const Model& mod,
-                                const DomainFieldType veloEps = 1e-8)
+                                const DomainFieldType veloEps = 1e-8,
+                                const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
       : model_(mod)
-      , limiterFunction_()
+      , limiterFunction_(parameter)
       , velocity_(0)
       , veloEps_( veloEps )
     {

dune/fem-dg/solver/dg.hh

@@ -140,6 +140,41 @@ namespace Fem
       std::cout << "cfl = " << double(tp_.factor()) << " " << tp_.time() << std::endl;
     }
 
+    DGOperator( const DiscreteFunctionSpaceType& space,
+                const AdvectionModel &advectionModel,
+                const DiffusionModel &diffusionModel,
+                const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : space_( space ),
+        extra_(),
+        tpPtr_( new TimeProviderType(space_.gridPart().comm(), parameter) ),
+        tp_( *tpPtr_ ),
+        model_( advectionModel, diffusionModel ),
+        fullOperator_( space.gridPart(), model_, extra_, name(), parameter ),
+        explOperator_( space.gridPart(), model_, extra_, name(), parameter ),
+        implOperator_( space.gridPart(), model_, extra_, name(), parameter ),
+        rkSolver_( tp_, fullOperator_, explOperator_, implOperator_, name(), parameter ),
+        initialized_( false )
+    {
+      //Dune::Fem::Parameter::append("fem.parallel.numberofthreads", std::to_string( Additional::nThreads ) );
+
+      const TimeSteppingParameters param("femdg.stepper.",parameter);
+      const double maxTimeStep = param.maxTimeStep();
+      fixedTimeStep_ = param.fixedTimeStep();
+
+      // start first time step with prescribed fixed time step
+      // if it is not 0 otherwise use the internal estimate
+      tp_.provideTimeStepEstimate(maxTimeStep);
+
+      // adjust fixed time step with timeprovider.factor()
+      fixedTimeStep_ /= tp_.factor() ;
+      if ( fixedTimeStep_ > 1e-20 )
+        tp_.init( fixedTimeStep_ );
+      else
+        tp_.init();
+
+      std::cout << "cfl = " << double(tp_.factor()) << " " << tp_.time() << std::endl;
+    }
+
     DGOperator( TimeProviderType& tp,
                 const DiscreteFunctionSpaceType& space,
                 const AdvectionModel &advectionModel,

dune/fem-dg/solver/rungekuttasolver.hh

@@ -29,11 +29,13 @@ namespace Fem
      *
      * \param[in] keyPrefix key prefix for parameter file.
      */
-    RungeKuttaSolverParameters( const std::string keyPrefix = "fem.ode." )
-      : DuneODE::ImplicitRungeKuttaSolverParameters( keyPrefix )
+    RungeKuttaSolverParameters( const std::string keyPrefix = "fem.ode.",
+                                const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+      : DuneODE::ImplicitRungeKuttaSolverParameters( keyPrefix, parameter )
     {}
 
     using DuneODE::ImplicitRungeKuttaSolverParameters::keyPrefix_;
+    using DuneODE::ImplicitRungeKuttaSolverParameters::parameter;
 
     /**
      * \brief returns a factor for the decision whether to use IMEX Runge-Kutta
@@ -50,7 +52,7 @@ namespace Fem
      */
     virtual double explicitFactor() const
     {
-      return Fem::Parameter::getValue< double >( keyPrefix_ + "explicitfactor" , 1.0 );
+      return parameter().getValue< double >( keyPrefix_ + "explicitfactor" , 1.0 );
     }
 
     /**
@@ -82,7 +84,7 @@ namespace Fem
       // methods
       static const std::string odeSolver[]  = { "EX", "IM" ,"IMEX", "IMEX+"  };
       std::string key( keyPrefix_ + "odesolver" );
-      return Fem::Parameter::getEnum( key, odeSolver, 0 );
+      return parameter().getEnum( key, odeSolver, 0 );
     }
 
     /**
@@ -95,11 +97,10 @@ namespace Fem
     {
       std::string key( keyPrefix_ + "order");
       if ( Fem :: Parameter :: exists( key ) )
-        return Fem::Parameter::getValue< int > ( key );
+        return parameter().getValue< int > ( key );
       else
         return defaultRKOrder ;
     }
-
   };
 
 
@@ -162,7 +163,9 @@ namespace Fem
     {
       template < class OdeParameter >
       static solverpair_t
-      createExplicitSolver( Op& op, Fem::TimeProviderBase& tp, const int rkSteps, const OdeParameter& param, const std::string& name = ""  )
+      createExplicitSolver( Op& op, Fem::TimeProviderBase& tp, const int rkSteps, const OdeParameter& param,
+                            const Dune::Fem::ParameterReader &parameter,
+                            const std::string& name = ""  )
       {
         typedef DuneODE :: ExplicitRungeKuttaSolver< DiscreteFunctionType >          ExplicitOdeSolverType;
         return solverpair_t( new ExplicitOdeSolverType( op, tp, rkSteps ), nullptr );
@@ -170,7 +173,9 @@ namespace Fem
 
       template < class OdeParameter >
       static solverpair_t
-      createImplicitSolver( Op& op, Fem::TimeProviderBase& tp, const int rkSteps, const OdeParameter& param, const std::string& name = "" )
+      createImplicitSolver( Op& op, Fem::TimeProviderBase& tp, const int rkSteps, const OdeParameter& param,
+                            const Dune::Fem::ParameterReader &parameter,
+                            const std::string& name = "" )
       {
 #ifdef COUNT_FLOPS
         return solverpair_t();
@@ -187,14 +192,16 @@ namespace Fem
 
         typedef typename NonlinearInverseOperatorType::ParametersType NonlinParametersType;
 
-        return solverpair_t(new ImplicitOdeSolverType( *helmOp, tp, rkSteps, param, NonlinParametersType( ParameterKey::generate( name, "fem.solver.newton." ) ) ), helmOp );
+        return solverpair_t(new ImplicitOdeSolverType( *helmOp, tp, rkSteps, param, NonlinParametersType( ParameterKey::generate( name, "fem.solver.newton." ), parameter ) ), helmOp );
 #endif
       }
 
       template < class ExplOp, class ImplOp, class OdeParameter >
       static solverpair_t
       createSemiImplicitSolver( ExplOp& explOp, ImplOp& implOp, Fem::TimeProviderBase& tp,
-                                const int rkSteps, const OdeParameter& param, const std::string& name = "" )
+                                const int rkSteps, const OdeParameter& param,
+                                const Dune::Fem::ParameterReader &parameter,
+                                const std::string& name = "" )
       {
 #ifdef COUNT_FLOPS
         return solverpair_t();
@@ -213,7 +220,7 @@ namespace Fem
         typedef typename NonlinearInverseOperatorType::ParametersType NonlinParametersType;
 
 
-        return solverpair_t(new SemiImplicitOdeSolverType( explOp, *helmOp, tp, rkSteps, param, NonlinParametersType( ParameterKey::generate( name, "fem.solver.newton." ) ) ), helmOp );
+        return solverpair_t(new SemiImplicitOdeSolverType( explOp, *helmOp, tp, rkSteps, param, NonlinParametersType( ParameterKey::generate( name, "fem.solver.newton." ), parameter ) ), helmOp );
 #endif
       }
 
@@ -248,13 +255,14 @@ namespace Fem
                       OperatorType& op,
                       ExplicitOperatorType& advOp,
                       ImplicitOperatorType& diffOp,
-                      const std::string name = "" )
+                      const std::string name = "",
+                      const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
      : operator_( op ),
        timeProvider_( tp ),
        name_( name ),
        explicitOperator_( advOp ),
        implicitOperator_( diffOp ),
-       param_( new RungeKuttaSolverParameters( ParameterKey::generate( name_, "fem.ode." ) ) ),
+       param_( new RungeKuttaSolverParameters( ParameterKey::generate( name_, "fem.ode." ), parameter ) ),
        explicitSolver_( 0 ),
        odeSolver_( 0 ),
        helmholtzOperator_( 0 ),
@@ -271,11 +279,11 @@ namespace Fem
       // create implicit or explicit ode solver
       if( odeSolverType_ == 0 )
       {
-        solver = OdeSolversType :: createExplicitSolver( operator_, tp, rkSteps_, *param_, name_ );
+        solver = OdeSolversType :: createExplicitSolver( operator_, tp, rkSteps_, *param_, parameter, name_ );
       }
       else if (odeSolverType_ == 1)
       {
-        solver = OdeSolversType :: createImplicitSolver( operator_, tp, rkSteps_, *param_, name_ );
+        solver = OdeSolversType :: createImplicitSolver( operator_, tp, rkSteps_, *param_, parameter, name_ );
       }
       else if( odeSolverType_ > 1 )
       {
@@ -285,11 +293,11 @@ namespace Fem
           DUNE_THROW(Dune::InvalidStateException,"Advection and Diffusion operator are the same, therefore IMEX cannot work!");
         }
 
-        solver = OdeSolversType :: createSemiImplicitSolver( explicitOperator_, implicitOperator_, tp, rkSteps_, *param_, name_ );
+        solver = OdeSolversType :: createSemiImplicitSolver( explicitOperator_, implicitOperator_, tp, rkSteps_, *param_, parameter, name_ );
 
         // IMEX+
         if( odeSolverType_ == 3 )
-          explicitSolver_ = OdeSolversType :: createExplicitSolver( operator_, tp, rkSteps_, *param_, name_ ).first;
+          explicitSolver_ = OdeSolversType :: createExplicitSolver( operator_, tp, rkSteps_, *param_, parameter, name_ ).first;
       }
       else
       {

pydemo/euler/main.py

@@ -12,12 +12,22 @@ dim = 2
 gamma = 1.4
 
 parameter.append({"fem.verboserank": -1})
-parameter.append({"fem.parallel.numberofthreads": 4})
-parameter.append("parameter")
 
-primitive=lambda Model,uh: {"pressure":Model.toPrim(uh)[2]}
+primitive=lambda Model,uh: {"pressure": Model.toPrim(uh)[2]}
+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}
+#-----------------
+# femdg.limiter.admissiblefunctions:
+#    0 = only dg solution | 1 = only reconstruction | 2 = both
+#-----------------
+
 
 run(*problem(),
         startLevel=0, polOrder=2, limiter="default",
         primitive=primitive, saveStep=0.1, subsamp=2,
-        dt=None,threading=True,grid="alucube")
+        dt=None,threading=True,grid="alucube",
+        parameters=parameters)

pydemo/euler/paramBase

-# OMP THREADS 
-#------------
-fem.verboserank: 0
-# write diagnostics file (
-# 0 don't, 1 only speedup file, 2 write all runfiles 
-# 3 only write 0, others at end, 4 all files at end for scaling) 
-fem.parallel.diagnostics: 1
-# if true non-blocking communication is enabled
-femdg.nonblockingcomm: true
-fem.threads.verbose: true
-# if true thread 0 only communicates data but does not computation
-fem.threads.communicationthread: false
-fem.threads.partitioningmethod: sfc

pydemo/euler/paramSolver

-# SOLVER CONFIGURATION
-#---------------------
-
-fem.ode.odesolver: EX # ode solvers: EX, IM, IMEX
-# fem.ode.order: 3
-fem.ode.verbose: cfl # ode output: none, cfl, full
-fem.ode.cflincrease: 1.25
-fem.ode.miniterations: 95
-fem.ode.maxiterations: 105
-fem.ode.cflStart: 1.
-#fem.ode.cflMax: 5
-fem.timeprovider.factor: 0.45
-fem.timeprovider.updatestep: 1
-femdg.stepper.maxtimestep: 1e-3
-
-# parameter for the implicit solvers
-fem.solver.verbose: false
-fem.solver.gmres.restart: 15
-fem.solver.newton.verbose: false
-fem.solver.newton.linear.verbose: false
-fem.solver.newton.maxlineariterations: 1000
-fem.solver.newton.tolerance: 1e-10
-
-dgdiffusionflux.method: CDG2 # diffusion flux: CDG2, CDG, BR2, IP, NIPG, BO
-dgdiffusionflux.theoryparameters: 1 # scaling with theory parameters
-dgdiffusionflux.penalty: 0.
-dgdiffusionflux.liftfactor: 1.0

pydemo/euler/parameter

-# LIMITER SETTINGS
-#-----------------
-# 0 = only dg solution | 1 = only reconstruction | 2 = both
-femdg.limiter.admissiblefunctions: 1
-# tolerance for shock indicator
-femdg.limiter.tolerance: 1 # 1e-10
-# threshold for avoiding over-excessive limitation
-femdg.limiter.limiteps: 1e-8
-
-# GENERAL
-#--------
-paramfile: paramBase
-
-
-# choises are: LLF, HLL, HLLC, LLF2
-dgadvectionflux.method: LLF
-
-# SOLVER CONFIGURATION
-#---------------------
-fem.ode.odesolver: EX
-paramfile: paramSolver

pydemo/fulltest.py

@@ -9,3 +9,7 @@ parameter.append("parameter")
 for p in shallowWater.problems + euler.problems:
     run(*p(), startLevel=0, polOrder=2, limiter="default",
               primitive=None, saveStep=None, subsamp=0)
+              dt=None,threading=True,grid="alusimplex")
+    run(*p(), startLevel=0, polOrder=2, limiter="default",
+              primitive=None, saveStep=None, subsamp=0)
+              dt=None,threading=True,grid="yasp")

pydemo/paramBase → pydemo/paramThreading

 # OMP THREADS 
 #------------
-fem.verboserank: 0
 # number of threads used in OMP program
 fem.parallel.numberofthreads: 1
 # write diagnostics file (

pydemo/scalar/main.py

@@ -8,8 +8,23 @@ from dune.femdg.testing import run
 from scalar import diffusivePulse as problem
 
 parameter.append({"fem.verboserank": 0})
-parameter.append("parameter")
+
+parameters = {"fem.ode.odesolver": "IM",   # EX, IM, IMEX
+              "fem.ode.order": 3,
+              "fem.ode.verbose": "none",      # none, cfl, full
+              "fem.ode.cflincrease": 1.25,
+              "fem.ode.miniterations": 35,
+              "fem.ode.maxiterations": 100,
+              "fem.timeprovider.factor": 0.45,
+              "dgadvectionflux.method": "LLF",
+              "fem.solver.gmres.restart": 50,
+              "dgdiffusionflux.method": "CDG2",      # CDG2, CDG, BR2, IP, NIPG, BO
+              "dgdiffusionflux.theoryparameters": 1, # scaling with theory parameters
+              "dgdiffusionflux.penalty": 0,
+              "dgdiffusionflux.liftfactor": 1}
 
 run(*problem(),
-        startLevel=0, polOrder=0, limiter=None,
-        primitive=None, saveStep=0.01, subsamp=0)
+        startLevel=0, polOrder=2, limiter=None,
+        primitive=None, saveStep=0.01, subsamp=0,
+        dt=0.1,
+        parameters=parameters)

pydemo/scalar/paramBase

-# OMP THREADS 
-#------------
-fem.verboserank: 0
-# number of threads used in OMP program
-fem.parallel.numberofthreads: 4
-# write diagnostics file (
-# 0 don't, 1 only speedup file, 2 write all runfiles 
-# 3 only write 0, others at end, 4 all files at end for scaling) 
-fem.parallel.diagnostics: 1
-# if true non-blocking communication is enabled
-femdg.nonblockingcomm: true
-fem.threads.verbose: true
-# if true thread 0 only communicates data but does not computation
-fem.threads.communicationthread: false
-fem.threads.partitioningmethod: sfc

pydemo/scalar/paramSolver

-# SOLVER CONFIGURATION
-#---------------------
-
-fem.ode.odesolver: IMEX # ode solvers: EX, IM, IMEX
-fem.ode.order: 3
-fem.ode.verbose: cfl # ode output: none, cfl, full
-fem.ode.cflincrease: 1.25
-fem.ode.miniterations: 35
-fem.ode.maxiterations: 100
-fem.ode.cflStart: 1.
-fem.ode.cflMax: 5
-fem.timeprovider.factor: 0.45
-fem.timeprovider.updatestep: 1
-
-# parameter for the implicit solvers
-# fem.differenceoperator.eps: 1e-12
-fem.solver.gmres.restart: 50
-fem.solver.newton.verbose: false
-fem.solver.newton.linear.verbose: false
-fem.solver.verbose: false
-fem.solver.newton.maxlineariterations: 100000
-fem.solver.newton.tolerance: 1e-07
-fem.solver.newton.linabstol: 2e-8
-fem.solver.newton.linreduction: 2e-8
-
-
-
-dgdiffusionflux.method: CDG2 # diffusion flux: CDG2, CDG, BR2, IP, NIPG, BO
-dgdiffusionflux.theoryparameters: 1 # scaling with theory parameters
-dgdiffusionflux.penalty: 0.
-dgdiffusionflux.liftfactor: 1.0