ParticleContainerInterface.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <vector>
 
#include "autopas/cells/ParticleCell.h"
#include "autopas/containers/CompatibleTraversals.h"
#include "autopas/containers/TraversalInterface.h"
#include "autopas/options/ContainerOption.h"
#include "autopas/options/IteratorBehavior.h"
#include "autopas/options/TraversalOption.h"
#include "autopas/tuning/selectors/TraversalSelectorInfo.h"
#include "autopas/utils/AutoPasMacros.h"
#include "autopas/utils/inBox.h"
#include "autopas/utils/optRef.h"
 
namespace autopas {
 
// forward declaration
template <class Particle_T, bool modifiable, bool regionIter>
class ContainerIterator;
 
template <class Particle_T>
class ParticleContainerInterface {
 public:
  using ParticleType = Particle_T;
 
  ParticleContainerInterface(double skin) : _skin(skin) {}
 
  virtual ~ParticleContainerInterface() = default;
 
  ParticleContainerInterface(const ParticleContainerInterface &obj) = delete;
 
  ParticleContainerInterface &operator=(const ParticleContainerInterface &other) = delete;
 
  [[nodiscard]] virtual ContainerOption getContainerType() const = 0;
 
  virtual void reserve(size_t numParticles, size_t numParticlesHaloEstimate) = 0;
 
  template <bool checkInBox = true>
  void addParticle(const Particle_T &p) {
    if constexpr (checkInBox) {
      if (utils::notInBox(p.getR(), this->getBoxMin(), this->getBoxMax())) {
        utils::ExceptionHandler::exception(
            "ParticleContainerInterface: Trying to add a particle that is not in the bounding box.\n"
            "Box Min {}\n"
            "Box Max {}\n"
            "{}",
            this->getBoxMin(), this->getBoxMax(), p.toString());
      }
    }
    addParticleImpl(p);
  };
 
 protected:
  virtual void addParticleImpl(const Particle_T &p) = 0;
 
 public:
  template <bool checkInBox = true>
  void addHaloParticle(const Particle_T &haloParticle) {
    if constexpr (checkInBox) {
      if (utils::inBox(haloParticle.getR(), this->getBoxMin(), this->getBoxMax())) {
        utils::ExceptionHandler::exception(
            "ParticleContainerInterface: Trying to add a halo particle that is not outside of in the bounding box.\n"
            "Box Min {}\n"
            "Box Max {}\n"
            "{}",
            this->getBoxMin(), this->getBoxMax(), haloParticle.toString());
      }
    }
    addHaloParticleImpl(haloParticle);
  }
 
 protected:
  virtual void addHaloParticleImpl(const Particle_T &haloParticle) = 0;
 
 public:
  virtual bool updateHaloParticle(const Particle_T &haloParticle) = 0;
 
  virtual void rebuildNeighborLists(TraversalInterface *traversal) = 0;
 
  virtual void deleteHaloParticles() = 0;
 
  virtual void deleteAllParticles() = 0;
 
  [[nodiscard]] virtual size_t getNumberOfParticles(IteratorBehavior behavior = IteratorBehavior::owned) const = 0;
 
  [[nodiscard]] virtual size_t size() const = 0;
 
  [[nodiscard]] virtual ContainerIterator<Particle_T, true, false> begin(
      IteratorBehavior behavior = IteratorBehavior::ownedOrHalo,
      utils::optRef<typename ContainerIterator<Particle_T, true, false>::ParticleVecType> additionalVectors =
          std::nullopt) = 0;
 
  [[nodiscard]] virtual ContainerIterator<Particle_T, false, false> begin(
      IteratorBehavior behavior = IteratorBehavior::ownedOrHalo,
      utils::optRef<typename ContainerIterator<Particle_T, false, false>::ParticleVecType> additionalVectors =
          std::nullopt) const = 0;
 
  [[nodiscard]] ContainerIterator<Particle_T, false, false> cbegin(
      IteratorBehavior behavior = IteratorBehavior::ownedOrHalo,
      utils::optRef<typename ContainerIterator<Particle_T, false, false>::ParticleVecType> additionalVectors =
          std::nullopt) const {
    return begin(behavior, additionalVectors);
  }
 
  [[nodiscard]] virtual ContainerIterator<Particle_T, true, true> getRegionIterator(
      const std::array<double, 3> &lowerCorner, const std::array<double, 3> &higherCorner, IteratorBehavior behavior,
      utils::optRef<typename ContainerIterator<Particle_T, true, true>::ParticleVecType> additionalVectors =
          std::nullopt) = 0;
 
  [[nodiscard]] virtual ContainerIterator<Particle_T, false, true> getRegionIterator(
      const std::array<double, 3> &lowerCorner, const std::array<double, 3> &higherCorner, IteratorBehavior behavior,
      utils::optRef<typename ContainerIterator<Particle_T, false, true>::ParticleVecType> additionalVectors =
          std::nullopt) const = 0;
 
  [[nodiscard]] constexpr bool end() const { return false; }
 
  virtual void computeInteractions(TraversalInterface *traversal) = 0;
 
  [[nodiscard]] virtual const std::array<double, 3> &getBoxMax() const = 0;
 
  [[nodiscard]] virtual const std::array<double, 3> &getBoxMin() const = 0;
 
  [[nodiscard]] virtual double getCutoff() const = 0;
 
  virtual void setCutoff(double cutoff) = 0;
 
  [[nodiscard]] virtual double getVerletSkin() const = 0;
 
  [[nodiscard]] virtual size_t getStepsSinceLastRebuild() const { return _stepsSinceLastRebuild; }
 
  virtual void setStepsSinceLastRebuild(size_t stepsSinceLastRebuild) {
    _stepsSinceLastRebuild = stepsSinceLastRebuild;
  }
 
  [[nodiscard]] virtual double getInteractionLength() const = 0;
 
  [[nodiscard]] virtual std::vector<Particle_T> updateContainer(bool keepNeighborListsValid) = 0;
 
  [[nodiscard]] virtual TraversalSelectorInfo getTraversalSelectorInfo() const = 0;
 
  [[nodiscard]] std::set<TraversalOption> getAllTraversals(const InteractionTypeOption interactionType) const {
    return compatibleTraversals::allCompatibleTraversals(this->getContainerType(), interactionType);
  }
 
  virtual std::tuple<const Particle_T *, size_t, size_t> getParticle(size_t cellIndex, size_t particleIndex,
                                                                     IteratorBehavior iteratorBehavior) const = 0;
 
  virtual std::tuple<const Particle_T *, size_t, size_t> getParticle(size_t cellIndex, size_t particleIndex,
                                                                     IteratorBehavior iteratorBehavior,
                                                                     const std::array<double, 3> &boxMin,
                                                                     const std::array<double, 3> &boxMax) const = 0;
 
  // clang-format off
  // clang-format on
  std::tuple<Particle_T *, size_t, size_t> getParticle(size_t cellIndex, size_t particleIndex,
                                                       IteratorBehavior iteratorBehavior,
                                                       const std::array<double, 3> &boxMin,
                                                       const std::array<double, 3> &boxMax) {
    const Particle_T *ptr{};
    size_t nextCellIndex{}, nextParticleIndex{};
    std::tie(ptr, nextCellIndex, nextParticleIndex) =
        const_cast<const ParticleContainerInterface<Particle_T> *>(this)->getParticle(cellIndex, particleIndex,
                                                                                      iteratorBehavior, boxMin, boxMax);
    return {const_cast<Particle_T *>(ptr), nextCellIndex, nextParticleIndex};
  }
 
  std::tuple<Particle_T *, size_t, size_t> getParticle(size_t cellIndex, size_t particleIndex,
                                                       IteratorBehavior iteratorBehavior) {
    const Particle_T *ptr{};
    size_t nextCellIndex{}, nextParticleIndex{};
    std::tie(ptr, nextCellIndex, nextParticleIndex) =
        const_cast<const ParticleContainerInterface<Particle_T> *>(this)->getParticle(cellIndex, particleIndex,
                                                                                      iteratorBehavior);
    return {const_cast<Particle_T *>(ptr), nextCellIndex, nextParticleIndex};
  }
 
  virtual bool deleteParticle(Particle_T &particle) = 0;
 
  virtual bool deleteParticle(size_t cellIndex, size_t particleIndex) = 0;
 
 protected:
  size_t _stepsSinceLastRebuild{0};
 
  double _skin;
};
 
}  // namespace autopas