OctreeNodeWrapper.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
 
#include "autopas/containers/octree/OctreeNodeInterface.h"
#include "autopas/containers/octree/OctreeStaticNodeSelector.h"
#include "autopas/utils/ArrayMath.h"
#include "autopas/utils/WrapOpenMP.h"
 
namespace autopas {
template <typename Particle_T>
class OctreeNodeWrapper : public ParticleCell<Particle_T> {
 public:
  using ParticleCell = OctreeNodeWrapper<Particle_T>;
  using ParticleType = typename ParticleCell::ParticleType;
  using StorageType = std::vector<Particle_T *>;
 
  OctreeNodeWrapper(const std::array<double, 3> &boxMin, const std::array<double, 3> &boxMax,
                    int unsigned const treeSplitThreshold, double const interactionLength,
                    double const cellSizeFactor) {
    _pointer = std::make_unique<OctreeLeafNode<Particle_T>>(boxMin, boxMax, nullptr, treeSplitThreshold,
                                                            interactionLength, cellSizeFactor);
  }
 
  void collectAllParticles(StorageType &ps) {
    std::lock_guard<AutoPasLock> lock(_lock);
    _pointer->collectAllParticles(ps);
  }
 
  void appendAllLeaves(std::vector<OctreeLeafNode<Particle_T> *> &leaves) { _pointer->appendAllLeaves(leaves); }
 
  void addParticle(const Particle_T &p) override {
    std::lock_guard<AutoPasLock> lock(_lock);
 
    auto ret = _pointer->insert(p);
    if (ret) _pointer = std::move(ret);
 
    ++_enclosedParticleCount;
  }
 
  CellIterator<StorageType, true> begin() {
    std::lock_guard<AutoPasLock> lock(_lock);
    _ps.clear();
    _pointer->collectAllParticles(_ps);
    return CellIterator<StorageType, true>(_ps.begin());
  }
 
  CellIterator<StorageType, false> begin() const {
    std::lock_guard<AutoPasLock> lock(_lock);
    _ps.clear();
    _pointer->collectAllParticles(_ps);
    return CellIterator<StorageType, false>(_ps.cbegin());
  }
 
  CellIterator<StorageType, true> end() { return CellIterator<StorageType, true>(_ps.end()); }
  CellIterator<StorageType, false> end() const { return CellIterator<StorageType, false>(_ps.end()); }
 
  [[nodiscard]] size_t size() const override {
    std::lock_guard<AutoPasLock> lock(_lock);
    return _enclosedParticleCount;
  }
 
  [[nodiscard]] size_t getNumberOfParticles(IteratorBehavior behavior) const override {
    std::lock_guard<AutoPasLock> lock(_lock);
    return _pointer->getNumberOfParticles(behavior);
  }
 
  [[nodiscard]] bool isEmpty() const override {
    std::lock_guard<AutoPasLock> lock(_lock);
    return _enclosedParticleCount == 0;
  }
 
  void clear() override {
    std::lock_guard<AutoPasLock> lock(_lock);
    _pointer->clearChildren(_pointer);
    _enclosedParticleCount = 0;
  }
 
  void deleteDummyParticles() override {}
 
  CellType getParticleCellTypeAsEnum() override { return CellType::FullParticleCell; }
 
  bool deleteParticle(Particle_T &particle) {
    --_enclosedParticleCount;
 
    return _pointer->deleteParticle(particle);
  };
 
  void deleteByIndex(size_t index) override {
    throw std::runtime_error("[OctreeNodeWrapper::deleteByIndex()] Operation not supported");
  }
 
  void setCellLength(std::array<double, 3> &cellLength) override {
    throw std::runtime_error("[OctreeNodeWrapper::setCellLength()] Operation not supported");
  }
 
  [[nodiscard]] std::array<double, 3> getCellLength() const override {
    using namespace autopas::utils::ArrayMath::literals;
    return _pointer->getBoxMin() - _pointer->getBoxMax();
  }
 
  Particle_T &at(size_t index) {
    std::lock_guard<AutoPasLock> lock(_lock);
    return _ps.at(index);
  }
 
  const Particle_T &at(size_t index) const {
    std::lock_guard<AutoPasLock> lock(_lock);
    return _ps.at(index);
  }
 
  Particle_T &operator[](size_t index) {
    std::lock_guard<AutoPasLock> lock(_lock);
    return *_ps[index];
  }
 
  const Particle_T &operator[](size_t index) const {
    std::lock_guard<AutoPasLock> lock(_lock);
    return *_ps[index];
  }
 
  std::set<OctreeLeafNode<Particle_T> *> getLeavesInRange(const std::array<double, 3> &min,
                                                          const std::array<double, 3> &max) {
    return _pointer->getLeavesInRange(min, max);
  }
 
  OctreeNodeInterface<Particle_T> *getRaw() const { return _pointer.get(); }
 
  template <typename Lambda>
  void forEach(Lambda forEachLambda) {
    withStaticNodeType(_pointer, [&](auto nodePtr) { nodePtr->forEach(forEachLambda); });
  }
 
  template <typename Lambda, typename A>
  void reduce(Lambda reduceLambda, A &result) {
    withStaticNodeType(_pointer, [&](auto nodePtr) { nodePtr->reduce(reduceLambda, result); });
  }
 
  template <typename Lambda>
  void forEachInRegion(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
                       const std::array<double, 3> &higherCorner) {
    withStaticNodeType(_pointer, [&](auto nodePtr) {
      // The iterator behavior is set to ownedOrHalo to include all particles inside this subtree. The baseclass
      // (Octree) decides whether this instance of OctreeNodeWrapper should be included in the iteration or not.
      nodePtr->forEach(forEachLambda, lowerCorner, higherCorner, IteratorBehavior::ownedOrHalo);
    });
  }
 
  template <typename Lambda, typename A>
  void reduceInRegion(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
                      const std::array<double, 3> &higherCorner) {
    withStaticNodeType(_pointer, [&](auto nodePtr) {
      // The iterator behavior is set to ownedOrHalo to include all particles inside this subtree. The baseclass
      // (Octree) decides whether this instance of OctreeNodeWrapper should be included in the iteration or not.
      nodePtr->reduce(reduceLambda, result, lowerCorner, higherCorner, IteratorBehavior::ownedOrHalo);
    });
  }
 
 private:
  std::unique_ptr<OctreeNodeInterface<Particle_T>> _pointer;
 
  mutable StorageType _ps;
 
  mutable AutoPasLock _lock;
 
  long _enclosedParticleCount{0L};
};
}  // namespace autopas