LoopBody.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 "exahype2/fd/Functors.h"
#include "KernelVariants.h"
 
#include "exahype2/enumerator/AoSLexicographicEnumerator.h"
#include "exahype2/enumerator/SoALexicographicEnumerator.h"
#include "exahype2/enumerator/AoSoALexicographicEnumerator.h"
 
#include "tarch/multicore/multicore.h"
 
namespace exahype2 {
  namespace fd {
    namespace fd4 {
      namespace internal {
 
        #if defined(SharedOMP) and (!defined(__INTEL_LLVM_COMPILER) or !defined(GPUOffloadingOMP))
        #pragma omp declare simd
        #endif
        template <class QInEnumeratorType, class QOutEnumeratorType>
        static void computeAuxiliaryVariables_LoopBody(
          double* __restrict__                           QIn,
          const QInEnumeratorType&                       QInEnumerator,
          const tarch::la::Vector<Dimensions,double>&    patchCentre,
          const tarch::la::Vector<Dimensions,double>&    patchSize,
          int                                            patchIndex,
          const tarch::la::Vector<Dimensions,int>&       volumeIndex,
          int                                            normal,
          const QOutEnumeratorType&                      QOutEnumerator
        ) InlineMethod;
 
        #if defined(SharedOMP) and ((!defined(__INTEL_LLVM_COMPILER) and !defined(__clang__) and !defined(__GNUC__)) or !defined(GPUOffloadingOMP))
        #pragma omp declare simd
        #endif
        template <class QInEnumeratorType, class QOutEnumeratorType>
        static void computeDifferentialSourceTerm_LoopBody(
          const double* __restrict__                     QIn,
          const QInEnumeratorType&                       QInEnumerator,
          exahype2::fd::NonconservativeProduct           DifferentialSource,
          const tarch::la::Vector<Dimensions,double>&    patchCentre,
          const tarch::la::Vector<Dimensions,double>&    patchSize,
          int                                            patchIndex,
          const tarch::la::Vector<Dimensions,int>&       volumeIndex,
          double                                         t,
          double                                         dt,
          int                                            normal,
          double* __restrict__                           QDiffSrc,
          const QOutEnumeratorType&                      QDiffSrcEnumerator,
          DifferentialSourceTermVariant                  variant
        ) InlineMethod;
 
 
/*
 *      not implemented yet
 *      ===================
 
        template <>
        void computeDifferentialSourceTerm_LoopBody(
          const double* __restrict__                     QIn,
          const exahype2::enumerator::AoSLexicographicEnumerator& QInEnumerator,
          exahype2::fd::NonconservativeProduct           DifferentialSource,
          const tarch::la::Vector<Dimensions,double>&    patchCentre,
          const tarch::la::Vector<Dimensions,double>&    patchSize,
          int                                            patchIndex,
          const tarch::la::Vector<Dimensions,int>&       volumeIndex,
          double                                         t,
          double                                         dt,
          int                                            normal,
          double* __restrict__                           QDiffSrc,
          const exahype2::enumerator::AoSLexicographicEnumerator& QDiffSrcEnumerator,
          DifferentialSourceTermVariant                  variant
        ) InlineMethod;
*/
 
 
        template <typename Solver, class QInEnumeratorType, class QOutEnumeratorType>
        static void computeDifferentialSourceTerm_LoopBody(
          const double* __restrict__                     QIn,
          const QInEnumeratorType&                       QInEnumerator,
          const tarch::la::Vector<Dimensions,double>&    patchCentre,
          const tarch::la::Vector<Dimensions,double>&    patchSize,
          int                                            patchIndex,
          const tarch::la::Vector<Dimensions,int>&       volumeIndex,
          double                                         t,
          double                                         dt,
          int                                            normal,
          double* __restrict__                           QDiffSrc,
          const QOutEnumeratorType&                      QDiffSrcEnumerator,
          DifferentialSourceTermVariant                  variant
        ) InlineMethod;
 
 
        #if defined(SharedOMP) and ((!defined(__INTEL_LLVM_COMPILER) and !defined(__clang__) and !defined(__GNUC__)) or !defined(GPUOffloadingOMP))
        #pragma omp declare simd
        #endif
        #if defined(GPUOffloadingOMP)
        #pragma omp declare target
        #endif
        template <typename QOutEnumeratorType>
        static void updateSolutionWithDifferentialSourceTerm_LoopBody(
          const double* __restrict__                   QDiffSrcX,
          const double* __restrict__                   QDiffSrcY,
          const double* __restrict__                   QDiffSrcZ,
          const QOutEnumeratorType&                    QDiffSrcEnumerator,
          const tarch::la::Vector<Dimensions,double>&  patchCentre,
          const tarch::la::Vector<Dimensions,double>&  patchSize,
          int                                          patchIndex,
          const tarch::la::Vector<Dimensions,int>&     volumeIndex,
          int                                          unknown,
          double                                       dt,
          double* __restrict__                         QOut,
          const QOutEnumeratorType&                    QOutEnumerator
        ) InlineMethod;
        #if defined(GPUOffloadingOMP)
        #pragma omp end declare target
        #endif
 
        #if defined(SharedOMP) and ((!defined(__INTEL_LLVM_COMPILER) and !defined(__clang__) and !defined(__GNUC__)) or !defined(GPUOffloadingOMP))
        #pragma omp declare simd
        #endif
        template <class QInEnumeratorType, class QOutEnumeratorType>
        static void computeKreissOligerDissipationTerm_LoopBody(
          const double* __restrict__                     QIn,
          const QInEnumeratorType&                       QInEnumerator,
          const tarch::la::Vector<Dimensions,double>&    patchCentre,
          const tarch::la::Vector<Dimensions,double>&    patchSize,
          int                                            patchIndex,
          const tarch::la::Vector<Dimensions,int>&       volumeIndex,
          double                                         t,
          double                                         dt,
          int                                            normal,
          double* __restrict__                           QKODsp,
          const QOutEnumeratorType&                      QKODspEnumerator
        ) InlineMethod;
 
        #if defined(SharedOMP) and ((!defined(__INTEL_LLVM_COMPILER) and !defined(__clang__) and !defined(__GNUC__)) or !defined(GPUOffloadingOMP))
        #pragma omp declare simd
        #endif
        #if defined(GPUOffloadingOMP)
        #pragma omp declare target
        #endif
        template <typename QOutEnumeratorType>
        static void updateSolutionWithKODissipationTerm_LoopBody(
          const double                                 KOSigma,
          const double* __restrict__                   QKODspX,
          const double* __restrict__                   QKODspY,
          const double* __restrict__                   QKODspZ,
          const QOutEnumeratorType&                    QKODspEnumerator,
          const tarch::la::Vector<Dimensions,double>&  patchCentre,
          const tarch::la::Vector<Dimensions,double>&  patchSize,
          int                                          patchIndex,
          const tarch::la::Vector<Dimensions,int>&     volumeIndex,
          int                                          unknown,
          double                                       dt,
          double* __restrict__                         QOut,
          const QOutEnumeratorType&                    QOutEnumerator
        ) InlineMethod;
        #if defined(GPUOffloadingOMP)
        #pragma omp end declare target
        #endif
 
 
        #if defined(SharedOMP) and ((!defined(__INTEL_LLVM_COMPILER) and !defined(__clang__) and !defined(__GNUC__)) or !defined(GPUOffloadingOMP))
        #pragma omp declare simd
        #endif
        template <class QInEnumeratorType, class QOutEnumeratorType>
        static void computeFlux_LoopBody(
          const double* __restrict__                   QIn,
          const QInEnumeratorType&                     QInEnumerator,
          exahype2::fd::Flux                           flux,
          const tarch::la::Vector<Dimensions,double>&  patchCentre,
          const tarch::la::Vector<Dimensions,double>&  patchSize,
          int                                          patchIndex,
          const tarch::la::Vector<Dimensions,int>&     volumeIndex,
          double                                       t,
          double                                       dt,
          int                                          normal,
          double* __restrict__                         QFlux,
          const QOutEnumeratorType&                    QFluxEnumerator
        ) InlineMethod;
 
 
        template <typename Solver, class QInEnumeratorType, class QOutEnumeratorType>
        static void computeFlux_LoopBody(
          const double* __restrict__                   QIn,
          const QInEnumeratorType&                     QInEnumerator,
          const tarch::la::Vector<Dimensions,double>&  patchCentre,
          const tarch::la::Vector<Dimensions,double>&  patchSize,
          int                                          patchIndex,
          const tarch::la::Vector<Dimensions,int>&     volumeIndex,
          double                                       t,
          double                                       dt,
          int                                          normal,
          double* __restrict__                         QFlux,
          const QOutEnumeratorType&                    QFluxEnumerator
        ) InlineMethod;
 
 
        #if defined(SharedOMP) and ((!defined(__INTEL_LLVM_COMPILER) and !defined(__clang__) and !defined(__GNUC__)) or !defined(GPUOffloadingOMP))
        #pragma omp declare simd
        #endif
        #if defined(GPUOffloadingOMP)
        #pragma omp declare target
        #endif
        template <typename QOutEnumeratorType>
        static void updateSolutionWithFlux_LoopBody(
          const double* __restrict__                   tempFluxX,
          const double* __restrict__                   tempFluxY,
          const double* __restrict__                   tempFluxZ,
          const QOutEnumeratorType&                    fluxEnumerator,
          const tarch::la::Vector<Dimensions,double>&  patchCentre,
          const tarch::la::Vector<Dimensions,double>&  patchSize,
          int                                          patchIndex,
          const tarch::la::Vector<Dimensions,int>&     volumeIndex,
          int                                          unknown,
          double                                       dt,
          double* __restrict__                         QOut,
          const QOutEnumeratorType&                    QOutEnumerator
        ) InlineMethod;
        #if defined(GPUOffloadingOMP)
        #pragma omp end declare target
        #endif
      }
    }
  }
}
 
#include "LoopBody.cpph"