1048 lines
35 KiB
C++
1048 lines
35 KiB
C++
/*+
|
|
ARES/HADES/BORG Package -- ./libLSS/physics/classic_cic.hpp
|
|
Copyright (C) 2009-2019 Jens Jasche <jens.jasche@fysik.su.se>
|
|
Copyright (C) 2014-2019 Guilhem Lavaux <guilhem.lavaux@iap.fr>
|
|
Copyright (C) 2019 Florent Leclercq <florent.leclercq@polytechnique.org>
|
|
|
|
Additional contributions from:
|
|
Guilhem Lavaux <guilhem.lavaux@iap.fr> (2023)
|
|
|
|
+*/
|
|
#ifndef __LIBLSS_PHYSICS_CLASSIC_CIC_HPP
|
|
# define __LIBLSS_PHYSICS_CLASSIC_CIC_HPP
|
|
|
|
# include <cmath>
|
|
# include "libLSS/tools/console.hpp"
|
|
# include <boost/multi_array.hpp>
|
|
# include "libLSS/physics/generic_cic.hpp"
|
|
# include "libLSS/tools/mpi_fftw_helper.hpp"
|
|
# include <memory>
|
|
|
|
namespace LibLSS {
|
|
|
|
template <typename T, bool ignore_overflow>
|
|
struct ClassicCloudInCell_impl {
|
|
typedef T Type;
|
|
// Number of extra planes required in case of MPI
|
|
static const int MPI_PLANE_LEAKAGE = 1;
|
|
static const bool EXTRA_CHECK = true;
|
|
typedef boost::multi_array<T, 3> DensityArray;
|
|
typedef boost::multi_array_ref<T, 1> ParticleBasedScalar;
|
|
typedef boost::multi_array_ref<T, 2> ParticleBasedArray;
|
|
|
|
template <typename A>
|
|
static inline void _safe_set(
|
|
A &&density, size_t const ix, size_t const iy, size_t const iz,
|
|
size_t const bounds[3][2], T const &value) {
|
|
if (ix >= bounds[0][0] && ix < bounds[0][1] && iy >= bounds[1][0] &&
|
|
iy < bounds[1][1] && iz >= bounds[2][0] && iz < bounds[2][1]) {
|
|
density[ix][iy][iz] += value;
|
|
} else {
|
|
}
|
|
} //_safe_set
|
|
|
|
template <
|
|
typename ParticleArray, typename ProjectionDensityArray,
|
|
typename WeightArray, typename PeriodicFunction>
|
|
static typename std::enable_if<WeightArray::dimensionality == 1>::type
|
|
projection(
|
|
const ParticleArray &particles, ProjectionDensityArray &density, T Lx,
|
|
T Ly, T Lz, int N0, int N1, int N2, const PeriodicFunction &p,
|
|
const WeightArray &weight, size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC projection");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
size_t minX = density.index_bases()[0];
|
|
size_t minY = density.index_bases()[1];
|
|
size_t minZ = density.index_bases()[2];
|
|
size_t maxX = density.index_bases()[0] + density.shape()[0];
|
|
size_t maxY = density.index_bases()[1] + density.shape()[1];
|
|
size_t maxZ = density.index_bases()[2] + density.shape()[2];
|
|
|
|
ctx.print(boost::format("minX=%d, maxX=%d, N0=%d") % minX % maxX % N0);
|
|
|
|
size_t const bounds[3][2] = {{minX, maxX}, {minY, maxY}, {minZ, maxZ}};
|
|
for (long i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = ix + 1;
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
T rx = (x - ix);
|
|
T ry = (y - iy);
|
|
T rz = (z - iz);
|
|
|
|
T qx = 1 - rx;
|
|
T qy = 1 - ry;
|
|
T qz = 1 - rz;
|
|
|
|
double w = weight[i];
|
|
|
|
if (!ignore_overflow) {
|
|
if (jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format(
|
|
"Overflow at ix=%d, jx=%d (maxX=%d), x=%g, rx=%g, qx=%g") %
|
|
ix % jx % maxX % x % rx % qx);
|
|
}
|
|
if (ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d") % ix % jx);
|
|
}
|
|
if (jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d)") % iy % jy %
|
|
maxY);
|
|
}
|
|
if (iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d") % iy % jy);
|
|
}
|
|
density[ix][iy][iz] += (qx) * (qy) * (qz)*w;
|
|
density[ix][iy][jz] += (qx) * (qy) * (rz)*w;
|
|
density[ix][jy][iz] += (qx) * (ry) * (qz)*w;
|
|
density[ix][jy][jz] += (qx) * (ry) * (rz)*w;
|
|
density[jx][iy][iz] += (rx) * (qy) * (qz)*w;
|
|
density[jx][iy][jz] += (rx) * (qy) * (rz)*w;
|
|
density[jx][jy][iz] += (rx) * (ry) * (qz)*w;
|
|
density[jx][jy][jz] += (rx) * (ry) * (rz)*w;
|
|
|
|
} else {
|
|
|
|
_safe_set(density, ix, iy, iz, bounds, qx * qy * qz * w);
|
|
_safe_set(density, ix, iy, jz, bounds, qx * qy * rz * w);
|
|
_safe_set(density, ix, jy, iz, bounds, qx * ry * qz * w);
|
|
_safe_set(density, ix, jy, jz, bounds, qx * ry * rz * w);
|
|
|
|
_safe_set(density, jx, iy, iz, bounds, rx * qy * qz * w);
|
|
_safe_set(density, jx, iy, jz, bounds, rx * qy * rz * w);
|
|
_safe_set(density, jx, jy, iz, bounds, rx * ry * qz * w);
|
|
_safe_set(density, jx, jy, jz, bounds, rx * ry * rz * w);
|
|
}
|
|
}
|
|
} //projection
|
|
|
|
template <
|
|
typename ParticleArray, typename ProjectionDensityArray,
|
|
typename WeightArray, typename PeriodicFunction>
|
|
static typename std::enable_if<WeightArray::dimensionality != 1>::type
|
|
projection(
|
|
const ParticleArray &particles, ProjectionDensityArray &density, T Lx,
|
|
T Ly, T Lz, int N0, int N1, int N2, const PeriodicFunction &p,
|
|
const WeightArray &weight, size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC projection");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
size_t minX = density.index_bases()[1];
|
|
size_t minY = density.index_bases()[2];
|
|
size_t minZ = density.index_bases()[3];
|
|
size_t maxX = density.index_bases()[1] + density.shape()[1];
|
|
size_t maxY = density.index_bases()[2] + density.shape()[2];
|
|
size_t maxZ = density.index_bases()[3] + density.shape()[3];
|
|
|
|
ctx.print(boost::format("minX=%d, maxX=%d, N0=%d") % minX % maxX % N0);
|
|
|
|
unsigned int dims = weight.shape()[1];
|
|
size_t const bounds[3][2] = {{minX, maxX}, {minY, maxY}, {minZ, maxZ}};
|
|
for (size_t i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = ix + 1;
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
T rx = (x - ix);
|
|
T ry = (y - iy);
|
|
T rz = (z - iz);
|
|
|
|
T qx = 1 - rx;
|
|
T qy = 1 - ry;
|
|
T qz = 1 - rz;
|
|
|
|
if (!ignore_overflow) {
|
|
if (jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at ix=%d, jx=%d (maxX=%d)") % ix % jx %
|
|
maxX);
|
|
}
|
|
if (ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d") % ix % jx);
|
|
}
|
|
if (jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d)") % iy % jy %
|
|
maxY);
|
|
}
|
|
if (iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d") % iy % jy);
|
|
}
|
|
|
|
for (unsigned int k = 0; k < dims; k++) {
|
|
T w = weight[i][k];
|
|
|
|
density[k][ix][iy][iz] += (qx) * (qy) * (qz)*w;
|
|
density[k][ix][iy][jz] += (qx) * (qy) * (rz)*w;
|
|
density[k][ix][jy][iz] += (qx) * (ry) * (qz)*w;
|
|
density[k][ix][jy][jz] += (qx) * (ry) * (rz)*w;
|
|
density[k][jx][iy][iz] += (rx) * (qy) * (qz)*w;
|
|
density[k][jx][iy][jz] += (rx) * (qy) * (rz)*w;
|
|
density[k][jx][jy][iz] += (rx) * (ry) * (qz)*w;
|
|
density[k][jx][jy][jz] += (rx) * (ry) * (rz)*w;
|
|
}
|
|
} else {
|
|
|
|
for (int k = 0; k < dims; k++) {
|
|
T w = weight[i][k];
|
|
|
|
_safe_set(density[k], ix, iy, iz, bounds, qx * qy * qz * w);
|
|
_safe_set(density[k], ix, iy, jz, bounds, qx * qy * rz * w);
|
|
_safe_set(density[k], ix, jy, iz, bounds, qx * ry * qz * w);
|
|
_safe_set(density[k], ix, jy, jz, bounds, qx * ry * rz * w);
|
|
|
|
_safe_set(density[k], jx, iy, iz, bounds, rx * qy * qz * w);
|
|
_safe_set(density[k], jx, iy, jz, bounds, rx * qy * rz * w);
|
|
_safe_set(density[k], jx, jy, iz, bounds, rx * ry * qz * w);
|
|
_safe_set(density[k], jx, jy, jz, bounds, rx * ry * rz * w);
|
|
}
|
|
}
|
|
}
|
|
} //projection
|
|
|
|
template <
|
|
typename ParticleBasedScalar, typename ProjectionDensityArray,
|
|
typename WeightArray>
|
|
static inline
|
|
typename std::enable_if<WeightArray::dimensionality == 1>::type
|
|
__do_interpolation(
|
|
ParticleBasedScalar &A, const ProjectionDensityArray &field,
|
|
const WeightArray &weight, size_t i, T qx, T qy, T qz, T rx, T ry,
|
|
T rz, size_t ix, size_t iy, size_t iz, size_t jx, size_t jy,
|
|
size_t jz) {
|
|
T f1 = 1. * qx * qy * qz;
|
|
T f2 = 1. * rx * qy * qz;
|
|
T f3 = 1. * qx * ry * qz;
|
|
T f4 = 1. * qx * qy * rz;
|
|
T f5 = 1. * rx * ry * qz;
|
|
T f6 = 1. * rx * qy * rz;
|
|
T f7 = 1. * qx * ry * rz;
|
|
T f8 = 1. * rx * ry * rz;
|
|
double w = weight[i];
|
|
|
|
A[i] = (field[ix][iy][iz] * f1 + field[jx][iy][iz] * f2 +
|
|
field[ix][jy][iz] * f3 + field[ix][iy][jz] * f4 +
|
|
field[jx][jy][iz] * f5 + field[jx][iy][jz] * f6 +
|
|
field[ix][jy][jz] * f7 + field[jx][jy][jz] * f8) /
|
|
w;
|
|
} //__do_interpolation
|
|
|
|
template <
|
|
typename ParticleBasedScalar, typename ParticleArray,
|
|
typename ProjectionDensityArray, typename WeightArray,
|
|
typename PeriodicFunction>
|
|
static typename std::enable_if<WeightArray::dimensionality == 1>::type
|
|
interpolation_scalar(
|
|
ParticleBasedScalar &A, const ParticleArray &particles,
|
|
const ProjectionDensityArray &field, T Lx, T Ly, T Lz, int N0, int N1,
|
|
int N2, const PeriodicFunction &p, const WeightArray &weight,
|
|
size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC interpolation");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
size_t minX = field.index_bases()[0];
|
|
size_t minY = field.index_bases()[1];
|
|
size_t minZ = field.index_bases()[2];
|
|
size_t maxX = field.index_bases()[0] + field.shape()[0];
|
|
size_t maxY = field.index_bases()[1] + field.shape()[1];
|
|
size_t maxZ = field.index_bases()[2] + field.shape()[2];
|
|
|
|
ctx.print(boost::format("minX=%d, maxX=%d, N0=%d") % minX % maxX % N0);
|
|
|
|
size_t const bounds[3][2] = {{minX, maxX}, {minY, maxY}, {minZ, maxZ}};
|
|
# pragma omp parallel for schedule(static)
|
|
for (long i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = ix + 1;
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
T rx = (x - ix);
|
|
T ry = (y - iy);
|
|
T rz = (z - iz);
|
|
|
|
T qx = 1 - rx;
|
|
T qy = 1 - ry;
|
|
T qz = 1 - rz;
|
|
|
|
if (jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at ix=%d, jx=%d (maxX=%d)") % ix % jx %
|
|
maxX);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d") % ix % jx);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d)") % iy % jy %
|
|
maxY);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d") % iy % jy);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
|
|
__do_interpolation(
|
|
A, field, weight, i, qx, qy, qz, rx, ry, rz, ix, iy, iz, jx, jy,
|
|
jz);
|
|
}
|
|
} //interpolation
|
|
|
|
template <
|
|
typename ParticleBasedArray, typename ProjectionDensityArray,
|
|
typename WeightArray>
|
|
static inline
|
|
typename std::enable_if<WeightArray::dimensionality != 1>::type
|
|
__do_interpolation_vec(
|
|
ParticleBasedArray &A, const ProjectionDensityArray &field,
|
|
const WeightArray &weight, size_t i, T qx, T qy, T qz, T rx, T ry,
|
|
T rz, size_t ix, size_t iy, size_t iz, size_t jx, size_t jy,
|
|
size_t jz) {
|
|
T f1 = 1. * qx * qy * qz;
|
|
T f2 = 1. * rx * qy * qz;
|
|
T f3 = 1. * qx * ry * qz;
|
|
T f4 = 1. * qx * qy * rz;
|
|
T f5 = 1. * rx * ry * qz;
|
|
T f6 = 1. * rx * qy * rz;
|
|
T f7 = 1. * qx * ry * rz;
|
|
T f8 = 1. * rx * ry * rz;
|
|
unsigned int dims = A.shape()[1];
|
|
|
|
for (unsigned int k = 0; k < dims; k++) {
|
|
T w = weight[i][k];
|
|
|
|
A[i][k] = (field[k][ix][iy][iz] * f1 + field[k][jx][iy][iz] * f2 +
|
|
field[k][ix][jy][iz] * f3 + field[k][ix][iy][jz] * f4 +
|
|
field[k][jx][jy][iz] * f5 + field[k][jx][iy][jz] * f6 +
|
|
field[k][ix][jy][jz] * f7 + field[k][jx][jy][jz] * f8) /
|
|
w;
|
|
}
|
|
} //__do_interpolation_vec
|
|
|
|
template <
|
|
typename ParticleBasedArray, typename ParticleArray,
|
|
typename ProjectionDensityArray, typename WeightArray,
|
|
typename PeriodicFunction>
|
|
static typename std::enable_if<WeightArray::dimensionality != 1>::type
|
|
interpolation(
|
|
ParticleBasedArray &A, const ParticleArray &particles,
|
|
const ProjectionDensityArray &field, T Lx, T Ly, T Lz, int N0, int N1,
|
|
int N2, const PeriodicFunction &p, const WeightArray &weight,
|
|
size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC interpolation");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
size_t minX = field.index_bases()[1];
|
|
size_t minY = field.index_bases()[2];
|
|
size_t minZ = field.index_bases()[3];
|
|
size_t maxX = field.index_bases()[1] + field.shape()[1];
|
|
size_t maxY = field.index_bases()[2] + field.shape()[2];
|
|
size_t maxZ = field.index_bases()[3] + field.shape()[3];
|
|
|
|
ctx.print(boost::format("minX=%d, maxX=%d, N0=%d") % minX % maxX % N0);
|
|
|
|
size_t const bounds[3][2] = {{minX, maxX}, {minY, maxY}, {minZ, maxZ}};
|
|
# pragma omp parallel for schedule(static)
|
|
for (size_t i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = ix + 1;
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
T rx = (x - ix);
|
|
T ry = (y - iy);
|
|
T rz = (z - iz);
|
|
|
|
T qx = 1 - rx;
|
|
T qy = 1 - ry;
|
|
T qz = 1 - rz;
|
|
|
|
if (jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at ix=%d, jx=%d (maxX=%d)") % ix % jx %
|
|
maxX);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d") % ix % jx);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d)") % iy % jy %
|
|
maxY);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d") % iy % jy);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
|
|
__do_interpolation_vec(
|
|
A, field, weight, i, qx, qy, qz, rx, ry, rz, ix, iy, iz, jx, jy,
|
|
jz);
|
|
}
|
|
} //interpolation
|
|
|
|
template <
|
|
typename GradientArray, typename ProjectionDensityArray,
|
|
typename WeightArray>
|
|
static inline
|
|
typename std::enable_if<WeightArray::dimensionality == 1>::type
|
|
__do_gradient(
|
|
GradientArray &adj_gradient, const ProjectionDensityArray &density,
|
|
const WeightArray &weight, size_t i, int axis, int ix, int iy,
|
|
int iz, int jx, int jy, int jz, T x, T y, T z, T global_w) {
|
|
T rx, ry, rz;
|
|
T qx, qy, qz;
|
|
|
|
switch (axis) {
|
|
case 0:
|
|
rx = 1;
|
|
qx = -1;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 1:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = 1;
|
|
qy = -1;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 2:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = 1;
|
|
qz = -1;
|
|
break;
|
|
}
|
|
|
|
double w = density[ix][iy][iz] * qx * qy * qz +
|
|
density[ix][iy][jz] * qx * qy * rz +
|
|
density[ix][jy][iz] * qx * ry * qz +
|
|
density[ix][jy][jz] * qx * ry * rz +
|
|
density[jx][iy][iz] * rx * qy * qz +
|
|
density[jx][iy][jz] * rx * qy * rz +
|
|
density[jx][jy][iz] * rx * ry * qz +
|
|
density[jx][jy][jz] * rx * ry * rz;
|
|
|
|
adj_gradient[i][axis] += w * global_w;
|
|
} //__do_gradient
|
|
|
|
template <
|
|
typename ParticleArray, typename GradientArray,
|
|
typename ProjectionDensityArray, typename PeriodicFunction,
|
|
typename WeightArray>
|
|
static typename std::enable_if<WeightArray::dimensionality == 1>::type
|
|
adjoint(
|
|
const ParticleArray &particles, ProjectionDensityArray &density,
|
|
GradientArray &adjoint_gradient, const WeightArray &weight, T Lx, T Ly,
|
|
T Lz, int N0, int N1, int N2, const PeriodicFunction &p, T nmean,
|
|
size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC adjoint-projection");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
T inv_nmean = T(1) / nmean;
|
|
size_t minX = density.index_bases()[0];
|
|
size_t minY = density.index_bases()[1];
|
|
size_t minZ = density.index_bases()[2];
|
|
size_t maxX = minX + density.shape()[0];
|
|
size_t maxY = minY + density.shape()[1];
|
|
size_t maxZ = minZ + density.shape()[2];
|
|
|
|
ctx.print(
|
|
boost::format(
|
|
"Number of particles = %d (array is %d), minX=%d maxX=%d") %
|
|
Np % particles.shape()[0] % minX % maxX);
|
|
ctx.print(
|
|
boost::format("Adjoint gradient = %d") % adjoint_gradient.shape()[0]);
|
|
|
|
# pragma omp parallel for schedule(static)
|
|
for (size_t i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = (ix + 1);
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
if (ignore_overflow) {
|
|
error_helper<ErrorBadState>("Overflow cannot be ignored in adjoint.");
|
|
}
|
|
|
|
if (EXTRA_CHECK && jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at ix=%d, jx=%d (maxX adj = %d)") % ix %
|
|
jx % maxX);
|
|
}
|
|
if (EXTRA_CHECK && ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d (adj)") % ix % jx);
|
|
}
|
|
if (EXTRA_CHECK && jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d) adj") % iy %
|
|
jy % maxY);
|
|
}
|
|
if (EXTRA_CHECK && iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d adj") % iy % jy);
|
|
}
|
|
if (EXTRA_CHECK && jz >= maxZ) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iz=%d, jz=%d (maxZ=%d) adj") % iz %
|
|
jz % maxZ);
|
|
}
|
|
if (EXTRA_CHECK && iz < minZ) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iz=%d, jz=%d adj") % iz % jz);
|
|
}
|
|
|
|
__do_gradient(
|
|
adjoint_gradient, density, weight[i], i, 0, ix, iy, iz, jx, jy, jz,
|
|
x, y, z, inv_nmean * inv_dx);
|
|
__do_gradient(
|
|
adjoint_gradient, density, weight[i], i, 1, ix, iy, iz, jx, jy, jz,
|
|
x, y, z, inv_nmean * inv_dy);
|
|
__do_gradient(
|
|
adjoint_gradient, density, weight[i], i, 2, ix, iy, iz, jx, jy, jz,
|
|
x, y, z, inv_nmean * inv_dz);
|
|
}
|
|
} //adjoint
|
|
|
|
template <typename GradientArray, typename ProjectionDensityArray>
|
|
static inline void __do_gradient(
|
|
GradientArray &adj_gradient, const ProjectionDensityArray &density,
|
|
double weight, size_t i, int axis, int ix, int iy, int iz, int jx,
|
|
int jy, int jz, T x, T y, T z, T global_w) {
|
|
T rx, ry, rz;
|
|
T qx, qy, qz;
|
|
|
|
switch (axis) {
|
|
case 0:
|
|
rx = 1;
|
|
qx = -1;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 1:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = 1;
|
|
qy = -1;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 2:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = 1;
|
|
qz = -1;
|
|
break;
|
|
}
|
|
|
|
double w = density[ix][iy][iz] * qx * qy * qz +
|
|
density[ix][iy][jz] * qx * qy * rz +
|
|
density[ix][jy][iz] * qx * ry * qz +
|
|
density[ix][jy][jz] * qx * ry * rz +
|
|
density[jx][iy][iz] * rx * qy * qz +
|
|
density[jx][iy][jz] * rx * qy * rz +
|
|
density[jx][jy][iz] * rx * ry * qz +
|
|
density[jx][jy][jz] * rx * ry * rz;
|
|
|
|
adj_gradient[i][axis] = w * global_w * weight;
|
|
} //__do_gradient
|
|
|
|
template <
|
|
typename GradientArray, typename ProjectionDensityArray,
|
|
typename WeightElement>
|
|
static inline void __do_gradient_vec(
|
|
GradientArray &adj_gradient, const ProjectionDensityArray &density,
|
|
WeightElement const &weight, size_t i, int axis, int ix, int iy, int iz,
|
|
int jx, int jy, int jz, T x, T y, T z, T global_w) {
|
|
T rx, ry, rz;
|
|
T qx, qy, qz;
|
|
|
|
switch (axis) {
|
|
case 0:
|
|
rx = 1;
|
|
qx = -1;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 1:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = 1;
|
|
qy = -1;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 2:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = 1;
|
|
qz = -1;
|
|
break;
|
|
}
|
|
|
|
unsigned int dims = weight.shape()[1];
|
|
|
|
adj_gradient[i][axis] = 0.;
|
|
for (unsigned int k = 0; k < dims; k++) {
|
|
double w = density[k][ix][iy][iz] * qx * qy * qz +
|
|
density[k][ix][iy][jz] * qx * qy * rz +
|
|
density[k][ix][jy][iz] * qx * ry * qz +
|
|
density[k][ix][jy][jz] * qx * ry * rz +
|
|
density[k][jx][iy][iz] * rx * qy * qz +
|
|
density[k][jx][iy][jz] * rx * qy * rz +
|
|
density[k][jx][jy][iz] * rx * ry * qz +
|
|
density[k][jx][jy][jz] * rx * ry * rz;
|
|
|
|
adj_gradient[i][axis] += w * global_w * weight[k];
|
|
}
|
|
} //__do_gradient_vec
|
|
|
|
template <
|
|
typename ParticleArray, typename GradientArray,
|
|
typename ProjectionDensityArray, typename PeriodicFunction,
|
|
typename WeightArray>
|
|
static typename std::enable_if<WeightArray::dimensionality != 1>::type
|
|
adjoint(
|
|
const ParticleArray &particles, ProjectionDensityArray &density,
|
|
GradientArray &adjoint_gradient, const WeightArray &weight, T Lx, T Ly,
|
|
T Lz, int N0, int N1, int N2, const PeriodicFunction &p, T nmean,
|
|
size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC adjoint-projection");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
T inv_nmean = T(1) / nmean;
|
|
size_t minX = density.index_bases()[0];
|
|
size_t minY = density.index_bases()[1];
|
|
size_t minZ = density.index_bases()[2];
|
|
size_t maxX = minX + density.shape()[0];
|
|
size_t maxY = minY + density.shape()[1];
|
|
size_t maxZ = minZ + density.shape()[2];
|
|
|
|
ctx.print(
|
|
boost::format(
|
|
"Number of particles = %d (array is %d), minX=%d maxX=%d") %
|
|
Np % particles.shape()[0] % minX % maxX);
|
|
ctx.print(
|
|
boost::format("Adjoint gradient = %d") % adjoint_gradient.shape()[0]);
|
|
|
|
# pragma omp parallel for schedule(static)
|
|
for (size_t i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = (ix + 1);
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
if (ignore_overflow) {
|
|
error_helper<ErrorBadState>("Overflow cannot be ignored in adjoint.");
|
|
}
|
|
|
|
if (EXTRA_CHECK && jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at ix=%d, jx=%d (maxX adj = %d)") % ix %
|
|
jx % maxX);
|
|
}
|
|
if (EXTRA_CHECK && ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d (adj)") % ix % jx);
|
|
}
|
|
if (EXTRA_CHECK && jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d) adj") % iy %
|
|
jy % maxY);
|
|
}
|
|
if (EXTRA_CHECK && iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d adj") % iy % jy);
|
|
}
|
|
if (EXTRA_CHECK && jz >= maxZ) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iz=%d, jz=%d (maxZ=%d) adj") % iz %
|
|
jz % maxZ);
|
|
}
|
|
if (EXTRA_CHECK && iz < minZ) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iz=%d, jz=%d adj") % iz % jz);
|
|
}
|
|
|
|
__do_gradient_vec(
|
|
adjoint_gradient, density, weight[i], i, 0, ix, iy, iz, jx, jy, jz,
|
|
x, y, z, inv_nmean * inv_dx);
|
|
__do_gradient_vec(
|
|
adjoint_gradient, density, weight[i], i, 1, ix, iy, iz, jx, jy, jz,
|
|
x, y, z, inv_nmean * inv_dy);
|
|
__do_gradient_vec(
|
|
adjoint_gradient, density, weight[i], i, 2, ix, iy, iz, jx, jy, jz,
|
|
x, y, z, inv_nmean * inv_dz);
|
|
}
|
|
} //adjoint
|
|
|
|
template <
|
|
typename ParticleBasedScalar, typename ParticleArray,
|
|
typename ProjectionDensityArray, typename WeightArray,
|
|
typename PeriodicFunction>
|
|
static typename std::enable_if<WeightArray::dimensionality == 1>::type
|
|
adjoint_interpolation_scalar(
|
|
int axis, ParticleBasedScalar &A, const ParticleArray &particles,
|
|
const ProjectionDensityArray &field, T Lx, T Ly, T Lz, int N0, int N1,
|
|
int N2, const PeriodicFunction &p, const WeightArray &weight,
|
|
size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC adjoint-interpolation");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
size_t minX = field.index_bases()[0];
|
|
size_t minY = field.index_bases()[1];
|
|
size_t minZ = field.index_bases()[2];
|
|
size_t maxX = field.index_bases()[0] + field.shape()[0];
|
|
size_t maxY = field.index_bases()[1] + field.shape()[1];
|
|
size_t maxZ = field.index_bases()[2] + field.shape()[2];
|
|
|
|
ctx.print(boost::format("minX=%d, maxX=%d, N0=%d") % minX % maxX % N0);
|
|
|
|
size_t const bounds[3][2] = {{minX, maxX}, {minY, maxY}, {minZ, maxZ}};
|
|
# pragma omp parallel for schedule(static)
|
|
for (long i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = ix + 1;
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
T rx, ry, rz;
|
|
T qx, qy, qz;
|
|
|
|
switch (axis) {
|
|
case 0:
|
|
rx = 1;
|
|
qx = -1;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 1:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = 1;
|
|
qy = -1;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 2:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = 1;
|
|
qz = -1;
|
|
break;
|
|
}
|
|
|
|
if (jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at ix=%d, jx=%d (maxX=%d)") % ix % jx %
|
|
maxX);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d") % ix % jx);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d)") % iy % jy %
|
|
maxY);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d") % iy % jy);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
|
|
__do_interpolation(
|
|
A, field, weight, i, qx, qy, qz, rx, ry, rz, ix, iy, iz, jx, jy,
|
|
jz);
|
|
}
|
|
} //adjoint_interpolation_scalar
|
|
|
|
template <
|
|
typename ParticleBasedArray, typename ParticleArray,
|
|
typename ProjectionDensityArray, typename WeightArray,
|
|
typename PeriodicFunction>
|
|
static typename std::enable_if<WeightArray::dimensionality != 1>::type
|
|
adjoint_interpolation(
|
|
int axis, ParticleBasedArray &A, const ParticleArray &particles,
|
|
const ProjectionDensityArray &field, T Lx, T Ly, T Lz, int N0, int N1,
|
|
int N2, const PeriodicFunction &p, const WeightArray &weight,
|
|
size_t Np) {
|
|
ConsoleContext<LOG_DEBUG> ctx("Classic CIC adjoint-interpolation");
|
|
|
|
T inv_dx = N0 / Lx;
|
|
T inv_dy = N1 / Ly;
|
|
T inv_dz = N2 / Lz;
|
|
size_t minX = field.index_bases()[0];
|
|
size_t minY = field.index_bases()[1];
|
|
size_t minZ = field.index_bases()[2];
|
|
size_t maxX = field.index_bases()[0] + field.shape()[0];
|
|
size_t maxY = field.index_bases()[1] + field.shape()[1];
|
|
size_t maxZ = field.index_bases()[2] + field.shape()[2];
|
|
|
|
ctx.print(boost::format("minX=%d, maxX=%d, N0=%d") % minX % maxX % N0);
|
|
|
|
size_t const bounds[3][2] = {{minX, maxX}, {minY, maxY}, {minZ, maxZ}};
|
|
# pragma omp parallel for schedule(static)
|
|
for (size_t i = 0; i < Np; i++) {
|
|
|
|
T x = particles[i][0] * inv_dx;
|
|
T y = particles[i][1] * inv_dy;
|
|
T z = particles[i][2] * inv_dz;
|
|
|
|
size_t ix = (size_t)std::floor(x);
|
|
size_t iy = (size_t)std::floor(y);
|
|
size_t iz = (size_t)std::floor(z);
|
|
|
|
size_t jx = ix + 1;
|
|
size_t jy = (iy + 1);
|
|
size_t jz = (iz + 1);
|
|
|
|
p(jx, jy, jz);
|
|
|
|
T rx, ry, rz;
|
|
T qx, qy, qz;
|
|
|
|
switch (axis) {
|
|
case 0:
|
|
rx = 1;
|
|
qx = -1;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 1:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = 1;
|
|
qy = -1;
|
|
rz = z - iz;
|
|
qz = 1 - rz;
|
|
break;
|
|
case 2:
|
|
rx = x - ix;
|
|
qx = 1 - rx;
|
|
ry = y - iy;
|
|
qy = 1 - ry;
|
|
rz = 1;
|
|
qz = -1;
|
|
break;
|
|
}
|
|
|
|
if (jx >= maxX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at ix=%d, jx=%d (maxX=%d)") % ix % jx %
|
|
maxX);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (ix < minX) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at ix=%d, jx=%d") % ix % jx);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (jy >= maxY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Overflow at iy=%d, jy=%d (maxY=%d)") % iy % jy %
|
|
maxY);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
if (iy < minY) {
|
|
Console::instance().print<LOG_ERROR>(
|
|
boost::format("Underflow at iy=%d, jy=%d") % iy % jy);
|
|
MPI_Communication::instance()->abort();
|
|
}
|
|
|
|
__do_interpolation_vec(
|
|
A, field, weight, i, qx, qy, qz, rx, ry, rz, ix, iy, iz, jx, jy,
|
|
jz);
|
|
}
|
|
} //adjoint_interpolation
|
|
};
|
|
|
|
template <typename T>
|
|
struct CIC_Distribution {
|
|
typedef long LongElt;
|
|
|
|
std::shared_ptr<FFTW_Manager_3d<T>> &force_mgr;
|
|
size_t f_N0;
|
|
size_t f_startN0;
|
|
size_t f_localN0;
|
|
double L0, inv_dx;
|
|
|
|
CIC_Distribution(
|
|
std::shared_ptr<FFTW_Manager_3d<T>> &mgr, double L0, double = 0,
|
|
double = 0)
|
|
: force_mgr(mgr), f_N0(mgr->N0), f_startN0(mgr->startN0),
|
|
f_localN0(mgr->localN0) {
|
|
this->L0 = L0;
|
|
this->inv_dx = f_N0 / L0;
|
|
}
|
|
|
|
template <typename Position, typename... U>
|
|
LongElt operator()(Position &&pos, U &&...) {
|
|
double q = pos[0] * inv_dx;
|
|
double floor_q = std::floor(q);
|
|
LongElt i0 = LongElt(floor_q);
|
|
if (i0 < 0 || i0 >= f_N0)
|
|
error_helper<ErrorBadState>(
|
|
"Do not know how to distribute that position: " +
|
|
std::to_string(pos[0]));
|
|
return force_mgr->get_peer(i0);
|
|
}
|
|
};
|
|
|
|
template <typename T, bool ignore_overflow = false>
|
|
class ClassicCloudInCell
|
|
: public GenericCIC<T, ClassicCloudInCell_impl<T, ignore_overflow>> {
|
|
public:
|
|
typedef T Type;
|
|
typedef ClassicCloudInCell_impl<T, ignore_overflow> Base;
|
|
// Number of extra planes required in case of MPI
|
|
static const int MPI_PLANE_LEAKAGE = 1;
|
|
static const int MPI_NEGATIVE_PLANE_LEAKAGE = 0;
|
|
|
|
typedef CIC_Tools::Periodic_MPI Periodic_MPI;
|
|
typedef CIC_Distribution<T> Distribution;
|
|
};
|
|
} // namespace LibLSS
|
|
|
|
#endif
|
|
|
|
// ARES TAG: authors_num = 3
|
|
// ARES TAG: name(0) = Jens Jasche
|
|
// ARES TAG: year(0) = 2009-2019
|
|
// ARES TAG: email(0) = jens.jasche@fysik.su.se
|
|
// ARES TAG: name(1) = Guilhem Lavaux
|
|
// ARES TAG: year(1) = 2014-2019
|
|
// ARES TAG: email(1) = guilhem.lavaux@iap.fr
|
|
// ARES TAG: name(2) = Florent Leclercq
|
|
// ARES TAG: year(2) = 2019
|
|
// ARES TAG: email(2) = florent.leclercq@polytechnique.org
|