FABADAMinimizer.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2014 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/IFuncMinimizer.h"
#include "MantidCurveFitting/CostFunctions/CostFuncLeastSquares.h"
#include "MantidCurveFitting/EigenMatrix.h"
#include "MantidCurveFitting/EigenVector.h"
#include "MantidKernel/System.h"
 
namespace Mantid {
namespace CurveFitting {
namespace CostFunctions {
class CostFuncLeastSquares;
} // namespace CostFunctions
} // namespace CurveFitting
} // namespace Mantid
 
namespace Mantid {
namespace CurveFitting {
namespace FuncMinimisers {
 
class MANTID_CURVEFITTING_DLL FABADAMinimizer : public API::IFuncMinimizer {
public:
  FABADAMinimizer();
  std::string name() const override { return "FABADA"; }
  void initialize(API::ICostFunction_sptr function, size_t maxIterations) override;
  bool iterate(size_t iter) override;
  double costFunctionVal() override;
  void finalize() override;
 
 
  void boundApplication(const size_t &parameterIndex, double &newValue, double &step);
 
private:
  double gaussianStep(const double &jump);
  void tieApplication(const size_t &parameterIndex, EigenVector &newParameters, double &newValue);
  void algorithmDisplacement(const size_t &parameterIndex, const double &chi2New, const EigenVector &newParameters);
  void jumpUpdate(const size_t &parameterIndex);
  void convergenceCheck();
  void simAnnealingRefrigeration();
  bool iterationContinuation();
  void outputChains();
  void outputConvergedChains(size_t convLength, int nSteps);
  void outputCostFunctionTable(size_t convLength, double mostProbableChi2);
  double outputPDF(std::size_t const &convLength, std::vector<std::vector<double>> &reducedChain);
  void outputPDF(std::vector<double> &xValues, std::vector<double> &yValues,
                 std::vector<std::vector<double>> &reducedChain, std::size_t const &convLength, int const &pdfLength);
  double getMostProbableChiSquared(std::size_t const &convLength, std::vector<std::vector<double>> &reducedChain,
                                   int const &pdfLength, std::vector<double> &xValues, std::vector<double> &yValues,
                                   std::vector<double> &PDFYAxis, double const &start, double const &bin);
  void setParameterXAndYValuesForPDF(std::vector<double> &xValues, std::vector<double> &yValues,
                                     std::vector<std::vector<double>> &reducedChain, std::size_t const &convLength,
                                     int const &pdfLength);
  void outputParameterTable(const std::vector<double> &bestParameters, const std::vector<double> &errorsLeft,
                            const std::vector<double> &errorsRight);
  void calculateConvChainAndBestParameters(size_t convLength, int nSteps,
                                           std::vector<std::vector<double>> &reducedChain,
                                           std::vector<double> &bestParameters, std::vector<double> &errorLeft,
                                           std::vector<double> &errorRight);
  void initChainsAndParameters();
  void initSimulatedAnnealing();
 
  // Variables declarations
  // Intentar encontrar una manera de sacar aqui el numero de parametros  que
  // no sea necesaria la cost function
  std::shared_ptr<CostFunctions::CostFuncLeastSquares> m_leastSquares;
  API::IFunction_sptr m_fitFunction;
  size_t m_counter;
  size_t m_chainIterations;
  std::vector<int> m_changes;
  std::vector<double> m_jump;
  EigenVector m_parameters;
  std::vector<std::vector<double>> m_chain;
  double m_chi2;
  bool m_converged;
  size_t m_convPoint;
  std::vector<bool> m_parConverged;
  std::vector<double> m_criteria;
  size_t m_maxIter;
  std::vector<bool> m_parChanged;
  double m_temperature;
  size_t m_counterGlobal;
  size_t m_simAnnealingItStep;
  size_t m_leftRefrPoints;
  double m_tempStep;
  bool m_overexploration;
  size_t m_nParams;
  std::vector<size_t> m_numInactiveRegenerations;
  std::vector<int> m_changesOld;
};
 
class MaleableCostFunction : public CostFunctions::CostFuncLeastSquares {
public:
  void setDirtyInherited() { setDirty(); }
};
 
} // namespace FuncMinimisers
} // namespace CurveFitting
} // namespace Mantid