FitPeak.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2013 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/Algorithm.h"
#include "MantidAPI/IBackgroundFunction.h"
#include "MantidAPI/IPeakFunction.h"
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidAlgorithms/DllConfig.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidKernel/cow_ptr.h"
 
namespace Mantid {
namespace HistogramData {
class HistogramX;
class HistogramY;
} // namespace HistogramData
 
namespace Algorithms {
size_t getIndex(const HistogramData::HistogramX &vecx, double x);
 
class MANTID_ALGORITHMS_DLL FitOneSinglePeak final : public API::Algorithm {
public:
  FitOneSinglePeak();
 
  const std::string summary() const override { return "Fit a single peak with checking mechanism. "; }
 
  void setWorskpace(const API::MatrixWorkspace_sptr &dataws, size_t wsindex);
 
  void setFittingMethod(std::string minimizer, const std::string &costfunction);
 
  void setFunctions(const API::IPeakFunction_sptr &peakfunc, const API::IBackgroundFunction_sptr &bkgdfunc);
 
  void setFitWindow(double leftwindow, double rightwindow);
 
  void setPeakRange(double xpeakleft, double xpeakright);
 
  void setupGuessedFWHM(double usrwidth, int minfwhm, int maxfwhm, int stepsize, bool fitwithsteppedfwhm);
 
  void setFitPeakCriteria(bool usepeakpostol, double peakpostol);
 
  std::string getDebugMessage();
 
  bool simpleFit();
 
  void highBkgdFit();
 
  std::map<std::string, double> getPeakError();
 
  std::map<std::string, double> getBackgroundError();
 
  double getFitCostFunctionValue();
 
  API::MatrixWorkspace_sptr genFitWindowWS();
 
private:
  const std::string name() const override { return "FitOneSinglePeak"; }
 
  int version() const override { return 1; }
  const std::vector<std::string> seeAlso() const override { return {"Fit"}; }
  void init() override;
  void exec() override;
 
  bool hasSetupToFitPeak(std::string &errmsg);
 
  double estimatePeakHeight(const API::IPeakFunction_const_sptr &peakfunc, const API::MatrixWorkspace_sptr &dataws,
                            size_t wsindex, size_t ixmin, size_t ixmax);
 
  double checkFittedPeak(const API::IPeakFunction_sptr &peakfunc, double costfuncvalue, std::string &errorreason);
 
  double fitPeakFunction(const API::IPeakFunction_sptr &peakfunc, const API::MatrixWorkspace_sptr &dataws,
                         size_t wsindex, double startx, double endx);
 
  double fitFunctionSD(API::IFunction_sptr fitfunc, const API::MatrixWorkspace_sptr &dataws, size_t wsindex,
                       double xmin, double xmax);
 
  double calChiSquareSD(const API::IFunction_sptr &fitfunc, const API::MatrixWorkspace_sptr &dataws, size_t wsindex,
                        double xmin, double xmax);
 
  double fitCompositeFunction(const API::IPeakFunction_sptr &peakfunc, const API::IBackgroundFunction_sptr &bkgdfunc,
                              const API::MatrixWorkspace_sptr &dataws, size_t wsindex, double startx, double endx);
 
  double fitFunctionMD(const API::IFunction_sptr &fitfunc, const API::MatrixWorkspace_sptr &dataws, size_t wsindex,
                       std::vector<double> vec_xmin, std::vector<double> vec_xmax);
  void removeBackground(const API::MatrixWorkspace_sptr &purePeakWS);
 
  void processNStoreFitResult(double rwp, bool storebkgd);
 
  std::map<std::string, double> backup(const API::IFunction_const_sptr &func);
 
  void pop(const std::map<std::string, double> &funcparammap, const API::IFunction_sptr &func);
 
  std::map<std::string, double> storeFunctionError(const API::IFunction_const_sptr &func);
 
  API::IBackgroundFunction_sptr fitBackground(API::IBackgroundFunction_sptr bkgdfunc);
 
  bool m_fitMethodSet;
  bool m_peakRangeSet;
  bool m_peakWidthSet;
  bool m_peakWindowSet;
  bool m_usePeakPositionTolerance;
 
  API::IPeakFunction_sptr m_peakFunc;
  API::IBackgroundFunction_sptr m_bkgdFunc;
 
  API::MatrixWorkspace_sptr m_dataWS;
  size_t m_wsIndex;
 
  double m_minFitX;
  double m_maxFitX;
  size_t i_minFitX;
  size_t i_maxFitX;
 
  double m_minPeakX;
  double m_maxPeakX;
  size_t i_minPeakX;
  size_t i_maxPeakX;
 
  std::map<std::string, double> m_bestPeakFunc;
  std::map<std::string, double> m_bestBkgdFunc;
 
  std::map<std::string, double> m_bkupPeakFunc;
  std::map<std::string, double> m_bkupBkgdFunc;
 
  std::map<std::string, double> m_fitErrorPeakFunc;
  std::map<std::string, double> m_fitErrorBkgdFunc;
 
  std::string m_minimizer;
  std::string m_costFunction;
 
  std::vector<double> m_vecFWHM;
 
  double m_peakPositionTolerance;
 
  double m_userPeakCentre;
 
  double m_bestRwp;
 
  double m_finalGoodnessValue;
 
  size_t m_numFitCalls;
 
  std::stringstream m_sstream;
};
 
class MANTID_ALGORITHMS_DLL FitPeak final : public API::Algorithm {
public:
  FitPeak();
 
  const std::string name() const override { return "FitPeak"; }
  const std::string summary() const override { return "Fit a single peak with checking mechanism. "; }
  int version() const override { return (1); }
  const std::string category() const override { return "Optimization"; }
 
private:
  void init() override;
  void exec() override;
 
  void processProperties();
 
  void prescreenInputData();
 
  void setupOutput(const std::map<std::string, double> &m_fitErrorPeakFunc,
                   const std::map<std::string, double> &m_fitErrorBkgdFunc);
 
  double fitPeakFunction(API::IPeakFunction_sptr peakfunc, API::MatrixWorkspace_sptr dataws, size_t wsindex,
                         double startx, double endx);
 
  API::IBackgroundFunction_sptr fitBackground(API::IBackgroundFunction_sptr bkgdfunc);
 
  double fitCompositeFunction(API::IPeakFunction_sptr peakfunc, API::IBackgroundFunction_sptr bkgdfunc,
                              API::MatrixWorkspace_sptr dataws, size_t wsindex, double startx, double endx);
 
  void makePurePeakWS(API::MatrixWorkspace_sptr purePeakWS);
 
  double estimatePeakHeight(API::IPeakFunction_sptr peakfunc, API::MatrixWorkspace_sptr dataws, size_t wsindex,
                            size_t ixmin, size_t ixmax);
 
  double fitFunctionSD(API::IFunction_sptr fitfunc, API::MatrixWorkspace_sptr dataws, size_t wsindex, double xmin,
                       double xmax, bool calmode);
 
  double fitFunctionMD(API::IFunction_sptr fitfunc, API::MatrixWorkspace_sptr dataws, size_t wsindex,
                       std::vector<double> vec_xmin, std::vector<double> vec_xmax);
 
  void processNStoreFitResult(double rwp, bool storebkgd);
 
  void setupGuessedFWHM(std::vector<double> &vec_FWHM);
 
  void pop(const std::map<std::string, double> &funcparammap, API::IFunction_sptr func);
 
  API::MatrixWorkspace_sptr genPurePeakWS();
 
  void createFunctions();
 
  double checkFittedPeak(API::IPeakFunction_sptr peakfunc, double costfuncvalue, std::string &errorreason);
 
  DataObjects::TableWorkspace_sptr genOutputTableWS(const API::IPeakFunction_sptr &peakfunc,
                                                    std::map<std::string, double> peakerrormap,
                                                    const API::IBackgroundFunction_sptr &bkgdfunc,
                                                    std::map<std::string, double> bkgderrormap);
 
  std::vector<std::string> addFunctionParameterNames(const std::vector<std::string> &funcnames);
 
  std::string parseFunctionTypeFull(const std::string &fullstring, bool &defaultparorder);
 
  API::MatrixWorkspace_sptr m_dataWS;
  size_t m_wsIndex;
 
  API::IPeakFunction_sptr m_peakFunc;
  API::IBackgroundFunction_sptr m_bkgdFunc;
  double m_minFitX;
  double m_maxFitX;
  double m_minPeakX;
  double m_maxPeakX;
 
  size_t i_minFitX;
  size_t i_maxFitX;
  size_t i_minPeakX;
  size_t i_maxPeakX;
 
  bool m_fitBkgdFirst;
 
  bool m_outputRawParams;
 
  double m_userGuessedFWHM;
  double m_userPeakCentre;
 
  int m_minGuessedPeakWidth;
  int m_maxGuessedPeakWidth;
  int m_fwhmFitStep;
  bool m_fitWithStepPeakWidth;
 
  bool m_usePeakPositionTolerance;
  double m_peakPositionTolerance;
 
  DataObjects::TableWorkspace_sptr m_peakParameterTableWS;
  DataObjects::TableWorkspace_sptr m_bkgdParameterTableWS;
 
  std::vector<std::string> m_peakParameterNames;
  std::vector<std::string> m_bkgdParameterNames;
 
  std::string m_minimizer;
 
  std::map<std::string, double> m_bkupBkgdFunc;
  std::map<std::string, double> m_bkupPeakFunc;
  std::map<std::string, double> m_bestPeakFunc;
  std::map<std::string, double> m_bestBkgdFunc;
  double m_bestRwp;
 
  double m_finalGoodnessValue;
 
  std::vector<double> m_vecybkup;
  std::vector<double> m_vecebkup;
 
  std::string m_costFunction;
 
  // std::map<std::string, double> m_fitErrorPeakFunc;
  // std::map<std::string, double> m_fitErrorBkgdFunc;
 
  bool m_lightWeightOutput;
};
 
} // namespace Algorithms
} // namespace Mantid