FunctionFactory.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/FunctionFactory.h"
#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/IBackgroundFunction.h"
#include "MantidAPI/IFunction.h"
#include "MantidAPI/IPeakFunction.h"
#include "MantidAPI/MultiDomainFunction.h"
#include "MantidKernel/WarningSuppressions.h"
#include "MantidPythonInterface/api/PythonAlgorithm/AlgorithmAdapter.h"
#include "MantidPythonInterface/core/GetPointer.h"
#include "MantidPythonInterface/core/PythonObjectInstantiator.h"
#include "MantidPythonInterface/core/UninstallTrace.h"
 
#include <boost/python/class.hpp>
#include <boost/python/def.hpp>
#include <mutex>
 
// Python frameobject. This is under the boost includes so that boost will have
// done the
// include of Python.h which it ensures is done correctly
#include <frameobject.h>
 
using Mantid::API::FunctionFactory;
using Mantid::API::FunctionFactoryImpl;
using Mantid::API::IBackgroundFunction;
using Mantid::API::IFunction;
using Mantid::API::IPeakFunction;
using Mantid::API::MultiDomainFunction;
using Mantid::PythonInterface::PythonObjectInstantiator;
using Mantid::PythonInterface::UninstallTrace;
 
using namespace boost::python;
 
GET_POINTER_SPECIALIZATION(FunctionFactoryImpl)
 
namespace Mantid::PythonInterface {
 
template <> std::shared_ptr<IFunction> PythonObjectInstantiator<IFunction>::createInstance() const {
  using namespace boost::python;
  GlobalInterpreterLock gil;
 
  // The class may instantiate different objects depending on whether
  // it is being created by the function factory or not
  bool const isClassFactoryAware = PyObject_HasAttrString(m_classObject.ptr(), "_factory_use");
 
  if (isClassFactoryAware) {
    m_classObject.attr("_factory_use")();
  }
  object instance = m_classObject();
  if (isClassFactoryAware) {
    m_classObject.attr("_factory_free")();
  }
  auto instancePtr = extract<std::shared_ptr<IFunction>>(instance)();
  auto *deleter = std::get_deleter<converter::shared_ptr_deleter, IFunction>(instancePtr);
  instancePtr.reset(instancePtr.get(), GILSharedPtrDeleter(*deleter));
  return instancePtr;
}
 
} // namespace Mantid::PythonInterface
 
namespace {
 
//------------------------------------------------------------------------------------------------------
PyObject *getFunctionNames(FunctionFactoryImpl const *const self) {
  const auto &names = self->getFunctionNames<Mantid::API::IFunction>();
 
  PyObject *registered = PyList_New(0);
  for (const auto &name : names) {
    PyObject *value = to_python_value<const std::string &>()(name);
    if (PyList_Append(registered, value))
      throw std::runtime_error("Failed to insert value into PyList");
  }
 
  return registered;
}
 
//------------------------------------------------------------------------------------------------------
PyObject *getBackgroundFunctionNames(FunctionFactoryImpl const *const self) {
  const auto &names = self->getFunctionNames<Mantid::API::IFunction>();
 
  PyObject *registered = PyList_New(0);
  for (const auto &name : names) {
    auto fun = self->createFunction(name);
    if (dynamic_cast<IBackgroundFunction *>(fun.get())) {
      PyObject *bkg_function = to_python_value<const std::string &>()(name);
      if (PyList_Append(registered, bkg_function))
        throw std::runtime_error("Failed to insert value into PyList");
    }
  }
 
  return registered;
}
 
//------------------------------------------------------------------------------------------------------
PyObject *getPeakFunctionNames(FunctionFactoryImpl const *const self) {
  const auto &names = self->getFunctionNames<Mantid::API::IFunction>();
 
  PyObject *registered = PyList_New(0);
  for (const auto &name : names) {
    auto fun = self->createFunction(name);
    if (dynamic_cast<IPeakFunction *>(fun.get())) {
      PyObject *peak_function = to_python_value<const std::string &>()(name);
      if (PyList_Append(registered, peak_function))
        throw std::runtime_error("Failed to insert value into PyList");
    }
  }
 
  return registered;
}
 
//------------------------------------------------------------------------------------------------------
Mantid::API::IPeakFunction_sptr createPeakFunction(FunctionFactoryImpl const *const self, const std::string &name) {
  auto fun = self->createFunction(name);
  auto peakFun = std::dynamic_pointer_cast<Mantid::API::IPeakFunction>(fun);
  if (!peakFun) {
    throw std::invalid_argument(name + " is not a PeakFunction");
  }
  return peakFun;
}
 
//------------------------------------------------------------------------------------------------------
Mantid::API::CompositeFunction_sptr createCompositeFunction(FunctionFactoryImpl const *const self,
                                                            const std::string &name) {
  auto fun = self->createFunction(name);
  auto composite = std::dynamic_pointer_cast<Mantid::API::CompositeFunction>(fun);
  if (composite) {
    return composite;
  }
  std::string error_message = name + " is not a composite function.";
  throw std::invalid_argument(error_message);
}
 
//----- Function registration -----
 
std::recursive_mutex FUNCTION_REGISTER_MUTEX;
 
void subscribe(FunctionFactoryImpl &self, PyObject *classObject) {
  UninstallTrace uninstallTrace;
  std::lock_guard<std::recursive_mutex> lock(FUNCTION_REGISTER_MUTEX);
  static auto *baseClass =
      const_cast<PyTypeObject *>(converter::registered<IFunction>::converters.to_python_target_type());
 
  // obj should be a class deriving from IFunction
  // PyObject_IsSubclass can set the error handler if classObject
  // is not a class so this needs to be checked in two stages
  const bool isSubClass = (PyObject_IsSubclass(classObject, reinterpret_cast<PyObject *>(baseClass)) == 1);
  if (PyErr_Occurred() || !isSubClass) {
    throw std::invalid_argument(std::string("subscribe(): Unexpected type. "
                                            "Expected a class derived from "
                                            "IFunction1D or IPeakFunction, "
                                            "found: ") +
                                classObject->ob_type->tp_name);
  }
  // Instantiator will store a reference to the class object, so increase
  // reference count with borrowed template
  auto creator = std::make_unique<PythonObjectInstantiator<IFunction>>(object(handle<>(borrowed(classObject))));
 
  // Can the function be created and initialized? It really shouldn't go in
  // to the factory if not
  auto func = creator->createInstance();
  func->initialize();
 
  // Takes ownership of instantiator
  self.subscribe(func->name(), std::move(creator), FunctionFactoryImpl::OverwriteCurrent);
}
} // namespace
 
void export_FunctionFactory() {
 
  class_<FunctionFactoryImpl, boost::noncopyable>("FunctionFactoryImpl", no_init)
      .def("getFunctionNames", &getFunctionNames, arg("self"), "Returns a list of the currently available functions")
      .def("createCompositeFunction", &createCompositeFunction, (arg("self"), arg("name")),
           "Return a pointer to the requested function")
      .def("createFunction", &FunctionFactoryImpl::createFunction, (arg("self"), arg("type")),
           "Return a pointer to the requested function")
      .def("createInitialized", &FunctionFactoryImpl::createInitialized, (arg("self"), arg("init_expr")),
           "Return a pointer to the requested function")
      .def("createInitializedMultiDomainFunction", &FunctionFactoryImpl::createInitializedMultiDomainFunction,
           (arg("self"), arg("init_expr"), arg("domain_number")), "Return a pointer to the requested function")
      .def("subscribe", &subscribe, (arg("self"), arg("object")),
           "Register a Python class derived from IFunction into the factory")
      .def("unsubscribe", &FunctionFactoryImpl::unsubscribe, (arg("self"), arg("class_name")),
           "Remove a type from the factory")
      .def("Instance", &FunctionFactory::Instance, return_value_policy<reference_existing_object>(),
           "Returns a reference to the FunctionFactory singleton")
      .def("getBackgroundFunctionNames", &getBackgroundFunctionNames, arg("self"),
           "Returns a list of the currently available background functions")
      .def("getPeakFunctionNames", &getPeakFunctionNames, arg("self"),
           "Returns a list of the currently available peak functions")
      .def("createPeakFunction", &createPeakFunction, (arg("self"), arg("name")), "Return pointer to peak function.")
      .staticmethod("Instance");
}