ReferenceParticleCell.h

Go to the documentation of this file.

 
#pragma once
 
#include <mutex>
#include <vector>
 
#include "autopas/cells/ParticleCell.h"
#include "autopas/particles/OwnershipState.h"
#include "autopas/utils/SoA.h"
#include "autopas/utils/WrapOpenMP.h"
 
namespace autopas {
 
template <class Particle_T>
class ReferenceParticleCell : public ParticleCell<Particle_T> {
 public:
  using SoAArraysType = typename Particle_T::SoAArraysType;
  using StorageType = std::vector<Particle_T *>;
 
  ReferenceParticleCell()
      : _cellLength({std::numeric_limits<double>::max(), std::numeric_limits<double>::max(),
                     std::numeric_limits<double>::max()}) {}
 
  explicit ReferenceParticleCell(const std::array<double, 3> &cellLength) : _cellLength(cellLength) {}
 
  void addParticle(const Particle_T &p) override {
    autopas::utils::ExceptionHandler::exception("Should use addParticleReference instead");
  }
 
  void addParticleReference(Particle_T *p) {
    // sanity check that ensures that only particles of the cells OwnershipState can be added. Note: is 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(
          "ReferenceParticleCell::addParticleReference() can not add a particle with OwnershipState {} to a cell with "
          "OwnershipState {}",
          p->getOwnershipState(), this->_ownershipState);
    }
 
    std::lock_guard<AutoPasLock> guard(this->_cellLock);
    _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, IteratorBehavior behavior) {
    const std::array<double, 3> dummy{};
    forEachImpl<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>(forEachLambda, lowerCorner, higherCorner, behavior);
  }
  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);
 
    size_t numParticles{0};
    numParticles =
        std::count_if(_particles.begin(), _particles.end(), [&behavior](auto p) { return behavior.contains(*p); });
 
    return numParticles;
  }
 
  Particle_T &operator[](size_t n) { return *(_particles[n]); }
 
  CellType getParticleCellTypeAsEnum() override { return CellType::ReferenceParticleCell; }
 
  const Particle_T &operator[](size_t n) const { return *(_particles[n]); }
 
  [[nodiscard]] Particle_T &at(size_t index) { return *(_particles.at(index)); }
 
  [[nodiscard]] 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);
    }
 
    _particles[index]->setOwnershipState(OwnershipState::dummy);
 
    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, std::unique_ptr<Particle_T>(toInsert)); }
 
  void sortByDim(const size_t dim) {
    std::sort(_particles.begin(), _particles.end(),
              [dim](const auto *a, const auto *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 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 (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