Merge pull request #37317 from mantidproject/37288_models_into_manipu…

…lation_presenters Pass Data Manipulation Models into Presenters
mantidproject · May 13, 2024 · 0e1ac9c · 0e1ac9c
2 parents 6c791ea + 376d2ec
commit 0e1ac9c
Show file tree

Hide file tree

Showing 24 changed files with 168 additions and 87 deletions.
diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/DataManipulation.h b/qt/scientific_interfaces/Inelastic/Manipulation/DataManipulation.h
@@ -69,7 +69,7 @@ private slots:
   virtual void runComplete(bool error) { (void)error; };
 
 private:
-  virtual void setFileExtensionsByName(bool filter) { UNUSED_ARG(filter); };
+  virtual void setFileExtensionsByName(bool filter) { (void)filter; };
 
   std::unique_ptr<OutputPlotOptionsPresenter> m_plotOptionsPresenter;
   bool m_tabRunning;

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/DataManipulationInterface.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/DataManipulationInterface.cpp
@@ -10,17 +10,23 @@
 #include "DataManipulationInterface.h"
 
 #include "Common/Settings.h"
-#include "ElwinPresenter.h"
-#include "IqtPresenter.h"
 #include "MantidAPI/AlgorithmManager.h"
 #include "MantidAPI/AnalysisDataService.h"
 #include "MantidAPI/ExperimentInfo.h"
 #include "MantidGeometry/IComponent.h"
 #include "MantidGeometry/Instrument.h"
 #include "MantidKernel/ConfigService.h"
 #include "MantidKernel/FacilityInfo.h"
+
+#include "ElwinModel.h"
+#include "ElwinPresenter.h"
+#include "IqtModel.h"
+#include "IqtPresenter.h"
+#include "MomentsModel.h"
 #include "MomentsPresenter.h"
+#include "SqwModel.h"
 #include "SqwPresenter.h"
+#include "SymmetriseModel.h"
 #include "SymmetrisePresenter.h"
 
 #include <QDir>
@@ -59,11 +65,11 @@ void DataManipulationInterface::initLayout() {
   m_uiForm.pbSettings->setIcon(Settings::icon());
 
   // Create the tabs
-  addMVPTab<SymmetrisePresenter, SymmetriseView>("Symmetrise");
-  addMVPTab<SqwPresenter, SqwView>("S(Q, w)");
-  addMVPTab<MomentsPresenter, MomentsView>("Moments");
-  addMVPTab<ElwinPresenter, ElwinView>("Elwin");
-  addMVPTab<IqtPresenter, IqtView>("Iqt");
+  addMVPTab<SymmetrisePresenter, SymmetriseView, SymmetriseModel>("Symmetrise");
+  addMVPTab<SqwPresenter, SqwView, SqwModel>("S(Q, w)");
+  addMVPTab<MomentsPresenter, MomentsView, MomentsModel>("Moments");
+  addMVPTab<ElwinPresenter, ElwinView, ElwinModel>("Elwin");
+  addMVPTab<IqtPresenter, IqtView, IqtModel>("Iqt");
 
   connect(m_uiForm.pbSettings, SIGNAL(clicked()), this, SLOT(settings()));
   // Connect "?" (Help) Button

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/DataManipulationInterface.h b/qt/scientific_interfaces/Inelastic/Manipulation/DataManipulationInterface.h
@@ -79,7 +79,7 @@ private slots:
    * @param name Name to be displayed on tab
    */
 
-  template <typename TabPresenter, typename TabView> void addMVPTab(const QString &name) {
+  template <typename TabPresenter, typename TabView, typename TabModel> void addMVPTab(const QString &name) {
     QWidget *tabWidget = new QWidget(m_uiForm.twIDRTabs);
     QVBoxLayout *tabLayout = new QVBoxLayout(tabWidget);
     tabWidget->setLayout(tabLayout);
@@ -93,7 +93,9 @@ private slots:
     tabScrollArea->setWidget(tabContent);
     tabScrollArea->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
-    DataManipulation *tabIDRContent = new TabPresenter(tabContent, new TabView(tabContent));
+    std::unique_ptr<TabModel> tabModel = std::make_unique<TabModel>();
+
+    DataManipulation *tabIDRContent = new TabPresenter(tabContent, new TabView(tabContent), std::move(tabModel));
 
     tabIDRContent->setupTab();
     tabContent->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
@@ -113,7 +115,6 @@ private slots:
 
   // All indirect tabs
   QMap<QString, QPair<QWidget *, DataManipulation *>> m_tabs;
-
   QString m_dataDir; ///< default data search directory
   QString m_saveDir; ///< default data save directory
 };

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/ElwinPresenter.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/ElwinPresenter.cpp
@@ -41,9 +41,9 @@ class ScopedFalse {
 
 namespace MantidQt::CustomInterfaces {
 using namespace Inelastic;
-ElwinPresenter::ElwinPresenter(QWidget *parent, IElwinView *view)
-    : DataManipulation(parent), m_view(view), m_model(std::make_unique<ElwinModel>()),
-      m_dataModel(std::make_unique<FitDataModel>()), m_selectedSpectrum(0) {
+ElwinPresenter::ElwinPresenter(QWidget *parent, IElwinView *view, std::unique_ptr<IElwinModel> model)
+    : DataManipulation(parent), m_view(view), m_model(std::move(model)), m_dataModel(std::make_unique<FitDataModel>()),
+      m_selectedSpectrum(0) {
   m_view->subscribePresenter(this);
   setOutputPlotOptionsPresenter(
       std::make_unique<OutputPlotOptionsPresenter>(m_view->getPlotOptions(), PlotWidget::Spectra));

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/ElwinPresenter.h b/qt/scientific_interfaces/Inelastic/Manipulation/ElwinPresenter.h
@@ -42,7 +42,7 @@ class IElwinPresenter {
 
 class MANTIDQT_INELASTIC_DLL ElwinPresenter : public DataManipulation, public IElwinPresenter {
 public:
-  ElwinPresenter(QWidget *parent, IElwinView *view);
+  ElwinPresenter(QWidget *parent, IElwinView *view, std::unique_ptr<IElwinModel> model);
   ElwinPresenter(QWidget *parent, IElwinView *view, std::unique_ptr<IElwinModel> model,
                  std::unique_ptr<IFitDataModel> dataModel);
   ~ElwinPresenter();

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/ElwinView.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/ElwinView.cpp
@@ -27,7 +27,7 @@ Mantid::Kernel::Logger g_log("Elwin");
 
 namespace MantidQt::CustomInterfaces {
 using namespace Inelastic;
-ElwinView::ElwinView(QWidget *parent) : m_presenter(), m_elwTree(nullptr) {
+ElwinView::ElwinView(QWidget *parent) : QWidget(parent), m_presenter(), m_elwTree(nullptr) {
 
   // Create Editor Factories
   m_dblEdFac = new DoubleEditorFactory(this);

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/IqtModel.h b/qt/scientific_interfaces/Inelastic/Manipulation/IqtModel.h
@@ -17,20 +17,37 @@ using namespace Mantid::API;
 namespace MantidQt {
 namespace CustomInterfaces {
 
-class MANTIDQT_INELASTIC_DLL IqtModel {
+class MANTIDQT_INELASTIC_DLL IIqtModel {
+
+public:
+  virtual ~IIqtModel() = default;
+  virtual void setupTransformToIqt(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner,
+                                   std::string const &outputWorkspace) = 0;
+  virtual void setSampleWorkspace(std::string const &sampleWorkspace) = 0;
+  virtual void setResWorkspace(std::string const &resWorkspace) = 0;
+  virtual void setNIterations(std::string const &nIterations) = 0;
+  virtual void setEnergyMin(double energyMin) = 0;
+  virtual void setEnergyMax(double energyMax) = 0;
+  virtual void setNumBins(double numBins) = 0;
+  virtual void setCalculateErrors(bool calculateErrors) = 0;
+  virtual void setEnforceNormalization(bool enforceNormalization) = 0;
+};
+
+class MANTIDQT_INELASTIC_DLL IqtModel : public IIqtModel {
 
 public:
   IqtModel();
   ~IqtModel() = default;
-  void setupTransformToIqt(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner, std::string const &outputWorkspace);
-  void setSampleWorkspace(std::string const &sampleWorkspace);
-  void setResWorkspace(std::string const &resWorkspace);
-  void setNIterations(std::string const &nIterations);
-  void setEnergyMin(double energyMin);
-  void setEnergyMax(double energyMax);
-  void setNumBins(double numBins);
-  void setCalculateErrors(bool calculateErrors);
-  void setEnforceNormalization(bool enforceNormalization);
+  void setupTransformToIqt(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner,
+                           std::string const &outputWorkspace) override;
+  void setSampleWorkspace(std::string const &sampleWorkspace) override;
+  void setResWorkspace(std::string const &resWorkspace) override;
+  void setNIterations(std::string const &nIterations) override;
+  void setEnergyMin(double energyMin) override;
+  void setEnergyMax(double energyMax) override;
+  void setNumBins(double numBins) override;
+  void setCalculateErrors(bool calculateErrors) override;
+  void setEnforceNormalization(bool enforceNormalization) override;
 
 private:
   std::string m_sampleWorkspace;

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/IqtPresenter.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/IqtPresenter.cpp
@@ -28,8 +28,8 @@ Mantid::Kernel::Logger g_log("Iqt");
 namespace MantidQt {
 namespace CustomInterfaces {
 
-IqtPresenter::IqtPresenter(QWidget *parent, IIqtView *view)
-    : DataManipulation(parent), m_view(view), m_model(std::make_unique<IqtModel>()), m_selectedSpectrum(0) {
+IqtPresenter::IqtPresenter(QWidget *parent, IIqtView *view, std::unique_ptr<IIqtModel> model)
+    : DataManipulation(parent), m_view(view), m_model(std::move(model)), m_selectedSpectrum(0) {
   m_view->subscribePresenter(this);
   setOutputPlotOptionsPresenter(
       std::make_unique<OutputPlotOptionsPresenter>(m_view->getPlotOptions(), PlotWidget::SpectraTiled));

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/IqtPresenter.h b/qt/scientific_interfaces/Inelastic/Manipulation/IqtPresenter.h
@@ -33,7 +33,7 @@ using namespace Mantid::API;
 class MANTIDQT_INELASTIC_DLL IqtPresenter : public DataManipulation, public IIqtPresenter {
 
 public:
-  IqtPresenter(QWidget *parent, IIqtView *view);
+  IqtPresenter(QWidget *parent, IIqtView *view, std::unique_ptr<IIqtModel> model);
   ~IqtPresenter() = default;
 
   void setup() override;
@@ -67,7 +67,7 @@ class MANTIDQT_INELASTIC_DLL IqtPresenter : public DataManipulation, public IIqt
   void setRunIsRunning(bool running);
 
   IIqtView *m_view;
-  std::unique_ptr<IqtModel> m_model;
+  std::unique_ptr<IIqtModel> m_model;
 
   int m_selectedSpectrum;
 

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/IqtView.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/IqtView.cpp
@@ -79,7 +79,7 @@ std::tuple<bool, float, int, int> calculateBinParameters(std::string const &wsNa
 
 namespace MantidQt::CustomInterfaces {
 
-IqtView::IqtView(QWidget *parent) : m_presenter(), m_iqtTree(nullptr) {
+IqtView::IqtView(QWidget *parent) : QWidget(parent), m_presenter(), m_iqtTree(nullptr) {
   m_uiForm.setupUi(parent);
   m_dblEdFac = new DoubleEditorFactory(this);
   m_dblManager = new QtDoublePropertyManager();

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/MomentsModel.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/MomentsModel.cpp
@@ -52,6 +52,6 @@ void MomentsModel::setScale(bool scale) { m_scale = scale; }
 
 void MomentsModel::setScaleValue(double scaleValue) { m_scaleValue = scaleValue; }
 
-std::string MomentsModel::getOutputWorkspace() { return m_outputWorkspaceName; }
+std::string MomentsModel::getOutputWorkspace() const { return m_outputWorkspaceName; }
 
 } // namespace MantidQt::CustomInterfaces
diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/MomentsModel.h b/qt/scientific_interfaces/Inelastic/Manipulation/MomentsModel.h
@@ -14,18 +14,31 @@ using namespace Mantid::API;
 namespace MantidQt {
 namespace CustomInterfaces {
 
-class MANTIDQT_INELASTIC_DLL MomentsModel {
+class MANTIDQT_INELASTIC_DLL IMomentsModel {
+
+public:
+  virtual ~IMomentsModel() = default;
+  virtual IAlgorithm_sptr setupAlgorithm() = 0;
+  virtual void setInputWorkspace(const std::string &workspace) = 0;
+  virtual void setEMin(double eMin) = 0;
+  virtual void setEMax(double eMax) = 0;
+  virtual void setScale(bool scale) = 0;
+  virtual void setScaleValue(double scaleValue) = 0;
+  virtual std::string getOutputWorkspace() const = 0;
+};
+
+class MANTIDQT_INELASTIC_DLL MomentsModel : public IMomentsModel {
 
 public:
   MomentsModel();
   ~MomentsModel() = default;
-  IAlgorithm_sptr setupAlgorithm();
-  void setInputWorkspace(const std::string &workspace);
-  void setEMin(double eMin);
-  void setEMax(double eMax);
-  void setScale(bool scale);
-  void setScaleValue(double scaleValue);
-  std::string getOutputWorkspace();
+  IAlgorithm_sptr setupAlgorithm() override;
+  void setInputWorkspace(const std::string &workspace) override;
+  void setEMin(double eMin) override;
+  void setEMax(double eMax) override;
+  void setScale(bool scale) override;
+  void setScaleValue(double scaleValue) override;
+  std::string getOutputWorkspace() const override;
 
 private:
   std::string m_inputWorkspace;

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/MomentsPresenter.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/MomentsPresenter.cpp
@@ -26,8 +26,8 @@ namespace MantidQt::CustomInterfaces {
 //----------------------------------------------------------------------------------------------
 /** Constructor
  */
-MomentsPresenter::MomentsPresenter(QWidget *parent, IMomentsView *view)
-    : DataManipulation(parent), m_model(std::make_unique<MomentsModel>()), m_view(view) {
+MomentsPresenter::MomentsPresenter(QWidget *parent, IMomentsView *view, std::unique_ptr<IMomentsModel> model)
+    : DataManipulation(parent), m_view(view), m_model(std::move(model)) {
   m_view->subscribePresenter(this);
   setOutputPlotOptionsPresenter(
       std::make_unique<OutputPlotOptionsPresenter>(m_view->getPlotOptions(), PlotWidget::Spectra, "0,2,4"));

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/MomentsPresenter.h b/qt/scientific_interfaces/Inelastic/Manipulation/MomentsPresenter.h
@@ -40,7 +40,7 @@ class IMomentsPresenter {
 class MANTIDQT_INELASTIC_DLL MomentsPresenter : public DataManipulation, public IMomentsPresenter {
 
 public:
-  MomentsPresenter(QWidget *parent, IMomentsView *view);
+  MomentsPresenter(QWidget *parent, IMomentsView *view, std::unique_ptr<IMomentsModel> model);
   ~MomentsPresenter() = default;
 
   void setup() override;
@@ -62,8 +62,9 @@ class MANTIDQT_INELASTIC_DLL MomentsPresenter : public DataManipulation, public
 private:
   void plotNewData(std::string const &filename);
   void setFileExtensionsByName(bool filter) override;
-  std::unique_ptr<MomentsModel> m_model;
+
   IMomentsView *m_view;
+  std::unique_ptr<IMomentsModel> m_model;
 };
 } // namespace CustomInterfaces
 } // namespace MantidQt
diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/MomentsView.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/MomentsView.cpp
@@ -24,7 +24,7 @@ namespace MantidQt::CustomInterfaces {
 //----------------------------------------------------------------------------------------------
 /** Constructor
  */
-MomentsView::MomentsView(QWidget *parent) : m_presenter() {
+MomentsView::MomentsView(QWidget *parent) : QWidget(parent), m_presenter() {
   m_uiForm.setupUi(parent);
   m_dblManager = new QtDoublePropertyManager();
   m_dblEdFac = new DoubleEditorFactory(this);

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/SqwModel.cpp b/qt/scientific_interfaces/Inelastic/Manipulation/SqwModel.cpp
@@ -114,16 +114,16 @@ void SqwModel::setEFixed(const double eFixed) { m_eFixed = eFixed; }
 
 void SqwModel::setRebinInEnergy(bool scale) { m_rebinInEnergy = scale; }
 
-std::string SqwModel::getOutputWorkspace() { return m_baseName + "_sqw"; }
+std::string SqwModel::getOutputWorkspace() const { return m_baseName + "_sqw"; }
 
-MatrixWorkspace_sptr SqwModel::getRqwWorkspace() {
+MatrixWorkspace_sptr SqwModel::getRqwWorkspace() const {
   auto const outputName = m_inputWorkspace.substr(0, m_inputWorkspace.size() - 4) + "_rqw";
   convertToSpectrumAxis(m_inputWorkspace, outputName);
   return getADSWorkspace(outputName);
 }
 
 UserInputValidator SqwModel::validate(std::tuple<double, double> const qRange,
-                                      std::tuple<double, double> const eRange) {
+                                      std::tuple<double, double> const eRange) const {
 
   double const tolerance = 1e-10;
 
@@ -145,7 +145,7 @@ UserInputValidator SqwModel::validate(std::tuple<double, double> const qRange,
 }
 
 std::string SqwModel::getEFixedFromInstrument(std::string const &instrumentName, std::string analyser,
-                                              std::string const &reflection) {
+                                              std::string const &reflection) const {
 
   // In the IRIS IPF there is no fmica component
   if (instrumentName == "IRIS" && analyser == "fmica")
@@ -179,7 +179,7 @@ std::string SqwModel::getEFixedFromInstrument(std::string const &instrumentName,
  * @param reflection Relection being used (optional)
  */
 MatrixWorkspace_sptr SqwModel::loadInstrumentWorkspace(const std::string &instrumentName, const std::string &analyser,
-                                                       const std::string &reflection) {
+                                                       const std::string &reflection) const {
   std::string idfdirectory = Mantid::Kernel::ConfigService::Instance().getString("instrumentDefinition.directory");
   auto const ipfFilename = idfdirectory + instrumentName + "_" + analyser + "_" + reflection + "_Parameters.xml";
 

diff --git a/qt/scientific_interfaces/Inelastic/Manipulation/SqwModel.h b/qt/scientific_interfaces/Inelastic/Manipulation/SqwModel.h
@@ -18,30 +18,57 @@ using namespace Mantid::API;
 namespace MantidQt {
 namespace CustomInterfaces {
 
-class MANTIDQT_INELASTIC_DLL SqwModel {
+class MANTIDQT_INELASTIC_DLL ISqwModel {
+
+public:
+  virtual ~ISqwModel() = default;
+  virtual void setupRebinAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner) = 0;
+  virtual void setupSofQWAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner) = 0;
+  virtual void setupAddSampleLogAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner) = 0;
+  virtual void setInputWorkspace(const std::string &workspace) = 0;
+  virtual void setQMin(double qMin) = 0;
+  virtual void setQWidth(double qWidth) = 0;
+  virtual void setQMax(double qMax) = 0;
+  virtual void setEMin(double eMin) = 0;
+  virtual void setEWidth(double eWidth) = 0;
+  virtual void setEMax(double eMax) = 0;
+  virtual void setEFixed(const double eFixed) = 0;
+  virtual void setRebinInEnergy(bool scale) = 0;
+  virtual std::string getEFixedFromInstrument(std::string const &instrumentName, std::string analyser,
+                                              std::string const &reflection) const = 0;
+  virtual std::string getOutputWorkspace() const = 0;
+  virtual MatrixWorkspace_sptr getRqwWorkspace() const = 0;
+  virtual UserInputValidator validate(std::tuple<double, double> const qRange,
+                                      std::tuple<double, double> const eRange) const = 0;
+  virtual MatrixWorkspace_sptr loadInstrumentWorkspace(const std::string &instrumentName, const std::string &analyser,
+                                                       const std::string &reflection) const = 0;
+};
+
+class MANTIDQT_INELASTIC_DLL SqwModel : public ISqwModel {
 
 public:
   SqwModel();
   ~SqwModel() = default;
-  void setupRebinAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner);
-  void setupSofQWAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner);
-  void setupAddSampleLogAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner);
-  void setInputWorkspace(const std::string &workspace);
-  void setQMin(double qMin);
-  void setQWidth(double qWidth);
-  void setQMax(double qMax);
-  void setEMin(double eMin);
-  void setEWidth(double eWidth);
-  void setEMax(double eMax);
-  void setEFixed(const double eFixed);
-  void setRebinInEnergy(bool scale);
+  void setupRebinAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner) override;
+  void setupSofQWAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner) override;
+  void setupAddSampleLogAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner) override;
+  void setInputWorkspace(const std::string &workspace) override;
+  void setQMin(double qMin) override;
+  void setQWidth(double qWidth) override;
+  void setQMax(double qMax) override;
+  void setEMin(double eMin) override;
+  void setEWidth(double eWidth) override;
+  void setEMax(double eMax) override;
+  void setEFixed(const double eFixed) override;
+  void setRebinInEnergy(bool scale) override;
   std::string getEFixedFromInstrument(std::string const &instrumentName, std::string analyser,
-                                      std::string const &reflection);
-  std::string getOutputWorkspace();
-  MatrixWorkspace_sptr getRqwWorkspace();
-  UserInputValidator validate(std::tuple<double, double> const qRange, std::tuple<double, double> const eRange);
+                                      std::string const &reflection) const override;
+  std::string getOutputWorkspace() const override;
+  MatrixWorkspace_sptr getRqwWorkspace() const override;
+  UserInputValidator validate(std::tuple<double, double> const qRange,
+                              std::tuple<double, double> const eRange) const override;
   MatrixWorkspace_sptr loadInstrumentWorkspace(const std::string &instrumentName, const std::string &analyser,
-                                               const std::string &reflection);
+                                               const std::string &reflection) const override;
 
 private:
   std::string m_inputWorkspace;