PairwiseFunctor.h

Go to the documentation of this file.

 
#pragma once
 
#include <type_traits>
#include <vector>
 
#include "Functor.h"
#include "autopas/options/DataLayoutOption.h"
#include "autopas/utils/AlignedAllocator.h"
#include "autopas/utils/SoAView.h"
 
namespace autopas {
 
template <class Particle>
class VerletListHelpers;
 
struct SoASortingData {
  size_t startI;                        
  const std::vector<size_t> &maxIndex;  
  const std::vector<size_t> &minIndex;  
};
 
template <class Particle_T, class CRTP_T>
class PairwiseFunctor : public Functor<Particle_T, CRTP_T> {
 public:
  using SoAArraysType = typename Particle_T::SoAArraysType;
 
  explicit PairwiseFunctor(double cutoff) : Functor<Particle_T, CRTP_T>(cutoff){};
 
  virtual ~PairwiseFunctor() = default;
 
  virtual void AoSFunctor(Particle_T &i, Particle_T &j, bool newton3) {
    utils::ExceptionHandler::exception("{}::AoSFunctor: not implemented", this->getName());
  }
 
  virtual void SoAFunctorSingle(SoAView<SoAArraysType> soa, bool newton3) {
    utils::ExceptionHandler::exception("{}::SoAFunctorSingle: not implemented", this->getName());
  }
 
  virtual void SoAFunctorVerlet(SoAView<SoAArraysType> soa, const size_t indexFirst,
                                const std::vector<size_t, AlignedAllocator<size_t>> &neighborList, bool newton3) {
    utils::ExceptionHandler::exception("{}::SoAFunctorVerlet: not implemented", this->getName());
  }
 
  virtual void SoAFunctorPair(SoAView<SoAArraysType> soa1, SoAView<SoAArraysType> soa2, bool newton3) {
    utils::ExceptionHandler::exception("{}::SoAFunctorPair: not implemented", this->getName());
  }
 
  virtual void SoAFunctorPairSorted(SoAView<SoAArraysType> soa1, SoAView<SoAArraysType> soa2,
                                    const SoASortingData &sortingData, bool newton3) {
    if constexpr (not CRTP_T::supportsSoASorting) {
      autopas::utils::ExceptionHandler::exception(
          "SoAFunctorPairSorted() called on functor {} which has supportsSoASorting=false.", typeid(CRTP_T).name());
    } else {
      autopas::utils::ExceptionHandler::exception(
          "Functor {} has supportsSoASorting=true but does not implement SoAFunctorPairSorted().",
          typeid(CRTP_T).name());
    }
  }
 
  bool isVecPatternAllowed(const VectorizationPatternOption::Value vecPattern) override {
    return vecPattern == VectorizationPatternOption::p1xVec;
  }
};
 
}  // namespace autopas