AutoPasDecl.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <set>
 
#include "autopas/LogicHandlerInfo.h"
#include "autopas/containers/ParticleContainerInterface.h"
#include "autopas/options//ExtrapolationMethodOption.h"
#include "autopas/options/AcquisitionFunctionOption.h"
#include "autopas/options/ContainerOption.h"
#include "autopas/options/DataLayoutOption.h"
#include "autopas/options/EnergySensorOption.h"
#include "autopas/options/IteratorBehavior.h"
#include "autopas/options/LoadEstimatorOption.h"
#include "autopas/options/Newton3Option.h"
#include "autopas/options/SelectorStrategyOption.h"
#include "autopas/options/TraversalOption.h"
#include "autopas/options/TuningMetricOption.h"
#include "autopas/options/TuningStrategyOption.h"
#include "autopas/options/VectorizationPatternOption.h"
#include "autopas/tuning/AutoTuner.h"
#include "autopas/tuning/Configuration.h"
#include "autopas/tuning/TuningManager.h"
#include "autopas/tuning/tuningStrategy/TuningStrategyFactoryInfo.h"
#include "autopas/utils/NumberSet.h"
#include "autopas/utils/StaticContainerSelector.h"
#include "autopas/utils/WrapMPI.h"
 
namespace autopas {
 
// Forward declare Handler so that including this header does not include the whole library with all
// containers and traversals.
template <class Particle_T>
class LogicHandler;
 
template <class Particle_T>
class AutoPas {
 public:
  using ParticleType = Particle_T;
 
  using IteratorT = autopas::ContainerIterator<Particle_T, true, false>;
 
  using ConstIteratorT = autopas::ContainerIterator<Particle_T, false, false>;
 
  using RegionIteratorT = autopas::ContainerIterator<Particle_T, true, true>;
 
  using RegionConstIteratorT = autopas::ContainerIterator<Particle_T, false, true>;
 
  explicit AutoPas(std::ostream &logOutputStream = std::cout);
 
  explicit AutoPas(const std::string &logFileName);
 
  ~AutoPas();
 
  AutoPas &operator=(AutoPas &&other) noexcept;
 
  void init();
 
  std::vector<Particle_T> resizeBox(const std::array<double, 3> &boxMin, const std::array<double, 3> &boxMax);
 
  void forceRetune();
 
  void finalize() {
    if (not _externalMPICommunicator) {
      AutoPas_MPI_Comm_free(&_tuningStrategyFactoryInfo.autopasMpiCommunicator);
    }
  }
 
  [[nodiscard]] std::vector<Particle_T> updateContainer();
 
  void reserve(size_t numParticles);
 
  void reserve(size_t numParticles, size_t numHaloParticles);
 
  void addParticle(const Particle_T &p);
 
  template <class Collection>
  void addParticles(Collection &&particles);
 
  template <class Collection, class F>
  void addParticlesIf(Collection &&particles, F predicate);
 
  void addHaloParticle(const Particle_T &haloParticle);
 
  template <class Collection>
  void addHaloParticles(Collection &&particles);
 
  template <class Collection, class F>
  void addHaloParticlesIf(Collection &&particles, F predicate);
 
  void deleteAllParticles();
 
  void deleteParticle(IteratorT &iter);
 
  void deleteParticle(RegionIteratorT &iter);
 
  bool deleteParticle(Particle_T &particle);
 
  template <class Functor>
  bool computeInteractions(Functor *f);
 
  IteratorT begin(IteratorBehavior behavior = IteratorBehavior::ownedOrHalo);
 
  ConstIteratorT begin(IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const;
 
  template <typename Lambda>
  void forEachParallel(Lambda forEachLambda, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    // TODO lgaertner: parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) { container.forEach(forEachLambda, behavior); });
  }
 
  template <typename Lambda>
  void forEachParallel(Lambda forEachLambda, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    // TODO lgaertner: parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) { container.forEach(forEachLambda, behavior); });
  }
 
  template <typename Lambda>
  void forEach(Lambda forEachLambda, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    withStaticContainerType(getContainer(), [&](auto &container) { container.forEach(forEachLambda, behavior); });
  }
 
  template <typename Lambda>
  void forEach(Lambda forEachLambda, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    withStaticContainerType(getContainer(), [&](auto &container) { container.forEach(forEachLambda, behavior); });
  }
 
  template <typename Lambda, typename A>
  void reduceParallel(Lambda reduceLambda, A &result, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    // TODO lgaertner: parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) { container.reduce(reduceLambda, result, behavior); });
  }
 
  template <typename Lambda, typename A>
  void reduceParallel(Lambda reduceLambda, A &result, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    // TODO lgaertner: parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) { container.reduce(reduceLambda, result, behavior); });
  }
 
  template <typename Lambda, typename A>
  void reduce(Lambda reduceLambda, A &result, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    withStaticContainerType(getContainer(), [&](auto &container) { container.reduce(reduceLambda, result, behavior); });
  }
 
  template <typename Lambda, typename A>
  void reduce(Lambda reduceLambda, A &result, IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    withStaticContainerType(getContainer(), [&](auto &container) { container.reduce(reduceLambda, result, behavior); });
  }
 
  ConstIteratorT cbegin(IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const { return begin(behavior); }
 
  [[nodiscard]] constexpr bool end() const { return false; }
 
  RegionIteratorT getRegionIterator(const std::array<double, 3> &lowerCorner, const std::array<double, 3> &higherCorner,
                                    IteratorBehavior behavior = IteratorBehavior::ownedOrHalo);
  RegionConstIteratorT getRegionIterator(const std::array<double, 3> &lowerCorner,
                                         const std::array<double, 3> &higherCorner,
                                         IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const;
 
  template <typename Lambda>
  void forEachInRegionParallel(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
                               const std::array<double, 3> &higherCorner,
                               IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    // TODO (lgaertner): parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.forEachInRegion(forEachLambda, lowerCorner, higherCorner, behavior);
    });
  }
 
  template <typename Lambda>
  void forEachInRegionParallel(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
                               const std::array<double, 3> &higherCorner,
                               IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    // TODO (lgaertner): parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.forEachInRegion(forEachLambda, lowerCorner, higherCorner, behavior);
    });
  }
 
  template <typename Lambda>
  void forEachInRegion(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
                       const std::array<double, 3> &higherCorner,
                       IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.forEachInRegion(forEachLambda, lowerCorner, higherCorner, behavior);
    });
  }
 
  template <typename Lambda>
  void forEachInRegion(Lambda forEachLambda, const std::array<double, 3> &lowerCorner,
                       const std::array<double, 3> &higherCorner,
                       IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.forEachInRegion(forEachLambda, lowerCorner, higherCorner, behavior);
    });
  }
 
  template <typename Lambda, typename A>
  void reduceInRegionParallel(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
                              const std::array<double, 3> &higherCorner,
                              IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    // TODO lgaertner: parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.reduceInRegion(reduceLambda, result, lowerCorner, higherCorner, behavior);
    });
  }
 
  template <typename Lambda, typename A>
  void reduceInRegionParallel(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
                              const std::array<double, 3> &higherCorner,
                              IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    // TODO lgaertner: parallelize with kokkos integration
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.reduceInRegion(reduceLambda, result, lowerCorner, higherCorner, behavior);
    });
  }
 
  template <typename Lambda, typename A>
  void reduceInRegion(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
                      const std::array<double, 3> &higherCorner,
                      IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) {
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.reduceInRegion(reduceLambda, result, lowerCorner, higherCorner, behavior);
    });
  }
 
  template <typename Lambda, typename A>
  void reduceInRegion(Lambda reduceLambda, A &result, const std::array<double, 3> &lowerCorner,
                      const std::array<double, 3> &higherCorner,
                      IteratorBehavior behavior = IteratorBehavior::ownedOrHalo) const {
    withStaticContainerType(getContainer(), [&](auto &container) {
      container.reduceInRegion(reduceLambda, result, lowerCorner, higherCorner, behavior);
    });
  }
 
  double getVerletSkin() { return _logicHandlerInfo.verletSkin; };
 
  [[nodiscard]] size_t getNumberOfParticles(IteratorBehavior behavior = IteratorBehavior::owned) const;
 
  [[nodiscard]] unsigned long getContainerType() const;
 
  [[nodiscard]] const std::array<double, 3> &getBoxMin() const;
 
  [[nodiscard]] const std::array<double, 3> &getBoxMax() const;
 
  [[nodiscard]] bool searchSpaceIsTrivial() const;
 
  void setBoxMin(const std::array<double, 3> &boxMin) { _logicHandlerInfo.boxMin = boxMin; }
 
  void setBoxMax(const std::array<double, 3> &boxMax) { _logicHandlerInfo.boxMax = boxMax; }
 
  [[nodiscard]] double getCutoff() const { return _logicHandlerInfo.cutoff; }
 
  void setCutoff(double cutoff) {
    if (cutoff <= 0.0) {
      utils::ExceptionHandler::exception("Error: Cutoff has to be positive {} <= 0.0!", cutoff);
    }
    _logicHandlerInfo.cutoff = cutoff;
  }
 
  [[nodiscard]] const NumberSet<double> &getAllowedCellSizeFactors() const { return *_allowedCellSizeFactors; }
 
  void setAllowedCellSizeFactors(const NumberSet<double> &allowedCellSizeFactors) {
    if (allowedCellSizeFactors.getMin() <= 0.0) {
      utils::ExceptionHandler::exception("Error: minimum cell size factor has to be positive {} <= 0.0!",
                                         allowedCellSizeFactors.getMin());
    }
    _allowedCellSizeFactors = std::move(allowedCellSizeFactors.clone());
  }
 
  void setCellSizeFactor(double cellSizeFactor) {
    if (cellSizeFactor <= 0.0) {
      utils::ExceptionHandler::exception("Error: cell size factor has to be positive! {}<= 0.0!", cellSizeFactor);
    }
    _allowedCellSizeFactors = std::make_unique<NumberSetFinite<double>>(std::set<double>{cellSizeFactor});
  }
 
  void setVerletSkin(double verletSkin) { _logicHandlerInfo.verletSkin = verletSkin; }
 
  void setDeltaT(double deltaT) { _logicHandlerInfo.deltaT = deltaT; }
 
  [[nodiscard]] unsigned int getVerletRebuildFrequency() const { return _verletRebuildFrequency; }
 
  void setVerletRebuildFrequency(unsigned int verletRebuildFrequency) {
    _verletRebuildFrequency = verletRebuildFrequency;
  }
  [[nodiscard]] unsigned int getVerletClusterSize() const { return _logicHandlerInfo.verletClusterSize; }
 
  void setVerletClusterSize(unsigned int verletClusterSize) { _logicHandlerInfo.verletClusterSize = verletClusterSize; }
 
  [[nodiscard]] unsigned int getTuningInterval() const { return _autoTunerInfo.tuningInterval; }
 
  void setTuningInterval(unsigned int tuningInterval) { _autoTunerInfo.tuningInterval = tuningInterval; }
 
  [[nodiscard]] unsigned int getNumSamples() const { return _autoTunerInfo.maxSamples; }
 
  void setNumSamples(unsigned int numSamples) { _autoTunerInfo.maxSamples = numSamples; }
 
  void setEarlyStoppingFactor(double earlyStoppingFactor) { _autoTunerInfo.earlyStoppingFactor = earlyStoppingFactor; }
 
  [[nodiscard]] bool getUseLOESSSmoothening() const { return _autoTunerInfo.useLOESSSmoothening; }
 
  void setUseLOESSSmoothening(bool useLOESSSmoothening) { _autoTunerInfo.useLOESSSmoothening = useLOESSSmoothening; }
 
  [[nodiscard]] unsigned int getMaxEvidence() const { return _tuningStrategyFactoryInfo.maxEvidence; }
 
  void setMaxEvidence(unsigned int maxEvidence) { _tuningStrategyFactoryInfo.maxEvidence = maxEvidence; }
 
  [[nodiscard]] double getRelativeOptimumRange() const { return _tuningStrategyFactoryInfo.relativeOptimumRange; }
 
  void setRelativeOptimumRange(double relativeOptimumRange) {
    _tuningStrategyFactoryInfo.relativeOptimumRange = relativeOptimumRange;
  }
 
  [[nodiscard]] unsigned int getMaxTuningPhasesWithoutTest() const {
    return _tuningStrategyFactoryInfo.maxTuningPhasesWithoutTest;
  }
 
  void setMaxTuningPhasesWithoutTest(unsigned int maxTuningPhasesWithoutTest) {
    _tuningStrategyFactoryInfo.maxTuningPhasesWithoutTest = maxTuningPhasesWithoutTest;
  }
 
  [[nodiscard]] double getRelativeBlacklistRange() const { return _tuningStrategyFactoryInfo.relativeBlacklistRange; }
 
  void setRelativeBlacklistRange(double relativeBlacklistRange) {
    _tuningStrategyFactoryInfo.relativeBlacklistRange = relativeBlacklistRange;
  }
 
  [[nodiscard]] unsigned int getEvidenceFirstPrediction() const {
    return _tuningStrategyFactoryInfo.minNumberOfEvidence;
  }
 
  void setEvidenceFirstPrediction(unsigned int evidenceFirstPrediction) {
    _tuningStrategyFactoryInfo.minNumberOfEvidence = evidenceFirstPrediction;
  }
 
  [[nodiscard]] AcquisitionFunctionOption getAcquisitionFunction() const {
    return _tuningStrategyFactoryInfo.acquisitionFunctionOption;
  }
 
  void setAcquisitionFunction(AcquisitionFunctionOption acqFun) {
    _tuningStrategyFactoryInfo.acquisitionFunctionOption = acqFun;
  }
 
  ExtrapolationMethodOption getExtrapolationMethodOption() const {
    return _tuningStrategyFactoryInfo.extrapolationMethodOption;
  }
 
  void setExtrapolationMethodOption(ExtrapolationMethodOption extrapolationMethodOption) {
    _tuningStrategyFactoryInfo.extrapolationMethodOption = extrapolationMethodOption;
  }
 
  [[nodiscard]] SelectorStrategyOption getSelectorStrategy() const { return _autoTunerInfo.selectorStrategy; }
 
  void setSelectorStrategy(SelectorStrategyOption selectorStrategy) {
    _autoTunerInfo.selectorStrategy = selectorStrategy;
  }
 
  const std::set<LoadEstimatorOption> &getAllowedLoadEstimators() const { return _allowedLoadEstimators; }
 
  void setAllowedLoadEstimators(const std::set<LoadEstimatorOption> &allowedLoadEstimators) {
    _allowedLoadEstimators = allowedLoadEstimators;
  }
 
  [[nodiscard]] const std::set<ContainerOption> &getAllowedContainers() const { return _allowedContainers; }
 
  void setAllowedContainers(const std::set<ContainerOption> &allowedContainers) {
    _allowedContainers = allowedContainers;
  }
 
  [[nodiscard]] const std::set<TraversalOption> &getAllowedTraversals(
      const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) const {
    return _allowedTraversals.at(interactionType);
  }
 
  void setAllowedTraversals(const std::set<TraversalOption> &allowedTraversals,
                            const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) {
    if (interactionType == InteractionTypeOption::all) {
      for (auto iType : InteractionTypeOption::getMostOptions()) {
        _allowedTraversals[iType] = allowedTraversals;
      }
    } else {
      _allowedTraversals[interactionType] = allowedTraversals;
    }
  }
 
  [[nodiscard]] const std::set<DataLayoutOption> &getAllowedDataLayouts(
      const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) const {
    return _allowedDataLayouts.at(interactionType);
  }
 
  void setAllowedDataLayouts(const std::set<DataLayoutOption> &allowedDataLayouts,
                             const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) {
    if (interactionType == InteractionTypeOption::all) {
      for (auto iType : InteractionTypeOption::getMostOptions()) {
        _allowedDataLayouts[iType] = allowedDataLayouts;
      }
    } else {
      _allowedDataLayouts[interactionType] = allowedDataLayouts;
    }
  }
 
  [[nodiscard]] const std::set<Newton3Option> &getAllowedNewton3Options(
      const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) const {
    return _allowedNewton3Options.at(interactionType);
  }
 
  void setAllowedNewton3Options(const std::set<Newton3Option> &allowedNewton3Options,
                                const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) {
    if (interactionType == InteractionTypeOption::all) {
      for (auto iType : InteractionTypeOption::getMostOptions()) {
        _allowedNewton3Options[iType] = allowedNewton3Options;
      }
    } else {
      _allowedNewton3Options[interactionType] = allowedNewton3Options;
    }
  }
 
  [[nodiscard]] const std::set<VectorizationPatternOption> &getAllowedVecPatternOptions(
      const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) const {
    return _allowedVecPatternsOptions.at(interactionType);
  }
 
  void setAllowedVecPatterns(const std::set<VectorizationPatternOption> &allowedVecPatterns,
                             const InteractionTypeOption interactionType = InteractionTypeOption::pairwise) {
    if (interactionType == InteractionTypeOption::all) {
      for (auto iType : InteractionTypeOption::getMostOptions()) {
        _allowedVecPatternsOptions[iType] = allowedVecPatterns;
      }
    } else {
      _allowedVecPatternsOptions[interactionType] = allowedVecPatterns;
    }
  }
 
  void setAllowedInteractionTypeOptions(const std::set<InteractionTypeOption> &allowedInteractionTypeOptions) {
    _allowedInteractionTypeOptions = allowedInteractionTypeOptions;
  }
 
  [[nodiscard]] std::unordered_map<InteractionTypeOption::Value, std::reference_wrapper<const Configuration>>
  getCurrentConfigs() const {
    std::unordered_map<InteractionTypeOption::Value, std::reference_wrapper<const Configuration>> currentConfigs;
    currentConfigs.reserve(_tuningManager->getAutoTuners().size());
 
    for (const auto &[type, tuner] : _tuningManager->getAutoTuners()) {
      currentConfigs.emplace(type, std::cref(tuner->getCurrentConfig()));
    }
    return currentConfigs;
  }
 
  [[nodiscard]] const std::vector<TuningStrategyOption> &getTuningStrategyOptions() const {
    return _tuningStrategyOptions;
  }
 
  void setTuningStrategyOption(const std::vector<TuningStrategyOption> &tuningStrategyOptions) {
    _tuningStrategyOptions = tuningStrategyOptions;
  }
 
  [[nodiscard]] const TuningMetricOption &getTuningMetricOption() const { return _autoTunerInfo.tuningMetric; }
 
  void setTuningMetricOption(TuningMetricOption tuningMetricOption) {
    _autoTunerInfo.tuningMetric = tuningMetricOption;
  }
 
  [[nodiscard]] const EnergySensorOption &getEnergySensorOption() const { return _autoTunerInfo.energySensor; }
 
  void setEnergySensorOption(EnergySensorOption energySensorOption) {
    _autoTunerInfo.energySensor = energySensorOption;
  }
 
  void setMPITuningMaxDifferenceForBucket(double MPITuningMaxDifferenceForBucket) {
    _tuningStrategyFactoryInfo.mpiTuningMaxDifferenceForBucket = MPITuningMaxDifferenceForBucket;
  }
 
  void setMPITuningWeightForMaxDensity(double MPITuningWeightForMaxDensity) {
    _tuningStrategyFactoryInfo.mpiTuningWeightForMaxDensity = MPITuningWeightForMaxDensity;
  }
 
// Only define the interface for the MPI communicator if AUTOPAS_INCLUDE_MPI=ON
// The internal implementation will use _autopasMPICommunicator with WrapMPI regardless of AUTOPAS_INCLUDE_MPI
#if defined(AUTOPAS_INCLUDE_MPI)
  void setMPICommunicator(MPI_Comm comm) { _tuningStrategyFactoryInfo.autopasMpiCommunicator = comm; }
 
  MPI_Comm getMPICommunicator() { return _tuningStrategyFactoryInfo.autopasMpiCommunicator; }
#endif
 
  void setOutputSuffix(const std::string &suffix) { _outputSuffix = suffix; }
 
  double getMeanRebuildFrequency() { return _logicHandler->getMeanRebuildFrequency(); }
 
  void setUseTuningLogger(bool useTuningLogger) { _useTuningStrategyLoggerProxy = useTuningLogger; }
 
  void setRuleFileName(const std::string &ruleFileName) { _tuningStrategyFactoryInfo.ruleFileName = ruleFileName; }
 
  void setFuzzyRuleFileName(const std::string &fuzzyRuleFileName) {
    _tuningStrategyFactoryInfo.fuzzyRuleFileName = fuzzyRuleFileName;
  }
 
  const std::string &getRuleFileName() const { return _tuningStrategyFactoryInfo.ruleFileName; }
 
  void setSortingThreshold(size_t sortingThreshold) { _sortingThreshold = sortingThreshold; }
 
  size_t getSortingThreshold() const { return _sortingThreshold; }
 
 private:
  autopas::ParticleContainerInterface<Particle_T> &getContainer();
 
  const autopas::ParticleContainerInterface<Particle_T> &getContainer() const;
  TuningStrategyFactoryInfo _tuningStrategyFactoryInfo{};
  AutoTunerInfo _autoTunerInfo{};
  LogicHandlerInfo _logicHandlerInfo{};
  bool _useTuningStrategyLoggerProxy{false};
  unsigned int _verletRebuildFrequency{100};
  std::vector<TuningStrategyOption> _tuningStrategyOptions{};
  std::set<ContainerOption> _allowedContainers{ContainerOption::getMostOptions()};
  std::unordered_map<InteractionTypeOption::Value, std::set<TraversalOption>> _allowedTraversals{
      {InteractionTypeOption::pairwise, TraversalOption::getMostPairwiseOptions()},
      {InteractionTypeOption::triwise, TraversalOption::getMostTriwiseOptions()}};
  std::unordered_map<InteractionTypeOption::Value, std::set<DataLayoutOption>> _allowedDataLayouts{
      {InteractionTypeOption::pairwise, DataLayoutOption::getMostOptions()},
      {InteractionTypeOption::triwise, DataLayoutOption::getMostOptions()}};
  std::unordered_map<InteractionTypeOption::Value, std::set<Newton3Option>> _allowedNewton3Options{
      {InteractionTypeOption::pairwise, Newton3Option::getMostOptions()},
      {InteractionTypeOption::triwise, Newton3Option::getMostOptions()}};
  std::unordered_map<InteractionTypeOption::Value, std::set<VectorizationPatternOption>> _allowedVecPatternsOptions{
      {InteractionTypeOption::pairwise, VectorizationPatternOption::getMostOptions()},
      // Note: Currently Vectorization Patterns are not implemented for threebody interactions. p1xVec is used as
      // default.
      {InteractionTypeOption::triwise, std::set<VectorizationPatternOption>{VectorizationPatternOption::p1xVec}}};
  std::set<InteractionTypeOption> _allowedInteractionTypeOptions{InteractionTypeOption::pairwise};
  std::unique_ptr<NumberSet<double>> _allowedCellSizeFactors{
      std::make_unique<NumberSetFinite<double>>(std::set<double>({1.}))};
  std::set<LoadEstimatorOption> _allowedLoadEstimators{LoadEstimatorOption::getAllOptions()};
  std::unique_ptr<LogicHandler<Particle_T>> _logicHandler;
 
  std::shared_ptr<TuningManager> _tuningManager;
  bool _externalMPICommunicator{false};
  std::string _outputSuffix{""};
  size_t _sortingThreshold{8};
  template <class F>
  void addParticlesAux(size_t numParticlesToAdd, size_t numHalosToAdd, size_t collectionSize, F loopBody);
};  // class AutoPas
}  // namespace autopas