ExperimentInfo.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/ExperimentInfo.h"
#include "MantidAPI/InstrumentFileFinder.h"
#include "MantidAPI/Run.h"
#include "MantidAPI/Sample.h"
#include "MantidAPI/SpectrumInfo.h"
#include "MantidGeometry/IDTypes.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/Goniometer.h"
#include "MantidGeometry/Instrument/InstrumentMetadata.h"
#include "MantidGeometry/Instrument_fwd.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidGeometry/Objects/ShapeRotation.h"
#include "MantidKernel/WarningSuppressions.h"
#include "MantidPythonInterface/core/Converters/PySequenceToVector.h"
#include "MantidPythonInterface/core/Converters/ToPyList.h"
#include "MantidPythonInterface/core/GetPointer.h"
#include "MantidPythonInterface/core/Policies/RemoveConst.h"
#include <boost/python/class.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/python/list.hpp>
#include <boost/python/overloads.hpp>
#include <boost/python/register_ptr_to_python.hpp>
 
using Mantid::API::ExperimentInfo;
using Mantid::API::InstrumentFileFinder;
using Mantid::PythonInterface::Policies::RemoveConstSharedPtr;
using namespace Mantid::PythonInterface;
using namespace boost::python;
 
GET_POINTER_SPECIALIZATION(ExperimentInfo)
 
 
// As we can't have two converters in the global namespace we will
// keep the converter with ExperimentInfo despite the C++ impl moving to
// InstrumentFileFinder for backwards compatibility and as there is a single
// user
list getResourceFilenames(const std::string &prefix, const list &fileFormats, const list &directoryNames,
                          const std::string &date) {
  return Converters::ToPyList<std::string>()(
      InstrumentFileFinder::getResourceFilenames(prefix, Converters::PySequenceToVector<std::string>(fileFormats)(),
                                                 Converters::PySequenceToVector<std::string>(directoryNames)(), date));
}
 
Mantid::Geometry::Instrument_const_sptr getInstrumentDeprecated(const ExperimentInfo &self) {
  return self.getInstrument();
}
 
std::string getInstrumentFilenameWarn(const std::string &instName, const std::string &date = "") {
  if (PyErr_Warn(PyExc_DeprecationWarning, "ExperimentInfo.getInstrumentFilename() is deprecated.\n"
                                           "Use InstrumentFileFinder.getInstrumentFilename() instead.") < 0)
    throw boost::python::error_already_set();
  return InstrumentFileFinder::getInstrumentFilename(instName, date);
}
 
GNU_DIAG_OFF("unused-local-typedef")
// Ignore -Wconversion warnings coming from boost::python
// Seen with GCC 7.1.1 and Boost 1.63.0
GNU_DIAG_OFF("conversion")
// cppcheck-suppress unknownMacro
BOOST_PYTHON_FUNCTION_OVERLOADS(getInstrumentFilename_Overload, getInstrumentFilenameWarn, 1, 2)
GNU_DIAG_ON("conversion")
GNU_DIAG_ON("unused-local-typedef")
 
namespace {
void setSample(ExperimentInfo &expInfo, const Mantid::API::Sample &sample) { expInfo.mutableSample() = sample; }
void setRun(ExperimentInfo &expInfo, const Mantid::API::Run &run) { expInfo.mutableRun() = run; }
 
// Forward the InstrumentMetadata accessors so that the metadata object itself does not
// need to be handed out to Python.
Mantid::Types::Core::DateAndTime instrumentValidFromDate(const ExperimentInfo &expInfo) {
  return expInfo.instrumentMetadata().validFromDate();
}
Mantid::Types::Core::DateAndTime instrumentValidToDate(const ExperimentInfo &expInfo) {
  return expInfo.instrumentMetadata().validToDate();
}
const std::string &instrumentFilename(const ExperimentInfo &expInfo) { return expInfo.instrumentMetadata().filename(); }
const std::string &instrumentXmlText(const ExperimentInfo &expInfo) { return expInfo.instrumentMetadata().xmlText(); }
const std::string &instrumentDefaultView(const ExperimentInfo &expInfo) {
  return expInfo.instrumentMetadata().defaultView();
}
const std::string &instrumentDefaultAxis(const ExperimentInfo &expInfo) {
  return expInfo.instrumentMetadata().defaultAxis();
}
 
Mantid::Geometry::IObject_sptr getLabFrameSampleShape(const ExperimentInfo &self) {
  return Mantid::Geometry::getLabFrameShape(self.sample().getShape(), self.run().getGoniometer().getR());
}
} // namespace
 
void export_ExperimentInfo() {
  register_ptr_to_python<std::shared_ptr<ExperimentInfo>>();
 
  class_<ExperimentInfo, boost::noncopyable>("ExperimentInfo", no_init)
      .def("getInstrument", &getInstrumentDeprecated, return_value_policy<RemoveConstSharedPtr>(), args("self"),
           "Returns the :class:`~mantid.geometry.Instrument` for this run "
           "(deprecated, use the componentInfo/detectorInfo/spectrumInfo access layers).")
      // InstrumentFileFinder binds Kept for backwards compat.
      .def("getResourceFilenames", &getResourceFilenames,
           (arg("prefix"), arg("fileFormats"), arg("directoryNames"), arg("date")),
           "Compile a list of files in compliance with name pattern-matching,\n"
           "file format, and date-stamp constraints\n\n"
           "Ideally, the valid-from and valid-to of any valid file should\n"
           "encapsulate the argument date. If this is not possible, then\n"
           "the file with the most recent valid-from stamp is selected\n\n"
           "prefix:         the name of a valid file must begin with this "
           "pattern\n"
           "fileFormats:    list of valid file extensions\n"
           "directoryNames: list of directories to be searched\n"
           "date :          the 'valid-from' and 'valid-to 'dates of a valid\n"
           "file will encapsulate this date (e.g '1900-01-31 23:59:00')\n"
           "\nreturns : list of absolute paths for each valid file\n")
      .staticmethod("getResourceFilenames")
      .def("getInstrumentFilename", &InstrumentFileFinder::getInstrumentFilename,
           getInstrumentFilename_Overload("Returns IDF filename", (arg("instrument"), arg("date") = "")))
      .staticmethod("getInstrumentFilename")
      .def("sample", &ExperimentInfo::sample, return_value_policy<reference_existing_object>(), args("self"),
           "Return the :class:`~mantid.api.Sample` object. This cannot be "
           "modified, use mutableSample to modify.")
      .def("mutableSample", &ExperimentInfo::mutableSample, return_value_policy<reference_existing_object>(),
           args("self"), "Return a modifiable :class:`~mantid.api.Sample` object.")
      .def("getLabFrameSampleShape", &getLabFrameSampleShape, args("self"),
           "Return the sample shape as it sits in the lab frame, rotated by whatever part of this "
           "workspace's goniometer rotation the shape does not already carry.\n\n"
           "A shape may be stored in its own frame or already rotated into the lab frame - "
           ":ref:`algm-CopySample` bakes the goniometer in, while :ref:`algm-SetGoniometer` alone "
           "leaves the shape untouched - so rotating by the goniometer unconditionally would turn an "
           "already-rotated shape a second time. This applies only what is outstanding, and returns "
           "a new shape; the workspace's own sample is unchanged.")
      .def("run", &ExperimentInfo::run, return_value_policy<reference_existing_object>(), args("self"),
           "Return the :class:`~mantid.api.Run` object. This cannot be "
           "modified, use mutableRun to modify.")
      .def("mutableRun", &ExperimentInfo::mutableRun, return_value_policy<reference_existing_object>(), args("self"),
           "Return a modifiable :class:`~mantid.api.Run` object.")
      .def("getRunNumber", &ExperimentInfo::getRunNumber, args("self"), "Returns the run identifier for this run.")
      .def("getEFixed", (double (ExperimentInfo::*)(const Mantid::detid_t) const) & ExperimentInfo::getEFixed,
           args("self", "detId"))
      .def("setEFixed", &ExperimentInfo::setEFixed, args("self", "detId", "value"))
      .def("getEMode", &ExperimentInfo::getEMode, args("self"), "Returns the energy mode.")
      .def("detectorInfo", &ExperimentInfo::detectorInfo, return_value_policy<reference_existing_object>(),
           args("self"),
           "Return a const reference to the "
           ":class:`~mantid.geometry.DetectorInfo` "
           "object.")
      .def("spectrumInfo", &ExperimentInfo::spectrumInfo, return_value_policy<reference_existing_object>(),
           args("self"),
           "Return a const reference to the :class:`~mantid.api.SpectrumInfo` "
           "object.")
      .def("componentInfo", &ExperimentInfo::componentInfo, return_value_policy<reference_existing_object>(),
           args("self"),
           "Return a const reference to the "
           ":class:`~mantid.geometry.ComponentInfo` "
           "object.")
      .def("baseComponentInfo", &ExperimentInfo::baseComponentInfo, return_value_policy<reference_existing_object>(),
           args("self"),
           "Return a const reference to a :class:`~mantid.geometry.ComponentInfo` "
           "describing the base instrument: the geometry as loaded from the instrument "
           "definition, before any moves, rotations or other parameters were applied.")
      .def("instrumentValidFromDate", &instrumentValidFromDate, args("self"),
           "Return the valid-from :class:`~mantid.kernel.DateAndTime` of the instrument.")
      .def("instrumentValidToDate", &instrumentValidToDate, args("self"),
           "Return the valid-to :class:`~mantid.kernel.DateAndTime` of the instrument.")
      .def("instrumentFilename", &instrumentFilename, args("self"), return_value_policy<copy_const_reference>(),
           "Return the name of the file that the original IDF was from.")
      .def("instrumentXmlText", &instrumentXmlText, args("self"), return_value_policy<copy_const_reference>(),
           "Return the instrument XML.")
      .def("instrumentDefaultView", &instrumentDefaultView, args("self"), return_value_policy<copy_const_reference>(),
           "Return the name of the preferred view in instrument view.")
      .def("instrumentDefaultAxis", &instrumentDefaultAxis, args("self"), return_value_policy<copy_const_reference>(),
           "Return the axis the instrument view is wrapped around by default.")
      .def("getInstrumentName", &ExperimentInfo::getInstrumentName, args("self"),
           "Return the name of the instrument for this experiment.")
      .def("setSample", setSample, args("self", "sample"))
      .def("setRun", setRun, args("self", "run"))
      .def("populateInstrumentParameters", &ExperimentInfo::populateInstrumentParameters, (arg("self")),
           "Update parameters in the instrument-parameter map. Logs must be loaded before calling this method");
}