VCLC06Traversal.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/containers/cellTraversals/ColorBasedTraversal.h"
#include "autopas/containers/verletClusterLists/VerletClusterLists.h"
#include "autopas/containers/verletClusterLists/traversals/VCLClusterFunctor.h"
#include "autopas/containers/verletClusterLists/traversals/VCLTraversalInterface.h"
 
namespace autopas {
 
template <class ParticleCell, class PairwiseFunctor>
class VCLC06Traversal : public ColorBasedTraversal<ParticleCell, PairwiseFunctor>,
                        public VCLTraversalInterface<typename ParticleCell::ParticleType> {
 private:
  using ParticleType = typename ParticleCell::ParticleType;
 
  static constexpr std::array<unsigned long, 3> _stride{3ul, 2ul, 1ul};
 
  void processColorCell(unsigned long xColorCell, unsigned long yColorCell, unsigned long zColorCell,
                        int towersPerColoringCell);
 
 public:
  explicit VCLC06Traversal(PairwiseFunctor *pairwiseFunctor, size_t clusterSize, DataLayoutOption dataLayout,
                           bool useNewton3)
      : ColorBasedTraversal<ParticleCell, PairwiseFunctor>({0, 0, 0}, pairwiseFunctor, 0, {}, dataLayout, useNewton3),
        _functor(pairwiseFunctor),
        _clusterFunctor(pairwiseFunctor, clusterSize, dataLayout, useNewton3) {}
 
  [[nodiscard]] TraversalOption getTraversalType() const override { return TraversalOption::vcl_c06; }
 
  [[nodiscard]] bool isApplicable() const override {
    return (this->_dataLayout == DataLayoutOption::aos || this->_dataLayout == DataLayoutOption::soa);
  }
 
  void initTraversal() override {
    if (this->_dataLayout == DataLayoutOption::soa) {
      VCLTraversalInterface<ParticleType>::_verletClusterLists->loadParticlesIntoSoAs(_functor);
    }
  }
 
  void endTraversal() override {
    if (this->_dataLayout == DataLayoutOption::soa) {
      VCLTraversalInterface<ParticleType>::_verletClusterLists->extractParticlesFromSoAs(_functor);
    }
  }
 
  void traverseParticles() override {
    auto &clusterList = *VCLTraversalInterface<ParticleType>::_verletClusterLists;
 
    const auto towersPerColoringCell = clusterList.getNumTowersPerInteractionLength();
    std::array<unsigned long, 2> coloringCellsPerDim{};
    for (int i = 0; i < 2; i++) {
      coloringCellsPerDim[i] =
          static_cast<unsigned long>(std::ceil(clusterList.getTowersPerDimension()[i] / (double)towersPerColoringCell));
    }
 
    auto loopBody = [this, towersPerColoringCell](unsigned long x, unsigned long y, unsigned long z) {
      processColorCell(x, y, z, towersPerColoringCell);
    };
 
    // localStride is necessary because stride is constexpr and colorTraversal() wants a const &
    auto localStride = _stride;
    this->colorTraversal(std::forward<decltype(loopBody)>(loopBody),
                         {coloringCellsPerDim[0], coloringCellsPerDim[1], 1}, localStride);
  }
 
  void setSortingThreshold(size_t sortingThreshold) override {}
 
 private:
  PairwiseFunctor *_functor;
  internal::VCLClusterFunctor<ParticleType, PairwiseFunctor> _clusterFunctor;
};
 
template <class ParticleCell, class PairwiseFunctor>
void VCLC06Traversal<ParticleCell, PairwiseFunctor>::processColorCell(unsigned long xColorCell,
                                                                      unsigned long yColorCell,
                                                                      unsigned long zColorCell,
                                                                      int towersPerColoringCell) {
  // We are only doing a 2D coloring.
  if (zColorCell != 0) {
    autopas::utils::ExceptionHandler::exception("Coloring should only be 2D, not in z-direction!");
  }
 
  auto &clusterList = *VCLTraversalInterface<ParticleType>::_verletClusterLists;
  const auto towersPerDim = clusterList.getTowersPerDimension();
 
  for (int yInner = 0; yInner < towersPerColoringCell; yInner++) {
    for (int xInner = 0; xInner < towersPerColoringCell; xInner++) {
      const auto y = yColorCell * towersPerColoringCell + yInner;
      const auto x = xColorCell * towersPerColoringCell + xInner;
 
      // Not every coloring cell has to have gridsPerColoringCell grids in every direction.
      if (x >= towersPerDim[0] or y >= towersPerDim[1]) {
        continue;
      }
 
      auto &currentTower = clusterList.getTowerByIndex(x, y);
      for (auto clusterIter = this->_useNewton3 ? currentTower.getClusters().begin()
                                                : currentTower.getFirstOwnedCluster();
           clusterIter <
           (this->_useNewton3 ? currentTower.getClusters().end() : currentTower.getFirstTailHaloCluster());
           ++clusterIter) {
        const auto isHaloCluster =
            clusterIter < currentTower.getFirstOwnedCluster() or clusterIter >= currentTower.getFirstTailHaloCluster();
        _clusterFunctor.processCluster(*clusterIter, isHaloCluster);
      }
    }
  }
}
 
}  // namespace autopas