30 void accumulateClipped(
const Vector_t* R,
const double* Q,
const int* bin,
31 std::size_t localNum,
const Vector_t& centre,
32 const Vector_t& halfWidth,
double sums[8]) {
33 std::fill(sums, sums + 8, 0.0);
34 for (std::size_t i = 0; i < localNum; ++i) {
39 if (std::abs(dr[0]) > halfWidth[0] ||
40 std::abs(dr[1]) > halfWidth[1] ||
41 std::abs(dr[2]) > halfWidth[2]) {
46 for (
unsigned int d = 0; d < 3; ++d) {
48 sums[5 + d] += dr[d] * dr[d];
54 void meanAndSigma(
const double sums[8],
const Vector_t& centre,
56 for (
unsigned int d = 0; d < 3; ++d) {
57 const double shift = sums[2 + d] / sums[0];
58 mean[d] = centre[d] + shift;
59 sigma[d] = std::sqrt(std::max(0.0, sums[5 + d] / sums[0] - shift * shift));
66 for (
unsigned int d = 0; d < 3; ++d) {
75 allreduce(values, count, std::plus<double>());
80 allreduce(values, count, std::less<double>());
85 return chargeLive != 0.0 ? chargeFar / chargeLive : 0.0;
90 const int* bin, std::size_t localNum,
91 double nSigma,
double clip,
102 const Vector_t unlimited(std::numeric_limits<double>::infinity());
103 accumulateClipped(R, Q, bin, localNum,
Vector_t(0.0), unlimited, sums);
104 reducer.
sum(sums, 8);
105 selection.
numLive =
static_cast<std::size_t
>(sums[0]);
110 meanAndSigma(sums,
Vector_t(0.0), mean, sigma);
114 double numPrevious = sums[0];
116 accumulateClipped(R, Q, bin, localNum, mean, getHalfWidth(clip, sigma), sums);
117 reducer.
sum(sums, 8);
118 if (sums[0] == 0.0) {
122 meanAndSigma(sums, mean, newMean, newSigma);
126 bool sigmaSettled =
true;
127 for (
unsigned int d = 0; d < 3; ++d) {
129 !(std::abs(newSigma[d] - sigma[d]) <
clipTolerance * newSigma[d])) {
130 sigmaSettled =
false;
136 if (sums[0] == numPrevious || sigmaSettled) {
140 numPrevious = sums[0];
143 selection.
mean = mean;
144 selection.
sigma = sigma;
148 const Vector_t coreWidth = getHalfWidth(nSigma, sigma);
151 std::fill(extrema, extrema + 7, std::numeric_limits<double>::max());
152 double farSums[3] = {0.0, 0.0, 0.0};
153 for (std::size_t i = 0; i < localNum; ++i) {
160 for (
unsigned int d = 0; d < 3; ++d) {
161 const double dist = std::abs(dr[d]);
162 if (dist > coreWidth[d]) {
165 if (dist > haloWidth[d]) {
173 for (
unsigned int d = 0; d < 3; ++d) {
174 extrema[d] = std::min(extrema[d], R[i][d]);
175 extrema[3 + d] = std::min(extrema[3 + d], -R[i][d]);
181 double distance = 0.0;
182 for (
unsigned int d = 0; d < 3; ++d) {
184 distance = std::max(distance, std::abs(dr[d]) / sigma[d]);
187 extrema[6] = std::min(extrema[6], -distance);
189 reducer.
sum(farSums, 3);
190 reducer.
min(extrema, 7);
192 selection.
numFar =
static_cast<std::size_t
>(farSums[0]);
194 selection.
numHalo =
static_cast<std::size_t
>(farSums[2]);
196 for (
unsigned int d = 0; d < 3; ++d) {
198 selection.
boundsMax[d] = -extrema[3 + d];
210 const Vector_t coreWidth = getHalfWidth(nSigma, selection.
sigma);
212 for (
unsigned int d = 0; d < 3; ++d) {
214 extrema[3 + d] = -selection.
boundsMax[d];
216 for (std::size_t i = 0; i < localNum; ++i) {
221 if (std::abs(dr[0]) > coreWidth[0] ||
222 std::abs(dr[1]) > coreWidth[1] ||
223 std::abs(dr[2]) > coreWidth[2]) {
226 for (
unsigned int d = 0; d < 3; ++d) {
227 extrema[d] = std::min(extrema[d], R[i][d]);
228 extrema[3 + d] = std::min(extrema[3 + d], -R[i][d]);
231 reducer.
min(extrema, 6);
233 for (
unsigned int d = 0; d < 3; ++d) {
234 boxMin[d] = extrema[d];
235 boxMax[d] = -extrema[3 + d];
245 if (
isInside(r, boundsMin, boundsMax)) {
263 for (
unsigned int i = 0; i < 3; ++i) {
264 sums_m[1 + i] += q * s[i];
268 for (
unsigned int i = 0; i < 3; ++i) {
269 for (
unsigned int j = i; j < 3; ++j, ++l) {
270 sums_m[l] += q * s[i] * s[j];
277 std::array<double, 10> sums = sums_m;
278 reducer.
sum(sums.data(), 10);
283 if (sums[0] == 0.0) {
286 for (
unsigned int i = 0; i < 3; ++i) {
287 moments.
centroid[i] = sums[1 + i] / sums[0];
292 for (
unsigned int i = 0, l = 0; i < 3; ++i) {
293 for (
unsigned int j = i; j < 3; ++j, ++l) {
297 const double trace = M[0] + M[3] + M[5];
298 for (
unsigned int i = 0, l = 0; i < 3; ++i) {
299 for (
unsigned int j = i; j < 3; ++j, ++l) {
300 const double Qij = 3.0 * M[l] - (i == j ?
trace : 0.0);
310 const std::vector<Vector_t>& position,
311 std::size_t
begin, std::size_t
end,
bool withQuadrupole,
312 std::vector<Vector_t>& field,
313 std::vector<double>& indicator) {
314 const std::array<Vector_t, 3>& Q = moments.
quadrupole;
315 for (std::size_t i =
begin; i <
end; ++i) {
317 const double r2 =
dot(d, d);
318 const double r3 = r2 * std::sqrt(r2);
320 const double dQd =
dot(d, Qd);
323 const Vector_t quadrupole = (2.5 * dQd / (r2 * r2 * r3)) * d - Qd / (r2 * r3);
326 indicator[i] = monopoleNorm > 0.0 ?
euclidean_norm(quadrupole) / monopoleNorm : 0.0;
327 field[i] = withQuadrupole ? monopole + quadrupole : monopole;
334 const std::vector<Vector_t>& source,
335 const std::vector<double>& charge,
336 double eps, std::vector<Vector_t>& field) {
337 const double eps2 = eps * eps;
338 const std::size_t numSources = source.size();
339 for (std::size_t i =
begin; i <
end; ++i) {
342 for (std::size_t j = 0; j < numSources; ++j) {
344 const double d2 =
dot(d, d);
348 const double r2 = d2 + eps2;
349 E += (charge[j] / (r2 * std::sqrt(r2))) * d;
358 const std::size_t p = rank;
359 const std::size_t numP = numRanks;
360 return std::make_pair(p * n / numP, (p + 1) * n / numP);
366 const double pairs =
static_cast<double>(numTargets) *
static_cast<double>(numSources);
367 if (pairs <= maxPairs) {
370 return static_cast<std::size_t
>(std::ceil(pairs / maxPairs));
375 for (
unsigned int d = 0; d < 3; ++d) {
376 const double centre = 0.5 * (lower[d] + upper[d]);
377 const double halfWidth = 0.5 * (upper[d] - lower[d]);
387 std::size_t numCore, std::size_t numLive,
388 double farChargeFraction,
double maxFarFraction,
389 unsigned int minDwell) {
390 const double core = numCore;
391 const double live = numLive;
392 const unsigned int maxDwell = std::max(minDwell, 1u);
394 const unsigned int dwell = (previous.
dwell == 0 ? maxDwell : previous.
dwell);
395 const bool dwellReached = (dwell >= minDwell);
399 (dwellReached && farChargeFraction > maxFarFraction)) {
402 }
else if (dwellReached &&
408 return ModeState{previous.
mode, dwell < maxDwell ? dwell + 1 : maxDwell};
T euclidean_norm(const Vector< T > &)
Euclidean norm.
double dot(const Vector3D &lhs, const Vector3D &rhs)
Vector dot product.
PartBunchBase< T, Dim >::ConstIterator end(PartBunchBase< T, Dim > const &bunch)
PartBunchBase< T, Dim >::ConstIterator begin(PartBunchBase< T, Dim > const &bunch)
void allreduce(const T *input, T *output, int count, Op op)
T trace(const AntiSymTenzor< T, D > &)
constexpr double returnCoreFraction
CoreSelection selectCore(const Vector_t *R, const double *Q, const int *bin, std::size_t localNum, double nSigma, double clip, const Reducer &reducer)
constexpr double returnFarFactor
constexpr double coreShellFraction
bool isInside(const Vector_t &r, const Vector_t &lower, const Vector_t &upper)
True if r lies in [lower, upper] in every axis.
constexpr double flatWidth
void addDirectField(const std::vector< Vector_t > &target, std::size_t begin, std::size_t end, const std::vector< Vector_t > &source, const std::vector< double > &charge, double eps, std::vector< Vector_t > &field)
ModeState decideMode(const ModeState &previous, std::size_t numCore, std::size_t numLive, double farChargeFraction, double maxFarFraction, unsigned int minDwell)
constexpr double haloSigma
The halo proper: live particles beyond haloSigma clipped rms widths in any axis.
ParticleClass classify(int bin, const Vector_t &r, const Vector_t &boundsMin, const Vector_t &boundsMax, const Vector_t &meshMin, const Vector_t &meshMax)
constexpr double minCoreFraction
void computeMultipoleField(const CoreMoments &moments, const std::vector< Vector_t > &position, std::size_t begin, std::size_t end, bool withQuadrupole, std::vector< Vector_t > &field, std::vector< double > &indicator)
std::pair< std::size_t, std::size_t > getTableRange(std::size_t n, int rank, int numRanks)
bool isInCoreShell(const Vector_t &r, const Vector_t &lower, const Vector_t &upper)
constexpr unsigned int maxClipPasses
constexpr double minCoreParticles
void getMeshBox(const Vector_t *R, const int *bin, std::size_t localNum, const CoreSelection &selection, double nSigma, const Reducer &reducer, Vector_t &boxMin, Vector_t &boxMax)
@ FAR
outside that range: multipole (or exact core) field, plus far-far
@ INSIDE
lost (Bin < 0), inside the core bounds: gathered, not deposited
@ CORE
live, inside the core bounds: deposited, field gathered from the mesh
std::size_t getSampleStride(std::size_t numTargets, std::size_t numSources, double maxPairs)
Vector_t toRestFrame(const Vector_t &r, const Vector_t &r0, double gamma)
constexpr double clipTolerance
The clipped passes stop when |dsigma_d| < clipTolerance * sigma_d in every axis.
virtual void sum(double *values, unsigned int count) const =0
Sums over all ranks.
virtual void min(double *values, unsigned int count) const =0
Minima over all ranks (maxima are the minima of the negated values)
void sum(double *values, unsigned int count) const override
Sums over all ranks.
void min(double *values, unsigned int count) const override
Minima over all ranks (maxima are the minima of the negated values)
Result of selectCore(), the same on every rank.
unsigned int passes
clipped passes done, 0 to maxClipPasses
double getFarChargeFraction() const
Far charge over live charge, 0 without live charge.
bool converged
false if the passes stopped at maxClipPasses
std::size_t numLive
particles with Bin >= 0
double chargeFar
charge of the far live particles [C]
Vector_t boundsMin
minimum over the core particles [m]
Vector_t mean
clipped mean [m]
std::size_t numFar
the other live particles
Vector_t sigma
clipped rms [m]
std::size_t numHalo
live particles beyond haloSigma * sigma in any axis
double chargeLive
charge of the live particles [C]
std::size_t numCore
live particles within nSigma * sigma in every axis
Rest-frame moments of the core charge.
Vector_t centroid
c', rest frame, about the centre [m]
std::array< Vector_t, 3 > quadrupole
void add(double q, const Vector_t &r)
Adds a particle of charge q at r (local frame, not rest frame)
std::array< double, 10 > sums_m
CoreMoments reduce(const Reducer &reducer) const
Moments of all ranks' particles: one sum of 10 doubles.
MomentSums(const Vector_t ¢re, double gamma)
Vektor< double, 3 > Vector_t