LeBailFunction.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2012 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
 
#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/IPowderDiffPeakFunction.h"
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidCurveFitting/DllConfig.h"
#include "MantidCurveFitting/Functions/BackgroundFunction.h"
 
#include <span>
 
namespace Mantid {
namespace HistogramData {
class HistogramX;
class HistogramY;
} // namespace HistogramData
namespace CurveFitting {
namespace Algorithms {
 
class MANTID_CURVEFITTING_DLL LeBailFunction {
public:
  LeBailFunction(const std::string &peaktype);
 
  virtual ~LeBailFunction();
 
  void setProfileParameterValues(std::map<std::string, double> parammap);
 
  void setFitProfileParameter(const std::string &paramname, double minvalue, double maxvalue);
 
  void setPeakHeights(const std::vector<double> &inheights);
 
  bool hasProfileParameter(const std::string &paramname);
 
  bool isParameterValid(double maxfwhm = DBL_MAX) const;
 
  void setPeakCentreTolerance(double peakpostol, double tofmin, double tofmax);
 
  void addPeaks(const std::vector<std::vector<int>> &peakhkls);
 
  void addBackgroundFunction(const std::string &backgroundtype, const unsigned int &order,
                             const std::vector<std::string> &vecparnames, const std::vector<double> &vecparvalues,
                             double startx, double endx);
 
  size_t getNumberOfPeaks() const { return m_numPeaks; }
 
  Mantid::HistogramData::HistogramY function(const Mantid::HistogramData::HistogramX &xvalues, bool calpeaks,
                                             bool calbkgd) const;
 
  Mantid::HistogramData::HistogramY calPeak(size_t ipk, std::span<double const> xvalues, size_t ySize) const;
 
  API::IFunction_sptr getFunction();
 
  API::IPowderDiffPeakFunction_sptr getPeak(size_t peakindex);
 
  void calPeaksParameters();
 
  double getPeakParameter(size_t index, const std::string &parname) const;
 
  double getPeakParameter(std::vector<int> hkl, const std::string &parname) const;
 
  void fixPeakParameter(const std::string &paramname, double paramvalue);
 
  void fixBackgroundParameters();
 
  void setFixPeakHeights();
 
  bool calculatePeaksIntensities(std::span<double const> vecX, std::span<double const> vecY,
                                 std::vector<double> &vec_summedpeaks);
 
  double getPeakMaximumValue(std::vector<int> hkl, const std::vector<double> &xvalues, size_t &ix);
 
private:
  void setPeakParameters(const API::IPowderDiffPeakFunction_sptr &peak, const std::map<std::string, double> &parammap,
                         double peakheight, bool setpeakheight);
 
  double getPeakParameterValue(const API::IPowderDiffPeakFunction_sptr &peak, const std::string &parname) const;
 
  void calculatePeakParameterValues() const;
 
  API::IPowderDiffPeakFunction_sptr generatePeak(int h, int k, int l);
 
  bool calculateGroupPeakIntensities(std::vector<std::pair<double, API::IPowderDiffPeakFunction_sptr>> peakgroup,
                                     std::span<double const> vecX, std::span<double const> vecY,
                                     std::vector<double> &vec_summedpeaks);
 
  void groupPeaks(std::vector<std::vector<std::pair<double, API::IPowderDiffPeakFunction_sptr>>> &peakgroupvec,
                  std::vector<API::IPowderDiffPeakFunction_sptr> &outboundpeakvec, double xmin, double xmax);
 
  std::string m_peakType;
 
  size_t m_numPeaks;
 
  std::vector<std::string> m_peakParameterNameVec;
  std::vector<std::string> m_orderedProfileParameterNames;
 
  std::vector<API::IPowderDiffPeakFunction_sptr> m_vecPeaks;
  std::vector<std::pair<double, API::IPowderDiffPeakFunction_sptr>> m_dspPeakVec;
  std::map<std::vector<int>, API::IPowderDiffPeakFunction_sptr> m_mapHKLPeak;
 
  API::CompositeFunction_sptr m_compsiteFunction;
  Functions::BackgroundFunction_sptr m_background;
 
  std::map<std::string, double> m_functionParameters;
 
  mutable bool m_hasNewPeakValue;
 
  bool m_isInputValue;
 
  std::vector<double> heights;
 
  double m_minTOFPeakCentre;
  double m_maxTOFPeakCentre;
  /*
  double mL1;
  double mL2;
 
  mutable double Alph0, Alph1, Alph0t, Alph1t;
  mutable double Beta0, Beta1, Beta0t, Beta1t;
  mutable double Sig0, Sig1, Sig2, Gam0, Gam1, Gam2;
  mutable double Dtt1, Dtt2, Dtt1t, Dtt2t, Zero, Zerot;
 
  // void calPeakParametersForD(double dh, double& alpha, double& beta, double
  &Tof_h, double &sigma_g2, double &gamma_l, std::map<std::string, double>&
  parmap) const;
  void adPeakPositionD(double dh);
  double calCubicDSpace(double a, int h, int k, int l) const;
  void addPeak(double d, double height);
  mutable std::vector<double> dvalues;
  mutable std::vector<std::map<std::string, double> > mPeakParameters;
  */
};
 
using LeBailFunction_sptr = std::shared_ptr<LeBailFunction>;
 
} // namespace Algorithms
} // namespace CurveFitting
} // namespace Mantid