VerletListsLinkedBase.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/containers/LeavingParticleCollector.h"
#include "autopas/containers/ParticleContainerInterface.h"
#include "autopas/containers/linkedCells/LinkedCells.h"
#include "autopas/utils/ArrayMath.h"
#include "autopas/utils/ParticleCellHelpers.h"
#include "autopas/utils/markParticleAsDeleted.h"
 
namespace autopas {
 
template <class Particle_T>
class VerletListsLinkedBase : public ParticleContainerInterface<Particle_T> {
 public:
  using ParticleType = Particle_T;
 
  using ParticleCellType = typename LinkedCells<Particle_T>::ParticleCellType;
 
  VerletListsLinkedBase(const std::array<double, 3> &boxMin, const std::array<double, 3> &boxMax, const double cutoff,
                        const double skin, const double cellSizeFactor)
      : ParticleContainerInterface<Particle_T>(skin),
        _linkedCells(boxMin, boxMax, cutoff, skin, std::max(1.0, cellSizeFactor)) {
    if (cellSizeFactor < 1.0) {
      // Throw exception - this config should have been caught by LogicHandler. Note: This is not a fundamental issue
      // with the algorithm but simply has not been implemented.
      utils::ExceptionHandler::exception(
          "Trying to construct a VerletListsLinkedBase with CSF < 1.0! This should never occur as the LogicHandler "
          "should reject this (as Configuration::hasCompatibleValues should return false).");
    }
  }
 
  void setAoSSortingThresholds(std::shared_ptr<const SortingThresholdInfoInterface> aosSortingThresholds) override {}
 
  void setSoASortingThresholds(std::shared_ptr<const SortingThresholdInfoInterface> soaSortingThresholds) override {}
 
  void reserve(size_t numParticles, size_t numParticlesHaloEstimate) override {
    _linkedCells.reserve(numParticles, numParticlesHaloEstimate);
  }
 
  void addParticleImpl(const Particle_T &p) override {
    _neighborListIsValid.store(false, std::memory_order_relaxed);
    // position is already checked, so call impl directly.
    _linkedCells.addParticleImpl(p);
  }
 
  void addHaloParticleImpl(const Particle_T &haloParticle) override {
    _neighborListIsValid.store(false, std::memory_order_relaxed);
    // position is already checked, so call impl directly.
    _linkedCells.addHaloParticleImpl(haloParticle);
  }
 
  size_t size() const override { return _linkedCells.size(); }
 
  [[nodiscard]] size_t getNumberOfParticles(IteratorBehavior behavior) const override {
    return _linkedCells.getNumberOfParticles(behavior);
  }
 
  void deleteHaloParticles() override {
    _neighborListIsValid.store(false, std::memory_order_relaxed);
    _linkedCells.deleteHaloParticles();
  }
 
  void deleteAllParticles() override {
    _neighborListIsValid.store(false, std::memory_order_relaxed);
    _linkedCells.deleteAllParticles();
  }
 
  std::tuple<const Particle_T *, size_t, size_t> getParticle(size_t cellIndex, size_t particleIndex,
                                                             IteratorBehavior iteratorBehavior,
                                                             const std::array<double, 3> &boxMin,
                                                             const std::array<double, 3> &boxMax) const override {
    return getParticleImpl<true>(cellIndex, particleIndex, iteratorBehavior, boxMin, boxMax);
  }
  std::tuple<const Particle_T *, size_t, size_t> getParticle(size_t cellIndex, size_t particleIndex,
                                                             IteratorBehavior iteratorBehavior) const override {
    // this is not a region iter hence we stretch the bounding box to the numeric max
    constexpr std::array<double, 3> boxMin{std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest(),
                                           std::numeric_limits<double>::lowest()};
 
    constexpr std::array<double, 3> boxMax{std::numeric_limits<double>::max(), std::numeric_limits<double>::max(),
                                           std::numeric_limits<double>::max()};
    return getParticleImpl<false>(cellIndex, particleIndex, iteratorBehavior, boxMin, boxMax);
  }
 
  template <bool regionIter>
  std::tuple<const Particle_T *, size_t, size_t> getParticleImpl(size_t cellIndex, size_t particleIndex,
                                                                 IteratorBehavior iteratorBehavior,
                                                                 const std::array<double, 3> &boxMin,
                                                                 const std::array<double, 3> &boxMax) const {
    return _linkedCells.template getParticleImpl<regionIter>(cellIndex, particleIndex, iteratorBehavior, boxMin,
                                                             boxMax);
  }
 
  bool deleteParticle(Particle_T &particle) override {
    // This function doesn't actually delete anything as it would mess up the references in the lists.
    internal::markParticleAsDeleted(particle);
    return false;
  }
 
  bool deleteParticle(size_t cellIndex, size_t particleIndex) override {
    // This function doesn't actually delete anything as it would mess up the references in the lists.
    internal::markParticleAsDeleted(this->_linkedCells.getCells()[cellIndex][particleIndex]);
    return false;
  }
 
  [[nodiscard]] std::vector<Particle_T> updateContainer(bool keepNeighborListsValid) override {
    if (keepNeighborListsValid) {
      return autopas::LeavingParticleCollector::collectParticlesAndMarkNonOwnedAsDummy(_linkedCells);
    }
    _neighborListIsValid.store(false, std::memory_order_relaxed);
    return _linkedCells.updateContainer(false);
  }
 
  bool updateHaloParticle(const Particle_T &haloParticle) override {
    auto cells = _linkedCells.getCellBlock().getNearbyHaloCells(haloParticle.getR(), this->getVerletSkin());
    for (auto cellptr : cells) {
      bool updated = internal::checkParticleInCellAndUpdateByID(*cellptr, haloParticle);
      if (updated) {
        return true;
      }
    }
    AutoPasLog(TRACE,
               "updateHaloParticle was not able to update particle at "
               "[{}, {}, {}]",
               haloParticle.getR()[0], haloParticle.getR()[1], haloParticle.getR()[2]);
    return false;
  }
 
  [[nodiscard]] ContainerIterator<Particle_T, true, false> begin(
      IteratorBehavior behavior = IteratorBehavior::ownedOrHalo,
      utils::optRef<typename ContainerIterator<Particle_T, true, false>::ParticleVecType> additionalVectors =
          std::nullopt) override {
    return _linkedCells.begin(behavior, additionalVectors);
  }
 
  [[nodiscard]] ContainerIterator<Particle_T, false, false> begin(
      IteratorBehavior behavior = IteratorBehavior::ownedOrHalo,
      utils::optRef<typename ContainerIterator<Particle_T, false, false>::ParticleVecType> additionalVectors =
          std::nullopt) const override {
    return _linkedCells.begin(behavior, additionalVectors);
  }
 
  template <typename Lambda>
  void forEach(Lambda forEachLambda, IteratorBehavior behavior) {
    return _linkedCells.forEach(forEachLambda, behavior);
  }
 
  template <typename Lambda, typename A>
  void reduce(Lambda reduceLambda, A &result, IteratorBehavior behavior) {
    return _linkedCells.reduce(reduceLambda, result, behavior);
  }
 
  [[nodiscard]] ContainerIterator<Particle_T, true, true> getRegionIterator(
      const std::array<double, 3> &lowerCorner, const std::array<double, 3> &higherCorner, IteratorBehavior behavior,
      utils::optRef<typename ContainerIterator<Particle_T, true, true>::ParticleVecType> additionalVectors =
          std::nullopt) override {
    return _linkedCells.getRegionIterator(lowerCorner, higherCorner, behavior, additionalVectors);
  }
 
  [[nodiscard]] ContainerIterator<Particle_T, false, true> getRegionIterator(
      const std::array<double, 3> &lowerCorner, const std::array<double, 3> &higherCorner, IteratorBehavior behavior,
      utils::optRef<typename ContainerIterator<Particle_T, false, true>::ParticleVecType> additionalVectors =
          std::nullopt) const override {
    return _linkedCells.getRegionIterator(lowerCorner, higherCorner, behavior, additionalVectors);
  }
 
  template <typename Lambda>
  void forEachInRegion(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
                       const std::array<double, 3> &higherCorner, IteratorBehavior behavior) {
    _linkedCells.forEachInRegion(forEachLambda, lowerCorner, higherCorner, behavior);
  }
 
  template <typename Lambda, typename A>
  void reduceInRegion(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
                      const std::array<double, 3> &higherCorner, IteratorBehavior behavior) {
    _linkedCells.reduceInRegion(reduceLambda, result, lowerCorner, higherCorner, behavior);
  }
 
  [[nodiscard]] const std::array<std::size_t, 3> &getCellsPerDimension() const {
    return _linkedCells.getCellBlock().getCellsPerDimensionWithHalo();
  }
 
  [[nodiscard]] TraversalSelectorInfo getTraversalSelectorInfo() const override {
    return TraversalSelectorInfo(this->_linkedCells.getCellBlock().getCellsPerDimensionWithHalo(),
                                 this->getInteractionLength(), this->_linkedCells.getCellBlock().getCellLength(), 0);
  }
 
  [[nodiscard]] const std::array<double, 3> &getBoxMax() const final { return _linkedCells.getBoxMax(); }
 
  [[nodiscard]] const std::array<double, 3> &getBoxMin() const final { return _linkedCells.getBoxMin(); }
 
  [[nodiscard]] double getCutoff() const final { return _linkedCells.getCutoff(); }
 
  void setCutoff(double cutoff) final { _linkedCells.setCutoff(cutoff); }
 
  [[nodiscard]] double getVerletSkin() const final { return _linkedCells.getVerletSkin(); }
 
  [[nodiscard]] double getInteractionLength() const final { return _linkedCells.getInteractionLength(); }
 
 protected:
  LinkedCells<Particle_T> _linkedCells;
 
  std::atomic<bool> _neighborListIsValid{false};
 
  bool _verletBuiltNewton3{false};
};
 
}  // namespace autopas