SymmetryElementFactory.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2015 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/SymmetryElement.h"
#include "MantidGeometry/Crystal/SymmetryOperation.h"
#include "MantidGeometry/DllConfig.h"
#include "MantidKernel/RegistrationHelper.h"
#include "MantidKernel/SingletonHolder.h"
 
#include <map>
#include <memory>
#include <unordered_set>
 
namespace Mantid {
namespace Geometry {
 
class MANTID_GEOMETRY_DLL AbstractSymmetryElementGenerator {
public:
  virtual ~AbstractSymmetryElementGenerator() = default;
 
  virtual SymmetryElement_sptr generateElement(const SymmetryOperation &operation) const = 0;
 
  virtual bool canProcess(const SymmetryOperation &operation) const = 0;
};
 
using AbstractSymmetryElementGenerator_sptr = std::shared_ptr<AbstractSymmetryElementGenerator>;
 
class MANTID_GEOMETRY_DLL SymmetryElementIdentityGenerator : public AbstractSymmetryElementGenerator {
public:
  SymmetryElement_sptr generateElement(const SymmetryOperation &operation) const override;
  bool canProcess(const SymmetryOperation &operation) const override;
};
 
class MANTID_GEOMETRY_DLL SymmetryElementTranslationGenerator : public AbstractSymmetryElementGenerator {
public:
  SymmetryElement_sptr generateElement(const SymmetryOperation &operation) const override;
  bool canProcess(const SymmetryOperation &operation) const override;
};
 
class MANTID_GEOMETRY_DLL SymmetryElementInversionGenerator : public AbstractSymmetryElementGenerator {
public:
  SymmetryElement_sptr generateElement(const SymmetryOperation &operation) const override;
  bool canProcess(const SymmetryOperation &operation) const override;
};
 
MANTID_GEOMETRY_DLL gsl_matrix *getGSLMatrix(const Kernel::IntMatrix &matrix);
MANTID_GEOMETRY_DLL gsl_matrix *getGSLIdentityMatrix(size_t rows, size_t cols);
 
class MANTID_GEOMETRY_DLL SymmetryElementWithAxisGenerator : public AbstractSymmetryElementGenerator {
public:
protected:
  V3R determineTranslation(const SymmetryOperation &operation) const;
  V3R determineAxis(const Kernel::IntMatrix &matrix) const;
 
  virtual std::string determineSymbol(const SymmetryOperation &operation) const = 0;
};
 
class MANTID_GEOMETRY_DLL SymmetryElementRotationGenerator : public SymmetryElementWithAxisGenerator {
public:
  SymmetryElement_sptr generateElement(const SymmetryOperation &operation) const override;
  bool canProcess(const SymmetryOperation &operation) const override;
 
protected:
  SymmetryElementRotation::RotationSense determineRotationSense(const SymmetryOperation &operation,
                                                                const V3R &rotationAxis) const;
 
  std::string determineSymbol(const SymmetryOperation &operation) const override;
};
 
class MANTID_GEOMETRY_DLL SymmetryElementMirrorGenerator : public SymmetryElementWithAxisGenerator {
public:
  SymmetryElement_sptr generateElement(const SymmetryOperation &operation) const override;
  bool canProcess(const SymmetryOperation &operation) const override;
 
protected:
  std::string determineSymbol(const SymmetryOperation &operation) const override;
 
  static std::map<V3R, std::string> g_glideSymbolMap;
};
 
class MANTID_GEOMETRY_DLL SymmetryElementFactoryImpl {
public:
  virtual ~SymmetryElementFactoryImpl() = default;
 
  SymmetryElement_sptr createSymElement(const SymmetryOperation &operation);
 
  template <typename T> void subscribeSymmetryElementGenerator(const std::string &generatorClassName) {
    AbstractSymmetryElementGenerator_sptr generator = std::make_shared<T>();
 
    if (isSubscribed(generatorClassName)) {
      throw std::runtime_error("A generator with name '" + generatorClassName + "' is already registered.");
    }
 
    subscribe(generator, generatorClassName);
  }
 
protected:
  bool isSubscribed(const std::string &generatorClassName) const;
  void subscribe(const AbstractSymmetryElementGenerator_sptr &generator, const std::string &generatorClassName);
 
  SymmetryElement_sptr createFromPrototype(const std::string &identifier) const;
  AbstractSymmetryElementGenerator_sptr getGenerator(const SymmetryOperation &operation) const;
  void insertPrototype(const std::string &identifier, const SymmetryElement_sptr &prototype);
 
  std::vector<AbstractSymmetryElementGenerator_sptr> m_generators;
  std::unordered_set<std::string> m_generatorNames;
  std::map<std::string, SymmetryElement_sptr> m_prototypes;
 
private:
  friend struct Mantid::Kernel::CreateUsingNew<SymmetryElementFactoryImpl>;
};
 
using SymmetryElementFactory = Mantid::Kernel::SingletonHolder<SymmetryElementFactoryImpl>;
 
} // namespace Geometry
} // namespace Mantid
 
namespace Mantid {
namespace Kernel {
EXTERN_MANTID_GEOMETRY template class MANTID_GEOMETRY_DLL
    Mantid::Kernel::SingletonHolder<Mantid::Geometry::SymmetryElementFactoryImpl>;
}
} // namespace Mantid
 
#define DECLARE_SYMMETRY_ELEMENT_GENERATOR(classname)                                                                  \
  namespace {                                                                                                          \
  Mantid::Kernel::RegistrationHelper register_symmetry_element_generator_##classname((                                 \
      (Mantid::Geometry::SymmetryElementFactory::Instance().subscribeSymmetryElementGenerator<classname>(#classname)), \
      0));                                                                                                             \
  }