cutcell.hpp

Go to the documentation of this file.

 
#ifndef PECLET_CORE_VOF_CUTCELL_HPP
#define PECLET_CORE_VOF_CUTCELL_HPP
 
#include <Kokkos_Core.hpp>
 
namespace peclet::core::vof {
 
inline constexpr double kVofEpsFloor = 1.0 / 64.0;
 
inline constexpr double kVofCourantEpsFloor = 0.1;
 
enum VofCellKind : unsigned char {
  kVofFluid = 0,  
  kVofSolid = 1,  
};
 
KOKKOS_INLINE_FUNCTION double vofEpsEff(double eps, bool solid) {
  if (solid)
    return 0.0;
  return eps > kVofEpsFloor ? eps : kVofEpsFloor;
}
 
KOKKOS_INLINE_FUNCTION bool vofIsSolidCell(double eps, const double oLo[3], const double oHi[3]) {
  if (eps > 0.0)
    return false;
  for (int d = 0; d < 3; ++d)
    if (oLo[d] > 0.0 || oHi[d] > 0.0)
      return false;
  return true;
}
 
KOKKOS_INLINE_FUNCTION double vofCutFlux(double openness, double rawFlux) {
  return openness * rawFlux;
}
 
KOKKOS_INLINE_FUNCTION double vofCutFluxClamp(double fluxMag, double sweep, double epsDon,
                                              double cDon) {
  double hi = epsDon * cDon;
  if (sweep < hi)
    hi = sweep;
  double lo = sweep - epsDon * (1.0 - cDon);
  if (lo < 0.0)
    lo = 0.0;
  if (lo > hi)
    lo = hi;  // a donor thinner than the swept volume: give everything it has
  return fluxMag > hi ? hi : (fluxMag < lo ? lo : fluxMag);
}
 
KOKKOS_INLINE_FUNCTION double vofCutCourant(double openness, double a, double eps) {
  const double e = eps > kVofCourantEpsFloor ? eps : kVofCourantEpsFloor;
  const double aa = a < 0.0 ? -a : a;
  const double cut = openness * aa / e;
  return aa > cut ? aa : cut;
}
 
KOKKOS_INLINE_FUNCTION double vofClipCut(double c, double epsEff, double& moved) {
  const double cc = c < 0.0 ? 0.0 : (c > 1.0 ? 1.0 : c);
  moved = epsEff * (cc - c);
  return cc;
}
 
enum VofFillState : unsigned char {
  kVofFillNone = 0,
  kVofFillFluid = 1,
  kVofFillPass0 = 1,  
};
 
KOKKOS_INLINE_FUNCTION bool vofFillReadable(unsigned char state, int k) {
  return state != kVofFillNone && state <= static_cast<unsigned char>(kVofFillPass0 + k - 1);
}
 
KOKKOS_INLINE_FUNCTION int vofGhostDepth1(int i, int g, int n) {
  if (i < g)
    return g - i;
  if (i >= g + n)
    return i - (g + n) + 1;
  return 0;
}
 
KOKKOS_INLINE_FUNCTION int vofGhostDepth(int x, int y, int z, int g, int nx, int ny, int nz) {
  const int a = vofGhostDepth1(x, g, nx), b = vofGhostDepth1(y, g, ny),
            c = vofGhostDepth1(z, g, nz);
  const int m = a > b ? a : b;
  return m > c ? m : c;
}
 
}  // namespace peclet::core::vof
 
#endif  // PECLET_CORE_VOF_CUTCELL_HPP