CellBasedParticleContainer.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <array>
#include <memory>
 
#include "autopas/containers/ParticleContainerInterface.h"
#include "autopas/containers/TraversalInterface.h"
#include "autopas/utils/SortingThresholdInfoInterface.h"
#include "autopas/utils/SortingThresholdInfoSingle.h"
#include "autopas/utils/WrapOpenMP.h"
 
namespace autopas {
 
// consider multiple inheritance or delegation to avoid virtual call to Functor
template <class ParticleCell_T>
class CellBasedParticleContainer : public ParticleContainerInterface<typename ParticleCell_T::ParticleType> {
  using ParticleType = typename ParticleCell_T::ParticleType;
  using ParticleCellType = ParticleCell_T;
 
 public:
  CellBasedParticleContainer(const std::array<double, 3> &boxMin, const std::array<double, 3> &boxMax,
                             const double cutoff, const double skin, const size_t aosSortingThresholdFallback,
                             const size_t soaSortingThresholdFallback)
      : ParticleContainerInterface<ParticleType>(skin),
        _cells(),
        _boxMin(boxMin),
        _boxMax(boxMax),
        _cutoff(cutoff),
        _skin(skin),
        _aosSortingThresholds(std::make_shared<const SortingThresholdInfoSingle>(aosSortingThresholdFallback)),
        _soaSortingThresholds(std::make_shared<const SortingThresholdInfoSingle>(soaSortingThresholdFallback)) {}
 
  ~CellBasedParticleContainer() override = default;
 
  CellBasedParticleContainer(const CellBasedParticleContainer &obj) = delete;
 
  CellBasedParticleContainer &operator=(const CellBasedParticleContainer &other) = delete;
 
  [[nodiscard]] const std::array<double, 3> &getBoxMax() const final { return _boxMax; }
 
  [[nodiscard]] const std::array<double, 3> &getBoxMin() const final { return _boxMin; }
 
  [[nodiscard]] double getCutoff() const final { return _cutoff; }
 
  void setCutoff(double cutoff) final { _cutoff = cutoff; }
 
  [[nodiscard]] double getInteractionLength() const final { return _cutoff + _skin; }
  [[nodiscard]] double getVerletSkin() const final { return _skin; }
 
  void deleteAllParticles() override {
    AUTOPAS_OPENMP(parallel for num_threads(std::clamp(static_cast<int>(this->_cells.size()) / 1000,  \
                                                       1,                                             \
                                                       autopas::autopas_get_max_threads())))
    for (size_t i = 0; i < this->_cells.size(); ++i) {
      this->_cells[i].clear();
    }
  }
 
  [[nodiscard]] size_t getNumberOfParticles(IteratorBehavior behavior) const override {
    size_t numParticles = 0ul;
    // parallelizing this loop is only worth it if we have LOTS of cells.
    // numThreads should be at least 1 and maximal max_threads
    AUTOPAS_OPENMP(parallel for num_threads(std::clamp(static_cast<int>(this->_cells.size()) / 100000, \
                                                       1,                                              \
                                                       autopas::autopas_get_max_threads()))            \
                                reduction(+ : numParticles))
    for (size_t index = 0; index < _cells.size(); ++index) {
      numParticles += _cells[index].getNumberOfParticles(behavior);
    }
    return numParticles;
  }
 
  [[nodiscard]] size_t size() const override {
    size_t numParticles = 0ul;
    // parallelizing this loop is only worth it if we have LOTS of cells.
    // numThreads should be at least 1 and maximal max_threads
    AUTOPAS_OPENMP(parallel for num_threads(std::clamp(static_cast<int>(this->_cells.size()) / 100000, \
                                                       1,                                              \
                                                       autopas::autopas_get_max_threads()))            \
                                reduction(+ : numParticles))
    for (size_t index = 0; index < _cells.size(); ++index) {
      numParticles += _cells[index].size();
    }
    return numParticles;
  }
 
  [[nodiscard]] const std::vector<ParticleCellType> &getCells() const { return _cells; }
 
  void setAoSSortingThresholds(std::shared_ptr<const SortingThresholdInfoInterface> aosSortingThresholds) override {
    _aosSortingThresholds = std::move(aosSortingThresholds);
  }
 
  void setSoASortingThresholds(std::shared_ptr<const SortingThresholdInfoInterface> soaSortingThresholds) override {
    _soaSortingThresholds = std::move(soaSortingThresholds);
  }
 
 protected:
  std::vector<ParticleCellType> _cells;
  std::shared_ptr<const SortingThresholdInfoInterface> _aosSortingThresholds;
  std::shared_ptr<const SortingThresholdInfoInterface> _soaSortingThresholds;
 
 private:
  std::array<double, 3> _boxMin;
  std::array<double, 3> _boxMax;
  double _cutoff;
  double _skin;
};
 
}  // namespace autopas