ClusterTower.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/cells/FullParticleCell.h"
#include "autopas/containers/ParticleDeletedObserver.h"
#include "autopas/containers/verletClusterLists/Cluster.h"
#include "autopas/particles/OwnershipState.h"
#include "autopas/utils/markParticleAsDeleted.h"
 
namespace autopas::internal {
 
template <class Particle_T>
class ClusterTower : public FullParticleCell<Particle_T> {
 public:
  using StorageType = typename FullParticleCell<Particle_T>::StorageType;
 
  ClusterTower() : _clusterSize(0) {}
 
  explicit ClusterTower(size_t clusterSize) : _clusterSize(clusterSize) {}
 
  CellType getParticleCellTypeAsEnum() override { return CellType::ClusterTower; }
 
  void clear() override {
    _clusters.clear();
    FullParticleCell<Particle_T>::clear();
    _firstOwnedCluster = _clusters.end();
    _firstTailHaloCluster = _clusters.end();
    _numDummyParticles = 0;
  }
 
  size_t generateClusters() {
    if (getNumActualParticles() == 0) {
      _clusters.resize(0, Cluster<Particle_T>(nullptr, _clusterSize));
      _firstOwnedCluster = _clusters.end();
      _firstTailHaloCluster = _clusters.end();
      return 0;
    }
    this->sortByDim(2);
 
    // if the number of particles is divisible by the cluster size this is 0
    const auto sizeLastCluster = this->_particles.size() % _clusterSize;
    _numDummyParticles = sizeLastCluster == 0 ? 0 : _clusterSize - sizeLastCluster;
 
    // fill the last cluster with dummy copies of the last particle
    auto lastParticle = this->_particles[this->_particles.size() - 1];
    markParticleAsDeleted(lastParticle);
    for (size_t i = 0; i < _numDummyParticles; i++) {
      this->addParticle(lastParticle);
    }
 
    // Mark start of the different clusters by adding pointers to _particles
    const size_t numClusters = this->_particles.size() / _clusterSize;
    _clusters.resize(numClusters, Cluster<Particle_T>(nullptr, _clusterSize));
    bool foundFirstOwnedCluster = false;
    bool foundFirstTailHaloCluster = false;
 
    const auto isAnyOfClusterOwned = [&](const auto &cluster) {
      for (size_t i = 0; i < _clusterSize; ++i) {
        if (cluster[i].isOwned()) {
          return true;
        }
      }
      return false;
    };
 
    for (size_t index = 0; index < numClusters; index++) {
      _clusters[index].reset(&(this->_particles[_clusterSize * index]));
 
      const bool clusterContainsOwnedParticles =
          not foundFirstTailHaloCluster and isAnyOfClusterOwned(_clusters[index]);
 
      // identify the range of owned clusters
      if (not foundFirstOwnedCluster and clusterContainsOwnedParticles) {
        _firstOwnedCluster = _clusters.begin() + index;
        foundFirstOwnedCluster = true;
      }
      if (not foundFirstTailHaloCluster and foundFirstOwnedCluster and not clusterContainsOwnedParticles) {
        _firstTailHaloCluster = _clusters.begin() + index;
        foundFirstTailHaloCluster = true;
      }
    }
    // for safety, make sure that worst case (e.g. no particles) the iterators point to reasonable positions
    if (not foundFirstOwnedCluster) {
      _firstOwnedCluster = _clusters.end();
    }
    if (not foundFirstTailHaloCluster) {
      _firstTailHaloCluster = _clusters.end();
    }
 
    return getNumClusters();
  }
 
  void setDummyValues(double dummyStartX, double dummyDistZ) {
    auto &lastCluster = getCluster(getNumClusters() - 1);
    for (size_t index = 1; index <= _numDummyParticles; index++) {
      auto &dummy = lastCluster[_clusterSize - index];
      dummy = lastCluster[0];  // use first Particle in last cluster as dummy particle!
      dummy.setOwnershipState(OwnershipState::dummy);
      dummy.setR({dummyStartX, 0, dummyDistZ * static_cast<double>(index)});
      dummy.setID(std::numeric_limits<size_t>::max());
    }
  }
 
  void setDummyParticlesToLastActualParticle() {
    if (_numDummyParticles > 0) {
      auto &lastCluster = getCluster(getNumClusters() - 1);
      auto lastActualParticle = lastCluster[_clusterSize - _numDummyParticles - 1];
      for (size_t index = 1; index <= _numDummyParticles; index++) {
        lastCluster[_clusterSize - index] = lastActualParticle;
      }
    }
  }
 
  template <class Functor>
  void loadSoA(Functor *functor) {
    functor->SoALoader(*this, this->_particleSoABuffer, 0, /*skipSoAResize*/ false);
    for (size_t index = 0; index < getNumClusters(); index++) {
      auto &cluster = getCluster(index);
      cluster.setSoAView({&(this->_particleSoABuffer), index * _clusterSize, (index + 1) * _clusterSize});
    }
  }
 
  template <class Functor>
  void extractSoA(Functor *functor) {
    functor->SoAExtractor(*this, this->_particleSoABuffer, 0);
  }
 
  std::vector<Particle_T> &&collectAllActualParticles() {
    if (not this->_particles.empty()) {
      // Workaround to remove requirement of default constructible particles.
      // This function will always only shrink the array, particles are not actually inserted.
      this->_particles.resize(getNumActualParticles(), this->_particles[0]);
    }
    return std::move(this->_particles);
  }
 
  std::vector<Particle_T> collectOutOfBoundsParticles(const std::array<double, 3> &boxMin,
                                                      const std::array<double, 3> &boxMax) {
    // make sure to get rid of all dummies
    deleteDummyParticles();
    // move all particles that are not in the tower to the back of the storage
    const auto firstOutOfBoundsParticleIter =
        std::partition(this->_particles.begin(), this->_particles.end(),
                       [&](const auto &p) { return utils::inBox(p.getR(), boxMin, boxMax); });
 
    // copy out of bounds particles
    std::vector<Particle_T> outOfBoundsParticles(firstOutOfBoundsParticleIter, this->_particles.end());
    // shrink the particle storage so all out of bounds particles are cut away
    this->_particles.resize(std::distance(this->_particles.begin(), firstOutOfBoundsParticleIter),
                            *this->_particles.begin());
    return outOfBoundsParticles;
  }
 
  [[nodiscard]] size_t getNumTailDummyParticles() const { return _numDummyParticles; }
 
  [[nodiscard]] size_t size() const override { return this->_particles.size(); }
 
  [[nodiscard]] unsigned long getNumActualParticles() const {
    return this->_particles.size() - getNumTailDummyParticles();
  }
 
  [[nodiscard]] size_t getNumClusters() const { return _clusters.size(); }
 
  [[nodiscard]] auto &getClusters() { return _clusters; }
 
  [[nodiscard]] const typename std::vector<autopas::internal::Cluster<Particle_T>>::iterator &getFirstOwnedCluster()
      const {
    return _firstOwnedCluster;
  }
 
  [[nodiscard]] size_t getFirstOwnedClusterIndex() const {
    return std::distance(_clusters.cbegin(), decltype(_clusters.cbegin()){_firstOwnedCluster});
  }
 
  [[nodiscard]] const typename std::vector<autopas::internal::Cluster<Particle_T>>::iterator &getFirstTailHaloCluster()
      const {
    return _firstTailHaloCluster;
  }
 
  [[nodiscard]] size_t getFirstTailHaloClusterIndex() const {
    return std::distance(_clusters.cbegin(), decltype(_clusters.cbegin()){_firstTailHaloCluster});
  }
 
  [[nodiscard]] auto &getCluster(size_t index) { return _clusters[index]; }
 
  [[nodiscard]] auto &getCluster(size_t index) const { return _clusters[index]; }
 
  [[nodiscard]] bool isEmpty() const override { return getNumActualParticles() == 0; }
 
  void deleteDummyParticles() override {
    // call super function to do the actual delete
    FullParticleCell<Particle_T>::deleteDummyParticles();
    _numDummyParticles = 0;
  }
 
  void deleteByIndex(size_t index) override {
 
    // swap particle that should be deleted to end of actual particles.
    std::swap(this->_particles[index], this->_particles[getNumActualParticles() - 1]);
    if (getNumTailDummyParticles() != 0) {
      // swap particle that should be deleted (now at end of actual particles) with last dummy particle.
      std::swap(this->_particles[getNumActualParticles() - 1], this->_particles[this->_particles.size() - 1]);
    }
 
    this->_particles.pop_back();
 
    if (_particleDeletionObserver) {
      _particleDeletionObserver->notifyParticleDeleted();
    }
  }
 
  void setCellLength(std::array<double, 3> &) override {
    autopas::utils::ExceptionHandler::exception("ClusterTower::setCellLength(): Not supported!");
  }
 
  [[nodiscard]] std::array<double, 3> getCellLength() const override {
    autopas::utils::ExceptionHandler::exception("ClusterTower::getCellLength(): Not supported!");
    return {0, 0, 0};
  }
 
  void setClusterSize(size_t clusterSize) { _clusterSize = clusterSize; }
 
  [[nodiscard]] size_t getClusterSize() const { return _clusterSize; }
 
  void setParticleDeletionObserver(internal::ParticleDeletedObserver *observer) {
    _particleDeletionObserver = observer;
  };
 
  StorageType &particleVector() { return this->_particles; }
 
 private:
  size_t _clusterSize;
 
  std::vector<Cluster<Particle_T>> _clusters;
 
  typename decltype(_clusters)::iterator _firstOwnedCluster{_clusters.end()};
  typename decltype(_clusters)::iterator _firstTailHaloCluster{_clusters.end()};
 
  size_t _numDummyParticles{};
 
  internal::ParticleDeletedObserver *_particleDeletionObserver{nullptr};
};
}  // namespace autopas::internal