LCC08CellHandler.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/baseFunctors/CellFunctor.h"
#include "autopas/baseFunctors/CellFunctor3B.h"
#include "autopas/containers/linkedCells/traversals/LCC08CellHandlerUtility.h"
#include "autopas/utils/checkFunctorType.h"
 
namespace autopas {
 
template <class ParticleCell_T, class Functor_T>
class LCC08CellHandler {
 public:
  explicit LCC08CellHandler(Functor_T &functor, 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)
      : _overlap(overlap),
        _dataLayout(dataLayout),
        _useNewton3(useNewton3),
        _cellFunctor(functor, interactionLength /*should use cutoff here, if not used to build verlet-lists*/,
                     dataLayout, useNewton3),
        _interactionLength(interactionLength),
        _cellLength(cellLength) {
    if constexpr (utils::isPairwiseFunctor<Functor_T>()) {
      _cellOffsets =
          LCC08CellHandlerUtility::computePairwiseCellOffsetsC08<LCC08CellHandlerUtility::C08OffsetMode::sorting>(
              cellsPerDimension, cellLength, interactionLength);
    } else if constexpr (utils::isTriwiseFunctor<Functor_T>()) {
      _cellOffsets =
          LCC08CellHandlerUtility::computeTriwiseCellOffsetsC08<LCC08CellHandlerUtility::C08OffsetMode::sorting>(
              cellsPerDimension, cellLength, interactionLength);
    } else {
      utils::ExceptionHandler::exception("LCC08CellHandler::LCC08CellHandler(): Functor is not valid.");
    }
  }
 
  void processBaseCell(std::vector<ParticleCell_T> &cells, unsigned long baseIndex);
 
  inline void processBaseCellPairwise(std::vector<ParticleCell_T> &cells, unsigned long baseIndex);
 
  inline void processBaseCellTriwise(std::vector<ParticleCell_T> &cells, unsigned long baseIndex);
 
  void setSortingThreshold(size_t sortingThreshold) { _cellFunctor.setSortingThreshold(sortingThreshold); }
 
 protected:
  using CellOffsetType =
      std::conditional_t<decltype(utils::isPairwiseFunctor<Functor_T>())::value,
                         LCC08CellHandlerUtility::OffsetPairSorting, LCC08CellHandlerUtility::OffsetTripletSorting>;
 
  std::vector<CellOffsetType> _cellOffsets;
 
  const std::array<unsigned long, 3> _overlap;
 
  DataLayoutOption _dataLayout;
 
  bool _useNewton3;
 
 private:
  // CellFunctor type for either Pairwise or Triwise Functors.
  using CellFunctorType =
      std::conditional_t<decltype(utils::isPairwiseFunctor<Functor_T>())::value,
                         internal::CellFunctor<ParticleCell_T, Functor_T, /*bidirectional*/ true>,
                         internal::CellFunctor3B<ParticleCell_T, Functor_T, /*bidirectional*/ true>>;
 
  CellFunctorType _cellFunctor;
 
  const double _interactionLength;
 
  const std::array<double, 3> _cellLength;
};
 
template <class ParticleCell_T, class Functor_T>
inline void LCC08CellHandler<ParticleCell_T, Functor_T>::processBaseCell(std::vector<ParticleCell_T> &cells,
                                                                         unsigned long baseIndex) {
  if constexpr (utils::isPairwiseFunctor<Functor_T>()) {
    processBaseCellPairwise(cells, baseIndex);
  } else if constexpr (utils::isTriwiseFunctor<Functor_T>()) {
    processBaseCellTriwise(cells, baseIndex);
  } else {
    utils::ExceptionHandler::exception(
        "LCC08CellHandler::processBaseCell(): Given Functor type is not of type PairwiseFunctor or TriwiseFunctor.");
  }
}
 
template <class ParticleCell_T, class Functor_T>
inline void LCC08CellHandler<ParticleCell_T, Functor_T>::processBaseCellPairwise(std::vector<ParticleCell_T> &cells,
                                                                                 unsigned long baseIndex) {
  for (auto const &[offset1, offset2, r] : _cellOffsets) {
    const unsigned long cellIndex1 = baseIndex + offset1;
    const unsigned long cellIndex2 = baseIndex + offset2;
 
    ParticleCell_T &cell1 = cells[cellIndex1];
    ParticleCell_T &cell2 = cells[cellIndex2];
 
    if (cellIndex1 == cellIndex2) {
      this->_cellFunctor.processCell(cell1);
    } else {
      this->_cellFunctor.processCellPair(cell1, cell2, r);
    }
  }
}
 
template <class ParticleCell_T, class Functor_T>
inline void LCC08CellHandler<ParticleCell_T, Functor_T>::processBaseCellTriwise(std::vector<ParticleCell_T> &cells,
                                                                                unsigned long baseIndex) {
  for (auto const &[offset1, offset2, offset3, r] : _cellOffsets) {
    const unsigned long index1 = baseIndex + offset1;
    const unsigned long index2 = baseIndex + offset2;
    const unsigned long index3 = baseIndex + offset3;
 
    ParticleCell_T &cell1 = cells[index1];
    ParticleCell_T &cell2 = cells[index2];
    ParticleCell_T &cell3 = cells[index3];
 
    if (index1 == index2 and index1 == index3) {
      this->_cellFunctor.processCell(cell1);
    } else if (index1 == index2 and index1 != index3) {
      this->_cellFunctor.processCellPair(cell1, cell3, r);
    } else if (index1 != index2 and (index1 == index3 or index2 == index3)) {
      this->_cellFunctor.processCellPair(cell1, cell2, r);
    } else {
      this->_cellFunctor.processCellTriple(cell1, cell2, cell3, r);
    }
  }
}
 
}  // namespace autopas