colour_field.hpp

Go to the documentation of this file.

 
#ifndef PECLET_FLOW_VOF_COLOUR_FIELD_HPP
#define PECLET_FLOW_VOF_COLOUR_FIELD_HPP
 
#include <Kokkos_Core.hpp>
 
#include "mac_stencils.hpp"  // peclet::flow::SExec, SField, I3, L3
#include "policy.hpp"
 
namespace peclet::flow::vof {
 
inline void copyFaceVelocity(SField dst, I3 de, int dg, SField src, I3 se, int sg, int dir) {
  const int s = dg - sg;
  const int ox = s - (dir == 0 ? 1 : 0), oy = s - (dir == 1 ? 1 : 0), oz = s - (dir == 2 ? 1 : 0);
  Kokkos::parallel_for(
      "vof::copyFaceVelocity", MDRange3<SExec>(SExec(), {0, 0, 0}, {se.x, se.y, se.z}),
      KOKKOS_LAMBDA(int x, int y, int z) {
        dst(L3(x + ox, y + oy, z + oz, de)) = src(L3(x, y, z, se));
      });
}
 
inline void copyAdvectedVelocity(SField dst, I3 de, int dg, SField src, I3 se, int sg, int dir,
                                 I3 n) {
  const int ox = sg - (dir == 0 ? 1 : 0), oy = sg - (dir == 1 ? 1 : 0),
            oz = sg - (dir == 2 ? 1 : 0);
  Kokkos::parallel_for(
      "vof::copyAdvectedVelocity", MDRange3<SExec>(SExec(), {0, 0, 0}, {n.x, n.y, n.z}),
      KOKKOS_LAMBDA(int x, int y, int z) {
        dst(L3(x + dg, y + dg, z + dg, de)) = src(L3(x + ox, y + oy, z + oz, se));
      });
}
 
inline void periodicFill(SField f, I3 e, int g, bool px, bool py, bool pz) {
  const long st[3] = {1, e.x, static_cast<long>(e.x) * e.y};
  const int dims[3] = {e.x, e.y, e.z};
  const bool per[3] = {px, py, pz};
  for (int a = 0; a < 3; ++a) {
    if (!per[a])
      continue;
    const int b = (a + 1) % 3, c = (a + 2) % 3;
    const long sa = st[a], sb = st[b], sc = st[c];
    const int N = dims[a] - 2 * g;
    Kokkos::parallel_for(
        "vof::periodicFill", MDRange2<SExec>(SExec(), {0, 0}, {dims[b], dims[c]}),
        KOKKOS_LAMBDA(int p0, int p1) {
          const long base = static_cast<long>(p0) * sb + static_cast<long>(p1) * sc;
          for (int gl = 0; gl < g; ++gl) {
            f(base + static_cast<long>(gl) * sa) = f(base + static_cast<long>(gl + N) * sa);
            f(base + static_cast<long>(g + N + gl) * sa) = f(base + static_cast<long>(g + gl) * sa);
          }
        });
  }
}
 
inline void clampFill(SField f, I3 e, int g, I3 o, I3 gs, bool px, bool py, bool pz, int skip = 0) {
  if (px && py && pz)
    return;
  const bool p0 = px, p1 = py, p2 = pz;
  const int q0 = gs.x, q1 = gs.y, q2 = gs.z;
  const int sk = skip;
  Kokkos::parallel_for(
      "vof::clampFill", MDRange3<SExec>(SExec(), {0, 0, 0}, {e.x, e.y, e.z}),
      KOKKOS_LAMBDA(int x, int y, int z) {
        const int gx = x - g + o.x, gy = y - g + o.y, gz = z - g + o.z;
        if (sk) {
          const int gi[3] = {gx, gy, gz}, qq[3] = {q0, q1, q2};
          const bool pp[3] = {p0, p1, p2};
          for (int a = 0; a < 3; ++a) {
            if (pp[a])
              continue;
            if (gi[a] < 0 && (sk & (1 << (2 * a))))
              return;
            if (gi[a] >= qq[a] && (sk & (1 << (2 * a + 1))))
              return;
          }
        }
        const int cx = p0 ? gx : (gx < 0 ? 0 : (gx >= q0 ? q0 - 1 : gx));
        const int cy = p1 ? gy : (gy < 0 ? 0 : (gy >= q1 ? q1 - 1 : gy));
        const int cz = p2 ? gz : (gz < 0 ? 0 : (gz >= q2 ? q2 - 1 : gz));
        if (cx != gx || cy != gy || cz != gz)
          f(L3(x, y, z, e)) = f(L3(cx - o.x + g, cy - o.y + g, cz - o.z + g, e));
      });
}
 
}  // namespace peclet::flow::vof
 
#endif  // PECLET_FLOW_VOF_COLOUR_FIELD_HPP