BraggScattererInCrystalStructure.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/BraggScattererInCrystalStructure.h"
#include <stdexcept>
 
#include "MantidGeometry/Crystal/SpaceGroupFactory.h"
#include "MantidKernel/ListValidator.h"
#include <boost/algorithm/string.hpp>
#include <boost/regex.hpp>
#include <memory>
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4005)
#endif
 
#include <muParser.h>
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
namespace Mantid::Geometry {
 
using namespace Kernel;
 
BraggScattererInCrystalStructure::BraggScattererInCrystalStructure()
    : BraggScatterer(), m_position(), m_cell(UnitCell(1, 1, 1, 90, 90, 90)) {}
 
void BraggScattererInCrystalStructure::setPosition(const Kernel::V3D &position) {
  m_position = getWrappedVector(position);
}
 
Kernel::V3D BraggScattererInCrystalStructure::getPosition() const { return m_position; }
 
void BraggScattererInCrystalStructure::setCell(const UnitCell &cell) { m_cell = cell; }
 
void BraggScattererInCrystalStructure::declareProperties() {
  declareProperty(std::make_unique<Kernel::PropertyWithValue<std::string>>("Position", "[0, 0, 0]"),
                  "Position of the scatterer");
 
  IValidator_sptr unitCellStringValidator = std::make_shared<UnitCellStringValidator>();
  declareProperty(std::make_unique<Kernel::PropertyWithValue<std::string>>("UnitCell", "1.0 1.0 1.0 90.0 90.0 90.0",
                                                                           unitCellStringValidator),
                  "Unit cell.");
  exposePropertyToComposite("UnitCell");
 
  declareScattererProperties();
}
 
V3D BraggScattererInCrystalStructure::getPositionFromString(const std::string &positionString) const {
  std::vector<std::string> numberParts = getTokenizedPositionString(positionString);
 
  mu::Parser parser;
 
  V3D position;
  for (size_t i = 0; i < numberParts.size(); ++i) {
    parser.SetExpr(numberParts[i]);
    position[i] = parser.Eval();
  }
 
  return position;
}
 
void BraggScattererInCrystalStructure::afterPropertySet(const std::string &propertyName) {
  if (propertyName == "Position") {
    std::string position = getProperty("Position");
 
    setPosition(getPositionFromString(position));
  } else if (propertyName == "UnitCell") {
    setCell(strToUnitCell(getProperty("UnitCell")));
  }
 
  afterScattererPropertySet(propertyName);
}
 
IValidator_sptr UnitCellStringValidator::clone() const { return std::make_shared<UnitCellStringValidator>(*this); }
 
std::string UnitCellStringValidator::checkValidity(const std::string &unitCellString) const {
  boost::regex unitCellRegex("((\\d+(\\.\\d+){0,1}\\s+){2}|(\\d+(\\.\\d+){0,1}"
                             "\\s+){5})(\\d+(\\.\\d+){0,1}\\s*)");
 
  if (!boost::regex_match(unitCellString, unitCellRegex)) {
    return "Unit cell string is invalid: " + unitCellString;
  }
 
  return "";
}
 
std::vector<std::string> getTokenizedPositionString(const std::string &position) {
  std::string positionStringClean = position;
  positionStringClean.erase(
      std::remove_if(positionStringClean.begin(), positionStringClean.end(), boost::is_any_of("[]")),
      positionStringClean.end());
 
  std::vector<std::string> numberParts;
  boost::split(numberParts, positionStringClean, boost::is_any_of(","));
 
  if (numberParts.size() != 3) {
    throw std::invalid_argument("Cannot parse '" + position + "' as a position.");
  }
 
  return numberParts;
}
 
} // namespace Mantid::Geometry