ReflectionCondition.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidGeometry/Crystal/ReflectionCondition.h"
#include <algorithm>
#include <functional>
#include <iterator>
#include <memory>
#include <stdexcept>
 
namespace Mantid::Geometry {
 
// General template definition for RegisterConditions
template <typename... Args> struct RegisterConditions;
 
// Specialisation for recursive case
template <typename R, typename... Args> struct RegisterConditions<R, Args...> {
  static void run(ReflectionConditions &container) {
    container.emplace_back(std::make_shared<R>());
    RegisterConditions<Args...>::run(container);
  }
};
 
// Specialisation to end recursion
template <> struct RegisterConditions<> {
  static void run(ReflectionConditions &) {}
};
 
const ReflectionConditions &getAllReflectionConditions() {
  static ReflectionConditions conditions;
  if (conditions.empty()) {
    RegisterConditions<ReflectionConditionPrimitive, ReflectionConditionCFaceCentred, ReflectionConditionAFaceCentred,
                       ReflectionConditionBFaceCentred, ReflectionConditionBodyCentred,
                       ReflectionConditionAllFaceCentred, ReflectionConditionRhombohedrallyObverse,
                       ReflectionConditionRhombohedrallyReverse,
                       ReflectionConditionHexagonallyReverse>::run(conditions);
  }
  return conditions;
}
 
std::vector<std::string>
transformReflectionConditions(const std::function<std::string(const ReflectionCondition_sptr &)> &fn) {
  const auto &conditions = getAllReflectionConditions();
 
  std::vector<std::string> names;
  names.reserve(conditions.size());
  std::transform(conditions.cbegin(), conditions.cend(), std::back_inserter(names), fn);
 
  return names;
}
 
std::vector<std::string> getAllReflectionConditionNames() {
  return transformReflectionConditions([](const ReflectionCondition_sptr &condition) { return condition->getName(); });
}
 
std::vector<std::string> getAllReflectionConditionSymbols() {
  return transformReflectionConditions(
      [](const ReflectionCondition_sptr &condition) { return condition->getSymbol(); });
}
 
ReflectionCondition_sptr getReflectionConditionWhere(const std::function<bool(const ReflectionCondition_sptr &)> &fn,
                                                     const std::string &hint) {
  const auto &conditions = getAllReflectionConditions();
 
  auto it = std::find_if(conditions.cbegin(), conditions.cend(), fn);
 
  if (it == conditions.cend()) {
    throw std::invalid_argument("No ReflectionCondition found that matches '" + hint + "'.");
  }
 
  return *it;
}
 
ReflectionCondition_sptr getReflectionConditionByName(const std::string &name) {
  return getReflectionConditionWhere(
      [=](const ReflectionCondition_sptr &condition) { return condition->getName() == name; }, name);
}
 
ReflectionCondition_sptr getReflectionConditionBySymbol(const std::string &symbol) {
  return getReflectionConditionWhere(
      [=](const ReflectionCondition_sptr &condition) { return condition->getSymbol() == symbol; }, symbol);
}
 
} // namespace Mantid::Geometry