PropertyHandler.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/IFunction.h"
 
/* Forward declarations */
namespace Mantid {
namespace API {
class IPeakFunction;
class CompositeFunction;
} // namespace API
} // namespace Mantid
 
// class FunctionCurve;
// class PlotCurve;
// class Graph;
class QtBrowserItem;
class QtProperty;
 
/* Qt includes */
#include <QList>
#include <QMap>
#include <QObject>
#include <QString>
 
namespace MantidQt {
namespace MantidWidgets {
class FitPropertyBrowser;
 
class EXPORT_OPT_MANTIDQT_COMMON PropertyHandler : public QObject, public Mantid::API::FunctionHandler {
  Q_OBJECT
public:
  // Constructor
  PropertyHandler(const Mantid::API::IFunction_sptr &fun, std::shared_ptr<Mantid::API::CompositeFunction> parent,
                  FitPropertyBrowser *browser, QtBrowserItem *item = nullptr);
 
  ~PropertyHandler() override;
 
  void init() override;
 
  PropertyHandler *addFunction(const std::string &fnName);
  // Removes handled function from its parent function and
  // properties from the browser
  void removeFunction();
 
  void renameChildren(const Mantid::API::CompositeFunction &cf);
 
  QString functionName() const;
 
  QString functionPrefix() const;
 
  // Return composite function
  std::shared_ptr<Mantid::API::CompositeFunction> cfun() const { return m_cf; }
  // Return peak function
  std::shared_ptr<Mantid::API::IPeakFunction> pfun() const { return m_pf; }
  // Return IFunction
  std::shared_ptr<Mantid::API::IFunction> ifun() const { return m_fun; }
  // Return the browser item
  QtBrowserItem *item() const { return m_item; }
  // Return the parent handler
  PropertyHandler *parentHandler() const;
  // Return the child's handler
  PropertyHandler *getHandler(std::size_t i) const;
  std::shared_ptr<const Mantid::API::CompositeFunction> findCompositeFunction(QtBrowserItem *item) const;
  std::shared_ptr<const Mantid::API::IFunction> findFunction(QtBrowserItem *item) const;
 
  PropertyHandler *findHandler(const Mantid::API::IFunction *fun);
  PropertyHandler *findHandler(const Mantid::API::IFunction_const_sptr &fun);
  PropertyHandler *findHandler(QtProperty *prop);
 
  bool setParameter(QtProperty *prop);
 
  // Check if it is a parameter property
  bool isParameter(QtProperty *prop);
 
  bool setAttribute(QtProperty *prop, bool resetProperties = true);
 
  void setAttribute(QString const &attName, Mantid::API::IFunction::Attribute const &attValue);
 
  template <typename AttributeType> void setAttribute(QString const &attName, AttributeType const &attValue);
 
  void setAttribute(const QString &attName, const QString &attValue);
 
  void setVectorAttribute(QtProperty *prop);
 
  void updateParameters();
 
  void updateAttributes();
 
  void updateErrors();
 
  void clearErrors();
 
  // Get property for function parameter parName
  QtProperty *getParameterProperty(const QString &parName) const;
 
  // Get parameter property which has the argument as a child (i.e. tie or
  // conatraint)
  QtProperty *getParameterProperty(QtProperty *prop) const;
 
  std::shared_ptr<Mantid::API::IFunction> changeType(QtProperty *prop);
 
  void setHeight(const double &h);
  void setCentre(const double &c);
  void setFwhm(const double &w);
  void setBase(const double &b) { m_base = b; }
  void calcBase();    //< caclulate baseline from workspace data
  void calcBaseAll(); //< calc baseline for all peaks in the function
  double EstimateFwhm() const;
 
  double height() const;
  double centre() const;
  double fwhm() const;
  std::string getWidthParameterName() const;
  std::string getCentreParameterName() const;
  bool isParameterExplicitlySet(const std::string &param) const;
  double base() const { return m_base; }
 
  void addTie(const QString &tieStr);
  void fix(const QString &parName);
  void removeTie(QtProperty *prop, const std::string &globalName);
  void removeTie(QtProperty *prop);
  void removeTie(const QString &propName);
  void addConstraint(QtProperty *parProp, bool lo, bool up, double loBound, double upBound);
  void removeConstraint(QtProperty *parProp);
 
  // Return list of handlers of peak functions which can be used in
  // PeakPickerTool
  // The item->pfun() will return a correct pointer to a peak
  // Non-const because it may return a non-const pointer to this.
  QList<PropertyHandler *> getPeakList();
 
  // Plot the function on a graph
  bool hasPlot() const { return m_hasPlot; }
  void setHasPlot(const bool state) { m_hasPlot = state; };
  void removeAllPlots();
 
  void fit();
 
  // update workspace property when workspaces added to or removed from ADS
  void updateWorkspaces(const QStringList &oldWorkspaces);
  // set workspace in workspace property to the function
  void setFunctionWorkspace();
 
  QString updateStructureTooltip();
 
  const QMap<QString, QtProperty *> &getTies() { return m_ties; };
  bool hasTies() { return !m_ties.isEmpty(); };
 
protected slots:
 
  //
  void plotRemoved();
 
protected:
  void initAttributes();
  void initParameters();
  void initWorkspace();
  void initTies();
 
private:
  FitPropertyBrowser *m_browser;
  std::shared_ptr<Mantid::API::CompositeFunction> m_cf;     //< if the function is composite holds pointer to it
  std::shared_ptr<Mantid::API::IPeakFunction> m_pf;         //< if the function is peak holds pointer to it
  std::shared_ptr<Mantid::API::CompositeFunction> m_parent; //< if the function has parent holds pointer to it
  QtProperty *m_type;
  QtBrowserItem *m_item;                                              //< the browser item
  QList<QtProperty *> m_attributes;                                   //< function attribute properties
  QList<QtProperty *> m_parameters;                                   //< function parameter properties
  QMap<QString, QtProperty *> m_ties;                                 //< tie properties
  QMap<QString, std::pair<QtProperty *, QtProperty *>> m_constraints; //< constraints
  QList<QtProperty *> m_vectorMembers;                                //< vector member properties
  QList<QtProperty *> m_vectorSizes;                                  //< vector size properties
  bool m_isMultispectral; 
  QtProperty *m_workspace;      
  QtProperty *m_workspaceIndex; 
  double m_base;                //< the baseline for a peak
  int m_ci;                     //< approximate index in the workspace at the peak centre
  // mutable FunctionCurve* m_curve;//< the curve to plot the handled function
  mutable bool m_hasPlot;
 
  void updateParameter(QtProperty *prop);
 
  void updateError(QtProperty *prop);
 
  void clearError(QtProperty *prop);
 
  void applyToAllParameters(void (PropertyHandler::*func)(QtProperty *));
 
  void updateAttribute(QtProperty *prop);
 
  void applyToAllAttributes(void (PropertyHandler::*func)(QtProperty *));
 
  friend class CreateAttributeProperty;
};
 
} // namespace MantidWidgets
} // namespace MantidQt