RefinePowderInstrumentParameters3.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 "MantidKernel/System.h"
 
#include "MantidAPI/Algorithm.h"
 
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
 
#include "MantidCurveFitting/Algorithms/LeBailFit.h"
#include "MantidCurveFitting/Constraints/BoundaryConstraint.h"
#include "MantidCurveFitting/Functions/ThermalNeutronDtoTOFFunction.h"
 
namespace Mantid {
namespace CurveFitting {
namespace Algorithms {
 
class MANTID_CURVEFITTING_DLL RefinePowderInstrumentParameters3 final : public API::Algorithm {
public:
  RefinePowderInstrumentParameters3();
 
  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 3; }
  const std::vector<std::string> seeAlso() const override { return {"RefinePowderDiffProfileSeq"}; }
 
  const std::string category() const override { return "Diffraction\\Fitting"; }
 
private:
  void init() override;
 
  void exec() override;
 
  double execFitParametersNonMC();
 
  double execFitParametersMC();
 
  double doSimulatedAnnealing(std::map<std::string, Parameter> inparammap);
 
  void setupRandomWalkStrategy(std::map<std::string, Parameter> &parammap,
                               std::vector<std::vector<std::string>> &mcgroups);
 
  void addParameterToMCMinimize(std::vector<std::string> &parnamesforMC, const std::string &parname,
                                std::map<std::string, Parameter> parammap);
 
  void proposeNewValues(const std::vector<std::string> &mcgroup, std::map<std::string, Parameter> &curparammap,
                        std::map<std::string, Parameter> &newparammap, double currchisq);
 
  bool acceptOrDenyChange(double curchisq, double newchisq, double temperature);
 
  void bookKeepMCResult(std::map<std::string, Parameter> parammap, double chisq, int istep, int igroup,
                        std::map<std::string, Parameter> &bestparammap);
  // vector<pair<double, map<string, Parameter> > > &bestresults, size_t
  // maxnumresults);
 
  double calculateFunction(const std::map<std::string, Parameter> &parammap, std::vector<double> &vecY);
 
  double calculateFunctionError(const API::IFunction_sptr &function, const DataObjects::Workspace2D_sptr &dataws,
                                int wsindex);
 
  double fitFunction(const API::IFunction_sptr &function, const DataObjects::Workspace2D_sptr &dataws, int wsindex,
                     bool powerfit);
 
  bool doFitFunction(const API::IFunction_sptr &function, const DataObjects::Workspace2D_sptr &dataws, int wsindex,
                     const std::string &minimizer, int numiters, double &chi2, std::string &fitstatus);
 
  void processInputProperties();
 
  void parseTableWorkspaces();
 
  void parseTableWorkspace(const DataObjects::TableWorkspace_sptr &tablews, std::map<std::string, Parameter> &parammap);
 
  void setFunctionParameterValues(const API::IFunction_sptr &function, std::map<std::string, Parameter> params);
 
  void updateFunctionParameterValues(API::IFunction_sptr function, std::map<std::string, Parameter> &params);
 
  void setFunctionParameterFitSetups(const API::IFunction_sptr &function, std::map<std::string, Parameter> params);
 
  DataObjects::Workspace2D_sptr genOutputWorkspace(const API::FunctionDomain1DVector &domain,
                                                   const API::FunctionValues &rawvalues);
 
  DataObjects::TableWorkspace_sptr genOutputProfileTable(std::map<std::string, Parameter> parameters, double startchi2,
                                                         double finalchi2);
 
  void addOrReplace(std::map<std::string, Parameter> &parameters, const std::string &parname, double parvalue);
 
  //--------  Variables ------------------------------------------------------
  DataObjects::Workspace2D_sptr m_dataWS;
 
  int m_wsIndex;
 
  DataObjects::TableWorkspace_sptr m_paramTable;
 
  enum { FIT, MONTECARLO } m_fitMode;
 
  enum { CONSTANT, USEINPUT } m_stdMode;
 
  int m_numWalkSteps;
 
  int m_randomSeed;
 
  std::map<std::string, Parameter> m_profileParameters;
 
  Functions::ThermalNeutronDtoTOFFunction_sptr m_positionFunc;
 
  double m_dampingFactor;
 
  double m_bestChiSq;
  int m_bestChiSqStep;
  int m_bestChiSqGroup;
};
 
//================================= External Functions
//=========================================
void convertToDict(std::vector<std::string> strvec, std::map<std::string, size_t> &lookupdict);
 
int getStringIndex(std::map<std::string, size_t> lookupdict, const std::string &key);
 
void storeFunctionParameterValue(const API::IFunction_sptr &function,
                                 std::map<std::string, std::pair<double, double>> &parvaluemap);
 
void restoreFunctionParameterValue(std::map<std::string, std::pair<double, double>> parvaluemap,
                                   const API::IFunction_sptr &function, std::map<std::string, Parameter> &parammap);
 
void duplicateParameters(std::map<std::string, Parameter> source, std::map<std::string, Parameter> &target);
 
void copyParametersValues(std::map<std::string, Parameter> source, std::map<std::string, Parameter> &target);
 
double calculateFunctionChiSquare(const std::vector<double> &modelY, const std::vector<double> &dataY,
                                  const std::vector<double> &dataE);
 
} // namespace Algorithms
} // namespace CurveFitting
} // namespace Mantid