PatchUtils.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 "tarch/la/Vector.h"
#include "tarch/multicore/multicore.h"
 
#include "peano4/grid/GridControlEvent.h"
#include "peano4/utils/Globals.h"
 
 
namespace exahype2 {
  namespace fv {
    static tarch::la::Vector<2,double>  getVolumeSize(
      const tarch::la::Vector<2,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch
    )
    //InlineMethod
    {
      tarch::la::Vector<2,double> volumeSize;
 
      for (int d=0; d<2; d++) {
        #if !defined(GPUOffloadingSYCL) and !defined(GPUOffloadingOMP)
        assertion2( numberOfVolumesPerAxisInPatch>=1, h, numberOfVolumesPerAxisInPatch );
        #endif
        volumeSize(d) = h(d)/numberOfVolumesPerAxisInPatch;
      }
 
      return volumeSize;
    }
 
 
    static tarch::la::Vector<3,double>  getVolumeSize(
      const tarch::la::Vector<3,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch
    )
    //InlineMethod
    {
      tarch::la::Vector<3,double> volumeSize;
 
      for (int d=0; d<3; d++) {
        volumeSize(d) = h(d)/numberOfVolumesPerAxisInPatch;
      }
 
      return volumeSize;
    }
 
 
    static tarch::la::Vector<2,double>  getFaceSize(
      const tarch::la::Vector<2,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch
    )
    //InlineMethod
    {
      return getVolumeSize(h,numberOfVolumesPerAxisInPatch);
    }
 
 
    static tarch::la::Vector<3,double>  getFaceSize(
      const tarch::la::Vector<3,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch
    )
    //InlineMethod
    {
      return getVolumeSize(h,numberOfVolumesPerAxisInPatch);
    }
 
 
    static tarch::la::Vector<2,double>  getVolumeCentre(
      const tarch::la::Vector<2,double>&  x,
      const tarch::la::Vector<2,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch,
      const tarch::la::Vector<2,int>&     index
    )
    //InlineMethod
    {
      tarch::la::Vector<2,double> volumeSize = getVolumeSize(h,numberOfVolumesPerAxisInPatch);
      tarch::la::Vector<2,double> result     = x - 0.5 * h + 0.5 * volumeSize;
      for (int d=0; d<2; d++) {
        result(d) += index(d) * volumeSize(d);
      }
      return result;
    }
 
 
    static tarch::la::Vector<3,double>  getVolumeCentre(
      const tarch::la::Vector<3,double>&  x,
      const tarch::la::Vector<3,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch,
      const tarch::la::Vector<3,int>&     index
    )
    //InlineMethod
    {
      tarch::la::Vector<3,double> volumeSize = getVolumeSize(h,numberOfVolumesPerAxisInPatch);
      tarch::la::Vector<3,double> result     = x - 0.5 * h + 0.5 * volumeSize;
      for (int d=0; d<3; d++) {
        result(d) += index(d) * volumeSize(d);
      }
      return result;
    }
 
 
    static tarch::la::Vector<2,double>  getFaceCentre(
      const tarch::la::Vector<2,double>&  x,
      const tarch::la::Vector<2,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch,
      int                                 overlap,
      int                                 normal,
      const tarch::la::Vector<2,int>&     index
    )
    //InlineMethod
    {
      tarch::la::Vector<2,double> volumeSize = getFaceSize(h,numberOfVolumesPerAxisInPatch);
      tarch::la::Vector<2,double> result;
 
      for (int d=0; d<2; d++) {
        if (d==normal) {
          result(d) = x(d) - overlap * volumeSize(d) + 0.5 * volumeSize(d);
        }
        else {
          result(d) = x(d) - 0.5 * h(d) + 0.5 * volumeSize(d);
        }
        result(d) += index(d) * volumeSize(d);
      }
 
      return result;
    }
 
 
    static tarch::la::Vector<3,double>  getFaceCentre(
      const tarch::la::Vector<3,double>&  x,
      const tarch::la::Vector<3,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch,
      int                                 overlap,
      int                                 normal,
      const tarch::la::Vector<3,int>&     index
    )
    //InlineMethod
    {
      tarch::la::Vector<3,double> volumeSize = getVolumeSize(h,numberOfVolumesPerAxisInPatch);
      tarch::la::Vector<3,double> result     = x - 0.5 * h + 0.5 * volumeSize;
 
      for (int d=0; d<3; d++) {
        if (d==normal) {
          result(d) = x(d) - overlap * volumeSize(d) + 0.5 * volumeSize(d);
        }
        else {
          result(d) = x(d) - 0.5 * h(d) + 0.5 * volumeSize(d);
        }
        result(d) += index(d) * volumeSize(d);
      }
 
      return result;
    }
 
 
    double  getVolumeLength(
      const tarch::la::Vector<2,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch
    );
 
 
    double  getVolumeLength(
      const tarch::la::Vector<3,double>&  h,
      int                                 numberOfVolumesPerAxisInPatch
    );
 
 
    void computeOneSidedGradient(
      const double* __restrict__               Q,
      int                                      unknownsPlusAuxiliaryVariables,
      int                                      numberOfVolumesPerAxisInPatch,
      const tarch::la::Vector<Dimensions,int>& volume,
      int                                      normal,
      bool                                     isRight,
      double                                   volumeSize,
      double* __restrict__                     gradient
    );
 
 
    std::string plotVolume(
      const double* __restrict__ Q,
      int    unknowns
    );
 
 
    void validatePatch(
      const double* __restrict__ Q,
      int    unknowns,
      int    auxiliaryVariables,
      int    numberOfVolumesPerAxisInPatch,
      int    haloSize,
      const std::string& location = "",
      bool   triggerNonCriticalAssertion = true,
      double* minValues = nullptr,
      double* maxValues = nullptr
    );
 
 
    std::string plotPatch(
      const double* __restrict__ Q,
      int    unknowns,
      int    auxiliaryVariables,
      int    numberOfVolumesPerAxisInPatch,
      int    haloSize,
      bool   prettyPrint = false
    );
 
 
    std::string plotPatchOverlap(
      const double* __restrict__ Q,
      int    unknowns,
      int    auxiliaryVariables,
      int    numberOfGridCellsPerPatchPerAxis,
      int    haloSize,
      int    normal,
      bool   prettyPrint = false
    );
 
 
    void copyHalfOfHalo(
      int    unknownsPlusAuxiliaryVariables,
      int    numberOfGridCellsPerPatchPerAxis,
      int    haloSize,  // same as overlap
      int    normal,
      bool   isRightLayer,
      const double* __restrict__   srcQ,
      double* __restrict__         destQ
    );
  }
}