SortedCellView.h

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
 
#include "autopas/cells/FullParticleCell.h"
#include "autopas/cells/ParticleCell.h"
#include "autopas/utils/ArrayMath.h"
#include "autopas/utils/SoA.h"
#include "autopas/utils/WrapOpenMP.h"
 
namespace autopas {
 
template <class ParticleCellType>
class SortedCellView : public ParticleCell<typename ParticleCellType::ParticleType> {
 public:
  using ParticleType = typename ParticleCellType::ParticleType;
  using StorageType = std::vector<ParticleType *>;
  SortedCellView(ParticleCellType &cell, const std::array<double, 3> &r) : _cell(&cell) {
    _particles.reserve(cell.size());
    for (auto &p : cell) {
      _particles.push_back(std::make_pair(utils::ArrayMath::dot(p.getR(), r), &p));
    }
    std::sort(_particles.begin(), _particles.end(),
              [](const auto &a, const auto &b) -> bool { return a.first < b.first; });
 
    this->setPossibleParticleOwnerships(cell.getPossibleParticleOwnerships());
  }
 
  CellType getParticleCellTypeAsEnum() override { return CellType::SortedCellView; }
 
  void addParticle(const ParticleType &p) override {}
 
  CellIterator<typename ParticleCellType::StorageType, true> begin() {
    return CellIterator<typename ParticleCellType::StorageType, true>(_cell->begin());
  }
 
  CellIterator<typename ParticleCellType::StorageType, false> begin() const {
    return CellIterator<typename ParticleCellType::StorageType, false>(_cell->begin());
  }
 
  CellIterator<typename ParticleCellType::StorageType, true> end() {
    return CellIterator<typename ParticleCellType::StorageType, true>(_cell->end());
  }
 
  CellIterator<typename ParticleCellType::StorageType, false> end() const {
    return CellIterator<typename ParticleCellType::StorageType, false>(_cell->end());
  }
 
  size_t size() const override { return _particles.size(); }
 
  [[nodiscard]] size_t getNumberOfParticles(IteratorBehavior behavior) const override {
    return std::count_if(_particles.begin(), _particles.end(),
                         [&behavior](auto pair) { return behavior.contains(*(std::get<1>(pair))); });
  }
 
  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 &particlePosPair) { return particlePosPair.second->isDummy(); }),
                     _particles.end());
  }
 
  void deleteByIndex(size_t index) override {
    if (index >= size()) {
      AutoPasLog(ERROR, "Index out of range");
      utils::ExceptionHandler::exception("Error: Index out of range");
    }
 
    if (index < size() - 1) {
      std::swap(_particles[index], _particles[size() - 1]);
    }
    _particles.pop_back();
  }
 
  void setCellLength(std::array<double, 3> &cellLength) override { _cell->setCellLength(cellLength); }
 
  std::array<double, 3> getCellLength() const override { return _cell->getCellLength(); }
 
  ParticleType &at(size_t index) { return _particles.at(index); }
 
  const ParticleType &at(size_t index) const { return _particles.at(index); }
 
  std::vector<std::pair<double, ParticleType *>> _particles;
 
  ParticleCellType *_cell;
 
 private:
};
}  // namespace autopas