RefinePowderInstrumentParameters.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/Algorithm.h"
#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/DeprecatedAlgorithm.h"
#include "MantidAPI/FunctionDomain.h"
#include "MantidAPI/FunctionValues.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidCurveFitting/Functions/BackToBackExponential.h"
#include "MantidCurveFitting/Functions/BackgroundFunction.h"
#include "MantidCurveFitting/Functions/Polynomial.h"
#include "MantidCurveFitting/Functions/ThermalNeutronDtoTOFFunction.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidHistogramData/HistogramX.h"
#include "MantidHistogramData/HistogramY.h"
#include "MantidKernel/System.h"
 
namespace Mantid {
namespace CurveFitting {
namespace Algorithms {
 
class MANTID_CURVEFITTING_DLL RefinePowderInstrumentParameters final : public API::Algorithm,
                                                                       public API::DeprecatedAlgorithm {
public:
  RefinePowderInstrumentParameters();
 
  const std::string name() const override { return "RefinePowderInstrumentParameters"; }
  const std::string summary() const override { return "Parameters include Dtt1, Dtt1t, Dtt2t, Zero, Zerot. "; }
 
  int version() const override { return 2; }
 
  const std::string category() const override { return "Diffraction\\Fitting"; }
 
private:
  // Implement abstract Algorithm methods
  void init() override;
  // Implement abstract Algorithm methods
  void exec() override;
 
  //----------------  Processing Input ---------------------
  void importParametersFromTable(const DataObjects::TableWorkspace_sptr &parameterWS,
                                 std::map<std::string, double> &parameters);
 
  void importMonteCarloParametersFromTable(const DataObjects::TableWorkspace_sptr &tablews,
                                           const std::vector<std::string> &parameternames,
                                           std::vector<double> &stepsizes, std::vector<double> &lowerbounds,
                                           std::vector<double> &upperbounds);
 
  void genPeakCentersWorkspace(bool montecarlo, size_t numbestfit);
 
  void genPeaksFromTable(const DataObjects::TableWorkspace_sptr &peakparamws);
 
  //---------------  Processing Output ------------------
  DataObjects::TableWorkspace_sptr genOutputInstrumentParameterTable();
 
  DataObjects::TableWorkspace_sptr genMCResultTable();
 
  //--------------- Fit and MC methods -------------------
  void fitInstrumentParameters();
 
  double calculateFunctionStatistic(const API::IFunction_sptr &func, const API::MatrixWorkspace_sptr &dataws,
                                    size_t workspaceindex);
 
  bool fitFunction(const API::IFunction_sptr &func, double &gslchi2);
 
  std::string parseFitParameterWorkspace(API::ITableWorkspace_sptr paramws);
 
  std::string parseFitResult(API::IAlgorithm_sptr fitalg, double &chi2);
 
  void refineInstrumentParametersMC(const DataObjects::TableWorkspace_sptr &parameterWS, bool fit2 = false);
 
  void doParameterSpaceRandomWalk(std::vector<std::string> parnames, std::vector<double> lowerbounds,
                                  std::vector<double> upperbounds, std::vector<double> stepsizes, size_t maxsteps,
                                  double stepsizescalefactor, bool fit2);
 
  void getD2TOFFuncParamNames(std::vector<std::string> &parnames);
 
  double calculateD2TOFFunction(const API::IFunction_sptr &func, const API::FunctionDomain1DVector &domain,
                                API::FunctionValues &values, const Mantid::HistogramData::HistogramY &rawY,
                                const Mantid::HistogramData::HistogramE &rawE);
 
  // double calculateDspaceValue(std::vector<int> hkl, double lattice);
 
  void calculateThermalNeutronSpecial(const API::IFunction_sptr &m_Function,
                                      const Mantid::HistogramData::HistogramX &xVals, std::vector<double> &vec_n);
 
  //--------------- Class Variables -------------------
  DataObjects::Workspace2D_sptr m_dataWS;
 
  std::map<std::vector<int>, Functions::BackToBackExponential_sptr> m_Peaks;
 
  std::map<std::vector<int>, double> m_PeakErrors;
 
  std::map<std::string, double> m_FuncParameters;
  std::map<std::string, double> m_OrigParameters;
 
  std::vector<std::string> m_PeakFunctionParameterNames;
  std::vector<std::pair<double, std::vector<double>>> m_BestMCParameters;
  std::vector<std::pair<double, std::vector<double>>> m_BestFitParameters;
  std::vector<std::pair<double, double>> m_BestFitChi2s;
  double m_BestGSLChi2;
 
  double m_MinSigma;
 
  size_t m_MinNumFittedPeaks;
 
  size_t m_MaxNumberStoredParameters;
 
  Functions::ThermalNeutronDtoTOFFunction_sptr m_Function;
};
 
inline double linearInterpolateX(double x0, double xf, double y0, double yf, double y) {
  double x = ((xf - x0) * y - (xf * y0 - x0 * yf)) / (yf - y0);
  return x;
}
 
inline double linearInterpolateY(double x0, double xf, double y0, double yf, double x) {
  double y = ((xf * y0 - x0 * yf) + x * (yf - y0)) / (xf - x0);
  return y;
}
 
} // namespace Algorithms
} // namespace CurveFitting
} // namespace Mantid