ReflectionGenerator.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 <utility>
 
#include "MantidGeometry/Crystal/BasicHKLFilters.h"
#include "MantidGeometry/Crystal/HKLGenerator.h"
#include "MantidGeometry/Crystal/ReflectionGenerator.h"
#include "MantidGeometry/Crystal/StructureFactorCalculatorSummation.h"
 
namespace Mantid::Geometry {
 
using namespace Kernel;
 
class LatticeSpacingCalculator {
public:
  explicit LatticeSpacingCalculator(const UnitCell &cell) : m_cell(cell) {}
 
  double operator()(const V3D &hkl) { return m_cell.d(hkl); }
 
private:
  UnitCell m_cell;
};
 
ReflectionGenerator::ReflectionGenerator(CrystalStructure crystalStructure, ReflectionConditionFilter defaultFilter)
    : m_crystalStructure(std::move(crystalStructure)),
      m_sfCalculator(StructureFactorCalculatorFactory::create<StructureFactorCalculatorSummation>(m_crystalStructure)),
      m_defaultHKLFilter(getReflectionConditionFilter(defaultFilter)) {}
 
const CrystalStructure &ReflectionGenerator::getCrystalStructure() const { return m_crystalStructure; }
 
HKLFilter_const_sptr ReflectionGenerator::getDRangeFilter(double dMin, double dMax) const {
  return std::make_shared<const HKLFilterDRange>(m_crystalStructure.cell(), dMin, dMax);
}
 
HKLFilter_const_sptr ReflectionGenerator::getReflectionConditionFilter(ReflectionConditionFilter filter) const {
  switch (filter) {
  case ReflectionConditionFilter::Centering:
    return std::make_shared<const HKLFilterCentering>(m_crystalStructure.centering());
    break;
  case ReflectionConditionFilter::SpaceGroup:
    return std::make_shared<const HKLFilterSpaceGroup>(m_crystalStructure.spaceGroup());
    break;
  case ReflectionConditionFilter::StructureFactor:
    return std::make_shared<const HKLFilterStructureFactor>(m_sfCalculator);
  default:
    return HKLFilter_const_sptr();
  }
}
 
std::vector<V3D> ReflectionGenerator::getHKLs(double dMin, double dMax) const {
  return getHKLs(dMin, dMax, m_defaultHKLFilter);
}
 
std::vector<Kernel::V3D> ReflectionGenerator::getHKLs(double dMin, double dMax,
                                                      const HKLFilter_const_sptr &reflectionConditionFilter) const {
  HKLGenerator generator(m_crystalStructure.cell(), dMin);
 
  HKLFilter_const_sptr filter = getDRangeFilter(dMin, dMax);
  if (reflectionConditionFilter) {
    filter = filter & reflectionConditionFilter;
  }
 
  std::vector<V3D> hkls;
  hkls.reserve(generator.size());
 
  std::remove_copy_if(generator.begin(), generator.end(), std::back_inserter(hkls), (~filter)->fn());
  return hkls;
}
 
std::vector<V3D> ReflectionGenerator::getUniqueHKLs(double dMin, double dMax) const {
  return getUniqueHKLs(dMin, dMax, m_defaultHKLFilter);
}
 
std::vector<V3D> ReflectionGenerator::getUniqueHKLs(double dMin, double dMax,
                                                    const HKLFilter_const_sptr &reflectionConditionFilter) const {
  HKLGenerator generator(m_crystalStructure.cell(), dMin);
 
  HKLFilter_const_sptr filter = getDRangeFilter(dMin, dMax);
  if (reflectionConditionFilter) {
    filter = filter & reflectionConditionFilter;
  }
 
  std::vector<V3D> hkls;
  hkls.reserve(generator.size());
 
  PointGroup_sptr pg = m_crystalStructure.spaceGroup()->getPointGroup();
 
  for (auto hkl = generator.begin(); hkl != generator.end(); ++hkl) {
    if (filter->isAllowed(*hkl)) {
      hkls.emplace_back(pg->getReflectionFamily(*hkl));
    }
  }
 
  std::sort(hkls.begin(), hkls.end());
  hkls.erase(std::unique(hkls.begin(), hkls.end()), hkls.end());
 
  return hkls;
}
 
std::vector<double> ReflectionGenerator::getDValues(const std::vector<V3D> &hkls) const {
  std::vector<double> dValues;
  dValues.reserve(hkls.size());
 
  std::transform(hkls.begin(), hkls.end(), std::back_inserter(dValues),
                 LatticeSpacingCalculator(m_crystalStructure.cell()));
 
  return dValues;
}
 
std::vector<double> ReflectionGenerator::getFsSquared(const std::vector<V3D> &hkls) const {
  return m_sfCalculator->getFsSquared(hkls);
}
 
} // namespace Mantid::Geometry