IsotropicAtomBraggScatterer.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/IsotropicAtomBraggScatterer.h"
#include "MantidGeometry/Crystal/BraggScattererFactory.h"
#include "MantidJson/Json.h"
#include "MantidKernel/Atom.h"
#include "MantidKernel/BoundedValidator.h"
#include "MantidKernel/MandatoryValidator.h"
#include "MantidKernel/StringTokenizer.h"
 
#include <algorithm>
#include <boost/algorithm/string.hpp>
#include <json/json.h>
#include <stdexcept>
#include <utility>
 
namespace Mantid::Geometry {
 
using namespace Kernel;
 
IsotropicAtomBraggScatterer::IsotropicAtomBraggScatterer() : BraggScattererInCrystalStructure(), m_atom(), m_label() {}
 
BraggScatterer_sptr IsotropicAtomBraggScatterer::clone() const {
  IsotropicAtomBraggScatterer_sptr clone = std::make_shared<IsotropicAtomBraggScatterer>();
  clone->initialize();
  clone->setProperties(this->asString(false));
 
  return clone;
}
 
void IsotropicAtomBraggScatterer::setElement(const std::string &element) {
  PhysicalConstants::Atom atom = PhysicalConstants::getAtom(element);
 
  m_atom = atom.neutron;
  m_label = atom.symbol;
}
 
std::string IsotropicAtomBraggScatterer::getElement() const { return m_label; }
 
PhysicalConstants::NeutronAtom IsotropicAtomBraggScatterer::getNeutronAtom() const { return m_atom; }
 
double IsotropicAtomBraggScatterer::getOccupancy() const { return getProperty("Occupancy"); }
 
double IsotropicAtomBraggScatterer::getU() const { return getProperty("U"); }
 
StructureFactor IsotropicAtomBraggScatterer::calculateStructureFactor(const V3D &hkl) const {
  double amplitude = getOccupancy() * getDebyeWallerFactor(hkl) * getScatteringLength();
 
  double phase = 2.0 * M_PI * m_position.scalar_prod(hkl);
 
  return amplitude * StructureFactor(cos(phase), sin(phase));
}
 
void IsotropicAtomBraggScatterer::declareScattererProperties() {
  // Default behavior requires this.
  setElement("H");
 
  std::shared_ptr<BoundedValidator<double>> uValidator = std::make_shared<BoundedValidator<double>>();
  uValidator->setLower(0.0);
 
  declareProperty(std::make_unique<PropertyWithValue<double>>("U", 0.0, uValidator),
                  "Isotropic atomic displacement in Angstrom^2");
 
  IValidator_sptr occValidator = std::make_shared<BoundedValidator<double>>(0.0, 1.0);
  declareProperty(std::make_unique<PropertyWithValue<double>>("Occupancy", 1.0, occValidator),
                  "Site occupancy, values on interval [0,1].");
 
  declareProperty(std::make_unique<PropertyWithValue<std::string>>(
      "Element", "H", std::make_shared<MandatoryValidator<std::string>>()));
}
 
void IsotropicAtomBraggScatterer::afterScattererPropertySet(const std::string &propertyName) {
  if (propertyName == "Element") {
    setElement(getPropertyValue(propertyName));
  }
}
 
double IsotropicAtomBraggScatterer::getDebyeWallerFactor(const V3D &hkl) const {
  V3D dstar = getCell().getB() * hkl;
 
  return exp(-2.0 * M_PI * M_PI * getU() * dstar.norm2());
}
 
double IsotropicAtomBraggScatterer::getScatteringLength() const { return m_atom.coh_scatt_length_real; }
 
DECLARE_BRAGGSCATTERER(IsotropicAtomBraggScatterer)
 
 
IsotropicAtomBraggScattererParser::IsotropicAtomBraggScattererParser(std::string scattererString)
    : m_scattererString(std::move(scattererString)) {}
 
std::vector<BraggScatterer_sptr> IsotropicAtomBraggScattererParser::operator()() const {
  Mantid::Kernel::StringTokenizer tokens(m_scattererString, ";", Mantid::Kernel::StringTokenizer::TOK_TRIM);
  std::vector<BraggScatterer_sptr> scatterers;
  scatterers.reserve(tokens.size());
  std::transform(tokens.cbegin(), tokens.cend(), std::back_inserter(scatterers),
                 [this](const auto &token) { return getScatterer(token); });
  return scatterers;
}
 
BraggScatterer_sptr IsotropicAtomBraggScattererParser::getScatterer(const std::string &singleScatterer) const {
  std::vector<std::string> tokens;
  boost::split(tokens, singleScatterer, boost::is_any_of(" "));
 
  if (tokens.size() < 4 || tokens.size() > 6) {
    throw std::invalid_argument("Could not parse scatterer string: " + singleScatterer);
  }
 
  std::vector<std::string> cleanScattererTokens = getCleanScattererTokens(tokens);
  std::vector<std::string> properties = {"Element", "Position", "Occupancy", "U"};
 
  ::Json::Value root;
  for (size_t i = 0; i < cleanScattererTokens.size(); ++i) {
    root[properties[i]] = cleanScattererTokens[i];
  }
 
  std::string initString = Mantid::JsonHelpers::jsonToString(root);
 
  return BraggScattererFactory::Instance().createScatterer("IsotropicAtomBraggScatterer", initString);
}
 
std::vector<std::string>
IsotropicAtomBraggScattererParser::getCleanScattererTokens(const std::vector<std::string> &tokens) const {
  std::vector<std::string> cleanTokens;
 
  // Element
  cleanTokens.emplace_back(tokens[0]);
 
  // X, Y, Z
  cleanTokens.emplace_back("[" + tokens[1] + "," + tokens[2] + "," + tokens[3] + "]");
 
  for (size_t i = 4; i < tokens.size(); ++i) {
    cleanTokens.emplace_back(tokens[i]);
  }
 
  return cleanTokens;
}
 
std::string getIsotropicAtomBraggScattererString(const BraggScatterer_sptr &scatterer) {
  IsotropicAtomBraggScatterer_sptr isotropicAtom = std::dynamic_pointer_cast<IsotropicAtomBraggScatterer>(scatterer);
 
  if (!isotropicAtom) {
    throw std::invalid_argument("Printing function can only process IsotropicAtomBraggScatterer.");
  }
 
  std::string rawPositionString = isotropicAtom->getProperty("Position");
  std::vector<std::string> positionComponents = getTokenizedPositionString(rawPositionString);
 
  std::stringstream outStream;
  outStream << isotropicAtom->getElement() << " " << positionComponents[0] << " " << positionComponents[1] << " "
            << positionComponents[2] << " " << isotropicAtom->getOccupancy() << " " << isotropicAtom->getU();
 
  return outStream.str();
}
 
} // namespace Mantid::Geometry