05.03., 9:00 - 11:00: Due to updates GitLab will be unavailable for some minutes between 09:00 and 11:00.

Commit ba4cbd34 authored by Anne Reinarz's avatar Anne Reinarz

euler dim

parent 503c8df6
{
"project_name": "Euler",
"paths": {
"peano_kernel_path": "./Peano",
"exahype_path": "./ExaHyPE",
"output_directory": "./ApplicationExamples/EulerFlow/EulerFlow_DIM",
"log_file": "bla.log"
},
"architecture": "snb",
"computational_domain": {
"dimension": 2,
"end_time": 1.0,
"outside_cells_left": 0,
"outside_cells_right": 0,
"offset": [
-0.25,
-0.22
],
"width": [
1.5,
0.44
]
},
"optimisation": {
"fuse_algorithmic_steps": "all",
"fuse_algorithmic_steps_rerun_factor": 0.99,
"fuse_algorithmic_steps_diffusion_factor": 0.99,
"spawn_predictor_as_background_thread": false,
"spawn_amr_background_threads": false,
"disable_vertex_exchange_in_time_steps": true,
"time_step_batch_factor": 0.0,
"disable_metadata_exchange_in_batched_time_steps": false,
"double_compression": 0.0,
"spawn_double_compression_as_background_thread": false
},
"solvers": [
{
"type": "Limiting-ADER-DG",
"name": "LimitingADERDG",
"order": 4,
"patch_size": 9,
"maximum_mesh_size": 0.09,
"maximum_mesh_depth": 1,
"time_stepping": "global",
"aderdg_kernel": {
"language": "C",
"nonlinear": true,
"terms": [
"flux",
"ncp",
"source"
],
"space_time_predictor": {},
"optimised_terms": [],
"optimised_kernel_debugging": [],
"implementation": "optimised"
},
"point_sources": 0,
"limiter": {
"dmp_observables": 6,
"dmp_relaxation_parameter": 1e-3,
"dmp_difference_scaling": 1e-4,
"implementation": "generic"
},
"fv_kernel": {
"language": "C",
"terms": [
"flux",
"ncp",
"source"
],
"scheme": "musclhancock",
"slope_limiter": "minmod",
"implementation": "generic"
},
"variables": [
{
"name": "rho",
"multiplicity": 1
},
{
"name": "j",
"multiplicity": 3
},
{
"name": "E",
"multiplicity": 1
},
{
"name": "alpha",
"multiplicity": 1
},
{
"name": "vs",
"multiplicity": 3
}
],
"plotters": [
{
"type": "vtk::Cartesian::cells::limited::ascii",
"name": "Plotter",
"time": 0.0,
"repeat": 0.01,
"resolution": "0.0001",
"output": "./output/dg",
"variables": 6
}
]
}
]
}
// This file is generated by the ExaHyPE toolkit.
// Please do not modify - it will be overwritten by the next
// ExaHyPE toolkit call.
//
// ========================
// www.exahype.eu
// ========================
// ==============================================
// Please do not change the implementations below
// ==============================================
#include "LimitingADERDG.h"
#include "kernels/limiter/generic/Limiter.h"
#include "kernels/LimiterProjectionMatrices.h"
Euler::LimitingADERDG::LimitingADERDG(
const double maximumMeshSize,
const int maximumMeshDepth,
const int haloCells,
const int haloBufferCells,
const int limiterBufferCells,
const int regularisedFineGridLevels,
const exahype::solvers::Solver::TimeStepping timeStepping,
const int DMPObservables,
const double DMPRelaxationParameter,
const double DMPDifferenceScaling
) :
exahype::solvers::LimitingADERDGSolver::LimitingADERDGSolver(
"LimitingADERDG",
new Euler::LimitingADERDG_ADERDG(
maximumMeshSize,maximumMeshDepth,haloCells,haloBufferCells,limiterBufferCells,regularisedFineGridLevels,timeStepping,DMPObservables),
new Euler::LimitingADERDG_FV(
maximumMeshSize, timeStepping),
DMPRelaxationParameter,
DMPDifferenceScaling) {
kernels::computeDG2FVProjector<Order,PatchSize>(dg2fv);
kernels::computeFV2DGProjector<Order,PatchSize>(fv2dg,dg2fv);
kernels::computeLegendre2LobattoProjector<Order>(leg2lob);
}
void Euler::LimitingADERDG::projectOnFVLimiterSpace(const double* const luh, double* const lim) const {
kernels::limiter::generic::c::projectOnFVLimiterSpace<NumberOfVariables+NumberOfParameters, Order+1, PatchSize, GhostLayerWidth>(luh, dg2fv, lim);
}
void Euler::LimitingADERDG::projectOnDGSpace(const double* const lim, double* const luh) const {
kernels::limiter::generic::c::projectOnDGSpace<NumberOfVariables+NumberOfParameters, Order+1, PatchSize, GhostLayerWidth>(lim, fv2dg, luh);
}
bool Euler::LimitingADERDG::discreteMaximumPrincipleAndMinAndMaxSearch(const double* const luh, double* const boundaryMinPerVariables, double* const boundaryMaxPerVariables) {
return kernels::limiter::generic::c::discreteMaximumPrincipleAndMinAndMaxSearch<AbstractLimitingADERDG_ADERDG, NumberOfDMPObservables, Order+1, PatchSize, GhostLayerWidth>(
luh, *static_cast<AbstractLimitingADERDG_ADERDG*>(_solver.get()), dg2fv, fv2dg, leg2lob, _DMPMaximumRelaxationParameter, _DMPDifferenceScaling, boundaryMinPerVariables, boundaryMaxPerVariables);
}
void Euler::LimitingADERDG::findCellLocalMinAndMax(const double* const luh, double* const localMinPerVariables, double* const localMaxPerVariable) {
kernels::limiter::generic::c::findCellLocalMinAndMax<AbstractLimitingADERDG_ADERDG, NumberOfDMPObservables, Order+1, PatchSize>(
luh, *static_cast<AbstractLimitingADERDG_ADERDG*>(_solver.get()), dg2fv, fv2dg, leg2lob, localMinPerVariables, localMaxPerVariable);
}
void Euler::LimitingADERDG::findCellLocalLimiterMinAndMax(const double* const lim, double* const localMinPerObservable, double* const localMaxPerObservable) {
kernels::limiter::generic::c::findCellLocalLimiterMinAndMax<AbstractLimitingADERDG_ADERDG, NumberOfDMPObservables, Order+1, PatchSize, GhostLayerWidth>(
lim, *static_cast<AbstractLimitingADERDG_ADERDG*>(_solver.get()), localMinPerObservable, localMaxPerObservable);
}
\ No newline at end of file
#ifndef __LimitingADERDG_CLASS_HEADER__
#define __LimitingADERDG_CLASS_HEADER__
// This file is generated by the ExaHyPE toolkit.
// Please do not modify - it will be overwritten by the next
// ExaHyPE toolkit call.
//
// ========================
// www.exahype.eu
// ========================
#include <string>
#include "exahype/solvers/LimitingADERDGSolver.h"
#include "LimitingADERDG_ADERDG.h"
#include "LimitingADERDG_FV.h"
namespace Euler{
class LimitingADERDG;
}
class Euler::LimitingADERDG: public exahype::solvers::LimitingADERDGSolver {
public:
static constexpr int NumberOfVariables = Euler::AbstractLimitingADERDG_ADERDG::NumberOfVariables;
static constexpr int NumberOfParameters = Euler::AbstractLimitingADERDG_ADERDG::NumberOfParameters;
static constexpr int Order = Euler::AbstractLimitingADERDG_ADERDG::Order;
static constexpr int NumberOfGlobalObservables = Euler::AbstractLimitingADERDG_ADERDG::NumberOfGlobalObservables;
static constexpr int NumberOfDMPObservables = Euler::AbstractLimitingADERDG_ADERDG::NumberOfDMPObservables;
static constexpr int PatchSize = Euler::AbstractLimitingADERDG_FV::PatchSize;
static constexpr int GhostLayerWidth = Euler::AbstractLimitingADERDG_FV::GhostLayerWidth;
// limiter projection matrices
double dg2fv[(Order+1)*PatchSize];
double fv2dg[(Order+1)*PatchSize];
double leg2lob[(Order+1)*(Order+1)];
LimitingADERDG(
const double maximumMeshSize,
const int maximumMeshDepth,
const int haloCells,
const int haloBufferCells,
const int limiterBufferCells,
const int regularisedFineGridLevels,
const exahype::solvers::Solver::TimeStepping timeStepping,
const int DMPObservables,
const double DMPRelaxationParameter,
const double DMPDifferenceScaling
);
void projectOnFVLimiterSpace(const double* const luh, double* const lim) const override;
void projectOnDGSpace(const double* const lim, double* const luh) const override;
bool discreteMaximumPrincipleAndMinAndMaxSearch(const double* const luh, double* const boundaryMinPerVariables, double* const boundaryMaxPerVariables) override;
void findCellLocalMinAndMax(const double* const luh, double* const localMinPerVariables, double* const localMaxPerVariable) override;
void findCellLocalLimiterMinAndMax(const double* const lim, double* const localMinPerObservable, double* const localMaxPerObservable) override;
};
#endif // __LimitingADERDG_CLASS_HEADER__
\ No newline at end of file
// This file was generated by the ExaHyPE toolkit.
// It will NOT be regenerated or overwritten.
// Please adapt it to your own needs.
//
// ========================
// www.exahype.eu
// ========================
#include "LimitingADERDG_ADERDG.h"
#include "LimitingADERDG_ADERDG_Variables.h"
#include "kernels/KernelUtils.h"
#include "peano/utils/Loop.h"
#include "kernels/GaussLegendreBasis.h"
#include <cstring> // memset
#include "PDE.h"
tarch::logging::Log Euler::LimitingADERDG_ADERDG::_log( "Euler::LimitingADERDG_ADERDG" );
void Euler::LimitingADERDG_ADERDG::init(const std::vector<std::string>& cmdlineargs,const exahype::parser::ParserView& constants) {}
void Euler::LimitingADERDG_ADERDG::adjustPointSolution(const double* const x,const double t,const double dt,double* const Q) {
if (tarch::la::equals(t,0.0)) {
initialdata(x,t,Q);
}
}
void Euler::LimitingADERDG_ADERDG::boundaryValues(const double* const x,const double t,const double dt,const int faceIndex,const int normalNonZero,const double* const fluxIn,const double* const stateIn,const double* const gradStateIn,double* const fluxOut,double* const stateOut) {
stateOut[0] = stateIn[0];
stateOut[1] = stateIn[1];
stateOut[2] = stateIn[2];
stateOut[3] = stateIn[3];
stateOut[4] = stateIn[4];
stateOut[5] = stateIn[5];
stateOut[6] = stateIn[6];
stateOut[7] = stateIn[7];
stateOut[8] = stateIn[8];
fluxOut[0] = fluxIn[0];
fluxOut[1] = fluxIn[1];
fluxOut[2] = fluxIn[2];
fluxOut[3] = fluxIn[3];
fluxOut[4] = fluxIn[4];
fluxOut[5] = fluxIn[5];
fluxOut[6] = fluxIn[6];
fluxOut[7] = fluxIn[7];
fluxOut[8] = fluxIn[8];
stateOut[1+normalNonZero] = -stateIn[1+normalNonZero];
}
exahype::solvers::Solver::RefinementControl Euler::LimitingADERDG_ADERDG::refinementCriterion(const double* const luh,const tarch::la::Vector<DIMENSIONS,double>& cellCentre,const tarch::la::Vector<DIMENSIONS,double>& cellSize,double t,const int level) {
if (level>getCoarsestMeshLevel())
return exahype::solvers::Solver::RefinementControl::Erase;
return exahype::solvers::Solver::RefinementControl::Keep;
}
void Euler::LimitingADERDG_ADERDG::mapDiscreteMaximumPrincipleObservables(double* observables, const double* const Q) const {
observables[0] = Q[0]; //extract density
observables[1] = Q[1];
observables[2] = Q[2];
observables[3] = Q[3];
observables[4] = Q[4];
observables[5] = Q[5]; // extract alpha
}
bool Euler::LimitingADERDG_ADERDG::isPhysicallyAdmissible(
const double* const solution,
const double* const observablesMin,const double* const observablesMax,
const bool wasTroubledInPreviousTimeStep,
const tarch::la::Vector<DIMENSIONS,double>& center,
const tarch::la::Vector<DIMENSIONS,double>& dx,
const double t) const {
if (observablesMin[0] < 1.e-2) return false;
if(observablesMax[5] < 0.985 && observablesMin[5] > 0.015)
return false;
if(observablesMax[5]>1.005)
return false;
return true;
}
//*****************************************************************************
//******************************** PDE ****************************************
// To use other PDE terms, specify them in the specification file, delete this
// file and its header and rerun the toolkit
//*****************************************************************************
//TODO: modify with alpha
void Euler::LimitingADERDG_ADERDG::eigenvalues(const double* const Q,const int direction,double* const lambda) {
PDEEigenvalues(Q,direction,lambda);
}
void Euler::LimitingADERDG_ADERDG::flux(const double* const Q,double** F) {
PDEflux(Q,F);
}
void Euler::LimitingADERDG_ADERDG::nonConservativeProduct(const double* const Q,const double* const gradQ,double* const BgradQ){
PDEncp(Q,gradQ,BgradQ);
}
void Euler::LimitingADERDG_ADERDG::algebraicSource(const tarch::la::Vector<DIMENSIONS, double>& x, double t, const double *const Q, double *S) {
for(int i = 0; i < 9; i++) S[i]=0.0;
}
#ifndef __LimitingADERDG_ADERDG_CLASS_HEADER__
#define __LimitingADERDG_ADERDG_CLASS_HEADER__
// This file was initially generated by the ExaHyPE toolkit.
// You can modify it in order to extend your solver with features.
// Whenever this file is present, a re-run of the ExaHyPE toolkit will
// not overwrite it. Delete it to get it regenerated.
//
// ========================
// www.exahype.eu
// ========================
#include <ostream>
#include "AbstractLimitingADERDG_ADERDG.h"
#include "exahype/parser/ParserView.h"
/**
* We use Peano's logging
*/
#include "tarch/logging/Log.h"
namespace Euler{
class LimitingADERDG_ADERDG;
}
class Euler::LimitingADERDG_ADERDG : public Euler::AbstractLimitingADERDG_ADERDG {
private:
/**
* Log device
*/
static tarch::logging::Log _log;
public:
LimitingADERDG_ADERDG(
const double maximumMeshSize,
const int maximumMeshDepth,
const int haloCells,
const int haloBufferCells,
const int limiterBufferCells,
const int regularisedFineGridLevels,
const exahype::solvers::Solver::TimeStepping timeStepping,
const int DMPObservables
);
/**
* Initialise the solver.
*
* @param[in] cmdlineargs the command line arguments.
* @param[in] constants access to the constants specified for the solver.
*/
void init(const std::vector<std::string>& cmdlineargs,const exahype::parser::ParserView& constants) final override;
/**
* Adjust the conserved variables and parameters (together: Q) at a given time t at the (quadrature) point x.
*
* @note Please overwrite function adjustSolution(...) if you want to
* adjust the solution degrees of freedom in a cellwise manner.
*
* @param[in] x physical coordinate on the face.
* @param[in] t start of the time interval.
* @param[in] dt width of the time interval.
* @param[in] Q vector of state variables (plus parameters);
* range: [0,nVar+nPar-1], already allocated.
*/
void adjustPointSolution(const double* const x,const double t,const double dt,double* const Q) final override;
/**
* Compute the eigenvalues of the flux tensor per coordinate @p direction.
*
* @param[in] Q vector of state variables (plus parameters);
* range: [0,nVar+nPar-1], already allocated.
* @param[in] direction normal direction of the face / column of the flux vector (range: [0,nDims-1]).
* @param[inout] lambda eigenvalues as C array;
* range: [0,nVar-1], already allocated.
*/
void eigenvalues(const double* const Q,const int direction,double* const lambda) final override;
/**
* Impose boundary conditions at a point on a boundary face
* within the time interval [t,t+dt].
*
* @param[in] x physical coordinate on the face;
* range: [0,nDims-1].
* @param[in] t start of the time interval.
* @param[in] dt width of the time interval.
* @param[in] faceIndex indexing of the face (0 -- {x[0]=xmin}, 1 -- {x[1]=xmax}, 2 -- {x[1]=ymin}, 3 -- {x[2]=ymax}, and so on,
* where xmin,xmax,ymin,ymax are the bounds of the cell containing point x.
* @param[in] direction coordinate direction the face normal is pointing to.
*
* @param[in] QIn the conserved variables (plus parameters) at point x from inside of the domain
* and time-averaged (over [t,t+dt]);
* range: [0,nVar+nPar-1], already allocated.
* @param[in] FIn the normal fluxes at point x from inside of the domain
* and time-averaged (over [t,t+dt]);
* range: [0,nVar-1], already allocated.
*
* @param[inout] QOut the conserved variables at point x from outside of the domain
* and time-averaged (over [t,t+dt]);
* range: [0,nVar+nPar-1], already allocated.
* @param[inout] FOut the normal fluxes at point x from outside of the domain;
* range: [0,nVar-1], already allocated.
*/
void boundaryValues(const double* const x,const double t,const double dt,const int faceIndex,const int direction,const double * const fluxIn,const double* const stateIn, const double* const gradStateIn,double *fluxOut,double* stateOut) final override;
/**
* Evaluate the refinement criterion within a cell.
*
* @note Instead of a variables array at a single quadrature point we give
* you all NumberOfVariables*(Order+1)^DIMENSIONS solution degrees of freedom.
*
* @note Use this function and ::adjustSolution to set initial conditions.
*
* @param[in] luh all state variables (plus parameters) of a cell;
* range[outer->inner]: [0,(p+1)^nDim-1]x[0,nVar+nPar-1],
* already allocated.
*
* @param[in] cellCentre cellCentre of the cell.
* @param[in] cellSize extent of the cell.
* @param[in] t start of the time interval.
* @param[in] dt width of the time interval.
*
* @return One of exahype::solvers::Solver::RefinementControl::{Erase,Keep,Refine}.
*/
exahype::solvers::Solver::RefinementControl refinementCriterion(const double* const luh,const tarch::la::Vector<DIMENSIONS,double>& cellCentre,const tarch::la::Vector<DIMENSIONS,double>& cellSize,double t,const int level) override;
//PDE
/**
* Compute the flux tensor.
*
* @param[in] Q vector of state variables (plus parameters);
* range: [0,nVar+nPar-1], already allocated.
*
* @param[inout] F flux at that point;
* range[outer->inner]: [0,nDim-1]x[0,nVar-1],
* already allocated.
*/
void flux(const double* const Q,double** const F) final override;
/* viscousFlux() function not included, as requested in the specification file */
/* algebraicSource() function not included, as requested by the specification file */
/**
* Compute the nonconservative term $B(Q) \nabla Q$.
*
* This function shall return a vector BgradQ which holds the result
* of the full term. To do so, it gets the vector Q and the matrix
* gradQ which holds the derivative of Q in each spatial direction.
* Currently, the gradQ is a continous storage and users can use the
* kernels::icellSize2 class in order to compute the positions inside gradQ.
*
* @TODO: Check if the following is still right:
*
* !!! Warning: BgradQ is a vector of size NumberOfVariables if you
* use the ADER-DG kernels for nonlinear PDEs. If you use
* the kernels for linear PDEs, it is a tensor with dimensions
* Dim x NumberOfVariables.
*
* @param[in] Q vector of state variables (plus material
* parameters); range: [0,nVar+nPar-1], already allocated.
* @param[in] gradQ the gradients of the vector of unknowns, stored
* in a linearized array. (range: [0,dim*(nVar+nPar)-1].
* @param[inout] BgradQ the nonconservative product (extends nVar),
* already allocated.
*/
void nonConservativeProduct(const double* const Q,const double* const gradQ,double* const BgradQ) final override;
bool isPhysicallyAdmissible(
const double* const solution,
const double* const observablesMin,const double* const observablesMax,
const bool wasTroubledInPreviousTimeStep,
const tarch::la::Vector<DIMENSIONS,double>& center,
const tarch::la::Vector<DIMENSIONS,double>& dx,
const double t) const override;
void algebraicSource(const tarch::la::Vector<DIMENSIONS, double>& x, double t, const double *const Q, double *S) override;
void mapDiscreteMaximumPrincipleObservables(double* observables, const double* const Q) const override;
/* pointSource() function not included, as requested in the specification file */
/* multiplyMaterialParameterMatrix() not included, as requested in the specification file */
};
#endif // __LimitingADERDG_ADERDG_CLASS_HEADER__
#include "LimitingADERDG_FV.h"
#include "LimitingADERDG_FV_Variables.h"
#include "LimitingADERDG_ADERDG.h"
#include "PDE.h"
tarch::logging::Log Euler::LimitingADERDG_FV::_log( "Euler::LimitingADERDG_FV" );
void Euler::LimitingADERDG_FV::init(const std::vector<std::string>& cmdlineargs,const exahype::parser::ParserView& constants) {}
void Euler::LimitingADERDG_FV::adjustSolution(const double* const x,const double t,const double dt, double* const Q) {
if (tarch::la::equals(t,0.0)) {
initialdata(x,t,Q);
}
for(int i=0; i< 9; i++){
if(!std::isfinite(Q[i])){
std::cout << "Q[" << i << "]=" << Q[i] << std::endl;
throw(2);
}
}
}
void Euler::LimitingADERDG_FV::boundaryValues(
const double* const x,
const double t,const double dt,
const int faceIndex,
const int normalNonZero,
const double* const stateIn,
double* const stateOut) {
const int nVar = NumberOfVariables;
std::copy_n(stateIn,nVar,stateOut);
stateOut[1+normalNonZero] = -stateIn[1+normalNonZero];
}
//***********************************************************
//*********************** PDE *******************************
//***********************************************************
void Euler::LimitingADERDG_FV::eigenvalues(const double* const Q, const int direction, double* const lambda) {
PDEEigenvalues(Q,direction, lambda);
}
void Euler::LimitingADERDG_FV::flux(const double* const Q,double** const F) {
PDEflux(Q,F);
}
void Euler::LimitingADERDG_FV::nonConservativeProduct(const double* const Q,const double* const gradQ,double* const BgradQ){
PDEncp(Q,gradQ,BgradQ);
}
void Euler::LimitingADERDG_FV::algebraicSource(const tarch::la::Vector<DIMENSIONS, double>& x, double t, const double *const Q, double *S){
for(int i = 0; i < 9; i++) S[i]=0.0;
}
double Euler::LimitingADERDG_FV::riemannSolver(
double* fnL, double *fnR, const double* qL, const double* qR,
const double* gradQL, const double* gradQR,
const double* const cellSize,
int normalNonZero) {
constexpr int numberOfVariables = Euler::AbstractLimitingADERDG_FV::NumberOfVariables;
constexpr int numberOfParameters = Euler::AbstractLimitingADERDG_FV::NumberOfParameters;
constexpr int numberOfData = numberOfVariables+numberOfParameters;
// Compute penalty contribution of convective eigenvalues.
double sL[numberOfVariables];
double sR[numberOfVariables];
eigenvalues(qL, normalNonZero, sL);
eigenvalues(qR, normalNonZero, sR);
double maxEigenvalue = -1.0;
for (int i = 0; i < numberOfVariables; i++) {
maxEigenvalue = std::max( std::abs(sL[i]), maxEigenvalue);
}
for (int i = 0; i < numberOfVariables; i++) {
maxEigenvalue = std::max(std::abs(sR[i]), maxEigenvalue);
}
double s_max = maxEigenvalue;
double s_max_dt = maxEigenvalue;
// determine BgradQ from ncp
double ncp[numberOfData] = {0.0};
double gradQ[DIMENSIONS][numberOfData] = {0.0};
double Qavg[numberOfData];
for(int k=0; k < numberOfData; k++) {
Qavg[k] = (qR[k] + qL[k]) / 2;
gradQ[normalNonZero][k] = qR[k] - qL[k];
}
nonConservativeProduct(Qavg, gradQ[0], ncp);
double FL2[DIMENSIONS][numberOfVariables] = {0.0}; // Q: Can we skip this memset?
double FR2[DIMENSIONS][numberOfVariables] = {0.0};
double* FL[DIMENSIONS]={FL2[0], FL2[1]};
double* FR[DIMENSIONS]={FR2[0], FR2[1]};
flux(qL, FL);
flux(qR, FR);
for (int i = 0; i < numberOfVariables; i++) {
fnL[i] = 0.5 * s_max * (qL[i] - qR[i]);
fnL[i] += 0.5 * (FL2[normalNonZero][i] + FR2[normalNonZero][i]);
fnR[i] = fnL[i] - 0.5 * ncp[i];
fnL[i] = fnL[i] + 0.5 * ncp[i];
}
//fnL[5] = 0.0;
//fnR[5] = 0.0;
return s_max_dt;
}
#ifndef __LimitingADERDG_FV_CLASS_HEADER__
#define __LimitingADERDG_FV_CLASS_HEADER__
// This file was initially generated by the ExaHyPE toolkit.
// You can modify it in order to extend your solver with features.
// Whenever this file is present, a re-run of the ExaHyPE toolkit will
// not overwrite it. Delete it to get it regenerated.
//
// ========================
// www.exahype.eu
// ========================
#include <ostream>
#include "AbstractLimitingADERDG_FV.h"
#include "exahype/parser/ParserView.h"
/**
* We use Peano's logging
*/
#include "tarch/logging/Log.h"
namespace Euler{
class LimitingADERDG_FV;
}
class Euler::LimitingADERDG_FV : public Euler::AbstractLimitingADERDG_FV {
private:
/**
* Log device
*/
static tarch::logging::Log _log;
public:
LimitingADERDG_FV(
const double maximumMeshSize,
const exahype::solvers::Solver::TimeStepping timeStepping