VLCSlicedBalancedTraversal.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
 
#include "autopas/containers/cellTraversals/SlicedBalancedBasedTraversal.h"
#include "autopas/containers/verletListsCellBased/verletListsCells/traversals/VLCTraversalInterface.h"
#include "autopas/utils/ThreeDimensionalMapping.h"
 
namespace autopas {
 
template <class ParticleCell, class PairwiseFunctor, class NeighborList>
class VLCSlicedBalancedTraversal : public SlicedBalancedBasedTraversal<ParticleCell, PairwiseFunctor>,
                                   public VLCTraversalInterface<typename ParticleCell::ParticleType, NeighborList> {
 public:
  explicit VLCSlicedBalancedTraversal(const std::array<unsigned long, 3> &dims, PairwiseFunctor *pairwiseFunctor,
                                      double interactionLength, const std::array<double, 3> &cellLength,
                                      DataLayoutOption dataLayout, bool useNewton3, ContainerOption::Value typeOfList)
      : SlicedBalancedBasedTraversal<ParticleCell, PairwiseFunctor>(dims, pairwiseFunctor, interactionLength,
                                                                    cellLength, dataLayout, useNewton3, false),
        VLCTraversalInterface<typename ParticleCell::ParticleType, NeighborList>(typeOfList),
        _functor(pairwiseFunctor) {}
 
  void traverseParticles() override;
 
  [[nodiscard]] TraversalOption getTraversalType() const override {
    switch (this->_typeOfList) {
      case (ContainerOption::verletListsCells):
        return TraversalOption::vlc_sliced_balanced;
      case (ContainerOption::pairwiseVerletLists):
        return TraversalOption::vlp_sliced_balanced;
      default:
        autopas::utils::ExceptionHandler::exception("Traversal was created with an unsupported neighborlist type: {}",
                                                    this->_typeOfList.to_string());
    }
    // should never be reached.
    return TraversalOption();
  }
 
  [[nodiscard]] bool isApplicable() const override {
    return (this->_dataLayout == DataLayoutOption::aos or this->_dataLayout == DataLayoutOption::soa);
  }
 
  void setSortingThreshold(size_t sortingThreshold) override {}
 
 private:
  PairwiseFunctor *_functor;
};
 
template <class ParticleCell, class PairwiseFunctor, class NeighborList>
inline void VLCSlicedBalancedTraversal<ParticleCell, PairwiseFunctor, NeighborList>::traverseParticles() {
  if (this->_dataLayout == DataLayoutOption::soa) {
    this->loadSoA(_functor, *(this->_verletList));
  }
 
  this->slicedTraversal([&](unsigned long x, unsigned long y, unsigned long z) {
    auto baseIndex = utils::ThreeDimensionalMapping::threeToOneD(x, y, z, this->_cellsPerDimension);
    this->template processCellLists<PairwiseFunctor>(*(this->_verletList), baseIndex, _functor, this->_dataLayout,
                                                     this->_useNewton3);
  });
 
  if (this->_dataLayout == DataLayoutOption::soa) {
    this->extractSoA(_functor, *(this->_verletList));
  }
}
 
}  // namespace autopas