Configuration.h

Go to the documentation of this file.

 
#pragma once
 
#include <tuple>
 
#include "autopas/containers/CompatibleLoadEstimators.h"
#include "autopas/containers/CompatibleTraversals.h"
#include "autopas/containers/CompatibleVectorizationPattern.h"
#include "autopas/options/ContainerOption.h"
#include "autopas/options/DataLayoutOption.h"
#include "autopas/options/LoadEstimatorOption.h"
#include "autopas/options/Newton3Option.h"
#include "autopas/options/TraversalOption.h"
#include "autopas/options/VectorizationPatternOption.h"
 
namespace autopas {
 
class Configuration {
 public:
  constexpr Configuration(ContainerOption _container, double _cellSizeFactor, TraversalOption _traversal,
                          LoadEstimatorOption _loadEstimator, DataLayoutOption _dataLayout, Newton3Option _newton3,
                          InteractionTypeOption _interactionType,
                          VectorizationPatternOption _vecPattern = VectorizationPatternOption::p1xVec)
      : container(_container),
        traversal(_traversal),
        vecPattern(_vecPattern),
        loadEstimator(_loadEstimator),
        dataLayout(_dataLayout),
        newton3(_newton3),
        cellSizeFactor(_cellSizeFactor),
        interactionType(_interactionType) {}
 
  constexpr Configuration()
      : container(), traversal(), loadEstimator(), dataLayout(), newton3(), cellSizeFactor(-1.), interactionType() {}
 
  [[nodiscard]] std::string toString() const;
 
  [[nodiscard]] std::string toShortString(bool fixedLength = true) const {
    return "{" + interactionType.to_string(interactionType) + " , " + container.to_string(fixedLength) + " , " +
           std::to_string(cellSizeFactor) + " , " + traversal.to_string(fixedLength) + " , " +
           loadEstimator.to_string(fixedLength) + " , " + dataLayout.to_string(fixedLength) + " , " +
           newton3.to_string(fixedLength) + "}";
  }
 
  [[nodiscard]] std::string getCSVHeader() const;
 
  [[nodiscard]] std::string getCSVLine() const;
 
  [[nodiscard]] bool hasValidValues() const;
 
  [[nodiscard]] bool hasCompatibleValues() const;
 
  bool equalsDiscreteOptions(const Configuration &rhs) const;
 
  bool equalsContinuousOptions(const autopas::Configuration &rhs, double epsilon = 1e-12) const;
 
  ContainerOption container;
  TraversalOption traversal;
  VectorizationPatternOption vecPattern;
  LoadEstimatorOption loadEstimator;
  DataLayoutOption dataLayout;
  Newton3Option newton3;
  double cellSizeFactor;
  InteractionTypeOption interactionType;
 
 private:
  [[nodiscard]] std::string getCSVRepresentation(bool returnHeaderOnly) const;
};
 
std::ostream &operator<<(std::ostream &os, const Configuration &configuration);
 
std::istream &operator>>(std::istream &in, Configuration &configuration);
 
bool operator==(const Configuration &lhs, const Configuration &rhs);
 
bool operator!=(const Configuration &lhs, const Configuration &rhs);
 
bool operator<(const Configuration &lhs, const Configuration &rhs);
 
struct ConfigHash {
  std::size_t operator()(Configuration configuration) const {
    std::size_t enumHash = static_cast<std::size_t>(configuration.interactionType) +
                           static_cast<std::size_t>(configuration.newton3) * 10 +
                           static_cast<std::size_t>(configuration.dataLayout) * 100 +
                           static_cast<std::size_t>(configuration.loadEstimator) * 1000 +
                           static_cast<std::size_t>(configuration.traversal) * 10000 +
                           static_cast<std::size_t>(configuration.container) * 100000;
    std::size_t doubleHash = std::hash<double>{}(configuration.cellSizeFactor);
 
    return enumHash ^ doubleHash;
  }
};
 
}  // namespace autopas