Diffusion

Wall-normal relation

\[\dmomdif{1}{1}\]

src/fluid/predict/ux.c

const int isize = domain->glsizes[0];
const double * hxxc = domain->hxxc;
const double * jdxf = domain->jdxf;
const double * jdxc = domain->jdxc;
laplacians.lapx = memory_calloc(isize - 1, sizeof(laplacian_t));
for (int i = 2; i <= isize; i++) {
  const double l = 1. / JDXF(i  ) * JDXC(i-1) / HXXC(i-1) / HXXC(i-1);
  const double u = 1. / JDXF(i  ) * JDXC(i  ) / HXXC(i  ) / HXXC(i  );
  const double c = - l - u;
  laplacians.LAPX(i).l = l;
  laplacians.LAPX(i).c = c;
  laplacians.LAPX(i).u = u;
}

src/fluid/predict/ux.c

static int diffusion_x (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict ux,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
#if NDIMS == 3
  const int ksize = domain->mysizes[2];
#endif
  const laplacian_t * lapx = laplacians.lapx;
  BEGIN
    src[cnt] += diffusivity * (
#if NDIMS == 2
        + LAPX(i).l * UX(i-1, j  )
        + LAPX(i).c * UX(i  , j  )
        + LAPX(i).u * UX(i+1, j  )
#else
        + LAPX(i).l * UX(i-1, j  , k  )
        + LAPX(i).c * UX(i  , j  , k  )
        + LAPX(i).u * UX(i+1, j  , k  )
#endif
    );
  END
  return 0;
}

\[\dmomdif{2}{1}\]

src/fluid/predict/ux.c

const double hy = domain->hy;
const double l = 1. / hy / hy;
const double u = 1. / hy / hy;
const double c = - l - u;
laplacians.lapy.l = l;
laplacians.lapy.c = c;
laplacians.lapy.u = u;

src/fluid/predict/ux.c

static int diffusion_y (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict ux,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
#if NDIMS == 3
  const int ksize = domain->mysizes[2];
#endif
  const laplacian_t * lapy = &laplacians.lapy;
  BEGIN
    src[cnt] += diffusivity * (
#if NDIMS == 2
        + (*lapy).l * UX(i  , j-1)
        + (*lapy).c * UX(i  , j  )
        + (*lapy).u * UX(i  , j+1)
#else
        + (*lapy).l * UX(i  , j-1, k  )
        + (*lapy).c * UX(i  , j  , k  )
        + (*lapy).u * UX(i  , j+1, k  )
#endif
    );
  END
  return 0;
}

\[\dmomdif{3}{1}\]

src/fluid/predict/ux.c

const double hz = domain->hz;
const double l = 1. / hz / hz;
const double u = 1. / hz / hz;
const double c = - l - u;
laplacians.lapz.l = l;
laplacians.lapz.c = c;
laplacians.lapz.u = u;

src/fluid/predict/ux.c

static int diffusion_z (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict ux,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
  const int ksize = domain->mysizes[2];
  const laplacian_t * lapz = &laplacians.lapz;
  BEGIN
    src[cnt] += diffusivity * (
        + (*lapz).l * UX(i  , j  , k-1)
        + (*lapz).c * UX(i  , j  , k  )
        + (*lapz).u * UX(i  , j  , k+1)
    );
  END
  return 0;
}

Stream-wise relation

\[\dmomdif{1}{2}\]

src/fluid/predict/uy.c

const int isize = domain->glsizes[0];
const double * hxxf = domain->hxxf;
const double * jdxf = domain->jdxf;
const double * jdxc = domain->jdxc;
laplacians.lapx = memory_calloc(isize, sizeof(laplacian_t));
for (int i = 1; i <= isize; i++) {
  const double l = 1. / JDXC(i  ) * JDXF(i  ) / HXXF(i  ) / HXXF(i  );
  const double u = 1. / JDXC(i  ) * JDXF(i+1) / HXXF(i+1) / HXXF(i+1);
  const double c = - l - u;
  laplacians.LAPX(i).l = l;
  laplacians.LAPX(i).c = c;
  laplacians.LAPX(i).u = u;
}

src/fluid/predict/uy.c

static int diffusion_x (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict uy,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
#if NDIMS == 3
  const int ksize = domain->mysizes[2];
#endif
  const laplacian_t * lapx = laplacians.lapx;
  BEGIN
    src[cnt] += diffusivity * (
#if NDIMS == 2
        + LAPX(i).l * UY(i-1, j  )
        + LAPX(i).c * UY(i  , j  )
        + LAPX(i).u * UY(i+1, j  )
#else
        + LAPX(i).l * UY(i-1, j  , k  )
        + LAPX(i).c * UY(i  , j  , k  )
        + LAPX(i).u * UY(i+1, j  , k  )
#endif
    );
  END
  return 0;
}

\[\dmomdif{2}{2}\]

src/fluid/predict/uy.c

const double hy = domain->hy;
const double l = 1. / hy / hy;
const double u = 1. / hy / hy;
const double c = - l - u;
laplacians.lapy.l = l;
laplacians.lapy.c = c;
laplacians.lapy.u = u;

src/fluid/predict/uy.c

static int diffusion_y (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict uy,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
#if NDIMS == 3
  const int ksize = domain->mysizes[2];
#endif
  const laplacian_t * lapy = &laplacians.lapy;
  BEGIN
    src[cnt] += diffusivity * (
#if NDIMS == 2
        + (*lapy).l * UY(i  , j-1)
        + (*lapy).c * UY(i  , j  )
        + (*lapy).u * UY(i  , j+1)
#else
        + (*lapy).l * UY(i  , j-1, k  )
        + (*lapy).c * UY(i  , j  , k  )
        + (*lapy).u * UY(i  , j+1, k  )
#endif
    );
  END
  return 0;
}

\[\dmomdif{3}{2}\]

src/fluid/predict/uy.c

const double hz = domain->hz;
const double l = 1. / hz / hz;
const double u = 1. / hz / hz;
const double c = - l - u;
laplacians.lapz.l = l;
laplacians.lapz.c = c;
laplacians.lapz.u = u;

src/fluid/predict/uy.c

static int diffusion_z (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict uy,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
  const int ksize = domain->mysizes[2];
  const laplacian_t * lapz = &laplacians.lapz;
  BEGIN
    src[cnt] += diffusivity * (
        + (*lapz).l * UY(i  , j  , k-1)
        + (*lapz).c * UY(i  , j  , k  )
        + (*lapz).u * UY(i  , j  , k+1)
    );
  END
  return 0;
}

Span-wise relation

\[\dmomdif{1}{3}\]

src/fluid/predict/uz.c

static int diffusion_x (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict uz,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
  const int ksize = domain->mysizes[2];
  const laplacian_t * lapx = laplacians.lapx;
  BEGIN
    src[cnt] += diffusivity * (
        + LAPX(i).l * UZ(i-1, j  , k  )
        + LAPX(i).c * UZ(i  , j  , k  )
        + LAPX(i).u * UZ(i+1, j  , k  )
    );
  END
  return 0;
}

src/fluid/predict/uz.c

const int isize = domain->glsizes[0];
const double * hxxf = domain->hxxf;
const double * jdxf = domain->jdxf;
const double * jdxc = domain->jdxc;
laplacians.lapx = memory_calloc(isize, sizeof(laplacian_t));
for (int i = 1; i <= isize; i++) {
  const double l = 1. / JDXC(i  ) * JDXF(i  ) / HXXF(i  ) / HXXF(i  );
  const double u = 1. / JDXC(i  ) * JDXF(i+1) / HXXF(i+1) / HXXF(i+1);
  const double c = - l - u;
  laplacians.LAPX(i).l = l;
  laplacians.LAPX(i).c = c;
  laplacians.LAPX(i).u = u;
}

\[\dmomdif{2}{3}\]

src/fluid/predict/uz.c

static int diffusion_y (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict uz,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
  const int ksize = domain->mysizes[2];
  const laplacian_t * lapy = &laplacians.lapy;
  BEGIN
    src[cnt] += diffusivity * (
        + (*lapy).l * UZ(i  , j-1, k  )
        + (*lapy).c * UZ(i  , j  , k  )
        + (*lapy).u * UZ(i  , j+1, k  )
    );
  END
  return 0;
}

src/fluid/predict/uz.c

const double hy = domain->hy;
const double l = 1. / hy / hy;
const double u = 1. / hy / hy;
const double c = - l - u;
laplacians.lapy.l = l;
laplacians.lapy.c = c;
laplacians.lapy.u = u;

\[\dmomdif{3}{3}\]

src/fluid/predict/uz.c

const double hz = domain->hz;
const double l = 1. / hz / hz;
const double u = 1. / hz / hz;
const double c = - l - u;
laplacians.lapz.l = l;
laplacians.lapz.c = c;
laplacians.lapz.u = u;

src/fluid/predict/uz.c

static int diffusion_z (
    const domain_t * domain,
    const double diffusivity,
    const double * restrict uz,
    double * restrict src
) {
  const int isize = domain->mysizes[0];
  const int jsize = domain->mysizes[1];
  const int ksize = domain->mysizes[2];
  const laplacian_t * lapz = &laplacians.lapz;
  BEGIN
    src[cnt] += diffusivity * (
        + (*lapz).l * UZ(i  , j  , k-1)
        + (*lapz).c * UZ(i  , j  , k  )
        + (*lapz).u * UZ(i  , j  , k+1)
    );
  END
  return 0;
}