FunctionBrowser.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidQtWidgets/Common/FunctionBrowser.h"
#include "MantidQtWidgets/Common/FunctionMultiDomainPresenter.h"
#include "MantidQtWidgets/Common/FunctionTreeView.h"
 
#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/Expression.h"
#include "MantidAPI/FunctionFactory.h"
#include "MantidAPI/IConstraint.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/MultiDomainFunction.h"
#include "MantidAPI/ParameterTie.h"
 
#include "MantidKernel/Logger.h"
 
#include <QApplication>
#include <QClipboard>
#include <QHBoxLayout>
#include <QMessageBox>
 
#include <algorithm>
#include <boost/lexical_cast.hpp>
#include <utility>
 
namespace {
Mantid::Kernel::Logger g_log("Function Browser");
} // namespace
 
namespace MantidQt::MantidWidgets {
 
using namespace Mantid::API;
using namespace Mantid::Kernel;
 
FunctionBrowser::FunctionBrowser(QWidget *parent, bool multi, const std::vector<std::string> &categories)
    : QWidget(parent) {
  auto treeView = new FunctionTreeView(this, multi, categories);
  m_presenter = std::make_unique<FunctionMultiDomainPresenter>(treeView);
  QHBoxLayout *layout = new QHBoxLayout(this);
  layout->setMargin(0);
  layout->addWidget(treeView);
  connect(m_presenter.get(), SIGNAL(functionStructureChanged()), this, SIGNAL(functionStructureChanged()));
  connect(m_presenter.get(), SIGNAL(parameterChanged(std::string const &, std::string const &)), this,
          SIGNAL(parameterChanged(std::string const &, std::string const &)));
  connect(m_presenter.get(), SIGNAL(attributeChanged(std::string const &)), this,
          SIGNAL(attributeChanged(std::string const &)));
}
 
FunctionBrowser::~FunctionBrowser() = default;
 
void FunctionBrowser::clear() { m_presenter->clear(); }
 
void FunctionBrowser::setFunction(std::string const &funStr) { m_presenter->setFunctionString(funStr); }
 
void FunctionBrowser::setFunction(IFunction_sptr fun) { m_presenter->setFunction(std::move(fun)); }
 
IFunction_sptr FunctionBrowser::getFunctionByIndex(std::string const &index) {
  return m_presenter->getFunctionByIndex(index);
}
void FunctionBrowser::setParameter(std::string const &parameterName, double value) {
  m_presenter->setParameter(parameterName, value);
}
 
void FunctionBrowser::setParameterError(std::string const &parameterName, double error) {
  m_presenter->setParameterError(parameterName, error);
}
 
double FunctionBrowser::getParameter(std::string const &parameterName) const {
  return m_presenter->getParameter(parameterName);
}
 
void FunctionBrowser::updateParameters(const IFunction &fun) { m_presenter->updateParameters(fun); }
 
std::string FunctionBrowser::getFunctionString() { return m_presenter->getFunctionString(); }
 
Mantid::API::IFunction_sptr FunctionBrowser::getFunction() { return m_presenter->getFunction(); }
 
bool FunctionBrowser::hasFunction() const { return m_presenter->hasFunction(); }
 
int FunctionBrowser::getNumberOfDatasets() const { return m_presenter->getNumberOfDatasets(); }
 
std::vector<std::string> FunctionBrowser::getDatasetNames() const { return m_presenter->getDatasetNames(); }
 
std::vector<std::string> FunctionBrowser::getDatasetDomainNames() const { return m_presenter->getDatasetDomainNames(); }
 
void FunctionBrowser::setNumberOfDatasets(int n) { m_presenter->setNumberOfDatasets(n); }
 
void FunctionBrowser::setDatasets(const std::vector<std::string> &datasetNames) {
  m_presenter->setDatasets(datasetNames);
}
 
void FunctionBrowser::setDatasets(const QList<FunctionModelDataset> &datasets) { m_presenter->setDatasets(datasets); }
 
double FunctionBrowser::getLocalParameterValue(std::string const &parameterName, int i) const {
  return m_presenter->getLocalParameterValue(parameterName, i);
}
 
void FunctionBrowser::setLocalParameterValue(std::string const &parameterName, int i, double value) {
  m_presenter->setLocalParameterValue(parameterName, i, value);
}
 
void FunctionBrowser::setLocalParameterValue(std::string const &parameterName, int i, double value, double error) {
  m_presenter->setLocalParameterValue(parameterName, i, value, error);
}
 
double FunctionBrowser::getLocalParameterError(std::string const &parameterName, int i) const {
  return m_presenter->getLocalParameterValue(parameterName, i);
}
 
void FunctionBrowser::resetLocalParameters() {}
 
void FunctionBrowser::setCurrentDataset(int i) { m_presenter->setCurrentDataset(i); }
 
void FunctionBrowser::removeDatasets(const QList<int> &indices) { m_presenter->removeDatasets(indices); }
 
void FunctionBrowser::addDatasets(const std::vector<std::string> &names) { m_presenter->addDatasets(names); }
 
IFunction_sptr FunctionBrowser::getGlobalFunction() { return m_presenter->getFitFunction(); }
 
void FunctionBrowser::setLocalParameterFixed(std::string const &parameterName, int i, bool fixed) {
  m_presenter->setLocalParameterFixed(parameterName, i, fixed);
}
 
bool FunctionBrowser::isLocalParameterFixed(std::string const &parameterName, int i) const {
  return m_presenter->isLocalParameterFixed(parameterName, i);
}
 
std::string FunctionBrowser::getLocalParameterTie(std::string const &parameterName, int i) const {
  return m_presenter->getLocalParameterTie(parameterName, i);
}
 
void FunctionBrowser::setLocalParameterTie(std::string const &parameterName, int i, std::string const &tie) {
  m_presenter->setLocalParameterTie(parameterName, i, tie);
}
 
void FunctionBrowser::updateMultiDatasetParameters(const IFunction &fun) {
  m_presenter->updateMultiDatasetParameters(fun);
}
 
void FunctionBrowser::updateMultiDatasetAttributes(const IFunction &fun) {
  m_presenter->updateMultiDatasetAttributes(fun);
}
 
void FunctionBrowser::updateMultiDatasetParameters(const ITableWorkspace &paramTable) {
  auto const nRows = paramTable.rowCount();
  if (nRows == 0)
    return;
 
  auto const globalParameterNames = getGlobalParameters();
  for (auto &&name : globalParameterNames) {
    auto valueColumn = paramTable.getColumn(name);
    auto errorColumn = paramTable.getColumn(name + "_Err");
    setParameter(name, valueColumn->toDouble(0));
    setParameterError(name, errorColumn->toDouble(0));
  }
 
  auto const localParameterNames = getLocalParameters();
  for (auto &&name : localParameterNames) {
    auto valueColumn = paramTable.getColumn(name);
    auto errorColumn = paramTable.getColumn(name + "_Err");
    if (nRows > 1) {
      for (size_t i = 0; i < nRows; ++i) {
        setLocalParameterValue(name, static_cast<int>(i), valueColumn->toDouble(i), errorColumn->toDouble(i));
      }
    } else {
      auto const i = getCurrentDataset();
      setLocalParameterValue(name, i, valueColumn->toDouble(0), errorColumn->toDouble(0));
    }
  }
}
 
int FunctionBrowser::getCurrentDataset() const { return m_presenter->getCurrentDataset(); }
 
void FunctionBrowser::setColumnSizes(int s0, int s1, int s2) { m_presenter->setColumnSizes(s0, s1, s2); }
 
void FunctionBrowser::setStretchLastColumn(bool stretch) { m_presenter->setStretchLastColumn(stretch); }
 
void FunctionBrowser::setErrorsEnabled(bool enabled) { m_presenter->setErrorsEnabled(enabled); }
 
void FunctionBrowser::clearErrors() { m_presenter->clearErrors(); }
 
std::vector<std::string> FunctionBrowser::getGlobalParameters() const { return m_presenter->getGlobalParameters(); }
 
std::vector<std::string> FunctionBrowser::getLocalParameters() const { return m_presenter->getLocalParameters(); }
 
void FunctionBrowser::setGlobalParameters(std::vector<std::string> const &globals) {
  m_presenter->setGlobalParameters(globals);
}
 
std::optional<std::string> FunctionBrowser::currentFunctionIndex() { return m_presenter->currentFunctionIndex(); }
 
FunctionTreeView *FunctionBrowser::view() const { return dynamic_cast<FunctionTreeView *>(m_presenter->view()); }
 
std::string FunctionBrowser::getFitFunctionString() const { return m_presenter->getFitFunctionString(); }
 
void FunctionBrowser::setBackgroundA0(double value) { m_presenter->setBackgroundA0(value); }
 
void FunctionBrowser::hideGlobalCheckbox() { m_presenter->hideGlobals(); }
 
void FunctionBrowser::showGlobalCheckbox() { m_presenter->showGlobals(); }
 
} // namespace MantidQt::MantidWidgets