Merge pull request #22459 from mantidproject/22399_FDAUpdate

Frequency domain analysis clean up

scripts/Frequency_Domain_Analysis.py

@@ -5,27 +5,26 @@ import sys
 
 import PyQt4.QtGui as QtGui
 
-from Muon import model_constructor
-from Muon import transform_presenter
-from Muon import transform_view
-from Muon import view_constructor
+from Muon.GUI.FrequencyDomainAnalysis.Transform.transform_widget import TransformWidget
+from Muon.GUI.Common import load_utils
+from Muon.GUI.Common import message_box
 
 
 class FrequencyDomainAnalysisGui(QtGui.QMainWindow):
     def __init__(self,parent=None):
         super(FrequencyDomainAnalysisGui,self).__init__(parent)
 
-        groupedViews = view_constructor.ViewConstructor(True,self)
-        groupedModels = model_constructor.ModelConstructor(True)
-        view =transform_view.TransformView(groupedViews,self)
-        self.presenter =transform_presenter.TransformPresenter(view,groupedModels)
+        load = load_utils.LoadUtils()
+        if not load.MuonAnalysisExists:
+            return
+        self.transform = TransformWidget(load = load, parent = self)
 
-        self.setCentralWidget(view)
+        self.setCentralWidget(self.transform.widget)
         self.setWindowTitle("Frequency Domain Analysis")
 
     # cancel algs if window is closed
     def closeEvent(self,event):
-        self.presenter.close()
+        self.transform.closeEvent(event)
 
 
 def qapp():
@@ -43,5 +42,4 @@ try:
     ex.show()
     app.exec_()
 except RuntimeError as error:
-    ex = QtGui.QWidget()
-    QtGui.QMessageBox.warning(ex,"Frequency Domain Analysis",str(error))
+    message_box.warning(str(error))

scripts/Muon/GUI/dummy/dummy_widget.py → scripts/Muon/GUI/Common/dummy/dummy_widget.py

 from __future__ import (absolute_import, division, print_function)
 
 
-from Muon.GUI.dummy.dummy_view import DummyView
-from Muon.GUI.dummy.dummy_presenter import DummyPresenter
+from Muon.GUI.Common.dummy.dummy_view import DummyView
+from Muon.GUI.Common.dummy.dummy_presenter import DummyPresenter
 
 
 class DummyWidget(object):
@@ -14,7 +14,7 @@ class DummyWidget(object):
         self.presenter = DummyPresenter(view,model)
 
     @property
-    def presneter(self):
+    def presenter(self):
         return self.presenter
 
     @property

scripts/Muon/GUI/dummy_label/dummy_label_widget.py → scripts/Muon/GUI/Common/dummy_label/dummy_label_widget.py

 from __future__ import (absolute_import, division, print_function)
 
-from Muon.GUI.dummy_label.dummy_label_view import DummyLabelView
-from Muon.GUI.dummy_label.dummy_label_presenter import DummyLabelPresenter
+from Muon.GUI.Common.dummy_label.dummy_label_view import DummyLabelView
+from Muon.GUI.Common.dummy_label.dummy_label_presenter import DummyLabelPresenter
 
 
 class DummyLabelWidget(object):

scripts/Muon/GUI/Common/mock_widget.py

+
+import PyQt4.QtGui as QtGui
+
+
+def mockQapp():
+    qapp = QtGui.QApplication.instance()
+    if qapp is None:
+        return QtGui.QApplication([''])
+    else:
+        return qapp

scripts/Muon/thread_model.py → scripts/Muon/GUI/Common/thread_model.py

@@ -2,7 +2,7 @@ from __future__ import (absolute_import, division, print_function)
 
 from PyQt4.QtCore import QThread
 from PyQt4 import QtCore
-from Muon import message_box
+from Muon.GUI.Common import message_box
 
 
 class ThreadModel(QThread):

scripts/Muon/fft_model.py → scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_model.py

@@ -6,16 +6,25 @@ import mantid.simpleapi as mantid
 
 
 class FFTWrapper(object):
+
     """
     A class to wrap the different parts
     of the FFT and its preprocessing.
     This keeps the main FFT class simple.
     """
-    def __init__(self,FFT):
+
+    def __init__(self, FFT):
         self.name = "FFT"
         self.model = FFT
+        self.phaseTable = None
+        self.preRe = None
+        self.preIm = None
+        self.FFT = None
 
-    def loadData(self,inputs):
+    def cancel(self):
+        self.model.cancel()
+
+    def loadData(self, inputs):
         """
         store the data in the wrapper for later
         """
@@ -41,97 +50,110 @@ class FFTWrapper(object):
         """
         runs the relevant parts of the FFT and the preprocessing
         """
-        try:
-            if self.phaseTable is not None:
-                if self.phaseTable["newTable"]:
-                    self.model.makePhaseQuadTable(self.phaseTable)
-                self.model.PhaseQuad()
+        if self.phaseTable is not None:
+            if self.phaseTable["newTable"]:
+                self.model.makePhaseQuadTable(self.phaseTable)
+            self.model.PhaseQuad()
 
-            if self.preRe is not None:
-                self.model.preAlg(self.preRe)
+        if self.preRe is not None:
+            self.model.preAlg(self.preRe)
 
-            if self.preIm is not None:
-                self.model.preAlg(self.preIm)
+        if self.preIm is not None:
+            self.model.preAlg(self.preIm)
 
-            if self.FFT is not None:
-                self.model.FFTAlg(self.FFT)
-        except:
-            pass
+        if self.FFT is not None:
+            self.model.FFTAlg(self.FFT)
 
     def output(self):
         return
 
 
 class FFTModel(object):
+
     """
     A simple class which executes
     the relevant algorithms for
     the analysis.
     """
+
     def __init__(self):
         self.name = "FFT"
+        self.alg = None
+
+    def cancel(self):
+        if self.alg is not None:
+            self.alg.cancel()
 
-    def setRun(self,run):
-        self.runName=run
+    def setRun(self, run):
+        self.runName = run
 
-    def preAlg(self,preInputs):
+    def preAlg(self, preInputs):
         """
         PaddingAndApodization alg on the data
         """
-        preAlg = mantid.AlgorithmManager.create("PaddingAndApodization")
-        preAlg.initialize()
-        preAlg.setChild(True)
-        for name,value in iteritems(preInputs):
-            preAlg.setProperty(name,value)
-        preAlg.execute()
-        mantid.AnalysisDataService.addOrReplace(preInputs["OutputWorkspace"], preAlg.getProperty("OutputWorkspace").value)
-
-    def FFTAlg(self,FFTInputs):
+        self.alg = mantid.AlgorithmManager.create("PaddingAndApodization")
+        self.alg.initialize()
+        self.alg.setAlwaysStoreInADS(False)
+        for name, value in iteritems(preInputs):
+            self.alg.setProperty(name, value)
+        self.alg.execute()
+        mantid.AnalysisDataService.addOrReplace(
+            preInputs["OutputWorkspace"],
+            self.alg.getProperty("OutputWorkspace").value)
+        self.alg = None
+
+    def FFTAlg(self, FFTInputs):
         """
         Use the FFT alg
         """
-        alg = mantid.AlgorithmManager.create("FFT")
-        alg.initialize()
-        alg.setChild(True)
-        for name,value in iteritems(FFTInputs):
-            alg.setProperty(name,value)
-        alg.execute()
-        mantid.AnalysisDataService.addOrReplace(FFTInputs["OutputWorkspace"],alg.getProperty("OutputWorkspace").value)
-
-        ws = alg.getPropertyValue("OutputWorkspace")
+        self.alg = mantid.AlgorithmManager.create("FFT")
+        self.alg.initialize()
+        self.alg.setAlwaysStoreInADS(False)
+        for name, value in iteritems(FFTInputs):
+            self.alg.setProperty(name, value)
+        self.alg.execute()
+        mantid.AnalysisDataService.addOrReplace(
+            FFTInputs["OutputWorkspace"],
+            self.alg.getProperty("OutputWorkspace").value)
+
+        ws = self.alg.getPropertyValue("OutputWorkspace")
         group = mantid.AnalysisDataService.retrieve(self.runName)
         group.add(ws)
+        self.alg = None
 
-    def makePhaseQuadTable(self,inputs):
+    def makePhaseQuadTable(self, inputs):
         """
         generates a phase table from CalMuonDetectorPhases
         """
-        alg = mantid.AlgorithmManager.create("CalMuonDetectorPhases")
-        alg.initialize()
-        alg.setChild(True)
-
-        alg.setProperty("FirstGoodData",inputs["FirstGoodData"])
-        alg.setProperty("LastGoodData",inputs["LastGoodData"])
-
-        alg.setProperty("InputWorkspace","MuonAnalysis")
-        alg.setProperty("DetectorTable","PhaseTable")
-        alg.setProperty("DataFitted","fits")
-        alg.execute()
-        mantid.AnalysisDataService.addOrReplace("PhaseTable",alg.getProperty("DetectorTable").value)
+        self.alg = mantid.AlgorithmManager.create("CalMuonDetectorPhases")
+        self.alg.initialize()
+        self.alg.setAlwaysStoreInADS(False)
+
+        self.alg.setProperty("FirstGoodData", inputs["FirstGoodData"])
+        self.alg.setProperty("LastGoodData", inputs["LastGoodData"])
+
+        self.alg.setProperty("InputWorkspace", "MuonAnalysis")
+        self.alg.setProperty("DetectorTable", "PhaseTable")
+        self.alg.setProperty("DataFitted", "fits")
+        self.alg.execute()
+        mantid.AnalysisDataService.addOrReplace(
+            "PhaseTable",
+            self.alg.getProperty("DetectorTable").value)
+        self.alg = None
 
     def PhaseQuad(self):
         """
         do the phaseQuad algorithm
         groups data into a single set
         """
-        phaseQuad = mantid.AlgorithmManager.create("PhaseQuad")
-        phaseQuad.initialize()
-        phaseQuad.setChild(False)
-        print (self.runName)
-        phaseQuad.setProperty("InputWorkspace","MuonAnalysis")
-        phaseQuad.setProperty("PhaseTable","PhaseTable")
-        phaseQuad.setProperty("OutputWorkspace","__phaseQuad__")
-        phaseQuad.execute()
+        self.alg = mantid.AlgorithmManager.create("PhaseQuad")
+        self.alg.initialize()
+        self.alg.setChild(False)
+        self.alg.setProperty("InputWorkspace", "MuonAnalysis")
+        self.alg.setProperty("PhaseTable", "PhaseTable")
+        self.alg.setProperty("OutputWorkspace", "__phaseQuad__")
+        self.alg.execute()
+        self.alg = None
 
     def getName(self):
         return self.name

scripts/Muon/fft_presenter.py → scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_presenter.py

@@ -3,25 +3,35 @@ from __future__ import (absolute_import, division, print_function)
 
 import mantid.simpleapi as mantid
 
-from Muon import thread_model
+from Muon.GUI.Common import thread_model
 
 
 class FFTPresenter(object):
+
     """
     This class links the FFT model to the GUI
     """
-    def __init__(self,view,alg,load):
-        self.view=view
-        self.alg=alg
-        self.load=load
+
+    def __init__(self, view, alg, load):
+        self.view = view
+        self.alg = alg
+        self.load = load
         self.thread = None
         # set data
         self.getWorkspaceNames()
-        #connect
+        # connect
         self.view.tableClickSignal.connect(self.tableClicked)
         self.view.buttonSignal.connect(self.handleButton)
         self.view.phaseCheckSignal.connect(self.phaseCheck)
 
+    def cancel(self):
+        if self.thread is not None:
+            self.thread.cancel()
+
+    @property
+    def widget(self):
+        return self.view
+
     # turn on button
     def activate(self):
         self.view.activateButton()
@@ -31,21 +41,25 @@ class FFTPresenter(object):
         self.view.deactivateButton()
 
     def getWorkspaceNames(self):
-        final_options=self.load.getWorkspaceNames()
+        final_options = self.load.getWorkspaceNames()
         self.view.addItems(final_options)
 
-    #functions
+    # functions
     def phaseCheck(self):
         self.view.phaseQuadChanged()
-        #check if a phase table exists
+        # check if a phase table exists
         if mantid.AnalysisDataService.doesExist("PhaseTable"):
             self.view.setPhaseBox()
 
-    def tableClicked(self,row,col):
-        if row == self.view.getImBoxRow() and col == 1 and self.view.getWS() !="PhaseQuad":
-            self.view.changedHideUnTick(self.view.getImBox(),self.view.getImBoxRow()+1)
-        elif  row == self.view.getShiftBoxRow() and col == 1:
-            self.view.changed(self.view.getShiftBox(),self.view.getShiftBoxRow()+1)
+    def tableClicked(self, row, col):
+        if row == self.view.getImBoxRow() and col == 1 and self.view.getWS() != "PhaseQuad":
+            self.view.changedHideUnTick(
+                self.view.getImBox(),
+                self.view.getImBoxRow() + 1)
+        elif row == self.view.getShiftBoxRow() and col == 1:
+            self.view.changed(
+                self.view.getShiftBox(),
+                self.view.getShiftBoxRow() + 1)
 
     def createThread(self):
         return thread_model.ThreadModel(self.alg)
@@ -58,50 +72,49 @@ class FFTPresenter(object):
             self.getWorkspaceNames()
             return
         # put this on its own thread so not to freeze Mantid
-        self.thread=self.createThread()
-        self.thread.started.connect(self.deactivate)
-        self.thread.finished.connect(self.handleFinished)
+        self.thread = self.createThread()
+        self.thread.threadWrapperSetUp(self.deactivate,self.handleFinished)
 
         # make some inputs
-        inputs={}
-        inputs["Run"]=self.load.getRunName()
+        inputs = {}
+        inputs["Run"] = self.load.getRunName()
 
-        #do apodization and padding to real data
+        # do apodization and padding to real data
 
-        preInputs=self.view.initAdvanced()
+        preInputs = self.view.initAdvanced()
 
         if self.view.getWS() == "PhaseQuad":
-            phaseTable={}
-            phaseTable["newTable"]= self.view.isNewPhaseTable()
-            phaseTable["FirstGoodData"]=self.view.getFirstGoodData()
-            phaseTable["LastGoodData"]=self.view.getLastGoodData()
-            phaseTable["Instrument"]=self.load.getInstrument()
-            inputs["phaseTable"]=phaseTable
+            phaseTable = {}
+            phaseTable["newTable"] = self.view.isNewPhaseTable()
+            phaseTable["FirstGoodData"] = self.view.getFirstGoodData()
+            phaseTable["LastGoodData"] = self.view.getLastGoodData()
+            phaseTable["Instrument"] = self.load.getInstrument()
+            inputs["phaseTable"] = phaseTable
             self.view.RePhaseAdvanced(preInputs)
         else:
             self.view.ReAdvanced(preInputs)
             if self.view.isRaw():
-                self.view.addRaw(preInputs,"InputWorkspace")
-        inputs["preRe"]=preInputs
+                self.view.addRaw(preInputs, "InputWorkspace")
+        inputs["preRe"] = preInputs
 
-        #do apodization and padding to complex data
-        if self.view.isComplex() and self.view.getWS()!="PhaseQuad":
-            ImPreInputs=self.view.initAdvanced()
+        # do apodization and padding to complex data
+        if self.view.isComplex() and self.view.getWS() != "PhaseQuad":
+            ImPreInputs = self.view.initAdvanced()
             self.view.ImAdvanced(ImPreInputs)
             if self.view.isRaw():
-                self.view.addRaw(ImPreInputs,"InputWorkspace")
-            inputs["preIm"]=ImPreInputs
+                self.view.addRaw(ImPreInputs, "InputWorkspace")
+            inputs["preIm"] = ImPreInputs
 
-        #do FFT to transformed data
+        # do FFT to transformed data
         FFTInputs = self.get_FFT_input()
-        if self.view.getWS()=="PhaseQuad":
+        if self.view.getWS() == "PhaseQuad":
             self.view.getFFTRePhase(FFTInputs)
             if self.view.isComplex():
                 self.view.getFFTImPhase(FFTInputs)
         else:
             if self.view.isRaw():
-                self.view.addRaw(FFTInputs,"OutputWorkspace")
-        inputs["FFT"]=FFTInputs
+                self.view.addRaw(FFTInputs, "OutputWorkspace")
+        inputs["FFT"] = FFTInputs
         try:
             self.thread.loadData(inputs)
             self.thread.start()
@@ -112,13 +125,14 @@ class FFTPresenter(object):
     # kills the thread at end of execution
     def handleFinished(self):
         self.activate()
+        self.thread.threadWrapperTearDown(self.deactivate,self.handleFinished)
         self.thread.deleteLater()
-        self.thread=None
+        self.thread = None
 
     def get_FFT_input(self):
-        FFTInputs=self.view.initFFTInput()
-        if  self.view.isAutoShift():
-            FFTInputs["AutoShift"]=True
+        FFTInputs = self.view.initFFTInput()
+        if self.view.isAutoShift():
+            FFTInputs["AutoShift"] = True
         else:
             self.view.addFFTShift(FFTInputs)
         if self.view.isComplex():