LCC08CellHandler.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/baseFunctors/CellFunctor.h"
#include "autopas/containers/cellTraversals/CellTraversal.h"
#include "autopas/containers/linkedCells/traversals/LCC08CellHandlerUtility.h"
#include "autopas/utils/ThreeDimensionalMapping.h"
 
namespace autopas {
 
template <class ParticleCell, class PairwiseFunctor>
class LCC08CellHandler {
 public:
  explicit LCC08CellHandler(PairwiseFunctor *pairwiseFunctor, const std::array<unsigned long, 3> &cellsPerDimension,
                            double interactionLength, const std::array<double, 3> &cellLength,
                            const std::array<unsigned long, 3> &overlap, DataLayoutOption dataLayout, bool useNewton3)
      : _cellFunctor(pairwiseFunctor, interactionLength /*should use cutoff here, if not used to build verlet-lists*/,
                     dataLayout, useNewton3),
        _interactionLength(interactionLength),
        _cellLength(cellLength),
        _overlap(overlap),
        _dataLayout(dataLayout),
        _useNewton3(useNewton3),
        _cellPairOffsets{LCC08CellHandlerUtility::computePairwiseCellOffsetsC08<
            LCC08CellHandlerUtility::C08OffsetMode::c08CellPairsSorting>(cellsPerDimension, cellLength,
                                                                         interactionLength)} {}
 
  void processBaseCell(std::vector<ParticleCell> &cells, unsigned long baseIndex);
 
  void setSortingThreshold(size_t sortingThreshold) { _cellFunctor.setSortingThreshold(sortingThreshold); }
 
 protected:
  std::vector<LCC08CellHandlerUtility::OffsetPairSorting> _cellPairOffsets;
 
  const std::array<unsigned long, 3> _overlap;
 
  DataLayoutOption _dataLayout;
 
  bool _useNewton3;
 
 private:
  internal::CellFunctor<ParticleCell, PairwiseFunctor,
                        /*bidirectional*/ true>
      _cellFunctor;
 
  const double _interactionLength;
 
  const std::array<double, 3> _cellLength;
};
 
template <class ParticleCell, class PairwiseFunctor>
inline void LCC08CellHandler<ParticleCell, PairwiseFunctor>::processBaseCell(std::vector<ParticleCell> &cells,
                                                                             unsigned long baseIndex) {
  for (auto const &[offset1, offset2, r] : _cellPairOffsets) {
    const unsigned long cellIndex1 = baseIndex + offset1;
    const unsigned long cellIndex2 = baseIndex + offset2;
 
    ParticleCell &cell1 = cells[cellIndex1];
    ParticleCell &cell2 = cells[cellIndex2];
 
    if (cellIndex1 == cellIndex2) {
      this->_cellFunctor.processCell(cell1);
    } else {
      this->_cellFunctor.processCellPair(cell1, cell2, r);
    }
  }
}
 
}  // namespace autopas