ContainerIterator.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <limits>
#include <tuple>
#include <type_traits>
#include <vector>
 
#include "autopas/containers/ParticleContainerInterface.h"
#include "autopas/options/IteratorBehavior.h"
#include "autopas/utils/ArrayMath.h"
#include "autopas/utils/WrapOpenMP.h"
#include "autopas/utils/inBox.h"
 
namespace autopas {
 
namespace internal {
template <class ParticleIterator>
void deleteParticle(ParticleIterator &iterator) {
  iterator.deleteCurrentParticle();
}
}  // namespace internal
 
namespace containerIteratorUtils {
template <bool regionIter, class Particle_T, class Arr>
[[nodiscard]] bool particleFulfillsIteratorRequirements(const Particle_T &p, IteratorBehavior behavior,
                                                        const Arr &regionMin, const Arr &regionMax) {
  // If this is a region iterator check box condition first, otherwise race conditions can occur
  // if multiple region iterator overlap and ownership state is touched.
  // (e.g. during collection of leaving particles)
  if constexpr (regionIter) {
    if (not utils::inBox(p.getR(), regionMin, regionMax)) {
      return false;
    }
  }
 
  // Check ownership
  // Dummy is not in sync with iterator behavior because it needs to be 0.
  // `a & b == b` idiom is to check a == b disregarding any bits beyond b. This is needed due to e.g. forceSequential.
  if (((behavior & IteratorBehavior::ownedOrHaloOrDummy) == IteratorBehavior::ownedOrHaloOrDummy) or
      (behavior & IteratorBehavior::dummy and p.isDummy())) {
    return true;
  } else {
    // relies on both enums having the same encoding. This should be guaranteed statically in IteratorBehaviorTest!
    return static_cast<unsigned int>(p.getOwnershipState()) & static_cast<unsigned int>(behavior);
  }
}
}  // namespace containerIteratorUtils
 
template <class Particle_T, bool modifiable, bool regionIter>
class ContainerIterator {
  template <class T>
  friend void internal::deleteParticle(T &);
 
 public:
  using ParticleType = std::conditional_t<modifiable, Particle_T, const Particle_T>;
  using ParticleVecType = std::conditional_t<modifiable, std::vector<std::vector<Particle_T> *>,
                                             std::vector<std::vector<Particle_T> const *>>;
  using ContainerType = std::conditional_t<modifiable, ParticleContainerInterface<Particle_T>,
                                           const ParticleContainerInterface<Particle_T>>;
 
  ContainerIterator() : _currentParticle(nullptr){};
 
  ContainerIterator(ContainerType &container, IteratorBehavior behavior, ParticleVecType *additionalVectorsToIterate,
                    const std::array<double, 3> &regionMin, const std::array<double, 3> &regionMax)
      : ContainerIterator(nullptr, container, behavior, additionalVectorsToIterate, regionMin, regionMax) {
    // sanity check
    static_assert(regionIter == true,
                  "Constructor for Region iterator called but template argument regionIter is false");
  }
 
  ContainerIterator(ContainerType &container, IteratorBehavior behavior, ParticleVecType *additionalVectorsToIterate)
      : ContainerIterator(nullptr, container, behavior, additionalVectorsToIterate, {}, {}) {
    static_assert(regionIter == false,
                  "Constructor for non-Region iterator called but template argument regionIter is true");
  }
 
  ContainerIterator(const ContainerIterator<Particle_T, modifiable, regionIter> &other)
      : _container(other._container),
        _currentParticleIndex(other._currentParticleIndex),
        _currentVectorIndex(other._currentVectorIndex),
        _currentParticle(other._currentParticle),
        _additionalVectors(other._additionalVectors),
        _behavior(other._behavior),
        _iteratingAdditionalVectors(other._iteratingAdditionalVectors),
        _vectorIndexOffset(other._vectorIndexOffset),
        _regionMin(other._regionMin),
        _regionMax(other._regionMax) {}
 
  ContainerIterator<Particle_T, modifiable, regionIter> &operator=(
      const ContainerIterator<Particle_T, modifiable, regionIter> &other) {
    if (this != other) {
      _container = other._container;
      _currentParticleIndex = other._currentParticleIndex;
      _currentVectorIndex = other._currentVectorIndex;
      _currentParticle = other._currentParticle;
      _additionalVectors = other._additionalVectors;
      _behavior = other._behavior;
      _iteratingAdditionalVectors = other._iteratingAdditionalVectors;
      _vectorIndexOffset = other._vectorIndexOffset;
      if constexpr (regionIter) {
        _regionMin = other._regionMin;
        _regionMax = other._regionMax;
      }
    }
    return *this;
  }
 
  ContainerIterator(ContainerIterator<Particle_T, modifiable, regionIter> &&other) noexcept
      : _container(other._container),
        _currentParticleIndex(other._currentParticleIndex),
        _currentVectorIndex(other._currentVectorIndex),
        _currentParticle(other._currentParticle),
        _additionalVectors(std::move(other._additionalVectors)),
        _behavior(other._behavior),
        _iteratingAdditionalVectors(other._iteratingAdditionalVectors),
        _vectorIndexOffset(other._vectorIndexOffset),
        _regionMin(std::move(other._regionMin)),
        _regionMax(std::move(other._regionMax)) {}
 
  ContainerIterator<Particle_T, modifiable, regionIter> &operator=(
      ContainerIterator<Particle_T, modifiable, regionIter> &&other) noexcept {
    if (this != &other) {
      _container = other._container;
      _currentParticleIndex = other._currentParticleIndex;
      _currentVectorIndex = other._currentVectorIndex;
      _currentParticle = other._currentParticle;
      _additionalVectors = std::move(other._additionalVectors);
      _behavior = other._behavior;
      _iteratingAdditionalVectors = other._iteratingAdditionalVectors;
      _vectorIndexOffset = other._vectorIndexOffset;
      if constexpr (regionIter) {
        _regionMin = std::move(other._regionMin);
        _regionMax = std::move(other._regionMax);
      }
    }
    return *this;
  }
 
 private:
  ContainerIterator(void * /*dummy*/, ContainerType &container, IteratorBehavior behavior,
                    ParticleVecType *additionalVectorsToIterate, const std::array<double, 3> &regionMin,
                    const std::array<double, 3> &regionMax)
      : _container(&container),
        _behavior(behavior),
        _vectorIndexOffset((behavior & IteratorBehavior::forceSequential) ? 1 : autopas_get_num_threads()) {
    if (additionalVectorsToIterate) {
      // store pointers to all additional vectors
      _additionalVectors.insert(_additionalVectors.end(), additionalVectorsToIterate->begin(),
                                additionalVectorsToIterate->end());
    }
 
    if constexpr (regionIter) {
      // clamp region to the container, either with or without halo
      const auto boxMaxWithHalo = utils::ArrayMath::addScalar(container.getBoxMax(), container.getInteractionLength());
      const auto boxMinWithHalo = utils::ArrayMath::subScalar(container.getBoxMin(), container.getInteractionLength());
      _regionMax = utils::ArrayMath::min(regionMax, boxMaxWithHalo);
      _regionMin = utils::ArrayMath::max(regionMin, boxMinWithHalo);
    }
    // fetches the next (=first) valid particle or sets _currentParticle = nullptr which marks the iterator as invalid.
    fetchParticleAtCurrentIndex();
  }
 
 public:
  inline ContainerIterator<Particle_T, modifiable, regionIter> &operator++() {
    // bump the index. If it is invalid now, the container will give us the proper one.
    ++_currentParticleIndex;
    fetchParticleAtCurrentIndex();
    return *this;
  }
 
  inline ParticleType &operator*() const { return *_currentParticle; }
 
  inline ParticleType *operator->() const { return _currentParticle; }
 
  [[nodiscard]] bool isValid() const { return _currentParticle != nullptr; }
 
  bool operator==(const bool input) const { return isValid() == input; }
 
  bool operator!=(const bool input) const { return not(*this == input); }
 
 private:
  void fetchParticleAtCurrentIndex() {
    if (not _iteratingAdditionalVectors) {
      // getParticle either gives us a particle with the desired properties or a nullptr
      if constexpr (regionIter) {
        std::tie(_currentParticle, _currentVectorIndex, _currentParticleIndex) =
            _container->getParticle(_currentVectorIndex, _currentParticleIndex, _behavior, _regionMin, _regionMax);
      } else {
        std::tie(_currentParticle, _currentVectorIndex, _currentParticleIndex) =
            _container->getParticle(_currentVectorIndex, _currentParticleIndex, _behavior);
      }
      // if getParticle told us that the container doesn't have a particle in the first vector for our thread...
      if (_currentParticle == nullptr and not _additionalVectors.empty()) {
        // determine which additional vector this thread should start to iterate
        _currentVectorIndex = (_behavior & IteratorBehavior::forceSequential) ? 0 : autopas_get_thread_num();
        _currentParticleIndex = 0;
        _iteratingAdditionalVectors = true;
      } else {
        // Case: nothing left in the container and no additional vectors to iterate
        return;
      }
    }
    // no "else" here because the first case might trigger the second if we reached the end of the container
    if (_iteratingAdditionalVectors) {
      // check all vectors ...
      for (; _currentVectorIndex < _additionalVectors.size(); _currentVectorIndex += _vectorIndexOffset) {
        // ... and all particles within the vector ...
        for (; _currentParticleIndex < _additionalVectors[_currentVectorIndex]->size(); ++_currentParticleIndex) {
          _currentParticle = &(_additionalVectors[_currentVectorIndex]->operator[](_currentParticleIndex));
          // ... until we find a particle that satisfies our requirements.
          if (containerIteratorUtils::particleFulfillsIteratorRequirements<regionIter>(*_currentParticle, _behavior,
                                                                                       _regionMin, _regionMax)) {
            return;
          }
        }
        _currentParticleIndex = 0;
      }
    }
    // if we reach this point there is no satisfying particle left neither in the container nor the additional vectors.
    _currentParticle = nullptr;
    _currentParticleIndex = std::numeric_limits<decltype(_currentParticleIndex)>::max();
    _currentVectorIndex = std::numeric_limits<decltype(_currentVectorIndex)>::max();
  }
 
  void deleteCurrentParticle() {
    if (_iteratingAdditionalVectors) {
      // the current particle address needs to be between start and end of the current vector
      // otherwise it is from the previous vector
      auto &currentVector = *_additionalVectors[_currentVectorIndex];
      // swap-delete
      *_currentParticle = currentVector.back();
      currentVector.pop_back();
      // make sure _currentParticle always points to a valid particle if there is one.
      if (currentVector.empty() or not containerIteratorUtils::particleFulfillsIteratorRequirements<regionIter>(
                                       *_currentParticle, _behavior, _regionMin, _regionMax)) {
        this->operator++();
      }
    } else {
      const auto indicesValid = _container->deleteParticle(_currentVectorIndex, _currentParticleIndex);
      // Edge cases:
      if (not indicesValid) {
        // CASE: the indices and thus the pointer are invalid now
        this->operator++();
      } else if (not containerIteratorUtils::particleFulfillsIteratorRequirements<regionIter>(
                     *_currentParticle, _behavior, _regionMin, _regionMax)) {
        // CASE: the particle was swapped and now the pointer points at something uninteresting
        this->operator++();
      }
    }
    // move the current index back so that the next ++ points again to the same particle.
    --_currentParticleIndex;
  }
 
  ContainerType *_container;
 
  size_t _currentParticleIndex{0};
 
  size_t _currentVectorIndex{};
 
  ParticleType *_currentParticle = nullptr;
 
  ParticleVecType _additionalVectors;
 
  IteratorBehavior _behavior;
 
  bool _iteratingAdditionalVectors{false};
 
  size_t _vectorIndexOffset{};
 
  struct empty {};
  using RegionCornerT = std::conditional_t<regionIter, std::array<double, 3>, empty>;
  [[no_unique_address]] RegionCornerT _regionMin{};
  [[no_unique_address]] RegionCornerT _regionMax{};
};
}  // namespace autopas