d3/d9a/IkedaCarpenterPV_8cpp_source.html

// Mantid Repository : https://github.com/mantidproject/mantid

//

// Copyright &copy; 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 +

//----------------------------------------------------------------------

// Includes

//----------------------------------------------------------------------

#include "MantidCurveFitting/Functions/IkedaCarpenterPV.h"

#include "MantidAPI/FunctionFactory.h"

#include "MantidAPI/MatrixWorkspace.h"

#include "MantidAPI/PeakFunctionIntegrator.h"

#include "MantidCurveFitting/Constraints/BoundaryConstraint.h"

#include "MantidCurveFitting/SpecialFunctionSupport.h"

#include "MantidGeometry/Instrument.h"

#include "MantidGeometry/Instrument/Component.h"

#include "MantidGeometry/Instrument/DetectorGroup.h"

#include "MantidGeometry/Instrument/FitParameter.h"

#include "MantidGeometry/Instrument/ParameterMap.h"

#include "MantidKernel/UnitFactory.h"


#include <cmath>

#include <gsl/gsl_math.h>

#include <gsl/gsl_multifit_nlin.h>

#include <gsl/gsl_sf_erf.h>

#include <limits>


namespace Mantid::CurveFitting::Functions {


using namespace CurveFitting;


namespace {

Kernel::Logger g_log("IkedaCarpenterPV");

} // namespace


using namespace Kernel;


using namespace CurveFitting::SpecialFunctionSupport;


using namespace Geometry;

using namespace Constraints;


DECLARE_FUNCTION(IkedaCarpenterPV)


double IkedaCarpenterPV::centre() const { return getParameter("X0"); }


void IkedaCarpenterPV::setHeight(const double h) {

  // calculate height of peakshape function corresponding to intensity = 1

  setParameter("I", 1);

  double h0 = height();


  // to avoid devide by zero and to insane value for I to be set

  double minCutOff = 100.0 * std::numeric_limits<double>::min();

  if (h0 > 0 && h0 < minCutOff)

    h0 = minCutOff;

  if (h0 < 0 && h0 > -minCutOff)

    h0 = -minCutOff;


  // The intensity is then estimated to be h/h0

  setParameter("I", h / h0);

}


double IkedaCarpenterPV::height() const {

  // return the function value at centre()

  // using arrays - otherwise coverity warning

  double h0[1];

  double toCentre[1];

  toCentre[0] = centre();

  constFunction(h0, toCentre, 1);

  return h0[0];

}


double IkedaCarpenterPV::fwhm() const {

  double sigmaSquared = getParameter("SigmaSquared");

  double gamma = getParameter("Gamma");


  if (sigmaSquared < 0) {

    g_log.debug() << "SigmaSquared NEGATIVE!.\n"

                  << "Likely due to a fit not converging properly\n"

                  << "If this is frequent problem please report to Mantid team.\n"

                  << "For now to calculate width force SigmaSquared positive.\n";

    sigmaSquared = -sigmaSquared;

  }

  if (gamma < 0) {

    g_log.debug() << "Gamma NEGATIVE!.\n"

                  << "Likely due to a fit not converging properly\n"

                  << "If this is frequent problem please report to Mantid team.\n"

                  << "For now to calculate width force Gamma positive.\n";

    gamma = -gamma;

    ;

  }

  return sqrt(8.0 * M_LN2 * sigmaSquared) + gamma;

}


void IkedaCarpenterPV::setFwhm(const double w) {

  setParameter("SigmaSquared", w * w / (32.0 * M_LN2)); // used 4.0 * 8.0 = 32.0

  setParameter("Gamma", w / 2.0);

}


void IkedaCarpenterPV::setCentre(const double c) { setParameter("X0", c); }


void IkedaCarpenterPV::init() {

  declareParameter("I", 0.0,

                   "The integrated intensity of the peak. I.e. "

                   "approximately equal to HWHM times height of "

                   "peak");

  this->lowerConstraint0("I");

  declareParameter("Alpha0", 1.6, "Used to model fast decay constant");

  this->lowerConstraint0("Alpha0");

  declareParameter("Alpha1", 1.5, "Used to model fast decay constant");

  this->lowerConstraint0("Alpha1");

  declareParameter("Beta0", 31.9, "Inverse of slow decay constant");

  this->lowerConstraint0("Beta0");

  declareParameter("Kappa", 46.0, "Controls contribution of slow decay term");

  this->lowerConstraint0("Kappa");

  declareParameter("SigmaSquared", 1.0, "standard deviation squared (Voigt Guassian broadening)");

  this->lowerConstraint0("SigmaSquared");

  declareParameter("Gamma", 1.0, "Voigt Lorentzian broadening");

  this->lowerConstraint0("Gamma");

  declareParameter("X0", 0.0, "Peak position");

  this->lowerConstraint0("X0");

}


void IkedaCarpenterPV::lowerConstraint0(const std::string &paramName) {

  auto mixingConstraint = std::make_unique<BoundaryConstraint>(this, paramName, 0.0, true);

  mixingConstraint->setPenaltyFactor(1e9);


  addConstraint(std::move(mixingConstraint));

}


void IkedaCarpenterPV::calWavelengthAtEachDataPoint(const double *xValues, const size_t &nData) const {

  // if wavelength vector already have the right size no need for resizing it

  // further we make the assumption that no need to recalculate this vector if

  // it already has the right size


  if (m_waveLength.size() != nData) {

    m_waveLength.resize(nData);


    Mantid::Kernel::Unit_sptr wavelength = Mantid::Kernel::UnitFactory::Instance().create("Wavelength");

    for (size_t i = 0; i < nData; i++) {

      m_waveLength[i] = xValues[i];

    }


    // note if a version of convertValue was added which allows a double* as

    // first argument then could avoid copying above plus only have to resize

    // m_wavelength when its size smaller than nData

    API::MatrixWorkspace_const_sptr mws = getMatrixWorkspace();

    if (mws) {

      Instrument_const_sptr instrument = mws->getInstrument();

      Geometry::IComponent_const_sptr sample = instrument->getSample();

      if (sample != nullptr) {

        convertValue(m_waveLength, wavelength, mws, m_workspaceIndex);

      } else {

        g_log.warning() << "No sample set for instrument in workspace.\n"

                        << "Can't calculate wavelength in IkedaCarpenter.\n"

                        << "Default all wavelengths to one.\n"

                        << "Solution is to load appropriate instrument into workspace.\n";

        for (size_t i = 0; i < nData; i++)

          m_waveLength[i] = 1.0;

      }

    } else {

      g_log.warning() << "Workspace not set.\n"

                      << "Can't calculate wavelength in IkedaCarpenter.\n"

                      << "Default all wavelengths to one.\n"

                      << "Solution call setMatrixWorkspace() for function.\n";

      for (size_t i = 0; i < nData; i++)

        m_waveLength[i] = 1.0;

    }

  }

}


void IkedaCarpenterPV::convertVoigtToPseudo(const double &voigtSigmaSq, const double &voigtGamma, double &H,

                                            double &eta) const {

  double fwhmGsq = 8.0 * M_LN2 * voigtSigmaSq;

  double fwhmG = sqrt(fwhmGsq);

  double fwhmG4 = fwhmGsq * fwhmGsq;

  double fwhmL = voigtGamma;

  double fwhmLsq = voigtGamma * voigtGamma;

  double fwhmL4 = fwhmLsq * fwhmLsq;


  H = pow(fwhmG4 * fwhmG + 2.69269 * fwhmG4 * fwhmL + 2.42843 * fwhmGsq * fwhmG * fwhmLsq +

              4.47163 * fwhmGsq * fwhmLsq * fwhmL + 0.07842 * fwhmG * fwhmL4 + fwhmL4 * fwhmL,

          0.2);


  if (H == 0.0)

    H = std::numeric_limits<double>::epsilon() * 1000.0;


  double tmp = fwhmL / H;


  eta = 1.36603 * tmp - 0.47719 * tmp * tmp + 0.11116 * tmp * tmp * tmp;

}


void IkedaCarpenterPV::constFunction(double *out, const double *xValues, const int &nData) const {

  const double I = getParameter("I");

  const double alpha0 = getParameter("Alpha0");

  const double alpha1 = getParameter("Alpha1");

  const double beta0 = getParameter("Beta0");

  const double kappa = getParameter("Kappa");

  const double voigtsigmaSquared = getParameter("SigmaSquared");

  const double voigtgamma = getParameter("Gamma");

  const double X0 = getParameter("X0");


  // cal pseudo voigt sigmaSq and gamma and eta

  double gamma = 1.0; // dummy initialization

  double eta = 0.5;   // dummy initialization

  convertVoigtToPseudo(voigtsigmaSquared, voigtgamma, gamma, eta);

  double sigmaSquared = gamma * gamma / (8.0 * M_LN2);


  const double beta = 1 / beta0;


  // equations taken from Fullprof manual


  const double k = 0.05;


  // Not entirely sure what to do if sigmaSquared ever negative

  // for now just post a warning

  double someConst = std::numeric_limits<double>::max() / 100.0;

  if (sigmaSquared > 0)

    someConst = 1 / sqrt(2.0 * sigmaSquared);

  else if (sigmaSquared < 0) {

    g_log.warning() << "sigmaSquared negative in functionLocal.\n";

  }


  // update wavelength vector

  calWavelengthAtEachDataPoint(xValues, nData);


  for (int i = 0; i < nData; i++) {

    double diff = xValues[i] - X0;


    double R = exp(-81.799 / (m_waveLength[i] * m_waveLength[i] * kappa));

    double alpha = 1.0 / (alpha0 + m_waveLength[i] * alpha1);


    double a_minus = alpha * (1 - k);

    double a_plus = alpha * (1 + k);

    double x = a_minus - beta;

    double y = alpha - beta;

    double z = a_plus - beta;


    double Nu = 1 - R * a_minus / x;

    double Nv = 1 - R * a_plus / z;

    double Ns = -2 * (1 - R * alpha / y);

    double Nr = 2 * R * alpha * alpha * beta * k * k / (x * y * z);


    double u = a_minus * (a_minus * sigmaSquared - 2 * diff) / 2.0;

    double v = a_plus * (a_plus * sigmaSquared - 2 * diff) / 2.0;

    double s = alpha * (alpha * sigmaSquared - 2 * diff) / 2.0;

    double r = beta * (beta * sigmaSquared - 2 * diff) / 2.0;


    double yu = (a_minus * sigmaSquared - diff) * someConst;

    double yv = (a_plus * sigmaSquared - diff) * someConst;

    double ys = (alpha * sigmaSquared - diff) * someConst;

    double yr = (beta * sigmaSquared - diff) * someConst;


    std::complex<double> zs = std::complex<double>(-alpha * diff, 0.5 * alpha * gamma);

    std::complex<double> zu = (1 - k) * zs;

    std::complex<double> zv = (1 + k) * zs;

    std::complex<double> zr = std::complex<double>(-beta * diff, 0.5 * beta * gamma);


    double N = 0.25 * alpha * (1 - k * k) / (k * k);


    out[i] = I * N *

             ((1 - eta) * (Nu * exp(u + gsl_sf_log_erfc(yu)) + Nv * exp(v + gsl_sf_log_erfc(yv)) +

                           Ns * exp(s + gsl_sf_log_erfc(ys)) + Nr * exp(r + gsl_sf_log_erfc(yr))) -

              eta * 2.0 / M_PI *

                  (Nu * exponentialIntegral(zu).imag() + Nv * exponentialIntegral(zv).imag() +

                   Ns * exponentialIntegral(zs).imag() + Nr * exponentialIntegral(zr).imag()));

  }

}


void IkedaCarpenterPV::functionLocal(double *out, const double *xValues, const size_t nData) const {

  const double I = getParameter("I");

  const double alpha0 = getParameter("Alpha0");

  const double alpha1 = getParameter("Alpha1");

  const double beta0 = getParameter("Beta0");

  const double kappa = getParameter("Kappa");

  const double voigtsigmaSquared = getParameter("SigmaSquared");

  const double voigtgamma = getParameter("Gamma");

  const double X0 = getParameter("X0");


  // cal pseudo voigt sigmaSq and gamma and eta

  double gamma = 1.0; // dummy initialization

  double eta = 0.5;   // dummy initialization

  convertVoigtToPseudo(voigtsigmaSquared, voigtgamma, gamma, eta);

  double sigmaSquared = gamma * gamma / (8.0 * M_LN2); // pseudo voigt sigma^2


  const double beta = 1 / beta0;


  // equations taken from Fullprof manual


  const double k = 0.05;


  // Not entirely sure what to do if sigmaSquared ever negative

  // for now just post a warning

  double someConst = std::numeric_limits<double>::max() / 100.0;

  if (sigmaSquared > 0)

    someConst = 1 / sqrt(2.0 * sigmaSquared);

  else if (sigmaSquared < 0) {

    g_log.warning() << "sigmaSquared negative in functionLocal.\n";

  }


  // update wavelength vector

  calWavelengthAtEachDataPoint(xValues, nData);


  for (size_t i = 0; i < nData; i++) {

    double diff = xValues[i] - X0;


    double R = exp(-81.799 / (m_waveLength[i] * m_waveLength[i] * kappa));

    double alpha = 1.0 / (alpha0 + m_waveLength[i] * alpha1);


    double a_minus = alpha * (1 - k);

    double a_plus = alpha * (1 + k);

    double x = a_minus - beta;

    double y = alpha - beta;

    double z = a_plus - beta;


    double Nu = 1 - R * a_minus / x;

    double Nv = 1 - R * a_plus / z;

    double Ns = -2 * (1 - R * alpha / y);

    double Nr = 2 * R * alpha * alpha * beta * k * k / (x * y * z);


    double u = a_minus * (a_minus * sigmaSquared - 2 * diff) / 2.0;

    double v = a_plus * (a_plus * sigmaSquared - 2 * diff) / 2.0;

    double s = alpha * (alpha * sigmaSquared - 2 * diff) / 2.0;

    double r = beta * (beta * sigmaSquared - 2 * diff) / 2.0;


    double yu = (a_minus * sigmaSquared - diff) * someConst;

    double yv = (a_plus * sigmaSquared - diff) * someConst;

    double ys = (alpha * sigmaSquared - diff) * someConst;

    double yr = (beta * sigmaSquared - diff) * someConst;


    std::complex<double> zs = std::complex<double>(-alpha * diff, 0.5 * alpha * gamma);

    std::complex<double> zu = (1 - k) * zs;

    std::complex<double> zv = (1 + k) * zs;

    std::complex<double> zr = std::complex<double>(-beta * diff, 0.5 * beta * gamma);


    double N = 0.25 * alpha * (1 - k * k) / (k * k);


    out[i] = I * N *

             ((1 - eta) * (Nu * exp(u + gsl_sf_log_erfc(yu)) + Nv * exp(v + gsl_sf_log_erfc(yv)) +

                           Ns * exp(s + gsl_sf_log_erfc(ys)) + Nr * exp(r + gsl_sf_log_erfc(yr))) -

              eta * 2.0 / M_PI *

                  (Nu * exponentialIntegral(zu).imag() + Nv * exponentialIntegral(zv).imag() +

                   Ns * exponentialIntegral(zs).imag() + Nr * exponentialIntegral(zr).imag()));

  }

}


void IkedaCarpenterPV::functionDerivLocal(API::Jacobian * /*jacobian*/, const double * /*xValues*/,

                                          const size_t /*nData*/) {

  throw Mantid::Kernel::Exception::NotImplementedError("functionDerivLocal is not implemented for IkedaCarpenterPV.");

}


void IkedaCarpenterPV::functionDeriv(const API::FunctionDomain &domain, API::Jacobian &jacobian) {

  calNumericalDeriv(domain, jacobian);

}


double IkedaCarpenterPV::intensity() const {

  auto interval = getDomainInterval(1e-2);


  API::PeakFunctionIntegrator integrator;

  API::IntegrationResult result = integrator.integrate(*this, interval.first, interval.second);


  return result.result;

}


void IkedaCarpenterPV::setMatrixWorkspace(std::shared_ptr<const API::MatrixWorkspace> workspace, size_t wi,

                                          double startX, double endX) {

  if (workspace) {

    // convert inital parameters that depend on x axis to correct units so

    // inital guess is reasonable

    auto tof = Mantid::Kernel::UnitFactory::Instance().create("TOF");

    const auto centre = getParameter("X0");

    const auto scaleFactor = centre / convertValue(centre, tof, workspace, wi);

    if (scaleFactor != 0) {

      if (isActive(parameterIndex("Alpha0")))

        setParameter("Alpha0", getParameter("Alpha0") * scaleFactor);

      if (isActive(parameterIndex("Alpha1")))

        setParameter("Alpha1", getParameter("Alpha1") * scaleFactor);

      if (isActive(parameterIndex("Beta0")))

        setParameter("Beta0", getParameter("Beta0") * scaleFactor);

    }

  }

  IFunctionMW::setMatrixWorkspace(workspace, wi, startX, endX);

}


} // namespace Mantid::CurveFitting::Functions

tmp
gsl_vector * tmp
Definition: AugmentedLagrangianOptimizer.cpp:49

BoundaryConstraint.h

Component.h

DetectorGroup.h

FitParameter.h

FunctionFactory.h

DECLARE_FUNCTION
#define DECLARE_FUNCTION(classname)
Macro for declaring a new type of function to be used with the FunctionFactory.
Definition: FunctionFactory.h:151

IkedaCarpenterPV.h

workspace
IPeaksWorkspace_sptr workspace
Definition: IndexPeaks.cpp:114

Instrument.h

MatrixWorkspace.h

ParameterMap.h

PeakFunctionIntegrator.h

SpecialFunctionSupport.h

UnitFactory.h

Mantid::API::FunctionDomain
Base class that represents the domain of a function.
Definition: FunctionDomain.h:31

Mantid::API::IFunctionMW::m_workspaceIndex
size_t m_workspaceIndex
An index to a spectrum.
Definition: IFunctionMW.h:44

Mantid::API::IFunctionMW::setMatrixWorkspace
void setMatrixWorkspace(std::shared_ptr< const API::MatrixWorkspace > workspace, size_t wi, double startX, double endX) override
Set MatrixWorkspace.
Definition: IFunctionMW.cpp:22

Mantid::API::IFunctionMW::getMatrixWorkspace
std::shared_ptr< const API::MatrixWorkspace > getMatrixWorkspace() const
Get shared pointer to the workspace.
Definition: IFunctionMW.cpp:33

Mantid::API::IFunction::isActive
bool isActive(size_t i) const
Check if an active parameter i is actually active.
Definition: IFunction.cpp:160

Mantid::API::IFunction::getParameter
virtual double getParameter(size_t i) const =0
Get i-th parameter.

Mantid::API::IFunction::convertValue
double convertValue(double value, Kernel::Unit_sptr &outUnit, const std::shared_ptr< const MatrixWorkspace > &ws, size_t wsIndex) const
Convert a value from one unit (inUnit) to unit defined in workspace (ws)
Definition: IFunction.cpp:1267

Mantid::API::IFunction::calNumericalDeriv
void calNumericalDeriv(const FunctionDomain &domain, Jacobian &jacobian)
Calculate numerical derivatives.
Definition: IFunction.cpp:1031

Mantid::API::IFunction::parameterIndex
virtual size_t parameterIndex(const std::string &name) const =0
Returns the index of parameter name.

Mantid::API::IFunction::addConstraint
virtual void addConstraint(std::unique_ptr< IConstraint > ic)
Add a constraint to function.
Definition: IFunction.cpp:376

Mantid::API::IFunction::declareParameter
virtual void declareParameter(const std::string &name, double initValue=0, const std::string &description="")=0
Declare a new parameter.

Mantid::API::IPeakFunction::setParameter
void setParameter(const std::string &name, const double &value, bool explicitlySet=true) override
Override parent so that we may bust the cache when a parameter is set.
Definition: IPeakFunction.cpp:151

Mantid::API::IPeakFunction::getDomainInterval
virtual std::pair< double, double > getDomainInterval(double level=DEFAULT_SEARCH_LEVEL) const
Get the interval on which the peak has all its values above a certain level.
Definition: IPeakFunction.cpp:230

Mantid::API::Jacobian
Represents the Jacobian in IFitFunction::functionDeriv.
Definition: Jacobian.h:22

Mantid::API::PeakFunctionIntegrator
Definition: PeakFunctionIntegrator.h:37

Mantid::API::PeakFunctionIntegrator::integrate
IntegrationResult integrate(const IPeakFunction &peakFunction, double lowerLimit, double upperLimit) const
Integration of peak function on the interval [a, b].
Definition: PeakFunctionIntegrator.cpp:109

Mantid::CurveFitting::Functions::IkedaCarpenterPV
Provide Ikeda-Carpenter-pseudo-Voigt peak shape function interface to IPeakFunction.
Definition: IkedaCarpenterPV.h:27

Mantid::CurveFitting::Functions::IkedaCarpenterPV::functionLocal
void functionLocal(double *out, const double *xValues, const size_t nData) const override
Function evaluation method to be implemented in the inherited classes.
Definition: IkedaCarpenterPV.cpp:287

Mantid::CurveFitting::Functions::IkedaCarpenterPV::constFunction
void constFunction(double *out, const double *xValues, const int &nData) const
calculate the const function
Definition: IkedaCarpenterPV.cpp:210

Mantid::CurveFitting::Functions::IkedaCarpenterPV::setHeight
void setHeight(const double h) override
Sets the parameters such that height == h.
Definition: IkedaCarpenterPV.cpp:49

Mantid::CurveFitting::Functions::IkedaCarpenterPV::setCentre
void setCentre(const double c) override
Sets the parameters such that centre == c.
Definition: IkedaCarpenterPV.cpp:102

Mantid::CurveFitting::Functions::IkedaCarpenterPV::intensity
double intensity() const override
Returns the integral intensity of the peak.
Definition: IkedaCarpenterPV.cpp:374

Mantid::CurveFitting::Functions::IkedaCarpenterPV::centre
double centre() const override
overwrite IPeakFunction base class methods
Definition: IkedaCarpenterPV.cpp:47

Mantid::CurveFitting::Functions::IkedaCarpenterPV::init
void init() override
overwrite IFunction base class method, which declare function parameters
Definition: IkedaCarpenterPV.cpp:104

Mantid::CurveFitting::Functions::IkedaCarpenterPV::setMatrixWorkspace
void setMatrixWorkspace(std::shared_ptr< const API::MatrixWorkspace > workspace, size_t wi, double startX, double endX) override
Set MatrixWorkspace.
Definition: IkedaCarpenterPV.cpp:383

Mantid::CurveFitting::Functions::IkedaCarpenterPV::setFwhm
void setFwhm(const double w) override
Sets the parameters such that FWHM = w.
Definition: IkedaCarpenterPV.cpp:97

Mantid::CurveFitting::Functions::IkedaCarpenterPV::lowerConstraint0
void lowerConstraint0(const std::string &paramName)
constrain all parameters to be non-negative
Definition: IkedaCarpenterPV.cpp:126

Mantid::CurveFitting::Functions::IkedaCarpenterPV::m_waveLength
std::vector< double > m_waveLength
container for storing wavelength values for each data point
Definition: IkedaCarpenterPV.h:57

Mantid::CurveFitting::Functions::IkedaCarpenterPV::height
double height() const override
Returns the height of the function.
Definition: IkedaCarpenterPV.cpp:65

Mantid::CurveFitting::Functions::IkedaCarpenterPV::convertVoigtToPseudo
void convertVoigtToPseudo(const double &voigtSigmaSq, const double &voigtGamma, double &H, double &eta) const
convert voigt params to pseudo voigt params
Definition: IkedaCarpenterPV.cpp:189

Mantid::CurveFitting::Functions::IkedaCarpenterPV::functionDerivLocal
void functionDerivLocal(API::Jacobian *out, const double *xValues, const size_t nData) override
Derivative evaluation method. Default is to calculate numerically.
Definition: IkedaCarpenterPV.cpp:364

Mantid::CurveFitting::Functions::IkedaCarpenterPV::functionDeriv
void functionDeriv(const API::FunctionDomain &domain, API::Jacobian &jacobian) override
Derivatives of function with respect to active parameters.
Definition: IkedaCarpenterPV.cpp:369

Mantid::CurveFitting::Functions::IkedaCarpenterPV::fwhm
double fwhm() const override
Returns the peak FWHM.
Definition: IkedaCarpenterPV.cpp:75

Mantid::CurveFitting::Functions::IkedaCarpenterPV::calWavelengthAtEachDataPoint
void calWavelengthAtEachDataPoint(const double *xValues, const size_t &nData) const
method for updating m_waveLength
Definition: IkedaCarpenterPV.cpp:141

Mantid::Kernel::Exception::NotImplementedError
Marks code as not implemented yet.
Definition: Exception.h:138

Mantid::Kernel::Logger::debug
void debug(const std::string &msg)
Logs at debug level.
Definition: Logger.cpp:114

Mantid::Kernel::Logger::warning
void warning(const std::string &msg)
Logs at warning level.
Definition: Logger.cpp:86

Mantid::Kernel::SingletonHolder::Instance
static T & Instance()
Return a reference to the Singleton instance, creating it if it does not already exist Creation is do...
Definition: SingletonHolder.h:91

Mantid::API::g_log
Kernel::Logger g_log("ExperimentInfo")
static logger object

Mantid::API::MatrixWorkspace_const_sptr
std::shared_ptr< const MatrixWorkspace > MatrixWorkspace_const_sptr
shared pointer to the matrix workspace base class (const version)
Definition: MatrixWorkspace.h:522

Mantid::CurveFitting::Functions
Definition: VesuvioCalculateGammaBackground.h:23

Mantid::CurveFitting::SpecialFunctionSupport::exponentialIntegral
std::complex< double > MANTID_CURVEFITTING_DLL exponentialIntegral(const std::complex< double > &z)
Compute exp(z)*E1(z) where z is complex and E1(z) is the Exponential Integral.
Definition: SpecialFunctionHelper.cpp:22

Mantid::Geometry::IComponent_const_sptr
std::shared_ptr< const IComponent > IComponent_const_sptr
Typdef of a shared pointer to a const IComponent.
Definition: IComponent.h:161

Mantid::Geometry::z
I a m z
Definition: SpaceGroupFactory.cpp:675

Mantid::Geometry::y
I a m y
Definition: SpaceGroupFactory.cpp:675

Mantid::Geometry::Instrument_const_sptr
std::shared_ptr< const Instrument > Instrument_const_sptr
Shared pointer to an const instrument object.
Definition: Instrument_fwd.h:23

Mantid::Geometry::x
I a m x
Definition: SpaceGroupFactory.cpp:675

Mantid::Kernel::Unit_sptr
std::shared_ptr< Unit > Unit_sptr
Shared pointer to the Unit base class.
Definition: Unit.h:229

Mantid::API::IntegrationResult
PeakFunctionIntegrator :
Definition: PeakFunctionIntegrator.h:28

Mantid::API::IntegrationResult::result
double result
Definition: PeakFunctionIntegrator.h:29