Group.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/SymmetryOperation.h"
#include "MantidGeometry/DllConfig.h"
#include "MantidKernel/Tolerance.h"
 
#include <set>
#include <vector>
 
#include <memory>
 
namespace Mantid {
namespace Geometry {
 
class MANTID_GEOMETRY_DLL AtomPositionsEqual {
public:
  AtomPositionsEqual(double precision = 1.e-4) : m_precision(precision) {}
 
  bool operator()(const Kernel::V3D &lhs, const Kernel::V3D &rhs) const {
    return !(fabs(lhs.X() - rhs.X()) > m_precision || fabs(lhs.Y() - rhs.Y()) > m_precision ||
             fabs(lhs.Z() - rhs.Z()) > m_precision);
  }
 
private:
  double m_precision;
};
 
class MANTID_GEOMETRY_DLL AtomPositionsLessThan {
public:
  AtomPositionsLessThan(double precision = 1.e-4) : m_precision(precision) {}
 
  bool operator()(const Kernel::V3D &lhs, const Kernel::V3D &rhs) const {
    if (fabs(lhs.X() - rhs.X()) > m_precision) {
      return lhs.X() < rhs.X();
    }
 
    if (fabs(lhs.Y() - rhs.Y()) > m_precision) {
      return lhs.Y() < rhs.Y();
    }
 
    if (fabs(lhs.Z() - rhs.Z()) > m_precision) {
      return lhs.Z() < rhs.Z();
    }
 
    return false;
  }
 
private:
  double m_precision;
};
 
class MANTID_GEOMETRY_DLL Group {
public:
  enum CoordinateSystem { Orthogonal, Hexagonal };
 
  enum GroupAxiom { Closure, Identity, Inversion, Associativity };
 
  Group();
  Group(const std::string &symmetryOperationString);
  Group(const std::vector<SymmetryOperation> &symmetryOperations);
  virtual ~Group() = default;
 
  size_t order() const;
  CoordinateSystem getCoordinateSystem() const;
  std::vector<SymmetryOperation> getSymmetryOperations() const;
  bool containsOperation(const SymmetryOperation &operation) const;
 
  Group operator*(const Group &other) const;
 
  std::vector<Kernel::V3D> operator*(const Kernel::V3D &vector) const;
 
  bool isInvariant(const Kernel::DblMatrix &tensor, double tolerance = 1e-8) const;
 
  bool operator==(const Group &other) const;
  bool operator!=(const Group &other) const;
 
  bool fulfillsAxiom(GroupAxiom axiom) const;
  bool isGroup() const;
 
protected:
  void setSymmetryOperations(const std::vector<SymmetryOperation> &symmetryOperations);
 
  CoordinateSystem getCoordinateSystemFromOperations(const std::vector<SymmetryOperation> &symmetryOperations) const;
 
  bool isClosed() const;
  bool hasIdentity() const;
  bool eachElementHasInverse() const;
  bool associativityHolds() const;
 
  std::vector<SymmetryOperation> m_allOperations;
  std::set<SymmetryOperation> m_operationSet;
  CoordinateSystem m_axisSystem;
};
 
using Group_sptr = std::shared_ptr<Group>;
using Group_const_sptr = std::shared_ptr<const Group>;
 
namespace GroupFactory {
template <typename T> Group_const_sptr create(const std::string &initializationString) {
  return std::make_shared<const T>(initializationString);
}
 
template <typename T> Group_const_sptr create(const std::vector<SymmetryOperation> &symmetryOperations) {
  return std::make_shared<const T>(symmetryOperations);
}
} // namespace GroupFactory
 
MANTID_GEOMETRY_DLL Group_const_sptr operator*(const Group_const_sptr &lhs, const Group_const_sptr &rhs);
MANTID_GEOMETRY_DLL std::vector<Kernel::V3D> operator*(const Group_const_sptr &lhs, const Kernel::V3D &rhs);
MANTID_GEOMETRY_DLL bool operator==(const Group_const_sptr &lhs, const Group_const_sptr &rhs);
MANTID_GEOMETRY_DLL bool operator!=(const Group_const_sptr &lhs, const Group_const_sptr &rhs);
 
} // namespace Geometry
} // namespace Mantid