FitPropertyBrowser.h

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 +
#pragma once
 
#include "DllOption.h"
#include "MantidAPI/AlgorithmObserver.h"
#include "MantidAPI/Workspace_fwd.h"
 
#include <QDockWidget>
#include <QHash>
#include <QList>
#include <QMap>
 
#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/FunctionFactory.h"
#include "MantidAPI/IFunction.h"
#include "MantidAPI/IPeakFunction.h"
#include "MantidAPI/MatrixWorkspace_fwd.h"
#include "MantidQtWidgets/Common/FitPropertyBrowserFindPeaksExt.h"
#include "MantidQtWidgets/Common/IWorkspaceFitControl.h"
#include "MantidQtWidgets/Common/SelectFunctionDialog.h"
#include "MantidQtWidgets/Common/WorkspaceObserver.h"
 
/* Forward declarations */
 
class QtTreePropertyBrowser;
class QtGroupPropertyManager;
class QtDoublePropertyManager;
class QtIntPropertyManager;
class QtBoolPropertyManager;
class QtStringPropertyManager;
class QtEnumPropertyManager;
class ParameterPropertyManager;
 
class QtProperty;
class QtBrowserItem;
 
class QAction;
class QComboBox;
class QLabel;
class QLineEdit;
class QListWidget;
class QListWidgetItem;
class QMenu;
class QPushButton;
class QSignalMapper;
class QTreeWidget;
class QVBoxLayout;
 
namespace MantidQt {
namespace MantidWidgets {
 
class PropertyHandler;
class SelectFunctionDialog;
class EXPORT_OPT_MANTIDQT_COMMON FitPropertyBrowser : public QDockWidget,
                                                      public Mantid::API::AlgorithmObserver,
                                                      public MantidQt::API::WorkspaceObserver,
                                                      public IWorkspaceFitControl {
  Q_OBJECT
public:
  FitPropertyBrowser(QWidget *parent = nullptr, QObject *mantidui = nullptr);
  ~FitPropertyBrowser() override;
  PropertyHandler *getHandler() const;
  virtual void init();
 
  double centre() const;
  void setCentre(double value);
  double height() const;
  void setHeight(double value);
  double fwhm() const;
  void setFwhm(double value);
  int count() const;
  bool isPeak() const;
  PropertyHandler *currentHandler() const;
  void setCurrentFunction(PropertyHandler *h) const;
  std::shared_ptr<const Mantid::API::IFunction> theFunction() const;
  void updateParameters();
  void updateAttributes();
  QList<double> getParameterValues() const;
  QStringList getParameterNames() const;
  // Get parameters used to run the Fit algorithm
  const std::string &getFitAlgorithmParameters() const;
  // Get the status string returned from Fit
  const std::string &getFitAlgorithmOutputStatus() const;
 
  void loadFunction(const QString &funcString);
  void saveFunction(const QString &fnName);
  PropertyHandler *addFunction(const std::string &fnName);
 
  virtual void removeFunction(PropertyHandler *handler);
 
  std::shared_ptr<Mantid::API::CompositeFunction> compositeFunction() const { return m_compositeFunction; }
 
  Mantid::API::IFunction_sptr getFittingFunction() const;
  Mantid::API::IFunction_sptr getFunctionAtIndex(std::size_t const &index) const;
 
  const std::string &defaultFunctionType() const;
  void setDefaultFunctionType(const std::string &fnType);
  std::string defaultPeakType();
  void setDefaultPeakType(const std::string &fnType);
  const std::string &defaultBackgroundType() const;
  void setDefaultBackgroundType(const std::string &fnType);
 
  std::shared_ptr<Mantid::API::Workspace> getWorkspace() const;
  std::string workspaceName() const;
  virtual void setWorkspaceName(const QString &wsName) override;
  int workspaceIndex() const;
  void setWorkspaceIndex(int i) override;
  virtual std::string outputName() const;
  void setOutputName(const std::string & /*name*/);
  std::string minimizer(bool withProperties = false) const;
  bool ignoreInvalidData() const;
  void setIgnoreInvalidData(bool on);
  std::string costFunction() const;
  bool convolveMembers() const;
  bool isHistogramFit() const;
  void normaliseData(bool on) { m_shouldBeNormalised = on; }
  int maxIterations() const;
  int getPeakRadius() const;
  std::string getExcludeRange() const;
  QVector<double> getXRange();
 
  std::string getFunctionString() const;
  double startX() const;
  void setStartX(double start) override;
  double endX() const;
  void setEndX(double end) override;
  void setXRange(double start, double end);
  QString getXColumnName() const;
  QString getYColumnName() const;
  QString getErrColumnName() const;
 
  const QStringList &registeredFunctions() const { return m_registeredFunctions; }
  const QStringList &registeredPeaks() const { return m_registeredPeaks; }
  const QStringList &registeredBackgrounds() const { return m_registeredBackgrounds; }
  const QStringList &registeredOthers() const { return m_registeredOther; }
 
  bool isUndoEnabled() const;
  bool isFitEnabled() const;
 
  virtual void setFitEnabled(bool enable);
 
  void setTip(const QString &txt);
 
  void setTextPlotGuess(const QString &text);
 
  QString getTieString() const;
 
  QString getConstraintsString() const;
 
  // send parameterChanged signal
  void sendParameterChanged(const Mantid::API::IFunction *f) { emit parameterChanged(f); }
 
  // send parameterChanged signal
  void sendParameterChanged(const QString &prefix) { emit changedParameterOf(prefix); }
 
  void addAutoBackground();
  bool isAutoBack() const { return m_autoBackground != nullptr; }
  void setAutoBackgroundName(const QString &aName);
  void refitAutoBackground();
  QString getAutoBackgroundString() const { return m_autoBgName + " " + m_autoBgAttributes; }
 
  int getDecimals() const { return m_decimals; }
  void setDecimals(int d);
 
  bool plotDiff() const;
  bool plotCompositeMembers() const;
 
  bool rawData() const override;
 
  void setADSObserveEnabled(bool enabled);
 
  void postDeleteHandle(const std::string &wsName) override;
  void renameHandle(const std::string &oldName, const std::string &newName) override;
  void addHandle(const std::string &wsName, const std::shared_ptr<Mantid::API::Workspace> &ws) override;
 
  // Remove Workspace
  void removeWorkspace(const std::string &wsName);
  void removeWorkspaceAndSpectra(const std::string &wsName);
 
  void finishHandle(const Mantid::API::IAlgorithm *alg) override;
 
  const QStringList &getWorkspaceNames();
 
  void allowSequentialFits(bool allow) override;
 
  QMenu *getFitMenu() const { return m_fitMenu; }
 
  QListWidget *getWorkspaceList() const { return m_wsListWidget; }
 
  void addFitResultWorkspacesToTableWidget();
 
  // Methods intended for testing only
 
  int sizeOfFunctionsGroup() const;
 
  // Methods intended for interfacing with the workbench fitting tools
 
  void addAllowedSpectra(const QString &wsName, const QList<int> &wsIndices);
  void addAllowedTableWorkspace(const QString &wsName);
  QString addFunction(const QString &fnName);
  PropertyHandler *getPeakHandler(const QString &prefix);
  void setPeakCentreOf(const QString &prefix, double value);
  double getPeakCentreOf(const QString &prefix);
  void setPeakHeightOf(const QString &prefix, double value);
  double getPeakHeightOf(const QString &prefix);
  void setPeakFwhmOf(const QString &prefix, double value);
  double getPeakFwhmOf(const QString &prefix);
  std::string getWidthParameterNameOf(const QString &prefix);
  std::string getCentreParameterNameOf(const QString &prefix);
  bool isParameterExplicitlySetOf(const QString &prefix, const std::string &param);
  QStringList getPeakPrefixes() const;
  void findPeaks(const std::unique_ptr<FindPeakStrategyGeneric> findPeakStrategy);
  bool createAndAddFunction(const Mantid::API::MatrixWorkspace_sptr inputWS, const size_t peakIndex,
                            const std::unique_ptr<FindPeakStrategyGeneric> &findPeakStrategy);
 
  // Emits a signal for when the sequential fit has finished
 
  void sequentialFitFinished() { emit sequentialFitDone(); }
 
public slots:
  virtual void fit();
  virtual void toggleSettingsBrowserVisible();
  virtual void removePropertiesFromSettingsBrowser(const QStringList &propsToRemove);
  virtual void toggleWsListVisible();
  virtual void sequentialFit();
  void undoFit();
  virtual void clear();
  void clearBrowser();
  void setPeakToolOn(bool on);
  virtual void executeFitMenu(const QString & /*item*/);
  void executeDisplayMenu(const QString & /*item*/);
  void executeSetupMenu(const QString & /*item*/);
  void executePeakFindingAlgMenu(const QString & /*item*/);
  void executeSetupManageMenu(const QString & /*item*/);
  void workspaceDoubleClicked(QListWidgetItem *item);
  void executeCustomSetupRemove(const QString &name);
  void executeClearCustomSetups();
 
signals:
  void currentChanged() const;
  void functionRemoved();
  void algorithmFinished(const QString & /*_t1*/);
  void algorithmFailed();
  void algorithmStarted(const QString & /*_t1*/);
  void workspaceIndexChanged(int index);
  void updatePlotSpectrum(int index);
  void workspaceNameChanged(const QString & /*_t1*/);
  void sequentialFitDone() const;
 
  void wsChangePPAssign(const QString & /*_t1*/);
  void functionChanged();
 
  void startXChanged(double /*_t1*/);
  void endXChanged(double /*_t1*/);
  void xRangeChanged(double /*_t1*/, double /*_t2*/);
  void parameterChanged(const Mantid::API::IFunction * /*_t1*/);
  void changedParameterOf(const QString &prefix);
  void functionCleared();
  void plotGuess();
  void plotCurrentGuess();
  void removeGuess();
  void removeCurrentGuess();
  void changeWindowTitle(const QString & /*_t1*/);
  void removePlotSignal(MantidQt::MantidWidgets::PropertyHandler * /*_t1*/);
  void removeFitCurves();
 
  void executeFit(QString /*_t1*/, QHash<QString, QString> /*_t2*/, Mantid::API::AlgorithmObserver * /*_t3*/);
  void multifitFinished();
 
  void fittingDone(const QString & /*_t1*/);
  void functionFactoryUpdateReceived();
  void errorsEnabled(bool enabled);
  void fitUndone();
  void functionLoaded(const QString & /*_t1*/);
  void fitResultsChanged(const QString &status);
  void workspaceClicked(const QString &wsName);
  void itemDoubleClicked(QListWidgetItem *item);
 
protected slots:
  virtual void populateFunctionNames();
  virtual void boolChanged(QtProperty *prop);
 
  virtual void enumChanged(QtProperty *prop);
 
  virtual void intChanged(QtProperty *prop);
 
  virtual void doubleChanged(QtProperty *prop);
 
  void enactAttributeChange(QtProperty *prop, PropertyHandler *h, const bool vectorAttribute = false);
 
private slots:
  void parameterChanged(QtProperty *prop);
  void stringChanged(QtProperty *prop);
  void filenameChanged(QtProperty *prop);
  void columnChanged(QtProperty *prop);
  void currentItemChanged(QtBrowserItem * /*current*/);
  void vectorDoubleChanged(QtProperty *prop);
  void vectorSizeChanged(QtProperty *prop);
  void addTie();
  void addTieToFunction();
  void addFixTie();
  void deleteTie();
  void addLowerBound10();
  void addLowerBound50();
  void addLowerBound();
  void addConstraint(int f, bool lo, bool up);
  void addUpperBound10();
  void addUpperBound50();
  void addUpperBound();
  void addBothBounds10();
  void addBothBounds50();
  void addBothBounds();
  void removeBounds();
  void plotGuessCurrent();
  void plotGuessAll();
  void removeGuessCurrent();
  void removeGuessAll();
  void plotOrRemoveGuessAll();
  void clearAllPlots();
  void saveFunction();
  void loadFunction();
  void loadFunctionFromString();
  void acceptFit();
  void closeFit();
  void copy();         
  void paste();        
  void reset();        
  void functionHelp(); 
  void browserHelp();  
 
  void popupMenu(const QPoint & /*unused*/);
  /* Context menu slots */
  void addFunction();
  void deleteFunction();
  void setupMultifit();
 
  void processMultiBGResults();
 
  void executeCustomSetupLoad(const QString &name);
 
  void updateStructureTooltips();
  void showFitResultStatus(const QString &status);
  void clearFitResultStatus();
 
public: // functions declared public for testing
  QString getOldExpressionAsString(const QString &parameterName) const;
  void createCompositeFunction(const QString &str = "");
 
protected:
  void modifyFitMenu(QAction *fitAction, bool enabled);
  virtual void populateFitMenuButton(QSignalMapper *fitMapper, QMenu *fitMenu);
  bool getShouldBeNormalised() { return m_shouldBeNormalised; };
  void showEvent(QShowEvent *e) override;
  void hideEvent(QHideEvent *e) override;
  void populateWorkspaceNames();
  void createEditors(QWidget *w);
  void initLayout(QWidget *w);
  void initBasicLayout(QWidget *w);
  void updateDecimals();
  void setWorkspace(const Mantid::API::IFunction_sptr &function) const;
  void setWorkspaceProperties();
  virtual void addWorkspaceIndexToBrowser();
  void updateBrowserFromFitResults(const Mantid::API::IFunction_sptr &finalFunction);
  QtProperty *addDoubleProperty(const QString &name, QtDoublePropertyManager *manager = nullptr) const;
  void minimizerChanged();
  void doFit(int maxIterations);
  Mantid::API::IFunction_sptr tryCreateFitFunction(const QString &str);
  void createCompositeFunction(const Mantid::API::IFunction_sptr &func);
 
  QtGroupPropertyManager *m_groupManager;
  QtDoublePropertyManager *m_doubleManager;
  QtEnumPropertyManager *m_enumManager;
  QtIntPropertyManager *m_intManager;
  QtBoolPropertyManager *m_boolManager;
  QtStringPropertyManager *m_stringManager;
  QtStringPropertyManager *m_filenameManager;
  QtStringPropertyManager *m_formulaManager;
  QtEnumPropertyManager *m_columnManager;
  QtGroupPropertyManager *m_vectorManager;
  QtIntPropertyManager *m_vectorSizeManager;
  QtDoublePropertyManager *m_vectorDoubleManager;
  ParameterPropertyManager *m_parameterManager;
 
  QtProperty *m_workspace;
  QtProperty *m_workspaceIndex;
  QtProperty *m_startX;
  QtProperty *m_endX;
  QtProperty *m_output;
  QtProperty *m_minimizer;
  QtProperty *m_ignoreInvalidData;
  QtProperty *m_costFunction;
  QtProperty *m_maxIterations;
  QtProperty *m_peakRadius;
  QtProperty *m_plotDiff;
  QtProperty *m_excludeRange;
  QtProperty *m_plotCompositeMembers;
  QtProperty *m_convolveMembers;
  QtProperty *m_rawData;
  QtProperty *m_xColumn;
  QtProperty *m_yColumn;
  QtProperty *m_errColumn;
  QtProperty *m_showParamErrors;
  QtProperty *m_evaluationType;
  QList<QtProperty *> m_minimizerProperties;
 
  std::shared_ptr<Mantid::API::CompositeFunction> m_compositeFunction;
 
  QtTreePropertyBrowser *m_browser;
 
  QAction *m_fitActionUndoFit;
  QAction *m_fitActionSeqFit;
  QAction *m_fitActionFit;
  QAction *m_fitActionEvaluate;
 
  QtBrowserItem *m_functionsGroup;
  QtBrowserItem *m_settingsGroup;
  QtBrowserItem *m_customSettingsGroup;
 
  bool m_changeSlotsEnabled;
  bool m_guessOutputName;
 
  mutable QStringList m_registeredFunctions;
  mutable QStringList m_registeredPeaks;
  mutable QStringList m_registeredBackgrounds;
  mutable QStringList m_registeredOther;
  mutable QStringList m_minimizers;
  mutable QStringList m_workspaceNames;
  mutable QStringList m_costFunctions;
  mutable QStringList m_evaluationTypes;
 
  std::vector<double> m_initialParameters;
 
private:
  QPushButton *createFitMenuButton(QWidget *w);
  virtual bool isWorkspaceValid(Mantid::API::Workspace_sptr /*ws*/) const;
  QtBrowserItem *findItem(QtBrowserItem *parent, QtProperty *prop) const;
 
  void disableUndo();
  QtProperty *addStringProperty(const QString &name) const;
  void setStringPropertyValue(QtProperty *prop, const QString &value) const;
  QString getStringPropertyValue(QtProperty *prop) const;
  QtProperty *addStringListProperty(const QString &name, const std::vector<std::string> &allowed_values) const;
  void checkFunction();
  int getAllowedIndex(int currentIndex) const;
 
  void setCurrentFunction(const Mantid::API::IFunction_const_sptr &f) const;
 
  virtual void workspaceChange(const QString &wsName);
 
  void hasConstraints(QtProperty *parProp, bool &hasTie, bool &hasFix, bool &hasBounds) const;
  QtProperty *getTieProperty(QtProperty *parProp) const;
 
  void handleFactoryUpdate(Mantid::API::FunctionFactoryUpdateNotification_ptr /*notice*/);
  Poco::NObserver<FitPropertyBrowser, Mantid::API::FunctionFactoryUpdateNotification> m_updateObserver;
 
  // void validateGroupMember();
 
  QSignalMapper *m_fitMapper;
  QMenu *m_fitMenu;
  QAction *m_displayActionPlotGuess;
  QAction *m_displayActionQuality;
  QAction *m_displayActionClearAll;
  QString m_windowBaseString;
 
  QAction *m_setupActionCustomSetup;
  QAction *m_setupActionRemove;
  void updateSetupMenus();
 
  QLabel *m_tip;
  QLabel *m_status;
 
  // The widget for choosing the fit function.
  SelectFunctionDialog *m_fitSelector;
  // The tree widget containing the fit functions.
  QTreeWidget *m_fitTree;
 
  //
  QListWidget *m_wsListWidget;
  QLabel *m_workspaceLabel;
 
  QMap<QString, QtStringPropertyManager *> m_stringManagers;
 
  mutable PropertyHandler *m_currentHandler;
 
  mutable QStringList m_dataTypes;
 
  std::string m_defaultFunction;
  std::string m_defaultPeak;
  std::string m_defaultBackground;
 
  bool m_peakToolOn;
 
  bool m_hideWsListWidget;
 
  bool m_auto_back;
 
  QString m_autoBgName;
  QString m_autoBgAttributes;
 
  PropertyHandler *m_autoBackground;
 
  int m_decimals;
 
  QObject *m_mantidui;
 
  std::string m_storedWorkspaceName;
 
  bool m_shouldBeNormalised;
 
  // Keep a history of the parameters used to run the Fit algorithm
  std::string m_fitAlgParameters;
  std::string m_fitAlgOutputStatus;
 
  QMap<QString, QList<int>> m_allowedSpectra;
  QString m_allowedTableWorkspace;
  int m_oldWorkspaceIndex;
 
  friend class PropertyHandler;
  friend class CreateAttributeProperty;
  friend class SetAttribute;
  friend class SetAttributeProperty;
  friend class SequentialFitDialog;
};
 
} // namespace MantidWidgets
} // namespace MantidQt