CompositeBraggScatterer.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/CompositeBraggScatterer.h"
#include "MantidGeometry/Crystal/BraggScattererFactory.h"
#include <stdexcept>
 
namespace Mantid::Geometry {
 
using namespace Kernel;
 
CompositeBraggScatterer::CompositeBraggScatterer() : BraggScatterer(), m_scatterers() {}
 
CompositeBraggScatterer_sptr CompositeBraggScatterer::create() {
  CompositeBraggScatterer_sptr compositeScatterer = std::make_shared<CompositeBraggScatterer>();
  compositeScatterer->initialize();
 
  return compositeScatterer;
}
 
CompositeBraggScatterer_sptr CompositeBraggScatterer::create(const std::vector<BraggScatterer_sptr> &scatterers) {
  CompositeBraggScatterer_sptr collection = CompositeBraggScatterer::create();
 
  collection->setScatterers(scatterers);
 
  return collection;
}
 
BraggScatterer_sptr CompositeBraggScatterer::clone() const {
  CompositeBraggScatterer_sptr clone = std::make_shared<CompositeBraggScatterer>();
  clone->initialize();
 
  clone->setScatterers(m_scatterers);
 
  clone->setProperties(this->asString(false));
 
  return clone;
}
 
void CompositeBraggScatterer::addScatterer(const BraggScatterer_sptr &scatterer) {
  addScattererImplementation(scatterer);
  redeclareProperties();
}
 
void CompositeBraggScatterer::addScatterers(const std::vector<BraggScatterer_sptr> &scatterers) {
  for (const auto &scatterer : scatterers) {
    addScattererImplementation(scatterer);
  }
  redeclareProperties();
}
 
void CompositeBraggScatterer::setScatterers(const std::vector<BraggScatterer_sptr> &scatterers) {
  removeAllScatterers();
  addScatterers(scatterers);
}
 
size_t CompositeBraggScatterer::nScatterers() const { return m_scatterers.size(); }
 
BraggScatterer_sptr CompositeBraggScatterer::getScatterer(size_t i) const {
  if (i >= nScatterers()) {
    throw std::out_of_range("Index is out of range.");
  }
 
  return m_scatterers[i];
}
 
const std::vector<BraggScatterer_sptr> &CompositeBraggScatterer::getScatterers() const { return m_scatterers; }
 
void CompositeBraggScatterer::removeScatterer(size_t i) {
  removeScattererImplementation(i);
 
  redeclareProperties();
}
 
void CompositeBraggScatterer::removeScattererImplementation(size_t i) {
  if (i >= nScatterers()) {
    throw std::out_of_range("Index is out of range.");
  }
 
  m_scatterers.erase(m_scatterers.begin() + i);
}
 
void CompositeBraggScatterer::removeAllScatterers() {
  while (nScatterers() > 0) {
    removeScattererImplementation(0);
  }
 
  redeclareProperties();
}
 
StructureFactor CompositeBraggScatterer::calculateStructureFactor(const Kernel::V3D &hkl) const {
  return std::accumulate(
      m_scatterers.cbegin(), m_scatterers.cend(), StructureFactor(0., 0.),
      [&hkl](const auto &sum, const auto &scatterer) { return sum + scatterer->calculateStructureFactor(hkl); });
  ;
}
 
void CompositeBraggScatterer::afterPropertySet(const std::string &propertyName) { propagateProperty(propertyName); }
 
void CompositeBraggScatterer::propagateProperty(const std::string &propertyName) {
  std::string propertyValue = getPropertyValue(propertyName);
 
  for (auto &scatterer : m_scatterers) {
    propagatePropertyToScatterer(scatterer, propertyName, propertyValue);
  }
}
 
void CompositeBraggScatterer::propagatePropertyToScatterer(BraggScatterer_sptr &scatterer,
                                                           const std::string &propertyName,
                                                           const std::string &propertyValue) {
  try {
    scatterer->setPropertyValue(propertyName, propertyValue);
  } catch (const Kernel::Exception::NotFoundError &) {
    // do nothing.
  }
}
 
void CompositeBraggScatterer::addScattererImplementation(const BraggScatterer_sptr &scatterer) {
  if (!scatterer) {
    throw std::invalid_argument("Cannot process null-scatterer.");
  }
 
  BraggScatterer_sptr localScatterer = scatterer->clone();
  m_scatterers.emplace_back(localScatterer);
}
 
void CompositeBraggScatterer::redeclareProperties() {
  std::map<std::string, size_t> propertyUseCount = getPropertyCountMap();
 
  for (auto &scatterer : m_scatterers) {
    // Check if any of the declared properties is in this scatterer (and set
    // value if that's the case)
    for (auto &prop : propertyUseCount) {
      if (scatterer->existsProperty(prop.first)) {
        prop.second += 1;
 
        propagatePropertyToScatterer(scatterer, prop.first, getPropertyValue(prop.first));
      }
    }
 
    // Use the properties of this scatterer which have been marked as exposed to
    // composite
    std::vector<Property *> properties = scatterer->getPropertiesInGroup(getPropagatingGroupName());
    for (auto &property : properties) {
      const std::string &propertyName = property->name();
      if (!existsProperty(propertyName)) {
        declareProperty(std::unique_ptr<Property>(property->clone()));
      }
    }
  }
 
  // Remove unused properties
  for (auto const &property : propertyUseCount) {
    if (property.second == 0) {
      removeProperty(property.first);
    }
  }
}
 
std::map<std::string, size_t> CompositeBraggScatterer::getPropertyCountMap() const {
  std::map<std::string, size_t> propertyUseCount;
 
  std::vector<Property *> compositeProperties = getProperties();
  for (auto &compositeProperty : compositeProperties) {
    propertyUseCount.emplace(compositeProperty->name(), 0);
  }
  return propertyUseCount;
}
 
DECLARE_BRAGGSCATTERER(CompositeBraggScatterer)
 
} // namespace Mantid::Geometry