Sample.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 "MantidAPI/Sample.h"
#include "MantidGeometry/Crystal/CrystalStructure.h"
#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidGeometry/Instrument/Container.h"
#include "MantidGeometry/Instrument/SampleEnvironment.h"
#include "MantidGeometry/Objects/CSGObject.h"
#include "MantidGeometry/Objects/MeshObject.h"
#include "MantidGeometry/Objects/ShapeFactory.h"
#include "MantidKernel/Material.h"
#include "MantidKernel/Strings.h"
#include "MantidNexus/NexusException.h"
#include <utility>
 
namespace Mantid::API {
using namespace Mantid::Kernel;
using Geometry::Container;
using Geometry::IObject;
using Geometry::IObject_const_sptr;
using Geometry::IObject_sptr;
using Geometry::OrientedLattice;
using Geometry::SampleEnvironment;
using Geometry::ShapeFactory;
 
namespace {
void saveShapeToFile(Nexus::File *file, const IObject_const_sptr &shape, const std::string &tag = "") {
  std::string shapeXML;
  if (auto csgObject = std::dynamic_pointer_cast<const Mantid::Geometry::CSGObject>(shape)) {
    shapeXML = csgObject->getShapeXML();
  }
  file->putAttr(tag + "shape_xml", shapeXML);
  if (auto meshObject = std::dynamic_pointer_cast<const Mantid::Geometry::MeshObject>(shape)) {
    meshObject->saveNexus(file, tag + "shape_mesh");
  }
  file->putAttr(tag + "shape_id", shape->id());
}
 
IObject_sptr loadShapeFromFile(Nexus::File *file, const std::string &tag = "") {
  Kernel::Material material;
  IObject_sptr shape;
  material.loadNexus(file, tag + "material");
  // Shape (from XML)
  std::string shape_xml;
  file->getAttr(tag + "shape_xml", shape_xml);
  shape_xml = Strings::strip(shape_xml);
  if (!shape_xml.empty()) {
    ShapeFactory shapeMaker;
    shape = shapeMaker.createShape(std::move(shape_xml), false /*Don't wrap with <type> tag*/);
  } else if (file->hasGroup(tag + "shape_mesh", "NXoff_geometry")) {
    shape = Mantid::Geometry::MeshObject::loadNexus(file, tag + "shape_mesh", material);
  } else {
    // if neither shape xml or shape mesh can be found this should return nullptr to be checked
    return nullptr;
  }
  shape->setMaterial(material);
  // Restore the shape id if it was saved (absent in older files)
  if (file->hasAttr(tag + "shape_id")) {
    std::string id;
    file->getAttr(tag + "shape_id", id);
    shape->setID(id);
  }
  return shape;
}
} // namespace
 
Sample::Sample()
    : m_name(), m_shape(ShapeFactory().createShape("")), m_environment(), m_lattice(nullptr), m_crystalStructure(),
      m_samples(), m_geom_id(0), m_thick(0.0), m_height(0.0), m_width(0.0) {}
 
Sample::Sample(const Sample &copy)
    : m_name(copy.m_name), m_shape(copy.m_shape), m_environment(copy.m_environment), m_lattice(nullptr),
      m_crystalStructure(), m_samples(copy.m_samples), m_geom_id(copy.m_geom_id), m_thick(copy.m_thick),
      m_height(copy.m_height), m_width(copy.m_width) {
  if (copy.m_lattice)
    m_lattice = std::make_unique<OrientedLattice>(copy.getOrientedLattice());
 
  if (copy.hasCrystalStructure()) {
    m_crystalStructure = std::make_unique<Geometry::CrystalStructure>(copy.getCrystalStructure());
  }
}
 
Sample::~Sample() = default;
 
Sample &Sample::operator=(const Sample &rhs) {
  if (this == &rhs)
    return *this;
  m_name = rhs.m_name;
  m_shape = rhs.m_shape;
  m_environment = rhs.m_environment;
  m_geom_id = rhs.m_geom_id;
  m_samples = std::vector<std::shared_ptr<Sample>>(rhs.m_samples);
  m_thick = rhs.m_thick;
  m_height = rhs.m_height;
  m_width = rhs.m_width;
  if (rhs.m_lattice)
    m_lattice = std::make_unique<OrientedLattice>(rhs.getOrientedLattice());
  else
    m_lattice.reset(nullptr);
 
  m_crystalStructure.reset();
  if (rhs.hasCrystalStructure()) {
    m_crystalStructure.reset(new Geometry::CrystalStructure(rhs.getCrystalStructure()));
  }
 
  return *this;
}
 
const std::string &Sample::getName() const { return m_name; }
 
void Sample::setName(const std::string &name) { m_name = name; }
 
bool Sample::hasShape() const { return (m_shape != nullptr); }
 
const IObject &Sample::getShape() const { return *m_shape; }
 
const IObject_sptr Sample::getShapePtr() const { return m_shape; }
 
void Sample::setShape(const IObject_sptr &shape) {
  if (!shape) {
    m_shape = ShapeFactory().createShape("");
  } else if (shape != m_shape) {
    m_shape = shape; // share ownership safely
  }
}
 
const Material &Sample::getMaterial() const { return m_shape->material(); }
 
bool Sample::hasEnvironment() const { return (m_environment != nullptr); }
 
const SampleEnvironment &Sample::getEnvironment() const {
  if (!m_environment) {
    throw std::runtime_error("Sample::getEnvironment - No sample enviroment has been defined.");
  }
  return *m_environment;
}
 
void Sample::setEnvironment(std::shared_ptr<SampleEnvironment> env) { m_environment = std::move(env); }
 
const OrientedLattice &Sample::getOrientedLattice() const {
  if (!m_lattice) {
    throw std::runtime_error("Sample::getOrientedLattice - No OrientedLattice has been defined.");
  }
  return *m_lattice;
}
 
OrientedLattice &Sample::getOrientedLattice() {
  if (!m_lattice) {
    throw std::runtime_error("Sample::getOrientedLattice - No OrientedLattice has been defined.");
  }
  return *m_lattice;
}
 
void Sample::setOrientedLattice(std::unique_ptr<Geometry::OrientedLattice> lattice) { m_lattice = std::move(lattice); }
 
bool Sample::hasOrientedLattice() const { return (m_lattice != nullptr); }
 
const Geometry::CrystalStructure &Sample::getCrystalStructure() const {
  if (!hasCrystalStructure()) {
    throw std::runtime_error("Sample::getCrystalStructure - No CrystalStructure has been defined.");
  }
 
  return *m_crystalStructure;
}
 
void Sample::setCrystalStructure(const Geometry::CrystalStructure &newCrystalStructure) {
  m_crystalStructure.reset(new Geometry::CrystalStructure(newCrystalStructure));
}
 
bool Sample::hasCrystalStructure() const {
  // Conversion to bool seems to be a problem in VS2012, so this is a bit more
  // verbose than it should be.
  return static_cast<bool>(m_crystalStructure);
}
 
void Sample::clearCrystalStructure() { m_crystalStructure.reset(); }
 
void Sample::setGeometryFlag(int geom_id) { m_geom_id = geom_id; }
 
int Sample::getGeometryFlag() const { return m_geom_id; }
 
void Sample::setThickness(double thick) { m_thick = thick; }
 
double Sample::getThickness() const { return m_thick; }
 
void Sample::setHeight(double height) { m_height = height; }
 
double Sample::getHeight() const { return m_height; }
 
void Sample::setWidth(double width) { m_width = width; }
 
double Sample::getWidth() const { return m_width; }
 
Sample &Sample::operator[](const int index) {
  if (index == 0) {
    return *this;
  } else if ((static_cast<std::size_t>(index) > m_samples.size()) || (index < 0)) {
    throw std::out_of_range("The index value provided was out of range");
  } else {
    return *m_samples[index - 1];
  }
}
 
std::size_t Sample::size() const { return m_samples.size() + 1; }
 
void Sample::addSample(const std::shared_ptr<Sample> &childSample) { m_samples.emplace_back(childSample); }
 
//--------------------------------------------------------------------------------------------
void Sample::saveNexus(Nexus::File *file, const std::string &group) const {
  file->makeGroup(group, "NXsample", true);
  file->putAttr("name", m_name);
  if (m_name.empty()) {
    file->putAttr("name_empty", 1);
  }
  file->putAttr("version", 1);
  saveShapeToFile(file, m_shape);
  m_shape->material().saveNexus(file, "material");
 
  // Write out the other (indexes 1+) samples
  file->writeData("num_other_samples", int(m_samples.size()));
  for (size_t i = 0; i < m_samples.size(); i++)
    m_samples[i]->saveNexus(file, "sample" + Strings::toString(i + 1));
 
  if (m_environment) {
    file->putAttr("env_name", m_environment->name());
    auto const nElem = m_environment->nelements();
    file->writeData("num_env_comp", int(nElem));
    for (size_t i = 0; i < nElem; ++i) {
      const std::string tag = "env_" + Strings::toString(i) + "_";
      // Component 0 is the Container wrapper; save its inner shape so it can be
      // re-wrapped on load. Other components are stored as plain shapes.
      IObject_const_sptr comp =
          (i == 0) ? m_environment->getContainer().getShapePtr() : m_environment->getComponentPtr(i);
      saveShapeToFile(file, comp, tag);
      comp->material().saveNexus(file, tag + "material");
    }
  }
 
  // OrientedLattice
  if (hasOrientedLattice()) {
    file->writeData("num_oriented_lattice", 1);
    m_lattice->saveNexus(file, "oriented_lattice");
  } else
    file->writeData("num_oriented_lattice", 0);
 
  // Legacy info from RAW file (I think)
  file->writeData("geom_id", m_geom_id);
  file->writeData("geom_thickness", m_thick);
  file->writeData("geom_height", m_height);
  file->writeData("geom_width", m_width);
 
  file->closeGroup();
}
 
//--------------------------------------------------------------------------------------------
int Sample::loadNexus(Nexus::File *file, const std::string &group) {
  file->openGroup(group, "NXsample");
 
  // Version 0 = saveNexusProcessed before Sep 8, 2011
  int version = 0;
  if (file->hasAttr("version")) {
    file->getAttr("version", version);
  } else {
    version = 0;
  }
 
  if (version == 0) {
    // Sample NAME field may/may not be present
    if (file->hasData("name")) {
      file->readData("name", m_name);
    } else {
      m_name = "";
    }
  }
 
  if (version > 0) {
    // Name is an attribute
    file->getAttr("name", m_name);
    if (file->hasAttr("name_empty")) {
      int isEmpty;
      file->getAttr("name_empty", isEmpty);
      if (isEmpty) {
        m_name.clear();
      }
    }
 
    // Only replace the default shape if the file actually defines one; otherwise
    // keep the valid (empty) shape so callers never observe a null m_shape.
    if (IObject_sptr loadedShape = loadShapeFromFile(file))
      m_shape = std::move(loadedShape);
 
    // sample environment
    if (file->hasAttr("env_name")) {
      std::string env_name;
      file->getAttr("env_name", env_name);
 
      int nElem;
      file->readData("num_env_comp", nElem);
      // component 0 is the container; without a valid shape there is no environment to build
      if (IObject_sptr container_shape = (nElem > 0) ? loadShapeFromFile(file, "env_0_") : nullptr) {
        auto env = std::make_shared<SampleEnvironment>(env_name, std::make_shared<Container>(container_shape));
        for (int i = 1; i < nElem; ++i) {
          const std::string tag = "env_" + Strings::toString(i) + "_";
          if (IObject_sptr comp = loadShapeFromFile(file, tag))
            env->add(comp);
        }
        m_environment = std::move(env);
      }
    }
 
    // Load other samples
    int num_other_samples;
    file->readData("num_other_samples", num_other_samples);
    for (int i = 0; i < num_other_samples; i++) {
      auto extra = std::make_shared<Sample>();
      extra->loadNexus(file, "sample" + Strings::toString(i + 1));
      this->addSample(extra);
    }
 
    // OrientedLattice
    int num_oriented_lattice;
    file->readData("num_oriented_lattice", num_oriented_lattice);
    if (num_oriented_lattice > 0) {
      m_lattice = std::make_unique<OrientedLattice>();
      m_lattice->loadNexus(file, "oriented_lattice");
    }
  }
 
  try {
    // Legacy info from RAW file (I think)
    file->readData("geom_id", m_geom_id);
    file->readData("geom_thickness", m_thick);
    file->readData("geom_height", m_height);
    file->readData("geom_width", m_width);
  } catch (...) { /* Very old files don't have them. Ignore. */
  }
 
  file->closeGroup();
 
  return version;
}
 
void Sample::clearOrientedLattice() {
  if (m_lattice) {
    m_lattice.reset(nullptr);
  }
}
 
bool Sample::operator==(const Sample &other) const {
  if (m_samples.size() != other.m_samples.size())
    return false;
  for (size_t i = 0; i < m_samples.size(); ++i) {
    if (*m_samples[i] != *other.m_samples[i])
      return false;
  }
  auto compare = [](const auto &a, const auto &b, auto call_on) {
    // both null or both not null
    if (bool(a) ^ bool(b))
      return false;
    if (a)
      return call_on(a) == call_on(b);
    else
      return true;
  };
  return *m_lattice == *other.m_lattice && this->m_name == other.m_name && this->m_height == other.m_height &&
         this->m_width == other.m_width && this->m_thick == other.m_thick && m_geom_id == other.m_geom_id &&
         compare(m_environment, other.m_environment, [](const auto &x) { return x->name(); }) &&
         compare(m_shape, other.m_shape, [](const auto &x) { return x->shape(); }) &&
         compare(m_crystalStructure, other.m_crystalStructure, [](const auto &x) { return *(x->spaceGroup()); });
}
bool Sample::operator!=(const Sample &other) const { return !this->operator==(other); }
} // namespace Mantid::API