CrystalStructure.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/CrystalStructure.h"
#include <algorithm>
#include <stdexcept>
 
#include "MantidGeometry/Crystal/BasicHKLFilters.h"
#include "MantidGeometry/Crystal/HKLGenerator.h"
#include "MantidGeometry/Crystal/IsotropicAtomBraggScatterer.h"
#include "MantidGeometry/Crystal/PointGroupFactory.h"
#include "MantidGeometry/Crystal/SpaceGroupFactory.h"
#include "MantidGeometry/Crystal/StructureFactorCalculatorSummation.h"
 
#include <iomanip>
 
namespace Mantid::Geometry {
 
using namespace Mantid::Kernel;
 
CrystalStructure::CrystalStructure(const UnitCell &unitCell, const SpaceGroup_const_sptr &spaceGroup,
                                   const CompositeBraggScatterer_sptr &scatterers) {
  initializeScatterers();
 
  addScatterers(scatterers);
  setCell(unitCell);
  setSpaceGroup(spaceGroup);
}
 
CrystalStructure::CrystalStructure(const std::string &unitCellString, const std::string &spaceGroupString,
                                   const std::string &scattererString) {
  initializeScatterers();
 
  addScatterers(CompositeBraggScatterer::create(IsotropicAtomBraggScattererParser(scattererString)()));
  setCell(strToUnitCell(unitCellString));
  setSpaceGroup(SpaceGroupFactory::Instance().createSpaceGroup(spaceGroupString));
}
 
UnitCell CrystalStructure::cell() const { return m_cell; }
 
void CrystalStructure::setCell(const UnitCell &cell) {
  m_cell = cell;
 
  assignUnitCellToScatterers(m_cell);
}
 
SpaceGroup_const_sptr CrystalStructure::spaceGroup() const { return m_spaceGroup; }
 
void CrystalStructure::setSpaceGroup(const SpaceGroup_const_sptr &spaceGroup) {
  m_spaceGroup = spaceGroup;
 
  setReflectionConditionFromSpaceGroup(m_spaceGroup);
}
 
CompositeBraggScatterer_sptr CrystalStructure::getScatterers() const {
  BraggScatterer_sptr clone = m_scatterers->clone();
 
  return std::dynamic_pointer_cast<CompositeBraggScatterer>(clone);
}
 
void CrystalStructure::setScatterers(const CompositeBraggScatterer_sptr &scatterers) {
  m_scatterers->removeAllScatterers();
 
  addScatterers(scatterers);
}
 
void CrystalStructure::addScatterers(const CompositeBraggScatterer_sptr &scatterers) {
  size_t count = scatterers->nScatterers();
 
  for (size_t i = 0; i < count; ++i) {
    m_scatterers->addScatterer(scatterers->getScatterer(i));
  }
 
  assignUnitCellToScatterers(m_cell);
}
 
void CrystalStructure::setReflectionConditionFromSpaceGroup(const SpaceGroup_const_sptr &spaceGroup) {
  m_centering.reset();
 
  // First letter is centering
  std::string centering = spaceGroup->hmSymbol().substr(0, 1);
 
  if (centering == "R") {
    centering = "Robv";
  }
 
  const auto &reflectionConditions = getAllReflectionConditions();
  for (auto &reflectionCondition : reflectionConditions) {
    if (reflectionCondition->getSymbol() == centering) {
      m_centering = reflectionCondition;
      break;
    }
  }
}
 
void CrystalStructure::assignUnitCellToScatterers(const UnitCell &unitCell) {
  if (!m_scatterers) {
    throw std::runtime_error("Scatterer collection is a null pointer. Aborting.");
  }
 
  if (m_scatterers->existsProperty("UnitCell")) {
    m_scatterers->setProperty("UnitCell", unitCellToStr(unitCell));
  }
}
 
void CrystalStructure::initializeScatterers() {
  if (!m_scatterers) {
    m_scatterers = CompositeBraggScatterer::create();
  }
}
 
} // namespace Mantid::Geometry