FullParticleCell.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <mutex>
#include <vector>
 
#include "autopas/cells/ParticleCell.h"
#include "autopas/iterators/CellIterator.h"
#include "autopas/options/IteratorBehavior.h"
#include "autopas/utils/SoA.h"
#include "autopas/utils/inBox.h"
 
namespace autopas {
 
template <class Particle_T>
class FullParticleCell : public ParticleCell<Particle_T> {
 public:
  using SoAArraysType = typename Particle_T::SoAArraysType;
 
  using StorageType = std::vector<Particle_T>;
 
  FullParticleCell()
      : _cellLength({std::numeric_limits<double>::max(), std::numeric_limits<double>::max(),
                     std::numeric_limits<double>::max()}) {}
 
  explicit FullParticleCell(const std::array<double, 3> &cellLength) : _cellLength(cellLength) {}
 
  void addParticle(const Particle_T &p) override {
    std::lock_guard<AutoPasLock> guard(this->_cellLock);
 
    // sanity check that ensures that only particles of the cells OwnershipState can be added. Note: if a cell is a
    // dummy-cell, only dummies can be added, otherwise dummies can always be added
    if ((not toInt64(p.getOwnershipState() & this->_ownershipState)) and
        p.getOwnershipState() != OwnershipState::dummy) {
      autopas::utils::ExceptionHandler::exception(
          "FullParticleCell::addParticle() can not add a particle with OwnershipState {} to a cell with OwnershipState "
          "{}",
          p.getOwnershipState(), this->_ownershipState);
    }
 
    _particles.push_back(p);
  }
 
  [[nodiscard]] CellIterator<StorageType, true> begin() { return CellIterator<StorageType, true>(_particles.begin()); }
 
  [[nodiscard]] CellIterator<StorageType, false> begin() const {
    return CellIterator<StorageType, false>(_particles.cbegin());
  }
 
  [[nodiscard]] CellIterator<StorageType, true> end() { return CellIterator<StorageType, true>(_particles.end()); }
 
  [[nodiscard]] CellIterator<StorageType, false> end() const {
    return CellIterator<StorageType, false>(_particles.cend());
  }
 
  template <typename Lambda>
  void forEach(Lambda forEachLambda) {
    const std::array<double, 3> dummy{};
    forEachImpl<false, false>(forEachLambda, dummy, dummy);
  }
 
  template <typename Lambda>
  void forEach(Lambda forEachLambda, IteratorBehavior behavior) {
    const std::array<double, 3> dummy{};
    forEachImpl<true, false>(forEachLambda, dummy, dummy, behavior);
  }
 
  template <typename Lambda>
  void forEach(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
               const std::array<double, 3> &higherCorner, IteratorBehavior behavior) {
    forEachImpl<true, true>(forEachLambda, lowerCorner, higherCorner, behavior);
  }
 
  template <typename Lambda, typename A>
  void reduce(Lambda reduceLambda, A &result) {
    const std::array<double, 3> dummy{};
    reduceImpl<false, false>(reduceLambda, result, dummy, dummy);
  }
 
  template <typename Lambda, typename A>
  void reduce(Lambda reduceLambda, A &result, IteratorBehavior behavior) {
    const std::array<double, 3> dummy{};
    reduceImpl<true, false>(reduceLambda, result, dummy, dummy, behavior);
  }
 
  template <typename Lambda, typename A>
  void reduce(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
              const std::array<double, 3> &higherCorner, IteratorBehavior behavior) {
    reduceImpl<true, true>(reduceLambda, result, lowerCorner, higherCorner, behavior);
  }
 
  [[nodiscard]] size_t size() const override { return _particles.size(); }
 
  [[nodiscard]] size_t getNumberOfParticles(IteratorBehavior behavior) const override {
    std::lock_guard<AutoPasLock> guard(this->_cellLock);
    return std::count_if(_particles.begin(), _particles.end(), [&behavior](auto p) { return behavior.contains(p); });
  }
 
  Particle_T &operator[](size_t n) { return _particles[n]; }
 
  const Particle_T &operator[](size_t n) const { return _particles[n]; }
 
  Particle_T &at(size_t index) { return _particles.at(index); }
 
  CellType getParticleCellTypeAsEnum() override { return CellType::FullParticleCell; }
 
  const Particle_T &at(size_t index) const { return _particles.at(index); }
 
  [[nodiscard]] bool isEmpty() const override { return size() == 0; }
 
  void clear() override { _particles.clear(); }
 
  void deleteDummyParticles() override {
    _particles.erase(
        std::remove_if(_particles.begin(), _particles.end(), [](const auto &particle) { return particle.isDummy(); }),
        _particles.end());
  }
 
  void deleteByIndex(size_t index) override {
    std::lock_guard<AutoPasLock> lock(this->_cellLock);
    if (index >= size()) {
      utils::ExceptionHandler::exception("Index out of range (range: [0, {}[, index: {})", size(), index);
    }
 
    if (index < size() - 1) {
      std::swap(_particles[index], _particles[size() - 1]);
    }
    _particles.pop_back();
  }
 
  void setCellLength(std::array<double, 3> &cellLength) override { _cellLength = cellLength; }
 
  [[nodiscard]] std::array<double, 3> getCellLength() const override { return _cellLength; }
 
  void resize(size_t n, const Particle_T &toInsert) { _particles.resize(n, toInsert); }
 
  void sortByDim(const size_t dim) {
    std::sort(_particles.begin(), _particles.end(),
              [dim](const Particle_T &a, const Particle_T &b) -> bool { return a.getR()[dim] < b.getR()[dim]; });
  }
 
  void reserve(size_t n) { _particles.reserve(n); }
 
  StorageType _particles{};
 
  SoA<SoAArraysType> _particleSoABuffer{};
 
 private:
  std::array<double, 3> _cellLength;
 
  template <bool ownershipCheck, bool regionCheck, typename Lambda>
  void forEachImpl(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
                   const std::array<double, 3> &higherCorner,
                   IteratorBehavior behavior = autopas::IteratorBehavior::ownedOrHaloOrDummy) {
    for (Particle_T &p : _particles) {
      if ((not ownershipCheck) or behavior.contains(p)) {
        if ((not regionCheck) or utils::inBox(p.getR(), lowerCorner, higherCorner)) {
          forEachLambda(p);
        }
      }
    }
  }
 
  template <bool ownershipCheck, bool regionCheck, typename Lambda, typename A>
  void reduceImpl(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
                  const std::array<double, 3> &higherCorner,
                  IteratorBehavior behavior = autopas::IteratorBehavior::ownedOrHaloOrDummy) {
    for (Particle_T &p : _particles) {
      if ((not ownershipCheck) or behavior.contains(p)) {
        if ((not regionCheck) or utils::inBox(p.getR(), lowerCorner, higherCorner)) {
          reduceLambda(p, result);
        }
      }
    }
  }
};
}  // namespace autopas