TempFunction.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2009 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 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/DllConfig.h"
#include "MantidAPI/IFunction.h"
#include "MantidAPI/IFunctionMW.h"
 
#ifdef _WIN32
#pragma warning(disable : 4250)
 
namespace Mantid {
namespace API {
class MANTID_API_DLL TempFunction : public virtual IFunction {
public:
  TempFunction(IFunctionMW *function);
 
  virtual std::string name() const { return m_function->name(); }
  virtual void setWorkspace(std::shared_ptr<const Workspace> ws) { UNUSED_ARG(ws) }
  // virtual std::shared_ptr<const API::Workspace> getWorkspace()const {return
  // m_function->getWorkspace();}
 
  virtual const std::string category() const { return m_function->category(); }
 
  virtual void function(FunctionDomain &domain) const;
  virtual void functionDeriv(FunctionDomain &domain, Jacobian &jacobian);
 
  virtual void setParameter(size_t i, const double &value, bool explicitlySet = true) {
    m_function->setParameter(i, value, explicitlySet);
  }
  virtual void setParameterDescription(size_t i, const std::string &description) {
    m_function->setParameterDescription(i, description);
  }
  virtual double getParameter(size_t i) const { return m_function->getParameter(i); }
  virtual void setParameter(const std::string &name, const double &value, bool explicitlySet = true) {
    m_function->setParameter(name, value, explicitlySet);
  }
  virtual void setParameterDescription(const std::string &name, const std::string &description) {
    m_function->setParameterDescription(name, description);
  }
  virtual double getParameter(const std::string &name) const { return m_function->getParameter(name); }
  virtual size_t nParams() const { return m_function->nParams(); }
  virtual size_t parameterIndex(const std::string &name) const { return m_function->parameterIndex(name); }
  virtual std::string parameterName(size_t i) const { return m_function->parameterName(i); }
  virtual std::string parameterDescription(size_t i) const { return m_function->parameterDescription(i); }
  virtual bool isExplicitlySet(size_t i) const { return m_function->isExplicitlySet(i); }
 
  virtual size_t nActive() const { return m_function->nActive(); }
  virtual size_t indexOfActive(size_t i) const { return m_function->indexOfActive(i); }
  virtual std::string nameOfActive(size_t i) const { return m_function->nameOfActive(i); }
  virtual std::string descriptionOfActive(size_t i) const { return m_function->descriptionOfActive(i); }
 
  virtual bool isActive(size_t i) const { return m_function->isActive(i); }
  virtual size_t activeIndex(size_t i) const { return m_function->activeIndex(i); }
  virtual void removeActive(size_t i) { m_function->removeActive(i); }
  virtual void restoreActive(size_t i) { m_function->restoreActive(i); }
 
  virtual size_t getParameterIndex(const ParameterReference &ref) const { return m_function->getParameterIndex(ref); }
  virtual IFunction *getContainingFunction(const ParameterReference &ref) const {
    return m_function->getContainingFunction(ref);
  }
  virtual IFunction *getContainingFunction(const IFunction *fun) { return m_function->getContainingFunction(fun); }
 
  virtual void applyTies() { m_function->applyTies(); }
  virtual void clearTies() { m_function->clearTies(); }
  virtual bool removeTie(size_t i) { return m_function->removeTie(i); }
  virtual void removeTie(const std::string &parName) { IFunction::removeTie(parName); }
  virtual ParameterTie *getTie(size_t i) const { return m_function->getTie(i); }
 
  virtual void addConstraint(IConstraint *ic) { m_function->addConstraint(ic); }
  virtual IConstraint *getConstraint(size_t i) const { return m_function->getConstraint(i); }
  virtual void removeConstraint(const std::string &parName) { m_function->removeConstraint(parName); }
 
protected:
  virtual void init() { m_function->init(); }
  virtual void declareParameter(const std::string &name, double initValue = 0, const std::string &description = "") {
    m_function->declareParameter(name, initValue, description);
  }
  virtual void addTie(ParameterTie *tie) { m_function->addTie(tie); }
 
  IFunctionMW *m_function;
};
 
class MANTID_API_DLL FunctionDomain1D : public FunctionDomain {
public:
  FunctionDomain1D(double start, double end, size_t n);
  FunctionDomain1D(const std::vector<double> &xvalues);
  double getX(size_t i) const { return m_X.at(i); }
 
protected:
  std::vector<double> m_X; 
  friend class TempFunction;
};
 
} // namespace API
} // namespace Mantid
 
/*MANTID_API_TEMPFUNCTION_H_*/