Cluster.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <iterator>
#include <vector>
 
#include "autopas/utils/SoAView.h"
 
namespace autopas::internal {
 
template <class Particle_T>
class Cluster {
 public:
  explicit Cluster(Particle_T *firstParticle, size_t clusterSize)
      : _firstParticle(firstParticle), _clusterSize(clusterSize) {}
 
  Particle_T &operator[](size_t index) { return *(_firstParticle + index); }
 
  const Particle_T &operator[](size_t index) const { return *(_firstParticle + index); }
 
  bool empty() const {
    const auto firstNonDummy = std::find_if(_firstParticle, _firstParticle + _clusterSize,
                                            [](const auto &particle) { return not particle.isDummy(); });
    return firstNonDummy > &_firstParticle[_clusterSize - 1];
  }
 
  [[nodiscard]] std::tuple<double, double, bool> getZMinMax() const {
    // Find first particle which is not a dummy and get its z-value.
    auto *begin = &operator[](0);
    auto *end = &operator[](_clusterSize);
    auto pfirst = std::find_if(begin, end, [](const auto &particle) { return not particle.isDummy(); });
    double min = pfirst != end ? pfirst->getR()[2] : std::numeric_limits<double>::max();
 
    // Find last particle which is not a dummy and get its z-value.
    auto rbegin = std::make_reverse_iterator(end);
    auto rend = std::make_reverse_iterator(begin);
    auto plast = std::find_if(rbegin, rend, [](const auto &particle) { return not particle.isDummy(); });
    double max = plast != rend ? plast->getR()[2] : std::numeric_limits<double>::min();
 
    return {min, max, pfirst != end};
  }
 
  auto getSoAView() { return _soaView; }
 
  void setSoAView(const SoAView<typename Particle_T::SoAArraysType> &view) { _soaView = view; }
 
  void setNeighborList(std::vector<Cluster<Particle_T> *> *neighborList) { _neighborClusters = neighborList; }
 
  std::vector<Cluster<Particle_T> *> *getNeighbors() { return _neighborClusters; }
 
  void addNeighbor(Cluster<Particle_T> &neighbor) { _neighborClusters->push_back(&neighbor); }
 
  void clearNeighbors() {
    if (_neighborClusters) {
      _neighborClusters->clear();
    }
  }
 
  void reset(Particle_T *firstParticle) { _firstParticle = firstParticle; }
 
  [[nodiscard]] std::tuple<std::array<double, 3>, std::array<double, 3>> getBoundingBox() const {
    auto lowerCorner = _firstParticle->getR();
    auto upperCorner = _firstParticle[_clusterSize - 1].getR();
 
    for (size_t i = 0; i < _clusterSize; ++i) {
      const auto &pos = _firstParticle[i].getR();
      // no need to check z direction, this is already correct by initialization thanks to the particles being sorted in
      // z dimension.
      for (size_t dim = 0; dim < 2; ++dim) {
        lowerCorner[dim] = std::min(lowerCorner[dim], pos[dim]);
        upperCorner[dim] = std::max(upperCorner[dim], pos[dim]);
      }
    }
    return {lowerCorner, upperCorner};
  }
 
 private:
  size_t _clusterSize;
 
  Particle_T *_firstParticle = nullptr;
  SoAView<typename Particle_T::SoAArraysType> _soaView;
  std::vector<Cluster *> *_neighborClusters = nullptr;
};
 
}  // namespace autopas::internal