CompatibleTraversals.h

Go to the documentation of this file.

 
#pragma once
 
#include <set>
 
#include "autopas/options/ContainerOption.h"
#include "autopas/options/InteractionTypeOption.h"
#include "autopas/options/TraversalOption.h"
#include "autopas/utils/ExceptionHandler.h"
#include "autopas/utils/StringUtils.h"
 
namespace autopas::compatibleTraversals {
 
namespace {
std::set<TraversalOption> filterAllOptions(const std::string &prefix, const InteractionTypeOption &interactionType) {
  const auto allOpts = TraversalOption::getAllOptionsOf(interactionType);
  std::set<TraversalOption> retSet;
  // If the lambda condition holds (=prefix matches) copy the option in the return set.
  std::copy_if(allOpts.begin(), allOpts.end(), std::inserter(retSet, retSet.begin()),
               [&](const auto &option) { return option.to_string().substr(0, prefix.length()) == prefix; });
  return retSet;
}
}  // namespace
 
[[maybe_unused]] static const std::set<TraversalOption> &allDSCompatibleTraversals() {
  static const auto s = filterAllOptions("ds_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allDSCompatibleTraversals3B() {
  static const auto s = filterAllOptions("ds_", InteractionTypeOption::triwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allLCCompatibleTraversals() {
  static const auto s = filterAllOptions("lc_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allLCCompatibleTraversals3B() {
  static const auto s = filterAllOptions("lc_", InteractionTypeOption::triwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allRLCCompatibleTraversals() {
  return allLCCompatibleTraversals();
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allVCLCompatibleTraversals() {
  static const auto s = filterAllOptions("vcl_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allVLCompatibleTraversals() {
  static const auto s = filterAllOptions("vl_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allVLCCompatibleTraversals() {
  static const auto s = filterAllOptions("vlc_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allVarVLAsBuildCompatibleTraversals() {
  static const auto s = filterAllOptions("vvl_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allVLPCompatibleTraversals() {
  static const auto s = filterAllOptions("vlp_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static const std::set<TraversalOption> &allOTCompatibleTraversals() {
  static const auto s = filterAllOptions("ot_", InteractionTypeOption::pairwise);
  return s;
}
 
[[maybe_unused]] static std::set<TraversalOption> allTraversalsSupportingOnlyNewton3Disabled() {
  return {TraversalOption::lc_c01,
          TraversalOption::lc_c01_combined_SoA,
          TraversalOption::ot_c01,
          TraversalOption::vcl_c01_balanced,
          TraversalOption::vcl_cluster_iteration,
          TraversalOption::vl_list_iteration,
          TraversalOption::vlc_c01,
          TraversalOption::vlp_c01};
};
[[maybe_unused]] static std::set<TraversalOption> allTraversalsSupportingOnlyNewton3Enabled() {
  return {
      TraversalOption::ot_c18,
  };
};
[[maybe_unused]] static std::set<TraversalOption> allTraversalsSupportingOnlyAoS() { return {}; };
[[maybe_unused]] static std::set<TraversalOption> allTraversalsSupportingOnlySoA() {
  return {
      TraversalOption::lc_c01_combined_SoA,
      TraversalOption::lc_c04_combined_SoA,
  };
};
 
[[maybe_unused]] static const std::set<TraversalOption> &allCompatibleTraversals(
    ContainerOption containerOption, const InteractionTypeOption interactionTypeOption) {
  switch (interactionTypeOption) {
    // Check compatible pairwise traversals
    case InteractionTypeOption::pairwise: {
      switch (containerOption) {
        case ContainerOption::linkedCells: {
          return allLCCompatibleTraversals();
        }
        case ContainerOption::directSum: {
          return allDSCompatibleTraversals();
        }
        case ContainerOption::verletClusterLists: {
          return allVCLCompatibleTraversals();
        }
        case ContainerOption::verletLists: {
          return allVLCompatibleTraversals();
        }
        case ContainerOption::verletListsCells: {
          return allVLCCompatibleTraversals();
        }
        case ContainerOption::varVerletListsAsBuild: {
          return allVarVLAsBuildCompatibleTraversals();
        }
        case ContainerOption::linkedCellsReferences: {
          return allRLCCompatibleTraversals();
        }
        case ContainerOption::pairwiseVerletLists: {
          return allVLPCompatibleTraversals();
        }
        case ContainerOption::octree: {
          return allOTCompatibleTraversals();
        }
      }
    }
    // Check compatible triwise traversals
    case InteractionTypeOption::triwise: {
      switch (containerOption) {
        case ContainerOption::directSum: {
          return allDSCompatibleTraversals3B();
        }
        case ContainerOption::linkedCells: {
          return allLCCompatibleTraversals3B();
        }
        default: {
          static const std::set<TraversalOption> s{};
          return s;
        }
      }
    }
    case InteractionTypeOption::all: {
      utils::ExceptionHandler::exception("CompatibleTraversals: Interaction type option {} is not supported!",
                                         interactionTypeOption.to_string());
    }
  }
 
  utils::ExceptionHandler::exception(
      "CompatibleTraversals: Unknown container option {} or unsupported interaction type {}!",
      containerOption.to_string(), interactionTypeOption.to_string());
 
  static const std::set<TraversalOption> s{};
  return s;
}
 
[[maybe_unused]] static std::set<ContainerOption> allCompatibleContainers(TraversalOption traversalOption) {
  std::set<ContainerOption> result{};
 
  for (const auto &container : ContainerOption::getAllOptions()) {
    for (const auto &interactionType : InteractionTypeOption::getMostOptions()) {
      auto allCompatible = compatibleTraversals::allCompatibleTraversals(container, interactionType);
      if (allCompatible.find(traversalOption) != allCompatible.end()) {
        result.insert(container);
      }
    }
  }
 
  return result;
}
 
}  // namespace autopas::compatibleTraversals