WorkspaceValidators.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/CommonBinsValidator.h"
#include "MantidAPI/HistogramValidator.h"
#include "MantidAPI/IMDWorkspace.h"
#include "MantidAPI/MDFrameValidator.h"
#include "MantidAPI/NumericAxisValidator.h"
#include "MantidAPI/PolSANSWorkspaceValidator.h"
#include "MantidAPI/RawCountValidator.h"
#include "MantidAPI/SpectraAxisValidator.h"
#include "MantidAPI/WorkspaceGroup.h"
#include "MantidAPI/WorkspaceUnitValidator.h"
#include "MantidPythonInterface/core/TypedValidatorExporter.h"
#include <boost/python/class.hpp>
#include <boost/python/list.hpp>
#include <boost/python/make_constructor.hpp>
 
using Mantid::API::IMDWorkspace_sptr;
using Mantid::API::WorkspaceGroup_sptr;
using Mantid::Kernel::TypedValidator;
using Mantid::PythonInterface::TypedValidatorExporter;
using namespace boost::python;
 
std::shared_ptr<Mantid::API::PolSANSWorkspaceValidator>
polSANSValidatorConstructor(bool expectHistogramData = true, bool allowMultiPeriodData = false,
                            list allowedNumberOfPeriods = list()) {
  // setup default value
  if (len(allowedNumberOfPeriods) == 0) {
    allowedNumberOfPeriods.append(4);
  }
 
  std::unordered_set<int> allowedPeriodsSet;
  for (int i = 0; i < len(allowedNumberOfPeriods); i++) {
    int periodN = extract<int>(allowedNumberOfPeriods[i]);
    allowedPeriodsSet.insert(periodN);
  }
 
  return std::make_shared<Mantid::API::PolSANSWorkspaceValidator>(expectHistogramData, allowMultiPeriodData,
                                                                  allowedPeriodsSet);
}
 
void export_MatrixWorkspaceValidator() {
  using Mantid::API::MatrixWorkspace_sptr;
  using Mantid::API::MatrixWorkspaceValidator;
  TypedValidatorExporter<MatrixWorkspace_sptr>::define("MatrixWorkspaceValidator");
  TypedValidatorExporter<IMDWorkspace_sptr>::define("IMDWorkspaceValidator");
  TypedValidatorExporter<WorkspaceGroup_sptr>::define("WorkspaceGroupValidator");
 
  class_<MatrixWorkspaceValidator, bases<TypedValidator<MatrixWorkspace_sptr>>, boost::noncopyable>(
      "MatrixWorkspaceValidator", no_init);
 
  class_<TypedValidator<IMDWorkspace_sptr>, boost::noncopyable>("IMDWorkspaceValidator", no_init);
  class_<TypedValidator<WorkspaceGroup_sptr>, boost::noncopyable>("WorkspaceGroupValidator", no_init);
}
#define EXPORT_WKSP_VALIDATOR_NO_ARG(ValidatorType, DocString)                                                         \
  class_<ValidatorType, bases<MatrixWorkspaceValidator>, boost::noncopyable>(#ValidatorType, init<>(DocString));
#define EXPORT_WKSP_VALIDATOR_ARG(ValidatorType, ArgType, ArgName, DocString)                                          \
  class_<ValidatorType, bases<MatrixWorkspaceValidator>, boost::noncopyable>(#ValidatorType,                           \
                                                                             init<ArgType>(arg(ArgName), DocString));
#define EXPORT_WKSP_VALIDATOR_DEFAULT_ARG(ValidatorType, ArgType, ArgName, DefaultValue, DocString)                    \
  class_<ValidatorType, bases<MatrixWorkspaceValidator>, boost::noncopyable>(                                          \
      #ValidatorType, init<ArgType>(arg(ArgName) = DefaultValue, DocString));
 
void export_WorkspaceValidators() {
  using namespace Mantid::API;
 
  EXPORT_WKSP_VALIDATOR_ARG(WorkspaceUnitValidator, std::string, "unit",
                            "Checks the workspace has the given unit along the X-axis");
  EXPORT_WKSP_VALIDATOR_DEFAULT_ARG(HistogramValidator, bool, "mustBeHistogram", true,
                                    "If mustBeHistogram=True then the "
                                    "workspace must be a histogram "
                                    "otherwise it must be point data.");
  EXPORT_WKSP_VALIDATOR_DEFAULT_ARG(RawCountValidator, bool, "mustNotBeDistribution", true,
                                    "If mustNotBeDistribution=True then the workspace must not have been "
                                    "divided by the bin-width");
  EXPORT_WKSP_VALIDATOR_NO_ARG(CommonBinsValidator, "A tentative check that the bins are common across the workspace");
  EXPORT_WKSP_VALIDATOR_DEFAULT_ARG(SpectraAxisValidator, int, "axisNumber", 1,
                                    "Checks whether the axis specified by axisNumber is a SpectraAxis");
  EXPORT_WKSP_VALIDATOR_DEFAULT_ARG(NumericAxisValidator, int, "axisNumber", 1,
                                    "Checks whether the axis specified by axisNumber is a NumericAxis");
 
  class_<MDFrameValidator, bases<TypedValidator<IMDWorkspace_sptr>>, boost::noncopyable>(
      "MDFrameValidator", init<std::string>(arg("frameName"), "Checks the MD workspace has the given frame along all "
                                                              "dimensions. Accepted values for the `frameName` are "
                                                              "currently: `HKL`, `QLab`, `QSample`, `Time of "
                                                              "Flight`, `Distance`, `General frame`, `Unknown "
                                                              "frame` "));
 
  class_<PolSANSWorkspaceValidator, bases<TypedValidator<WorkspaceGroup_sptr>>,
         std::shared_ptr<PolSANSWorkspaceValidator>, boost::noncopyable>("PolSANSWorkspaceValidator", no_init)
      .def("__init__",
           make_constructor(&polSANSValidatorConstructor, default_call_policies(),
                            (arg("expectHistogramData") = true, arg("allowMultiPeriodData") = false,
                             arg("allowedNumberOfPeriods") = list())),
           "Checks that the workspace group is a valid Polarised SANS transmission run. It should have 4 (by default, "
           "use allowedNumberOfPeriods with a list ints to change) "
           "group entries which are of type MatrixWorkspace, "
           "have X axis unit Wavelength, have a single spectrum per workspace (depending on the value of "
           "allowMultiPeriodData), and are histogram data "
           "(depending on expectHistogramData).");
}