PlotPeakByLogValue.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/IFunction.h"
#include "MantidAPI/IPeakFunction.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidCurveFitting/Algorithms/PlotPeakByLogValueHelper.h"
 
namespace Mantid {
namespace CurveFitting {
namespace Algorithms {
class MANTID_CURVEFITTING_DLL PlotPeakByLogValue final : public API::Algorithm {
public:
  const std::string name() const override { return "PlotPeakByLogValue"; }
  const std::string summary() const override { return "Fits a number of spectra with the same function."; }
 
  int version() const override { return 1; }
  const std::vector<std::string> seeAlso() const override { return {"Fit"}; }
  const std::string category() const override { return "Optimization"; }
 
private:
  // Overridden Algorithm methods
  void init() override;
  std::map<std::string, std::string> validateInputs() override;
  void exec() override;
 
  void setWorkspaceIndexAttribute(const API::IFunction_sptr &fun, int wsIndex) const;
 
  std::shared_ptr<Algorithm> runSingleFit(bool createFitOutput, bool outputCompositeMembers,
                                          bool outputConvolvedMembers, bool appendIdx, const API::IFunction_sptr &ifun,
                                          const InputSpectraToFit &data, double startX, double endX,
                                          const std::string &exclude);
 
  double calculateLogValue(const std::string &logName, const InputSpectraToFit &data);
 
  API::ITableWorkspace_sptr createResultsTable(const std::string &logName, const API::IFunction_sptr &ifunSingle,
                                               bool &isDataName);
 
  void appendTableRow(bool isDataName, API::ITableWorkspace_sptr &result, const API::IFunction_sptr &ifun,
                      const InputSpectraToFit &data, double logValue, double chi2) const;
 
  void finaliseOutputWorkspacesWithAppend(const std::vector<std::string> &fitWorkspaces,
                                          const std::vector<std::string> &parameterWorkspaces,
                                          const std::vector<std::string> &covarianceWorkspaces,
                                          const std::vector<InputSpectraToFit> &wsNames);
 
  void finaliseOutputWorkspaces(const std::vector<API::MatrixWorkspace_sptr> &fitWorkspaces,
                                const std::vector<API::ITableWorkspace_sptr> &parameterWorkspaces,
                                const std::vector<API::ITableWorkspace_sptr> &covarianceWorkspaces);
 
  void groupResParams(const std::vector<API::ITableWorkspace_sptr> &paramsWs,
                      const std::vector<std::string> &paramsNames);
 
  void finaliseMinimizerOutput();
 
  API::IFunction_sptr setupFunction(bool individual, bool passWSIndexToFunction,
                                    const API::IFunction_sptr &inputFunction, const std::vector<double> &initialParams,
                                    bool isMultiDomainFunction, int i, const InputSpectraToFit &data) const;
 
  std::string getMinimizerString(const std::string &wsName, const std::string &wsIndex);
 
  std::vector<std::string> getExclude(const size_t numSpectra);
 
  std::string m_baseName;
 
  std::map<std::string, std::vector<std::string>> m_minimizerWorkspaces;
};
 
} // namespace Algorithms
} // namespace CurveFitting
} // namespace Mantid