VerletListsCellsHelpers.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "autopas/options/TraversalOption.h"
#include "autopas/utils/ThreeDimensionalMapping.h"
 
namespace autopas::VerletListsCellsHelpers {
template <class Particle_T>
using AllCellsNeighborListsType = std::vector<std::vector<std::pair<Particle_T *, std::vector<Particle_T *>>>>;
 
template <class Particle_T>
using PairwiseNeighborListsType =
    std::vector<std::vector<std::vector<std::pair<Particle_T *, std::vector<Particle_T *>>>>>;
 
enum class VLCBuildType {
  aosBuild,
  soaBuild,
};
 
struct BaseStepOffsets {
  int offset1;
  int offset2;
  double listSizeEstimateFactor;
 
  bool operator==(const BaseStepOffsets &rhs) const;
 
  bool operator!=(const BaseStepOffsets &rhs) const;
};
 
std::vector<BaseStepOffsets> buildBaseStep(const std::array<int, 3> &cellsPerDim, const TraversalOption traversal);
 
size_t estimateListLength(size_t numParticles, const std::array<double, 3> &boxSize, double interactionLength,
                          double correctionFactor);
 
template <class Cells>
size_t estimateNumLists(size_t baseCellIndex, bool useNewton3, const Cells &cells,
                        const std::vector<BaseStepOffsets> &offsetsC08, const std::array<size_t, 3> cellsPerDim) {
  // First for every cell, find its biggest factor.
  // Meaning, find out what is the closest interaction type this cell is involved in.
  std::unordered_map<int, double> offsetFactors{};
  std::unordered_map<int, double> offsetFactorsNoN3{};
  for (const auto [offsetA, offsetB, factor] : offsetsC08) {
    offsetFactors[offsetA] = std::max(offsetFactors[offsetA], factor);
    offsetFactorsNoN3[offsetB] = std::max(offsetFactors[offsetB], factor);
  }
  // The estimate is constructed by summing the involved cells' sizes weighted by their factors.
  size_t estimate = 0;
  for (const auto &[offset, factor] : offsetFactors) {
    const auto otherCellCoords = utils::ThreeDimensionalMapping::oneToThreeD(baseCellIndex + offset, cellsPerDim);
    if (otherCellCoords[0] < cellsPerDim[0] and otherCellCoords[1] < cellsPerDim[1] and
        otherCellCoords[2] < cellsPerDim[2]) {
      estimate += cells[baseCellIndex + offset].size() * factor;
    }
  }
  // For the non Newton3 case, lists have to be created for particles that otherwise would already be covered.
  if (not useNewton3) {
    for (const auto &[offset, factor] : offsetFactorsNoN3) {
      const auto otherCellCoords = utils::ThreeDimensionalMapping::oneToThreeD(baseCellIndex + offset, cellsPerDim);
      if (otherCellCoords[0] < cellsPerDim[0] and otherCellCoords[1] < cellsPerDim[1] and
          otherCellCoords[2] < cellsPerDim[2]) {
        estimate += cells[baseCellIndex + offset].size() * factor;
      }
    }
  }
  return estimate;
};
}  // namespace autopas::VerletListsCellsHelpers