SymmetryOperationSymbolParser.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/SymmetryOperationSymbolParser.h"
#include "MantidGeometry/Crystal/MatrixVectorPairParser.h"
#include "MantidKernel/Exception.h"
 
#include <boost/algorithm/string.hpp>
#include <sstream>
 
namespace Mantid::Geometry {
 
void SymmetryOperationSymbolParser::verifyMatrix(const Kernel::IntMatrix &matrix) {
  for (size_t i = 0; i < matrix.numRows(); ++i) {
    if (!isValidMatrixRow(matrix[i], matrix.numCols())) {
      std::ostringstream error;
      error << "Matrix row " << i << " is invalid. Elements: [" << matrix[i][0] << ", " << matrix[i][1] << ", "
            << matrix[i][2] << "]";
      throw Kernel::Exception::ParseError(error.str(), "", 0);
    }
  }
}
 
MatrixVectorPair<int, V3R> SymmetryOperationSymbolParser::parseIdentifier(const std::string &identifier) {
  MatrixVectorPair<int, V3R> pair = parseMatrixVectorPair<int>(identifier);
 
  verifyMatrix(pair.getMatrix());
 
  return pair;
}
 
std::string SymmetryOperationSymbolParser::getNormalizedIdentifier(const MatrixVectorPair<int, V3R> &data) {
  return getNormalizedIdentifier(data.getMatrix(), data.getVector());
}
 
std::string SymmetryOperationSymbolParser::getNormalizedIdentifier(const Kernel::IntMatrix &matrix, const V3R &vector) {
  if (matrix.numCols() != 3 || matrix.numRows() != 3) {
    throw std::runtime_error("Matrix is not a 3x3 matrix.");
  }
 
  std::vector<std::string> symbols{"x", "y", "z"};
  std::vector<std::string> components;
 
  for (size_t r = 0; r < 3; ++r) {
    std::ostringstream currentComponent;
 
    for (size_t c = 0; c < 3; ++c) {
      if (matrix[r][c] != 0) {
        if (matrix[r][c] < 0) {
          currentComponent << "-";
        } else {
          if (!currentComponent.str().empty()) {
            currentComponent << "+";
          }
        }
 
        currentComponent << symbols[c];
      }
    }
 
    if (vector[r] != 0) {
      if (vector[r] > 0) {
        currentComponent << "+";
      }
 
      if (vector[r].denominator() != 1) {
        currentComponent << vector[r];
      } else {
        currentComponent << vector[r].numerator();
      }
    }
 
    components.emplace_back(currentComponent.str());
  }
 
  return boost::join(components, ",");
}
 
bool SymmetryOperationSymbolParser::isValidMatrixRow(const int *element, size_t columnNumber) {
  int nulls = 0;
  for (size_t i = 0; i < columnNumber; ++i) {
    if (abs(element[i]) > 1) {
      return false;
    } else if (element[i] == 0) {
      ++nulls;
    }
  }
 
  return nulls > 0 && nulls < 3;
}
 
} // namespace Mantid::Geometry