Group.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/Group.h"
#include "MantidGeometry/Crystal/SymmetryOperationFactory.h"
 
#include <algorithm>
 
namespace Mantid::Geometry {
 
Group::Group() : m_allOperations(), m_operationSet(), m_axisSystem() {
  std::vector<SymmetryOperation> operation(1);
  setSymmetryOperations(operation);
}
 
Group::Group(const std::string &symmetryOperationString) : m_allOperations(), m_operationSet(), m_axisSystem() {
  setSymmetryOperations(SymmetryOperationFactory::Instance().createSymOps(symmetryOperationString));
}
 
Group::Group(const std::vector<SymmetryOperation> &symmetryOperations)
    : m_allOperations(), m_operationSet(), m_axisSystem() {
  setSymmetryOperations(symmetryOperations);
}
 
size_t Group::order() const { return m_allOperations.size(); }
 
Group::CoordinateSystem Group::getCoordinateSystem() const { return m_axisSystem; }
 
std::vector<SymmetryOperation> Group::getSymmetryOperations() const { return m_allOperations; }
 
bool Group::containsOperation(const SymmetryOperation &operation) const {
  return std::find(m_allOperations.begin(), m_allOperations.end(), operation) != m_allOperations.end();
}
 
Group Group::operator*(const Group &other) const {
  std::vector<SymmetryOperation> result;
  result.reserve(order() * other.order());
 
  // performs multiplication between all operations in the Group and the all from the other Group
  std::transform(
      m_allOperations.begin(), m_allOperations.end(), std::back_inserter(result), [&result, &other](auto &operation) {
        std::transform(other.m_allOperations.begin(), other.m_allOperations.end(), std::back_inserter(result),
                       [&operation](const auto &otherOp) { return operation * otherOp; });
        return operation;
      });
  return Group(result);
}
 
std::vector<Kernel::V3D> Group::operator*(const Kernel::V3D &vector) const {
  std::vector<Kernel::V3D> result;
  result.reserve(m_allOperations.size());
  std::transform(m_allOperations.cbegin(), m_allOperations.cend(), std::back_inserter(result),
                 [&vector](const auto &operation) { return Geometry::getWrappedVector(operation * vector); });
 
  std::sort(result.begin(), result.end(), AtomPositionsLessThan());
  result.erase(std::unique(result.begin(), result.end()), result.end());
 
  return result;
}
 
bool Group::isInvariant(const Kernel::DblMatrix &tensor, double tolerance) const {
  auto transformTensor = [](const Kernel::DblMatrix &opMatrix, const Kernel::DblMatrix &tensor) {
    return opMatrix.Tprime() * tensor * opMatrix;
  };
 
  return std::all_of(m_allOperations.cbegin(), m_allOperations.cend(), [&](const SymmetryOperation &op) {
    return transformTensor(convertMatrix<double>(op.matrix()), tensor).equals(tensor, tolerance);
  });
}
 
bool Group::operator==(const Group &other) const { return m_operationSet == other.m_operationSet; }
 
bool Group::operator!=(const Group &other) const { return !(this->operator==(other)); }
 
bool Group::fulfillsAxiom(GroupAxiom axiom) const {
  switch (axiom) {
  case Closure:
    return isClosed();
  case Identity:
    return hasIdentity();
  case Inversion:
    return eachElementHasInverse();
  case Associativity:
    return associativityHolds();
  default:
    return false;
  }
}
 
bool Group::isGroup() const { return isClosed() && hasIdentity() && eachElementHasInverse() && associativityHolds(); }
 
void Group::setSymmetryOperations(const std::vector<SymmetryOperation> &symmetryOperations) {
  if (symmetryOperations.empty()) {
    throw std::invalid_argument("Group needs at least one element.");
  }
 
  m_operationSet.clear();
  std::transform(symmetryOperations.cbegin(), symmetryOperations.cend(),
                 std::inserter(m_operationSet, m_operationSet.begin()), &getUnitCellIntervalOperation);
 
  m_allOperations = std::vector<SymmetryOperation>(m_operationSet.begin(), m_operationSet.end());
  m_axisSystem = getCoordinateSystemFromOperations(m_allOperations);
}
 
Group::CoordinateSystem
Group::getCoordinateSystemFromOperations(const std::vector<SymmetryOperation> &symmetryOperations) const {
  for (const auto &symmetryOperation : symmetryOperations) {
    std::vector<int> matrix = symmetryOperation.matrix();
    if (std::count(matrix.begin(), matrix.end(), 0) == 5) {
      return Group::Hexagonal;
    }
  }
 
  return Group::Orthogonal;
}
 
bool Group::isClosed() const {
  Group result = (*this) * (*this);
 
  // If the order is different, there are additional or fewer elements
  if (result.order() != order()) {
    return false;
  }
 
  // Also, all operations need to be equal.
  std::vector<SymmetryOperation> ops = result.getSymmetryOperations();
  for (size_t i = 0; i < ops.size(); ++i) {
    if (ops[i] != m_allOperations[i]) {
      return false;
    }
  }
 
  return true;
}
 
bool Group::hasIdentity() const {
  // Since the identity element does not change, this is an easy check.
  return containsOperation(SymmetryOperation());
}
 
bool Group::eachElementHasInverse() const {
  return std::all_of(m_allOperations.cbegin(), m_allOperations.cend(), [this](const auto &operation) {
    return this->containsOperation(getUnitCellIntervalOperation(operation.inverse()));
  });
}
 
bool Group::associativityHolds() const { return true; }
 
Group_const_sptr operator*(const Group_const_sptr &lhs, const Group_const_sptr &rhs) {
  if (!lhs || !rhs) {
    throw std::invalid_argument("One of the operands is null. Aborting.");
  }
 
  return std::make_shared<const Group>((*lhs) * (*rhs));
}
 
std::vector<Kernel::V3D> operator*(const Group_const_sptr &lhs, const Kernel::V3D &rhs) {
  if (!lhs) {
    throw std::invalid_argument("Cannot use null pointer for multiplication.");
  }
 
  return (*lhs) * rhs;
}
 
bool operator==(const Group_const_sptr &lhs, const Group_const_sptr &rhs) {
  if (!lhs || !rhs) {
    throw std::invalid_argument("One of the operands is null. Aborting.");
  }
 
  return (*lhs) == (*rhs);
}
 
bool operator!=(const Group_const_sptr &lhs, const Group_const_sptr &rhs) { return !(operator==(lhs, rhs)); }
 
} // namespace Mantid::Geometry