OTC01Traversal.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/baseFunctors/CellFunctor.h"
#include "autopas/containers/cellTraversals/CellTraversal.h"
#include "autopas/containers/octree/OctreeInnerNode.h"
#include "autopas/containers/octree/OctreeLeafNode.h"
#include "autopas/containers/octree/OctreeNodeInterface.h"
#include "autopas/containers/octree/traversals/OTTraversalInterface.h"
#include "autopas/options/DataLayoutOption.h"
#include "autopas/utils/DataLayoutConverter.h"
#include "autopas/utils/logging/OctreeLogger.h"
 
namespace autopas {
 
template <class Particle_T, class PairwiseFunctor>
class OTC01Traversal : public CellTraversal<OctreeLeafNode<Particle_T>>,
                       public OTTraversalInterface<OctreeNodeWrapper<Particle_T>> {
 public:
  using ParticleCell = OctreeLeafNode<Particle_T>;
 
  explicit OTC01Traversal(PairwiseFunctor *pairwiseFunctor, double cutoff, double interactionLength,
                          DataLayoutOption dataLayout, bool useNewton3)
      : CellTraversal<ParticleCell>({2, 1, 1}),
        OTTraversalInterface<OctreeNodeWrapper<Particle_T>>(interactionLength, dataLayout, useNewton3),
        _cellFunctor(pairwiseFunctor, cutoff /*should use cutoff here, if not used to build verlet-lists*/, dataLayout,
                     useNewton3),
        _dataLayoutConverter(pairwiseFunctor, dataLayout) {}
 
  [[nodiscard]] TraversalOption getTraversalType() const override { return TraversalOption::ot_c01; }
 
  [[nodiscard]] bool isApplicable() const override { return not this->_useNewton3; }
 
  void initTraversal() override {
    // Preprocess all leaves
    this->loadBuffers(_dataLayoutConverter, this->getOwned(), this->_ownedLeaves);
    this->loadBuffers(_dataLayoutConverter, this->getHalo(), this->_haloLeaves);
  }
 
  void endTraversal() override {
    // Postprocess all leaves
    this->unloadBuffers(_dataLayoutConverter, this->_ownedLeaves);
    this->unloadBuffers(_dataLayoutConverter, this->_haloLeaves);
  }
 
  void traverseParticles() override {
    using namespace autopas::utils::ArrayMath::literals;
 
    auto *haloWrapper = this->getHalo();
 
    OctreeLogger<Particle_T>::octreeToJSON(this->getOwned()->getRaw(), this->getHalo()->getRaw(), this->_ownedLeaves,
                                           this->_haloLeaves);
 
    // Get neighboring cells for each leaf
    // #pragma omp parallel for
    for (int i = 0; i < this->_ownedLeaves.size(); ++i) {
      OctreeLeafNode<Particle_T> *leaf = this->_ownedLeaves[i];
 
      // Process cell itself
      _cellFunctor.processCell(*leaf);
 
      // Process connection to all neighbors in this octree
      auto uniqueNeighboringLeaves = leaf->getNeighborLeaves();
      for (OctreeLeafNode<Particle_T> *neighborLeaf : uniqueNeighboringLeaves) {
        _cellFunctor.processCellPair(*leaf, *neighborLeaf);
      }
 
      // Process particles in halo cell that are in range
      auto min = leaf->getBoxMin() - this->_interactionLength;
      auto max = leaf->getBoxMax() + this->_interactionLength;
      auto haloNeighbors = haloWrapper->getLeavesInRange(min, max);
 
      for (OctreeLeafNode<Particle_T> *neighborLeaf : haloNeighbors) {
        _cellFunctor.processCellPair(*leaf, *neighborLeaf);
      }
    }
  }
 
  void setSortingThreshold(size_t sortingThreshold) override { _cellFunctor.setSortingThreshold(sortingThreshold); }
 
 private:
  internal::CellFunctor<ParticleCell, PairwiseFunctor, /*bidirectional*/ false> _cellFunctor;
 
  utils::DataLayoutConverter<PairwiseFunctor> _dataLayoutConverter;
};
 
}  // namespace autopas