Peano 4
Loading...
Searching...
No Matches
kernels::aderdg::generic::c Namespace Reference

Data Structures

struct  RungeKuttaIntegrator
 This is a small standalone RungeKutta Integrator suitable for integrating a single DG cell in time without boundary exchange to another cell. More...
 

Functions

template<bool useFlux, bool useNCP, bool useMM, typename SolverType >
void riemannSolverLinear (SolverType &solver, double *FL, double *FR, const double *const QL, const double *const QR, const double t, const double dt, const tarch::la::Vector< Dimensions, double > &faceCentre, const tarch::la::Vector< Dimensions, double > &dx, const int direction)
 
template<bool useNCP, typename SolverType >
void riemannSolverNonlinear (SolverType &solver, double *FL, double *FR, const double *const QL, const double *const QR, const double t, const double dt, const tarch::la::Vector< Dimensions, double > &faceCentre, const tarch::la::Vector< Dimensions, double > &dx, const int direction)
 We implement a very simple Rusanov scheme with scalar dissipation (smax*Id).
 
constexpr int basisSizeD (int basisSize)
 
void computeGradQ (double *gradQ, const double *const u, const tarch::la::Vector< DIMENSIONS, double > &sizeOfPatch, const int numberOfVariables, const int order)
 Helper function to compute the gradients for all entries in Q with the ADER-DG scheme.
 
void computeGradQi (double *gradQi, const double *const u, const int requestedDirection, const int requestedVariableIndex, const tarch::la::Vector< DIMENSIONS, double > &sizeOfPatch, const int numberOfVariables, const int order)
 Convenience function to compute the gradient of only a single variable in a given direction.
 
template<typename SolverType >
void computeGradQ (double *gradQ, const double *const u, const tarch::la::Vector< DIMENSIONS, double > &sizeOfPatch)
 Read off values from SolverTypes, for convenience.
 
template<typename SolverType >
void computeGradQi (double *gradQi, const double *const u, const int requestedDirection, const int requestedVariableIndex, const tarch::la::Vector< DIMENSIONS, double > &sizeOfPatch)
 Convenience also for computeGradQi.
 
void computeGradQ (double *gradQ, const double *const u, double ***dudx, const tarch::la::Vector< Dimensions, double > &sizeOfPatch, const int numberOfVariables, const int order)
 Helper function to compute the gradients for all entries in Q with the ADER-DG scheme.
 
template<typename SolverType >
void computeGradQi (double *gradQi, const double *const u, double ***dudx, const int requestedDirection, const int requestedVariableIndex, const tarch::la::Vector< Dimensions, double > &sizeOfPatch, const int numberOfVariables, const int order)
 Convenience function to compute the gradient of only a single variable in a given direction.
 
template<typename SolverType >
void computeGradQ (double *gradQ, const double *const u, const tarch::la::Vector< Dimensions, double > &sizeOfPatch)
 Read off values from SolverTypes, for convenience.
 
template<typename SolverType >
void computeGradQi (double *gradQi, const double *const u, const int requestedDirection, const int requestedVariableIndex, const tarch::la::Vector< Dimensions, double > &sizeOfPatch)
 Convenience also for computeGradQi.
 
template<bool useNCP, bool useFlux, int numQuadPoints, typename SolverType >
void generalisedOsherSolomon (SolverType &solver, double *const FL, double *const FR, const double *const QL, const double *const QR, const double t, const double dt, const int direction)
 We implement a very simple Rusanov scheme with scalar dissipation (smax*Id).
 
template<typename SolverType >
void integrateBoundaryConditions (SolverType &solver, const double *const x, const double t, const double dt, const int faceIndex, const int dir, const double *const fluxIn, const double *const stateIn, double *fluxOut, double *stateOut)
 integrateBoundaryConditions is a helper function for the Solver's boundaryValues() method which is called by the Kernel's boundaryConditions method.
 
template<typename SolverType >
void computeLoehner (double *Xi, const double *const u, const int PhiIndex, const tarch::la::Vector< Dimensions, double > &sizeOfPatch)
 This is a hacky attemp to implement the Loehner scheme for an AMR criterion for our ADERDG kernels.
 
template<bool usePointSource, bool useSource, bool useFlux, bool useNCP, bool useMM, typename SolverType , typename pCompType , typename pStoreType >
void spaceTimePredictorLinear (SolverType &solver, pStoreType *lQbnd, pStoreType *lFbnd, pCompType *lQi, pCompType *lFi, pCompType *gradQ, pCompType *PSi, pCompType *PSderivatives, pCompType *tmp_PSderivatives, pCompType *lQhi, pCompType *lFhi, const double *const luh, const tarch::la::Vector< Dimensions, double > &cellCenter, const tarch::la::Vector< Dimensions, double > &invDx, const double t, const double dt)
 
template<bool useSource, bool useFlux, bool useNCP, bool noTimeAveraging, typename SolverType , typename pCompType , typename pStoreType >
int spaceTimePredictorNonlinear (SolverType &solver, pStoreType *lQhbnd, pStoreType *lGradQhbnd, pStoreType *lFhbnd, pCompType *lQi, pCompType *rhs, pCompType *lFi, pCompType *gradQ, pCompType *lQhi, pCompType *lFhi, const double *const luh, const tarch::la::Vector< Dimensions, double > &cellCenter, const tarch::la::Vector< Dimensions, double > &invDx, double t, const double dt)
 
template<typename SolverType , typename pType >
void solutionUpdate (SolverType &solver, double *luh, const double *const luhOld, const pType *const lduh, const double dt)
 
template<typename SolverType , typename pCompType , bool useSourceOrNCP, bool useFlux, int numberOfVariables, int basisSize>
void volumeIntegralLinear (pCompType *lduh, const pCompType *const lFhi, const tarch::la::Vector< Dimensions, double > &dx)
 
template<typename SolverType , typename pCompType , bool useSourceOrNCP, bool useFlux, bool noTimeAveraging, int numberOfVariables, int basisSize>
void volumeIntegralNonlinear (pCompType *lduh, const pCompType *const lFi, const tarch::la::Vector< Dimensions, double > &dx)
 
template<typename SolverType , int numberOfVariables, int basisSize>
void faceIntegralNonlinear (double *lduh, const double *const lFhbnd, const int direction, const int orientation, const tarch::la::Vector< Dimensions, double > &dx)
 
template<typename SolverType , int numberOfVariables, int basisSize>
void faceIntegralLinear (double *lduh, const double *const lFhbnd, const int direction, const int orientation, const tarch::la::Vector< Dimensions, double > &dx)
 
template<typename SolverType , int numberOfVariables, int basisSize>
void surfaceIntegralNonlinear (double *lduh, const double *const lFbnd, const tarch::la::Vector< Dimensions, double > &dx)
 
template<typename SolverType , int numberOfVariables, int basisSize>
void surfaceIntegralLinear (double *lduh, const double *const lFbnd, const tarch::la::Vector< Dimensions, double > &dx)
 
template<typename SolverType >
void solutionAdjustment (SolverType &solver, double *luh, const tarch::la::Vector< Dimensions, double > &center, const tarch::la::Vector< Dimensions, double > &dx, const double t, const double dt)
 This file is part of the ExaHyPE project.
 
template<bool useFlux, bool useNCP, typename SolverType >
void generalisedOsherSolomon (SolverType &solver, double *const FL, double *const FR, const double *const QL, const double *const QR, const double t, const double dt, const int direction)
 Implements a generalised osher type flux.
 
template<bool useGradientFlux, typename SolverType >
void boundaryConditions (SolverType &solver, double *fluxOut, double *stateOut, const double *const fluxIn, const double *const stateIn, const double *const gradStateIn, const tarch::la::Vector< Dimensions, double > &cellCentre, const tarch::la::Vector< Dimensions, double > &cellSize, const double t, const double dt, const int faceIndex, const int direction)
 
template<typename SolverType , typename T >
double maxScaledEigenvalue (SolverType &solver, const T *const luh, const tarch::la::Vector< Dimensions, double > &cellCentre, const tarch::la::Vector< Dimensions, double > &dx, const double t, const double dt)
 This file is part of the ExaHyPE project.
 
template<typename SolverType , typename pStoreType , int numberOfVariables, int basisSize>
void singleLevelFaceUnknownsProlongation (pStoreType *lQhbndFine, const pStoreType *lQhbndCoarse, const tarch::la::Vector< Dimensions - 1, int > &subfaceIndex)
 
template<typename SolverType , typename pStoreType , int numberOfVariables, int basisSize>
void singleLevelFaceUnknownsRestriction (pStoreType *lQhbndCoarse, const pStoreType *lQhbndFine, const tarch::la::Vector< Dimensions - 1, int > &subfaceIndex)
 
template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void faceUnknownsProlongation (double *lQhbndFine, double *lFhbndFine, const double *lQhbndCoarse, const double *lFhbndCoarse, const int coarseGridLevel, const int fineGridLevel, const tarch::la::Vector< Dimensions - 1, int > &subfaceIndex)
 
template<typename SolverType , int numberOfVariables, int basisSize>
void faceUnknownsRestriction (double *const lFhbndCoarse, const double *const lFhbndFine, const tarch::la::Vector< Dimensions - 1, int > &subfaceIndex, const int levelDelta)
 
template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void faceUnknownsRestriction (double *lQhbndCoarse, double *lFhbndCoarse, const double *lQhbndFine, const double *lFhbndFine, const int coarseGridLevel, const int fineGridLevel, const tarch::la::Vector< Dimensions - 1, int > &subfaceIndex)
 
template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void volumeUnknownsProlongation (double *luhFine, const double *luhCoarse, const int coarseGridLevel, const int fineGridLevel, const tarch::la::Vector< Dimensions, int > &subcellIndex)
 
template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void volumeUnknownsRestriction (double *luhCoarse, const double *luhFine, const int coarseGridLevel, const int fineGridLevel, const tarch::la::Vector< Dimensions, int > &subcellIndex)
 
template<typename SolverType >
std::vector< int > * getPointSources (SolverType &solver, const tarch::la::Vector< Dimensions, double > &center, const tarch::la::Vector< Dimensions, double > &dx)
 
template<typename SolverType >
void deltaDistribution (SolverType &solver, const double *const luh, const double t, const double dt, const tarch::la::Vector< Dimensions, double > &center, const tarch::la::Vector< Dimensions, double > &dx, std::vector< int > *pointSources, double *PSi)
 

Function Documentation

◆ basisSizeD()

constexpr int kernels::aderdg::generic::c::basisSizeD ( int basisSize)
constexpr

Definition at line 25 of file computeGradients.cpph.

Referenced by computeLoehner().

Here is the caller graph for this function:

◆ boundaryConditions()

template<bool useGradientFlux, typename SolverType >
void kernels::aderdg::generic::c::boundaryConditions ( SolverType & solver,
double * fluxOut,
double * stateOut,
const double *const fluxIn,
const double *const stateIn,
const double *const gradStateIn,
const tarch::la::Vector< Dimensions, double > & cellCentre,
const tarch::la::Vector< Dimensions, double > & cellSize,
const double t,
const double dt,
const int faceIndex,
const int direction )

◆ computeGradQ() [1/4]

template<typename SolverType >
void kernels::aderdg::generic::c::computeGradQ ( double * gradQ,
const double *const u,
const tarch::la::Vector< DIMENSIONS, double > & sizeOfPatch )

Read off values from SolverTypes, for convenience.

Definition at line 199 of file computeGradients.cpph.

References computeGradQ().

Here is the call graph for this function:

◆ computeGradQ() [2/4]

template<typename SolverType >
void kernels::aderdg::generic::c::computeGradQ ( double * gradQ,
const double *const u,
const tarch::la::Vector< Dimensions, double > & sizeOfPatch )

Read off values from SolverTypes, for convenience.

Definition at line 203 of file computeGradients.cpph.

References computeGradQ().

Here is the call graph for this function:

◆ computeGradQ() [3/4]

void kernels::aderdg::generic::c::computeGradQ ( double * gradQ,
const double *const u,
const tarch::la::Vector< DIMENSIONS, double > & sizeOfPatch,
const int numberOfVariables,
const int order )

Helper function to compute the gradients for all entries in Q with the ADER-DG scheme.

This is not optimal if you need only certain entries.

In any case, you have to provide the storage, ie. with double u[numberOfVariables] = ... // your conserved variables double dx[3] = {0.5, 0.5, 0.5}; // the cell size double gradQ[basisSize3 * DIMENSIONS * numberOfVariables]; computeGradQ<AbstractYourSolver>(gradQ, u, dx);

Another example how to use is

using namespace kernels::aderdg::generic::c;
double gradQ[basisSizeD(AbstractMyEulerSolver::Order + 1) * DIMENSIONS * AbstractMyEulerSolver::NumberOfVariables]; computeGradQ<AbstractMyEulerSolver>(gradQ, Q, sizeOfPatch);

For the array ordering, we assume u the DOF (luh) on a whole cell. The gradQ ordering is: Z, Y, X, nDim, nVars. If you use 2D, you only need storage for Y, X, nDim, nVars.

This function is dimension agnostic. It uses the kernels::index and just undestands basisSize=1 for the z direction if DIMENSIONS == 2. This applies nicely for the loops as for(int j=0; j<1; j++) { body } just executes "body" one time.

@TODO: This should not be an inline function. Make up a seperate cpp file.

Definition at line 65 of file computeGradients.cpph.

References exahype2::solvers::aderdg::ADERDGSolver::dudx, j, k, and kernels::index::size.

Referenced by computeGradQ(), and computeGradQ().

Here is the caller graph for this function:

◆ computeGradQ() [4/4]

void kernels::aderdg::generic::c::computeGradQ ( double * gradQ,
const double *const u,
double *** dudx,
const tarch::la::Vector< Dimensions, double > & sizeOfPatch,
const int numberOfVariables,
const int order )

Helper function to compute the gradients for all entries in Q with the ADER-DG scheme.

This is not optimal if you need only certain entries.

In any case, you have to provide the storage, ie. with double u[numberOfVariables] = ... // your conserved variables double dx[3] = {0.5, 0.5, 0.5}; // the cell size double gradQ[basisSize3 * Dimensions * numberOfVariables]; computeGradQ<AbstractYourSolver>(gradQ, u, dx);

Another example how to use is

using namespace kernels::aderdg::generic::c;
double gradQ[basisSizeD(AbstractMyEulerSolver::Order + 1) * Dimensions * AbstractMyEulerSolver::NumberOfVariables]; computeGradQ<AbstractMyEulerSolver>(gradQ, Q, sizeOfPatch);

For the array ordering, we assume u the DOF (luh) on a whole cell. The gradQ ordering is: Z, Y, X, nDim, nVars. If you use 2D, you only need storage for Y, X, nDim, nVars.

This function is dimension agnostic. It uses the kernels::index and just undestands basisSize=1 for the z direction if Dimensions == 2. This applies nicely for the loops as for(int j=0; j<1; j++) { body } just executes "body" one time.

@TODO: This should not be an inline function. Make up a seperate cpp file.

Definition at line 68 of file computeGradients.cpph.

References j, k, and kernels::index::size.

◆ computeGradQi() [1/4]

template<typename SolverType >
void kernels::aderdg::generic::c::computeGradQi ( double * gradQi,
const double *const u,
const int requestedDirection,
const int requestedVariableIndex,
const tarch::la::Vector< DIMENSIONS, double > & sizeOfPatch )

Convenience also for computeGradQi.

Definition at line 207 of file computeGradients.cpph.

References computeGradQi().

Here is the call graph for this function:

◆ computeGradQi() [2/4]

template<typename SolverType >
void kernels::aderdg::generic::c::computeGradQi ( double * gradQi,
const double *const u,
const int requestedDirection,
const int requestedVariableIndex,
const tarch::la::Vector< Dimensions, double > & sizeOfPatch )

Convenience also for computeGradQi.

Definition at line 211 of file computeGradients.cpph.

◆ computeGradQi() [3/4]

void kernels::aderdg::generic::c::computeGradQi ( double * gradQi,
const double *const u,
const int requestedDirection,
const int requestedVariableIndex,
const tarch::la::Vector< DIMENSIONS, double > & sizeOfPatch,
const int numberOfVariables,
const int order )

Convenience function to compute the gradient of only a single variable in a given direction.

One could extend this to compute the gradient of a number of requested variables (i.e. a mapping or simliar).

Parameters
iRequested Variable I
dirRequested Direction

For the shapes of the variables, see the idx functions.

Definition at line 136 of file computeGradients.cpph.

References exahype2::solvers::aderdg::ADERDGSolver::dudx, j, k, and kernels::index::size.

Referenced by computeGradQi(), and computeLoehner().

Here is the caller graph for this function:

◆ computeGradQi() [4/4]

template<typename SolverType >
void kernels::aderdg::generic::c::computeGradQi ( double * gradQi,
const double *const u,
double *** dudx,
const int requestedDirection,
const int requestedVariableIndex,
const tarch::la::Vector< Dimensions, double > & sizeOfPatch,
const int numberOfVariables,
const int order )

Convenience function to compute the gradient of only a single variable in a given direction.

One could extend this to compute the gradient of a number of requested variables (i.e. a mapping or simliar).

Parameters
iRequested Variable I
dirRequested Direction

For the shapes of the variables, see the idx functions.

Definition at line 140 of file computeGradients.cpph.

References j, k, and kernels::index::size.

◆ computeLoehner()

template<typename SolverType >
void kernels::aderdg::generic::c::computeLoehner ( double * Xi,
const double *const u,
const int PhiIndex,
const tarch::la::Vector< Dimensions, double > & sizeOfPatch )

This is a hacky attemp to implement the Loehner scheme for an AMR criterion for our ADERDG kernels.

Input: Solution on complete patch; Variable position inside solution where you want to compute the criterion on. We might think of having this more generic later on; Parmeters such as patch size, numberOfVariables, order

Output: The estimator Xi(Phi) on the whole patch. Xi has extends Xi(basisSize,basisSize,basisSize) as it is a scalar field.

ALERT This is not yet finished.

Definition at line 42 of file loehnerScheme.cpph.

References basisSizeD(), computeGradQi(), dfor, ford, and k.

Here is the call graph for this function:

◆ deltaDistribution()

template<typename SolverType >
void kernels::aderdg::generic::c::deltaDistribution ( SolverType & solver,
const double *const luh,
const double t,
const double dt,
const tarch::la::Vector< Dimensions, double > & center,
const tarch::la::Vector< Dimensions, double > & dx,
std::vector< int > * pointSources,
double * PSi )

◆ faceIntegralLinear()

template<typename SolverType , int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::faceIntegralLinear ( double * lduh,
const double *const lFhbnd,
const int direction,
const int orientation,
const tarch::la::Vector< Dimensions, double > & dx )

◆ faceIntegralNonlinear()

template<typename SolverType , int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::faceIntegralNonlinear ( double * lduh,
const double *const lFhbnd,
const int direction,
const int orientation,
const tarch::la::Vector< Dimensions, double > & dx )

◆ faceUnknownsProlongation()

template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void kernels::aderdg::generic::c::faceUnknownsProlongation ( double * lQhbndFine,
double * lFhbndFine,
const double * lQhbndCoarse,
const double * lFhbndCoarse,
const int coarseGridLevel,
const int fineGridLevel,
const tarch::la::Vector< Dimensions - 1, int > & subfaceIndex )

◆ faceUnknownsRestriction() [1/2]

template<typename SolverType , int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::faceUnknownsRestriction ( double *const lFhbndCoarse,
const double *const lFhbndFine,
const tarch::la::Vector< Dimensions - 1, int > & subfaceIndex,
const int levelDelta )

◆ faceUnknownsRestriction() [2/2]

template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void kernels::aderdg::generic::c::faceUnknownsRestriction ( double * lQhbndCoarse,
double * lFhbndCoarse,
const double * lQhbndFine,
const double * lFhbndFine,
const int coarseGridLevel,
const int fineGridLevel,
const tarch::la::Vector< Dimensions - 1, int > & subfaceIndex )
Note
We need to consider material parameters in lQhbndFine and lQhbndCoarse.

\deprecated

◆ generalisedOsherSolomon() [1/2]

template<bool useNCP, bool useFlux, int numQuadPoints, typename SolverType >
void kernels::aderdg::generic::c::generalisedOsherSolomon ( SolverType & solver,
double *const FL,
double *const FR,
const double *const QL,
const double *const QR,
const double t,
const double dt,
const int direction )

We implement a very simple Rusanov scheme with scalar dissipation (smax*Id).

We need to consider material parameters in QL and QR. We don't need to consider material parameters in FL,FR.

Definition at line 40 of file generalisedOsherSolomon.cpph.

References kernels::riemannsolvers::util::computeOsherMatrix(), j, and k.

Here is the call graph for this function:

◆ generalisedOsherSolomon() [2/2]

template<bool useFlux, bool useNCP, typename SolverType >
void kernels::aderdg::generic::c::generalisedOsherSolomon ( SolverType & solver,
double *const FL,
double *const FR,
const double *const QL,
const double *const QR,
const double t,
const double dt,
const int direction )

Implements a generalised osher type flux.

Note
Requires solver to implement a nonconservative product and an eigenvectors function which returns the eigenvalues and eigenvectors. The kernel supplies the solver with reference coordinate indices.

References:

[1] M. Dumbser and E. F. Toro, “On Universal Osher-Type Schemes for General Nonlinear Hyperbolic Conservation Laws,” Communications in Computational Physics, vol. 10, no. 03, pp. 635–671, Sep. 2011. [2] M. Dumbser and E. F. Toro, “A Simple Extension of the Osher Riemann Solver to Non-conservative Hyperbolic Systems,” Journal of Scientific Computing, vol. 48, no. 1–3, pp. 70–88, Jul. 2011.

Note
Currently, no viscous flux is supported.
Template Parameters
numQuadPointsthe number of quadrature points the Legendre quadrature should use. 3 is chosen in paper [1].
Parameters
solversolver implementing an eigenvectors function (plus a nonconservative product) if required.
FL"left"/"-" normal flux of size [0,nVar]^2.
FR"right"/"+"normal flux of size [0,nVar]^2.
QL"left"/"-" state variables (plus parameters); range: [0,nVar+nPar]^2.
QR"right"/"+"state variables (plus parameters); range: [0,nVar+nPar]^2.
ttime stamp
dttime step size
directionnormal direction

◆ getPointSources()

template<typename SolverType >
std::vector< int > * kernels::aderdg::generic::c::getPointSources ( SolverType & solver,
const tarch::la::Vector< Dimensions, double > & center,
const tarch::la::Vector< Dimensions, double > & dx )

◆ integrateBoundaryConditions()

template<typename SolverType >
void kernels::aderdg::generic::c::integrateBoundaryConditions ( SolverType & solver,
const double *const x,
const double t,
const double dt,
const int faceIndex,
const int dir,
const double *const fluxIn,
const double *const stateIn,
double * fluxOut,
double * stateOut )

integrateBoundaryConditions is a helper function for the Solver's boundaryValues() method which is called by the Kernel's boundaryConditions method.

It allows to compute time integrated boundary conditions.

Todo
: We could think about offering the time integration for boundary conditions in a similar manner as with useAdjustSolution, ie. allowing a mixture of point/patch wise as well as already time integrated BC.

For an example of how to use this function, cf. the guidebook or the SRMHD application.

Definition at line 37 of file integrateBoundaryConditions.cpph.

◆ maxScaledEigenvalue()

template<typename SolverType , typename T >
double kernels::aderdg::generic::c::maxScaledEigenvalue ( SolverType & solver,
const T *const luh,
const tarch::la::Vector< Dimensions, double > & cellCentre,
const tarch::la::Vector< Dimensions, double > & dx,
const double t,
const double dt )

This file is part of the ExaHyPE project.

Copyright (c) 2016 http://exahype.eu All rights reserved.

The project has received funding from the European Union's Horizon 2020 research and innovation programme under grant agreement No 671698. For copyrights and licensing, please consult the webpage.

Released under the BSD 3 Open Source License. For the full license text, see LICENSE.txt

Definition at line 24 of file maxScaledEigenvalue.cpph.

References dx, exahype2::dg::getQuadraturePoint(), and j.

Here is the call graph for this function:

◆ riemannSolverLinear()

template<bool useFlux, bool useNCP, bool useMM, typename SolverType >
void kernels::aderdg::generic::c::riemannSolverLinear ( SolverType & solver,
double * FL,
double * FR,
const double *const QL,
const double *const QR,
const double t,
const double dt,
const tarch::la::Vector< Dimensions, double > & faceCentre,
const tarch::la::Vector< Dimensions, double > & dx,
const int direction )

Definition at line 25 of file riemannSolverLinear.cpph.

References dx, j, and exahype2::solvers::aderdg::ADERDGSolver::weights.

◆ riemannSolverNonlinear()

template<bool useNCP, typename SolverType >
void kernels::aderdg::generic::c::riemannSolverNonlinear ( SolverType & solver,
double * FL,
double * FR,
const double *const QL,
const double *const QR,
const double t,
const double dt,
const tarch::la::Vector< Dimensions, double > & faceCentre,
const tarch::la::Vector< Dimensions, double > & dx,
const int direction )

We implement a very simple Rusanov scheme with scalar dissipation (smax*Id).

Implements a Rusanov Riemann solver.

We need to consider material parameters in QL and QR. We don't need to consider material parameters in FL,FR.

Parameters
solver
FL
FR
QL
QR
t
dt
faceCentre
dx
direction

Definition at line 38 of file riemannSolverNonlinear.cpph.

References dx, j, k, and exahype2::solvers::aderdg::ADERDGSolver::weights.

◆ singleLevelFaceUnknownsProlongation()

template<typename SolverType , typename pStoreType , int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::singleLevelFaceUnknownsProlongation ( pStoreType * lQhbndFine,
const pStoreType * lQhbndCoarse,
const tarch::la::Vector< Dimensions - 1, int > & subfaceIndex )
Note
We need to consider material parameters in lQhbndFine and lQhbndCoarse.

◆ singleLevelFaceUnknownsRestriction()

template<typename SolverType , typename pStoreType , int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::singleLevelFaceUnknownsRestriction ( pStoreType * lQhbndCoarse,
const pStoreType * lQhbndFine,
const tarch::la::Vector< Dimensions - 1, int > & subfaceIndex )

◆ solutionAdjustment()

template<typename SolverType >
void kernels::aderdg::generic::c::solutionAdjustment ( SolverType & solver,
double * luh,
const tarch::la::Vector< Dimensions, double > & center,
const tarch::la::Vector< Dimensions, double > & dx,
const double t,
const double dt )

This file is part of the ExaHyPE project.

Copyright (c) 2016 http://exahype.eu All rights reserved.

The project has received funding from the European Union's Horizon 2020 research and innovation programme under grant agreement No 671698. For copyrights and licensing, please consult the webpage.

Released under the BSD 3 Open Source License. For the full license text, see LICENSE.txt

Definition at line 14 of file solutionAdjustment.cpph.

References dx, and j.

◆ solutionUpdate()

template<typename SolverType , typename pType >
void kernels::aderdg::generic::c::solutionUpdate ( SolverType & solver,
double * luh,
const double *const luhOld,
const pType *const lduh,
const double dt )

◆ spaceTimePredictorLinear()

template<bool usePointSource, bool useSource, bool useFlux, bool useNCP, bool useMM, typename SolverType , typename pCompType , typename pStoreType >
void kernels::aderdg::generic::c::spaceTimePredictorLinear ( SolverType & solver,
pStoreType * lQbnd,
pStoreType * lFbnd,
pCompType * lQi,
pCompType * lFi,
pCompType * gradQ,
pCompType * PSi,
pCompType * PSderivatives,
pCompType * tmp_PSderivatives,
pCompType * lQhi,
pCompType * lFhi,
const double *const luh,
const tarch::la::Vector< Dimensions, double > & cellCenter,
const tarch::la::Vector< Dimensions, double > & invDx,
const double t,
const double dt )
Parameters
SolverTypeHas to be of type ADERDG Solver.

◆ spaceTimePredictorNonlinear()

template<bool useSource, bool useFlux, bool useNCP, bool noTimeAveraging, typename SolverType , typename pCompType , typename pStoreType >
int kernels::aderdg::generic::c::spaceTimePredictorNonlinear ( SolverType & solver,
pStoreType * lQhbnd,
pStoreType * lGradQhbnd,
pStoreType * lFhbnd,
pCompType * lQi,
pCompType * rhs,
pCompType * lFi,
pCompType * gradQ,
pCompType * lQhi,
pCompType * lFhi,
const double *const luh,
const tarch::la::Vector< Dimensions, double > & cellCenter,
const tarch::la::Vector< Dimensions, double > & invDx,
double t,
const double dt )

◆ surfaceIntegralLinear()

template<typename SolverType , int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::surfaceIntegralLinear ( double * lduh,
const double *const lFbnd,
const tarch::la::Vector< Dimensions, double > & dx )

◆ surfaceIntegralNonlinear()

template<typename SolverType , int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::surfaceIntegralNonlinear ( double * lduh,
const double *const lFbnd,
const tarch::la::Vector< Dimensions, double > & dx )

◆ volumeIntegralLinear()

template<typename SolverType , typename pCompType , bool useSourceOrNCP, bool useFlux, int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::volumeIntegralLinear ( pCompType * lduh,
const pCompType *const lFhi,
const tarch::la::Vector< Dimensions, double > & dx )

◆ volumeIntegralNonlinear()

template<typename SolverType , typename pCompType , bool useSourceOrNCP, bool useFlux, bool noTimeAveraging, int numberOfVariables, int basisSize>
void kernels::aderdg::generic::c::volumeIntegralNonlinear ( pCompType * lduh,
const pCompType *const lFi,
const tarch::la::Vector< Dimensions, double > & dx )

◆ volumeUnknownsProlongation()

template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void kernels::aderdg::generic::c::volumeUnknownsProlongation ( double * luhFine,
const double * luhCoarse,
const int coarseGridLevel,
const int fineGridLevel,
const tarch::la::Vector< Dimensions, int > & subcellIndex )
Note
We need to consider material parameters in luhCoarse and luhFine.

Definition at line 24 of file projections.cpph.

◆ volumeUnknownsRestriction()

template<typename SolverType , int numberOfVariables, int numberOfParameters, int basisSize>
void kernels::aderdg::generic::c::volumeUnknownsRestriction ( double * luhCoarse,
const double * luhFine,
const int coarseGridLevel,
const int fineGridLevel,
const tarch::la::Vector< Dimensions, int > & subcellIndex )
Note
We need to consider material parameters in luhCoarse and luhFine.