IPeakFunction.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/IFunctionWithLocation.h"
#include "boost/shared_ptr.hpp"
 
namespace Mantid {
namespace API {
 
class TempJacobian : public Jacobian {
public:
  TempJacobian(size_t y, size_t p) : m_y(y), m_p(p), m_J(y * p) {}
  void set(size_t iY, size_t iP, double value) override { m_J[iY * m_p + iP] = value; }
  double get(size_t iY, size_t iP) override { return m_J[iY * m_p + iP]; }
  size_t maxParam(size_t iY) {
    double max = -DBL_MAX;
    size_t maxIndex = 0;
    for (size_t i = 0; i < m_p; ++i) {
      double current = get(iY, i);
      if (current > max) {
        maxIndex = i;
        max = current;
      }
    }
 
    return maxIndex;
  }
  void zero() override { m_J.assign(m_J.size(), 0.0); }
 
protected:
  size_t m_y;
  size_t m_p;
  std::vector<double> m_J;
};
 
using IntegrationResultCache = std::pair<double, double>;
class MANTID_API_DLL IPeakFunction : public IFunctionWithLocation {
public:
  IPeakFunction();
 
  void function(const FunctionDomain &domain, FunctionValues &values) const override;
 
  virtual double fwhm() const = 0;
 
  virtual void setFwhm(const double w) = 0;
 
  virtual double intensity() const;
 
  virtual double intensityError() const;
 
  virtual void setIntensity(const double newIntensity);
 
  void setParameter(const std::string &name, const double &value, bool explicitlySet = true) override;
 
  void setParameter(size_t, const double &value, bool explicitlySet = true) override;
 
  void function1D(double *out, const double *xValues, const size_t nData) const override;
  void functionDeriv1D(Jacobian *out, const double *xValues, const size_t nData) override;
 
  virtual std::pair<double, double> getDomainInterval(double level = DEFAULT_SEARCH_LEVEL) const;
 
  virtual void functionLocal(double *out, const double *xValues, const size_t nData) const = 0;
  virtual void functionDerivLocal(Jacobian *jacobian, const double *xValues, const size_t nData);
 
  std::string getCentreParameterName() const;
 
  virtual std::string getWidthParameterName() const { return ""; }
 
  virtual void fixIntensity(bool isDefault = false) {
    UNUSED_ARG(isDefault);
    throw std::runtime_error("Generic intensity fixing isn't implemented for this function.");
  }
 
  virtual void unfixIntensity() {
    throw std::runtime_error("Generic intensity fixing isn't implemented for this function.");
  }
 
protected:
  virtual IntegrationResultCache integrate() const;
 
private:
  void setPeakRadius(int r) const;
  mutable int m_peakRadius;
  static constexpr double DEFAULT_SEARCH_LEVEL = 1e-5;
  // Cache the result of a PeakFunctionIntegrator call
  mutable boost::shared_ptr<IntegrationResultCache> integrationResult = nullptr;
  // Flag to dirty the cache when a param has been set
  mutable bool m_parameterContextDirty = false;
};
 
using IPeakFunction_sptr = std::shared_ptr<IPeakFunction>;
using IPeakFunction_const_sptr = std::shared_ptr<const IPeakFunction>;
 
} // namespace API
} // namespace Mantid