Average.h

Go to the documentation of this file.

// This file is part of the ExaHyPE2 project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
 
#include <vector>
 
#include "../DGUtils.h"
#include "../Functors.h"
 
#include "../CellIntegral.h"
#include "../Riemann.h"
 
#include "tarch/la/Vector.h"
#include "tarch/multicore/multicore.h"
 
#include "peano4/grid/GridControlEvent.h"
#include "peano4/utils/Globals.h"
 
#if defined(GPUOffloadingOMP)
#include "exahype2/dg/rusanov/omp/Rusanov.h"
#endif
 
 
namespace exahype2 {
  namespace dg {
    namespace average {
      void solveRiemannProblem_pointwise_in_situ(
        ::exahype2::dg::Flux                         flux,
        const tarch::la::Vector<Dimensions,double>&  faceCentre,
        const tarch::la::Vector<Dimensions,double>&  cellSize,
        double                                       t,
        double                                       dt,
        int                                          order,
        int                                          unknowns,
        int                                          auxiliaryVariables,
        int                                          faceNumber,
        const double* __restrict__                   quadraturePoints,
        bool                                         useFlux,
        const double* __restrict__                   projectedValues,
        double* __restrict__                         solution
      );
 
 
      static void cellIntegral_patchwise_in_situ_GaussLegendre_functors(
        ::exahype2::CellData<double, double>&          cellData,
        const int                                      order,
        const int                                      unknowns,
        const int                                      auxiliaryVariables,
        Flux                                           flux,
        NonConservativeProduct                         nonConservativeProduct,
        Source                                         source,
        PointSources                                   pointSources,
        const double* __restrict__                     QuadratureNodes1d,
        const double* __restrict__                     MassMatrixDiagonal1d,
        const double* __restrict__                     StiffnessMatrix1d,
        const double* __restrict__                     DerivativeOperator1d,
        bool                                           evaluateFlux,
        bool                                           evaluateNonconservativeProduct,
        bool                                           evaluateSource,
        bool                                           evaluatePointSources
      ) {
        ::exahype2::dg::cellIntegral_patchwise_in_situ_GaussLegendre_functors(
            cellData,
            order, unknowns, auxiliaryVariables,
            flux,  nonConservativeProduct,  source,  pointSources,
            QuadratureNodes1d,
            MassMatrixDiagonal1d,
            StiffnessMatrix1d,
            DerivativeOperator1d,
            evaluateFlux,  evaluateNonconservativeProduct,  evaluateSource,  evaluatePointSources
          );
      }
 
 
      static void multiplyWithInvertedMassMatrix_GaussLegendre(
        ::exahype2::CellData<double, double>&          cellData,
        const int                                      order,
        const int                                      unknowns,
        const int                                      auxiliaryVariables,
        const double* __restrict__                     MassMatrixDiagonal1d
      ) {
        ::exahype2::dg::multiplyWithInvertedMassMatrix_GaussLegendre(
          cellData,
          order, unknowns, auxiliaryVariables, MassMatrixDiagonal1d
        );
      }
 
 
      static void integrateOverRiemannSolutionsAndAddToVolume_GaussLegendre(
        const double* const __restrict__    faceQLeft,
        const double* const __restrict__    faceQRight,
        const double* const __restrict__    faceQBottom,
        const double* const __restrict__    faceQUp,
        int                                 order,
        int                                 unknowns,
        const int                           auxiliaryVariables,
        const tarch::la::Vector<2,double>&  cellSize,
        const double* const __restrict__    BasisFunctionValuesLeft,
        const double* __restrict__          MassMatrixDiagonal1d,
        double* __restrict__                cellQ
      ) {
        ::exahype2::dg::integrateOverRiemannSolutionsAndAddToVolume_GaussLegendre(
          faceQLeft,  faceQRight,  faceQBottom,  faceQUp,
          order, unknowns, auxiliaryVariables,
          cellSize,
          BasisFunctionValuesLeft,
          MassMatrixDiagonal1d,
          cellQ
        );
      }
 
 
      static void integrateOverRiemannSolutionsAndAddToVolume_GaussLegendre(
        const double* const __restrict__    faceQLeft,
        const double* const __restrict__    faceQRight,
        const double* const __restrict__    faceQBottom,
        const double* const __restrict__    faceQUp,
        const double* const __restrict__    faceQFront,
        const double* const __restrict__    faceQBack,
        int                                 order,
        int                                 unknowns,
        const int                           auxiliaryVariables,
        const tarch::la::Vector<3,double>&  cellSize,
        const double* const __restrict__    BasisFunctionValuesLeft,
        const double* __restrict__          MassMatrixDiagonal1d,
        double* __restrict__                cellQ
      ) {
        ::exahype2::dg::integrateOverRiemannSolutionsAndAddToVolume_GaussLegendre(
          faceQLeft,  faceQRight,  faceQBottom,  faceQUp, faceQFront, faceQBack,
          order, unknowns, auxiliaryVariables,
          cellSize,
          BasisFunctionValuesLeft,
          MassMatrixDiagonal1d,
          cellQ
        );
      }
 
 
      template <
        typename Solver,
        int      order,
        int      unknowns,
        int      auxiliaryVariables
      >
      void cellIntegral_patchwise_in_situ_GaussLegendre(
        ::exahype2::CellData<double, double>&          cellData,
        bool                                           evaluateFlux,
        bool                                           evaluateNonconservativeProduct,
        bool                                           evaluateSource,
        bool                                           evaluatePointSources
      ) {
        ::exahype2::dg::cellIntegral_patchwise_in_situ_GaussLegendre<Solver,order,unknowns,auxiliaryVariables>(
          cellData,
          evaluateFlux,
          evaluateNonconservativeProduct,
          evaluateSource,
          evaluatePointSources
        );
      }
    }
  }
}