SpaceGroupFactory.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2014 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 +
#pragma once
 
#include "MantidGeometry/Crystal/SpaceGroup.h"
#include "MantidGeometry/DllConfig.h"
#include "MantidKernel/RegistrationHelper.h"
#include "MantidKernel/SingletonHolder.h"
 
#include <map>
 
namespace Mantid {
namespace Geometry {
 
bool MANTID_GEOMETRY_DLL isValidGeneratorString(const std::string &generatorString);
 
std::vector<std::string> MANTID_GEOMETRY_DLL operator*(const SymmetryOperation &symOp,
                                                       const std::vector<std::string> &strings);
 
class MANTID_GEOMETRY_DLL AbstractSpaceGroupGenerator {
public:
  AbstractSpaceGroupGenerator(size_t number, std::string hmSymbol, std::string generatorInformation);
  virtual ~AbstractSpaceGroupGenerator() = default;
 
  inline size_t getNumber() const { return m_number; }
  inline std::string getHMSymbol() const { return m_hmSymbol; }
  inline std::string getGeneratorString() const { return m_generatorString; }
 
  SpaceGroup_const_sptr getPrototype();
 
protected:
  virtual Group_const_sptr generateGroup() const = 0;
 
private:
  inline bool hasValidPrototype() const { return static_cast<bool>(m_prototype); }
  SpaceGroup_const_sptr generatePrototype();
 
  size_t m_number;
  std::string m_hmSymbol;
  std::string m_generatorString;
 
  SpaceGroup_const_sptr m_prototype;
};
 
using AbstractSpaceGroupGenerator_sptr = std::shared_ptr<AbstractSpaceGroupGenerator>;
 
class MANTID_GEOMETRY_DLL AlgorithmicSpaceGroupGenerator : public AbstractSpaceGroupGenerator {
public:
  AlgorithmicSpaceGroupGenerator(size_t number, const std::string &hmSymbol, const std::string &generatorInformation);
 
protected:
  Group_const_sptr generateGroup() const override;
  std::string getCenteringSymbol() const;
};
 
class MANTID_GEOMETRY_DLL TransformationSpaceGroupGenerator : public AbstractSpaceGroupGenerator {
public:
  TransformationSpaceGroupGenerator(size_t number, const std::string &hmSymbol,
                                    const std::string &generatorInformation);
 
protected:
  Group_const_sptr generateGroup() const override;
  virtual SpaceGroup_const_sptr getBaseSpaceGroup() const;
 
  void setBaseAndTransformation(const std::string &generatorInformation);
 
  std::string m_baseGroupHMSymbol;
  std::string m_transformation;
};
 
class MANTID_GEOMETRY_DLL TabulatedSpaceGroupGenerator : public AbstractSpaceGroupGenerator {
public:
  TabulatedSpaceGroupGenerator(size_t number, const std::string &hmSymbol, const std::string &generatorInformation);
 
protected:
  Group_const_sptr generateGroup() const override;
};
 
class MANTID_GEOMETRY_DLL SpaceGroupFactoryImpl {
public:
  virtual ~SpaceGroupFactoryImpl() = default;
 
  SpaceGroup_const_sptr createSpaceGroup(const std::string &hmSymbol);
 
  bool isSubscribed(const std::string &hmSymbol) const;
  bool isSubscribed(size_t number) const;
 
  std::vector<std::string> subscribedSpaceGroupSymbols() const;
  std::vector<std::string> subscribedSpaceGroupSymbols(size_t number) const;
  std::vector<size_t> subscribedSpaceGroupNumbers() const;
 
  std::vector<std::string> subscribedSpaceGroupSymbols(const PointGroup_sptr &pointGroup);
 
  void unsubscribeSpaceGroup(const std::string &hmSymbol);
 
  void subscribeGeneratedSpaceGroup(size_t number, const std::string &hmSymbol, const std::string &generators);
  void subscribeTabulatedSpaceGroup(size_t number, const std::string &hmSymbol, const std::string &symmetryOperations);
 
  template <typename T>
  void subscribeUsingGenerator(size_t number, const std::string &hmSymbol, const std::string &generatorString) {
    if (isSubscribed(hmSymbol)) {
      throw std::invalid_argument("Space group with symbol '" + hmSymbol + "' is already registered.");
    }
 
    AbstractSpaceGroupGenerator_sptr generator = std::make_shared<T>(number, hmSymbol, generatorString);
 
    subscribe(generator);
  }
 
  template <typename T>
  void subscribeOrthorhombicSpaceGroup(size_t number, const std::string &hmSymbol, const std::string &generatorString) {
    // Subscribe the base type, this must always be done.
    subscribeUsingGenerator<T>(number, hmSymbol, generatorString);
 
    /* For each orthorhombic space group there are in principle 6 permutations.
     * The other 5 can be constructed by TransformationSpaceGroupGenerator,
     * using the following transformations.
     */
    std::vector<std::string> transformations{"y,x,-z", "y,z,x", "z,y,-x", "z,x,y", "x,z,-y"};
    /* For some space groups, some (or all) transformations lead to the same
     * space
     * group, it's necessary to keep track of this.
     */
    std::vector<std::string> transformedSpaceGroupSymbols;
 
    for (const auto &transformation : transformations) {
      std::string transformedSymbol = getTransformedSymbolOrthorhombic(hmSymbol, transformation);
 
      bool symbolExists = std::find(transformedSpaceGroupSymbols.cbegin(), transformedSpaceGroupSymbols.cend(),
                                    transformedSymbol) != transformedSpaceGroupSymbols.cend();
 
      if (transformedSymbol != hmSymbol && !symbolExists) {
        subscribeUsingGenerator<TransformationSpaceGroupGenerator>(
            number, transformedSymbol, std::string(hmSymbol).append("|").append(transformation));
        transformedSpaceGroupSymbols.emplace_back(transformedSymbol);
      }
    }
  }
 
protected:
  std::string getTransformedSymbolOrthorhombic(const std::string &hmSymbol, const std::string &transformation) const;
 
  SpaceGroup_const_sptr getPrototype(const std::string &hmSymbol);
  void subscribe(const AbstractSpaceGroupGenerator_sptr &generator);
  SpaceGroup_const_sptr constructFromPrototype(const SpaceGroup_const_sptr &prototype) const;
 
  void fillPointGroupMap();
 
  std::multimap<size_t, std::string> m_numberMap;
  std::map<std::string, AbstractSpaceGroupGenerator_sptr> m_generatorMap;
  std::multimap<std::string, std::string> m_pointGroupMap;
 
  SpaceGroupFactoryImpl();
 
private:
  friend struct Mantid::Kernel::CreateUsingNew<SpaceGroupFactoryImpl>;
};
 
using SpaceGroupFactory = Mantid::Kernel::SingletonHolder<SpaceGroupFactoryImpl>;
 
} // namespace Geometry
} // namespace Mantid
 
namespace Mantid {
namespace Kernel {
EXTERN_MANTID_GEOMETRY template class MANTID_GEOMETRY_DLL
    Mantid::Kernel::SingletonHolder<Mantid::Geometry::SpaceGroupFactoryImpl>;
}
} // namespace Mantid
 
/* Macros for compile time space group registration
 *
 * The macros are a bit different than in other factories,
 * because there is no identifier that can be used to generate
 * a unique name for each RegistrationHelper instance.
 *
 * Instead, the __COUNTER__ macro is used, which is available
 * in many compilers and is incremented every time it's called.
 *
 * Solution was found here: http://stackoverflow.com/a/1295338
 */
#define SPGF_CONCAT_IMPL(x, y) x##y
#define SPGF_CONCAT(x, y) SPGF_CONCAT_IMPL(x, y)
 
#define DECLARE_GENERATED_SPACE_GROUP(number, hmSymbol, generators)                                                    \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper SPGF_CONCAT(register_spacegroup_, __COUNTER__)(                                   \
      ((Mantid::Geometry::SpaceGroupFactory::Instance().subscribeGeneratedSpaceGroup(number, hmSymbol, generators)),   \
       0));                                                                                                            \
  }
 
#define DECLARE_TRANSFORMED_SPACE_GROUP(number, hmSymbol, generators)                                                  \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper SPGF_CONCAT(register_spacegroup_, __COUNTER__)(                                   \
      ((Mantid::Geometry::SpaceGroupFactory::Instance().subscribeUsingGenerator<TransformationSpaceGroupGenerator>(    \
           number, hmSymbol, generators)),                                                                             \
       0));                                                                                                            \
  }
 
#define DECLARE_TABULATED_SPACE_GROUP(number, hmSymbol, symmetryOperations)                                            \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper SPGF_CONCAT(register_spacegroup_, __COUNTER__)(                                   \
      ((Mantid::Geometry::SpaceGroupFactory::Instance().subscribeTabulatedSpaceGroup(number, hmSymbol,                 \
                                                                                     symmetryOperations)),             \
       0));                                                                                                            \
  }
 
#define DECLARE_ORTHORHOMBIC_SPACE_GROUP(number, hmSymbol, generators)                                                 \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper SPGF_CONCAT(register_spacegroup_, __COUNTER__)(                                   \
      ((Mantid::Geometry::SpaceGroupFactory::Instance()                                                                \
            .subscribeOrthorhombicSpaceGroup<AlgorithmicSpaceGroupGenerator>(number, hmSymbol, generators)),           \
       0));                                                                                                            \
  }
 
#define DECLARE_TRANSFORMED_ORTHORHOMBIC_SPACE_GROUP(number, hmSymbol, generators)                                     \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper SPGF_CONCAT(register_spacegroup_, __COUNTER__)(                                   \
      ((Mantid::Geometry::SpaceGroupFactory::Instance()                                                                \
            .subscribeOrthorhombicSpaceGroup<TransformationSpaceGroupGenerator>(number, hmSymbol, generators)),        \
       0));                                                                                                            \
  }