diff --git a/scripts/Frequency_Domain_Analysis.py b/scripts/Frequency_Domain_Analysis.py
index c8eefe082472f1bbfda9193831dbf26ff84ae6c8..fd35ff4ca14b2cb3d892c3196dffac8f1d860b03 100644
--- a/scripts/Frequency_Domain_Analysis.py
+++ b/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))
diff --git a/scripts/Muon/GUI/dock/__init__.py b/scripts/Muon/GUI/Common/__init__.py
similarity index 100%
rename from scripts/Muon/GUI/dock/__init__.py
rename to scripts/Muon/GUI/Common/__init__.py
diff --git a/scripts/Muon/GUI/dummy/__init__.py b/scripts/Muon/GUI/Common/dock/__init__.py
similarity index 100%
rename from scripts/Muon/GUI/dummy/__init__.py
rename to scripts/Muon/GUI/Common/dock/__init__.py
diff --git a/scripts/Muon/GUI/dock/dock_view.py b/scripts/Muon/GUI/Common/dock/dock_view.py
similarity index 100%
rename from scripts/Muon/GUI/dock/dock_view.py
rename to scripts/Muon/GUI/Common/dock/dock_view.py
diff --git a/scripts/Muon/GUI/dummy_label/__init__.py b/scripts/Muon/GUI/Common/dummy/__init__.py
similarity index 100%
rename from scripts/Muon/GUI/dummy_label/__init__.py
rename to scripts/Muon/GUI/Common/dummy/__init__.py
diff --git a/scripts/Muon/GUI/dummy/dummy_presenter.py b/scripts/Muon/GUI/Common/dummy/dummy_presenter.py
similarity index 100%
rename from scripts/Muon/GUI/dummy/dummy_presenter.py
rename to scripts/Muon/GUI/Common/dummy/dummy_presenter.py
diff --git a/scripts/Muon/GUI/dummy/dummy_view.py b/scripts/Muon/GUI/Common/dummy/dummy_view.py
similarity index 100%
rename from scripts/Muon/GUI/dummy/dummy_view.py
rename to scripts/Muon/GUI/Common/dummy/dummy_view.py
diff --git a/scripts/Muon/GUI/dummy/dummy_widget.py b/scripts/Muon/GUI/Common/dummy/dummy_widget.py
similarity index 77%
rename from scripts/Muon/GUI/dummy/dummy_widget.py
rename to scripts/Muon/GUI/Common/dummy/dummy_widget.py
index 099436c505253174630787625d37ee15b5e6eb18..b3a3cfcb49ee44fbae42ce62dee7871477a4fef1 100644
--- a/scripts/Muon/GUI/dummy/dummy_widget.py
+++ b/scripts/Muon/GUI/Common/dummy/dummy_widget.py
@@ -1,8 +1,8 @@
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
diff --git a/scripts/Muon/GUI/Common/dummy_label/__init__.py b/scripts/Muon/GUI/Common/dummy_label/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/GUI/dummy_label/dummy_label_presenter.py b/scripts/Muon/GUI/Common/dummy_label/dummy_label_presenter.py
similarity index 100%
rename from scripts/Muon/GUI/dummy_label/dummy_label_presenter.py
rename to scripts/Muon/GUI/Common/dummy_label/dummy_label_presenter.py
diff --git a/scripts/Muon/GUI/dummy_label/dummy_label_view.py b/scripts/Muon/GUI/Common/dummy_label/dummy_label_view.py
similarity index 100%
rename from scripts/Muon/GUI/dummy_label/dummy_label_view.py
rename to scripts/Muon/GUI/Common/dummy_label/dummy_label_view.py
diff --git a/scripts/Muon/GUI/dummy_label/dummy_label_widget.py b/scripts/Muon/GUI/Common/dummy_label/dummy_label_widget.py
similarity index 75%
rename from scripts/Muon/GUI/dummy_label/dummy_label_widget.py
rename to scripts/Muon/GUI/Common/dummy_label/dummy_label_widget.py
index be5ecff4d691829a8034f7b67d7d3d598287084c..f8b67d7fb6ac3e09361b82698e5c87a8375ae241 100644
--- a/scripts/Muon/GUI/dummy_label/dummy_label_widget.py
+++ b/scripts/Muon/GUI/Common/dummy_label/dummy_label_widget.py
@@ -1,7 +1,7 @@
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):
diff --git a/scripts/Muon/load_utils.py b/scripts/Muon/GUI/Common/load_utils.py
similarity index 100%
rename from scripts/Muon/load_utils.py
rename to scripts/Muon/GUI/Common/load_utils.py
diff --git a/scripts/Muon/message_box.py b/scripts/Muon/GUI/Common/message_box.py
similarity index 100%
rename from scripts/Muon/message_box.py
rename to scripts/Muon/GUI/Common/message_box.py
diff --git a/scripts/Muon/GUI/Common/mock_widget.py b/scripts/Muon/GUI/Common/mock_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..62fc5eed705f7732f84d4ab25d7b4d0d782c024a
--- /dev/null
+++ b/scripts/Muon/GUI/Common/mock_widget.py
@@ -0,0 +1,10 @@
+
+import PyQt4.QtGui as QtGui
+
+
+def mockQapp():
+ qapp = QtGui.QApplication.instance()
+ if qapp is None:
+ return QtGui.QApplication([''])
+ else:
+ return qapp
diff --git a/scripts/Muon/table_utils.py b/scripts/Muon/GUI/Common/table_utils.py
similarity index 100%
rename from scripts/Muon/table_utils.py
rename to scripts/Muon/GUI/Common/table_utils.py
diff --git a/scripts/Muon/thread_model.py b/scripts/Muon/GUI/Common/thread_model.py
similarity index 97%
rename from scripts/Muon/thread_model.py
rename to scripts/Muon/GUI/Common/thread_model.py
index 4008d79a9f5d8bfac51d28ce9cd25f602ad6a6b6..f3b616d6efbc5bb8ad1c7bfefd8c8dcff5f2a04f 100644
--- a/scripts/Muon/thread_model.py
+++ b/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):
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/__init__.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_model.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..d07c1060568831e608ecc3c403c25e241179ee57
--- /dev/null
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_model.py
@@ -0,0 +1,159 @@
+from __future__ import (absolute_import, division, print_function)
+
+from six import iteritems
+
+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):
+ self.name = "FFT"
+ self.model = FFT
+ self.phaseTable = None
+ self.preRe = None
+ self.preIm = None
+ self.FFT = None
+
+ def cancel(self):
+ self.model.cancel()
+
+ def loadData(self, inputs):
+ """
+ store the data in the wrapper for later
+ """
+ if "phaseTable" in inputs:
+ self.phaseTable = inputs["phaseTable"]
+ else:
+ self.phaseTable = None
+ if "preRe" in inputs:
+ self.preRe = inputs["preRe"]
+ else:
+ self.preRe = None
+ if "preIm" in inputs:
+ self.preIm = inputs["preIm"]
+ else:
+ self.preIm = None
+ if "FFT" in inputs:
+ self.FFT = inputs["FFT"]
+ else:
+ self.FFT = None
+ self.model.setRun(inputs["Run"])
+
+ def execute(self):
+ """
+ runs the relevant parts of the FFT and the preprocessing
+ """
+ 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.preIm is not None:
+ self.model.preAlg(self.preIm)
+
+ 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 preAlg(self, preInputs):
+ """
+ PaddingAndApodization alg on the data
+ """
+ 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
+ """
+ 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):
+ """
+ generates a phase table from CalMuonDetectorPhases
+ """
+ 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
+ """
+ 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
diff --git a/scripts/Muon/fft_presenter.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_presenter.py
similarity index 51%
rename from scripts/Muon/fft_presenter.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_presenter.py
index 085c399f0c167dd592b8d60aee437ac34ea98579..f9929e1ffb9a5fb0c15953f719c18f10b84d3f41 100644
--- a/scripts/Muon/fft_presenter.py
+++ b/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():
diff --git a/scripts/Muon/fft_view.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_view.py
similarity index 52%
rename from scripts/Muon/fft_view.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_view.py
index e57d107b55a6b19b5e6c4eccfcf0e7fbba30e13d..00fd76639c3897b7bc2946b34f622cc5d98ce9a6 100644
--- a/scripts/Muon/fft_view.py
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_view.py
@@ -4,119 +4,136 @@ from PyQt4 import QtCore, QtGui
import mantid.simpleapi as mantid
-from Muon import table_utils
+from Muon.GUI.Common import table_utils
class FFTView(QtGui.QWidget):
+
"""
creates the layout for the FFT GUI
"""
# signals
buttonSignal = QtCore.pyqtSignal()
- tableClickSignal = QtCore.pyqtSignal(object,object)
+ tableClickSignal = QtCore.pyqtSignal(object, object)
phaseCheckSignal = QtCore.pyqtSignal()
- def __init__(self, parent = None):
+ def __init__(self, parent=None):
super(FFTView, self).__init__(parent)
self.grid = QtGui.QGridLayout(self)
- #make table
+ # add splitter for resizing
+ splitter = QtGui.QSplitter(QtCore.Qt.Vertical)
+
+ # make table
self.FFTTable = QtGui.QTableWidget(self)
self.FFTTable.resize(800, 800)
self.FFTTable.setRowCount(9)
self.FFTTable.setColumnCount(2)
- self.FFTTable.setColumnWidth(0,300)
- self.FFTTable.setColumnWidth(1,300)
+ self.FFTTable.setColumnWidth(0, 300)
+ self.FFTTable.setColumnWidth(1, 300)
self.FFTTable.verticalHeader().setVisible(False)
self.FFTTable.horizontalHeader().setStretchLastSection(True)
- self.FFTTable.setHorizontalHeaderLabels(("FFT Property;Value").split(";"))
+ self.FFTTable.setHorizontalHeaderLabels(
+ ("FFT Property;Value").split(";"))
# populate table
options = ['test']
- table_utils.setRowName(self.FFTTable,0,"Workspace")
- self.ws = table_utils.addComboToTable(self.FFTTable,0,options)
+ table_utils.setRowName(self.FFTTable, 0, "Workspace")
+ self.ws = table_utils.addComboToTable(self.FFTTable, 0, options)
self.Im_box_row = 1
- table_utils.setRowName(self.FFTTable,self.Im_box_row,"Imaginary Data")
- self.Im_box = table_utils.addCheckBoxToTable(self.FFTTable,True,self.Im_box_row)
+ table_utils.setRowName(
+ self.FFTTable,
+ self.Im_box_row,
+ "Imaginary Data")
+ self.Im_box = table_utils.addCheckBoxToTable(
+ self.FFTTable, True, self.Im_box_row)
- table_utils.setRowName(self.FFTTable,2,"Imaginary Workspace")
- self.Im_ws= table_utils.addComboToTable(self.FFTTable,2,options)
+ table_utils.setRowName(self.FFTTable, 2, "Imaginary Workspace")
+ self.Im_ws = table_utils.addComboToTable(self.FFTTable, 2, options)
self.shift_box_row = 3
- table_utils.setRowName(self.FFTTable,self.shift_box_row,"Auto shift")
- self.shift_box = table_utils.addCheckBoxToTable(self.FFTTable,True,self.shift_box_row)
+ table_utils.setRowName(self.FFTTable, self.shift_box_row, "Auto shift")
+ self.shift_box = table_utils.addCheckBoxToTable(
+ self.FFTTable, True, self.shift_box_row)
- table_utils.setRowName(self.FFTTable,4,"Shift")
- self.shift = table_utils.addDoubleToTable(self.FFTTable,0.0,4)
+ table_utils.setRowName(self.FFTTable, 4, "Shift")
+ self.shift = table_utils.addDoubleToTable(self.FFTTable, 0.0, 4)
self.FFTTable.hideRow(4)
- table_utils.setRowName(self.FFTTable,5,"Use Raw data")
- self.Raw_box = table_utils.addCheckBoxToTable(self.FFTTable,True,5)
+ table_utils.setRowName(self.FFTTable, 5, "Use Raw data")
+ self.Raw_box = table_utils.addCheckBoxToTable(self.FFTTable, True, 5)
- table_utils.setRowName(self.FFTTable,6,"First Good Data")
- self.x0 = table_utils.addDoubleToTable(self.FFTTable,0.1,6)
+ table_utils.setRowName(self.FFTTable, 6, "First Good Data")
+ self.x0 = table_utils.addDoubleToTable(self.FFTTable, 0.1, 6)
self.FFTTable.hideRow(6)
- table_utils.setRowName(self.FFTTable,7,"Last Good Data")
- self.xN = table_utils.addDoubleToTable(self.FFTTable,15.0,7)
+ table_utils.setRowName(self.FFTTable, 7, "Last Good Data")
+ self.xN = table_utils.addDoubleToTable(self.FFTTable, 15.0, 7)
self.FFTTable.hideRow(7)
- table_utils.setRowName(self.FFTTable,8,"Construct Phase Table")
- self.phaseTable_box = table_utils.addCheckBoxToTable(self.FFTTable,True,8)
+ table_utils.setRowName(self.FFTTable, 8, "Construct Phase Table")
+ self.phaseTable_box = table_utils.addCheckBoxToTable(
+ self.FFTTable, True, 8)
self.FFTTable.hideRow(8)
self.FFTTable.resizeRowsToContents()
- #make advanced table options
+ # make advanced table options
self.advancedLabel = QtGui.QLabel("\n Advanced Options")
self.FFTTableA = QtGui.QTableWidget(self)
self.FFTTableA.resize(800, 800)
self.FFTTableA.setRowCount(4)
self.FFTTableA.setColumnCount(2)
- self.FFTTableA.setColumnWidth(0,300)
- self.FFTTableA.setColumnWidth(1,300)
+ self.FFTTableA.setColumnWidth(0, 300)
+ self.FFTTableA.setColumnWidth(1, 300)
self.FFTTableA.verticalHeader().setVisible(False)
self.FFTTableA.horizontalHeader().setStretchLastSection(True)
- self.FFTTableA.setHorizontalHeaderLabels(("Advanced Property;Value").split(";"))
-
- table_utils.setRowName(self.FFTTableA,0,"Apodization Function")
- options = ["None","Lorentz","Gaussian"]
- self.apodization = table_utils.addComboToTable(self.FFTTableA,0,options)
-
- table_utils.setRowName(self.FFTTableA,1,"Decay Constant (micro seconds)")
- self.decay = table_utils.addDoubleToTable(self.FFTTableA,1.4,1)
-
- table_utils.setRowName(self.FFTTableA,2,"Negative Padding")
- self.negativePadding = table_utils.addCheckBoxToTable(self.FFTTableA,True,2)
-
- table_utils.setRowName(self.FFTTableA,3,"Padding")
- self.padding = table_utils.addSpinBoxToTable(self.FFTTableA,1,3)
+ self.FFTTableA.setHorizontalHeaderLabels(
+ ("Advanced Property;Value").split(";"))
+
+ table_utils.setRowName(self.FFTTableA, 0, "Apodization Function")
+ options = ["None", "Lorentz", "Gaussian"]
+ self.apodization = table_utils.addComboToTable(
+ self.FFTTableA, 0, options)
+
+ table_utils.setRowName(
+ self.FFTTableA,
+ 1,
+ "Decay Constant (micro seconds)")
+ self.decay = table_utils.addDoubleToTable(self.FFTTableA, 1.4, 1)
+
+ table_utils.setRowName(self.FFTTableA, 2, "Negative Padding")
+ self.negativePadding = table_utils.addCheckBoxToTable(
+ self.FFTTableA, True, 2)
+
+ table_utils.setRowName(self.FFTTableA, 3, "Padding")
+ self.padding = table_utils.addSpinBoxToTable(self.FFTTableA, 1, 3)
self.FFTTableA.resizeRowsToContents()
- #make button
+ # make button
self.button = QtGui.QPushButton('Calculate FFT', self)
self.button.setStyleSheet("background-color:lightgrey")
- #connects
+ # connects
self.FFTTable.cellClicked.connect(self.tableClick)
self.button.clicked.connect(self.buttonClick)
self.ws.currentIndexChanged.connect(self.phaseCheck)
# add to layout
- self.FFTTable.setMinimumSize(40,158)
- self.FFTTableA.setMinimumSize(40,127)
+ self.FFTTable.setMinimumSize(40, 158)
+ self.FFTTableA.setMinimumSize(40, 127)
table_utils.setTableHeaders(self.FFTTable)
table_utils.setTableHeaders(self.FFTTableA)
- self.horizontalSpacer1 = QtGui.QSpacerItem(20, 94, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
- self.horizontalSpacer2 = QtGui.QSpacerItem(20, 280, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
# add to layout
- self.grid.addWidget(self.FFTTable)
- self.grid.addItem(self.horizontalSpacer1)
- self.grid.addWidget(self.advancedLabel)
- self.grid.addWidget(self.FFTTableA)
- self.grid.addItem(self.horizontalSpacer2)
+ splitter.addWidget(self.FFTTable)
+ splitter.addWidget(self.advancedLabel)
+ splitter.addWidget(self.FFTTableA)
+ self.grid.addWidget(splitter)
self.grid.addWidget(self.button)
- # add data to view
- def addItems(self,options):
+ def getLayout(self):
+ return self.grid
+
+ # add data to view
+ def addItems(self, options):
self.ws.clear()
self.ws.addItems(options)
self.ws.addItem("PhaseQuad")
@@ -128,8 +145,8 @@ class FFTView(QtGui.QWidget):
def phaseCheck(self):
self.phaseCheckSignal.emit()
- def tableClick(self,row,col):
- self.tableClickSignal.emit(row,col)
+ def tableClick(self, row, col):
+ self.tableClickSignal.emit(row, col)
def buttonClick(self):
self.buttonSignal.emit()
@@ -142,20 +159,20 @@ class FFTView(QtGui.QWidget):
self.button.setEnabled(False)
def setPhaseBox(self):
- self.FFTTable.setRowHidden(8,self.getWS() != "PhaseQuad")
+ self.FFTTable.setRowHidden(8, self.getWS() != "PhaseQuad")
- def changed(self,box,row ):
- self.FFTTable.setRowHidden(row,box.checkState() == QtCore.Qt.Checked)
+ def changed(self, box, row):
+ self.FFTTable.setRowHidden(row, box.checkState() == QtCore.Qt.Checked)
- def changedHideUnTick(self,box,row ):
+ def changedHideUnTick(self, box, row):
self.FFTTable.setRowHidden(row, box.checkState() != QtCore.Qt.Checked)
def phaseQuadChanged(self):
- #show axis
- self.FFTTable.setRowHidden(6,self.getWS() != "PhaseQuad")
- self.FFTTable.setRowHidden(7,self.getWS() != "PhaseQuad")
- #hide complex ws
- self.FFTTable.setRowHidden(2,self.getWS() == "PhaseQuad")
+ # show axis
+ self.FFTTable.setRowHidden(6, self.getWS() != "PhaseQuad")
+ self.FFTTable.setRowHidden(7, self.getWS() != "PhaseQuad")
+ # hide complex ws
+ self.FFTTable.setRowHidden(2, self.getWS() == "PhaseQuad")
# these are for getting inputs
def getRunName(self):
@@ -163,33 +180,34 @@ class FFTView(QtGui.QWidget):
tmpWS = mantid.AnalysisDataService.retrieve("MuonAnalysis_1")
else:
tmpWS = mantid.AnalysisDataService.retrieve("MuonAnalysis")
- return tmpWS.getInstrument().getName()+str(tmpWS.getRunNumber()).zfill(8)
+ return tmpWS.getInstrument().getName() + str(tmpWS.getRunNumber()).zfill(8)
def initFFTInput(self):
inputs = {}
- inputs['InputWorkspace'] = "__ReTmp__"#str( self.ws.currentText()).replace(";","; ")
- inputs['Real'] = 0 # always zero
- out = str( self.ws.currentText()).replace(";","; ")
- inputs['OutputWorkspace'] = self.getRunName()+";"+out+";FFT"
+ inputs[
+ 'InputWorkspace'] = "__ReTmp__" # str( self.ws.currentText()).replace(";","; ")
+ inputs['Real'] = 0 # always zero
+ out = str(self.ws.currentText()).replace(";", "; ")
+ inputs['OutputWorkspace'] = self.getRunName() + ";" + out + ";FFT"
inputs["AcceptXRoundingErrors"] = True
return inputs
- def addFFTComplex(self,inputs):
+ def addFFTComplex(self, inputs):
inputs["InputImagWorkspace"] = "__ImTmp__"
- inputs["Imaginary"] = 0 #always zero
+ inputs["Imaginary"] = 0 # always zero
- def addFFTShift(self,inputs):
+ def addFFTShift(self, inputs):
inputs['AutoShift'] = False
inputs['Shift'] = float(self.shift.text())
- def addRaw(self,inputs,key):
+ def addRaw(self, inputs, key):
inputs[key] += "_Raw"
- def getFFTRePhase(self,inputs):
+ def getFFTRePhase(self, inputs):
inputs['InputWorkspace'] = "__ReTmp__"
- inputs['Real'] = 0 # always zero
+ inputs['Real'] = 0 # always zero
- def getFFTImPhase(self,inputs):
+ def getFFTImPhase(self, inputs):
inputs['InputImagWorkspace'] = "__ReTmp__"
inputs['Imaginary'] = 1
@@ -201,21 +219,25 @@ class FFTView(QtGui.QWidget):
inputs["Padding"] = int(self.padding.text())
return inputs
- def ReAdvanced(self,inputs):
- inputs['InputWorkspace'] = str( self.ws.currentText()).replace(";","; ")
+ def ReAdvanced(self, inputs):
+ inputs['InputWorkspace'] = str(
+ self.ws.currentText()).replace(";",
+ "; ")
inputs['OutputWorkspace'] = "__ReTmp__"
- def ImAdvanced(self,inputs):
- inputs['InputWorkspace'] = str( self.Im_ws.currentText()).replace(";","; ")
+ def ImAdvanced(self, inputs):
+ inputs['InputWorkspace'] = str(
+ self.Im_ws.currentText()).replace(";",
+ "; ")
inputs['OutputWorkspace'] = "__ImTmp__"
- def RePhaseAdvanced(self,inputs):
+ def RePhaseAdvanced(self, inputs):
inputs['InputWorkspace'] = "__phaseQuad__"
inputs['OutputWorkspace'] = "__ReTmp__"
# get methods (from the GUI)
def getWS(self):
- return str( self.ws.currentText()).replace(";","; ")
+ return str(self.ws.currentText()).replace(";", "; ")
def isAutoShift(self):
return self.shift_box.checkState() == QtCore.Qt.Checked
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_widget.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab8bbaae54464549c888c11e313a9533f897ef3b
--- /dev/null
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/FFT/fft_widget.py
@@ -0,0 +1,30 @@
+from __future__ import (absolute_import, division, print_function)
+
+from Muon.GUI.FrequencyDomainAnalysis.FFT.fft_view import FFTView
+from Muon.GUI.FrequencyDomainAnalysis.FFT.fft_presenter import FFTPresenter
+from Muon.GUI.FrequencyDomainAnalysis.FFT.fft_model import FFTModel, FFTWrapper
+
+from PyQt4 import QtGui
+
+
+class FFTWidget(QtGui.QWidget):
+
+ def __init__(self, load, parent=None):
+ super(FFTWidget, self).__init__(parent)
+ view = FFTView(parent)
+
+ fft = FFTModel()
+ model = FFTWrapper(fft)
+
+ self._presenter = FFTPresenter(view=view, alg=model, load=load)
+
+ @property
+ def presenter(self):
+ return self._presenter
+
+ @property
+ def widget(self):
+ return self._presenter.widget
+
+ def closeEvent(self, event):
+ self._presenter.cancel()
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/__init__.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/maxent_model.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_model.py
similarity index 100%
rename from scripts/Muon/maxent_model.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_model.py
diff --git a/scripts/Muon/maxent_presenter.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_presenter.py
similarity index 97%
rename from scripts/Muon/maxent_presenter.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_presenter.py
index 6b598a1ef9b9c836b2df04210509195e28823a13..37a04879f03bc3f14fba8b85003b7df3bedffb56 100644
--- a/scripts/Muon/maxent_presenter.py
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_presenter.py
@@ -2,7 +2,7 @@ from __future__ import (absolute_import, division, print_function)
import math
-from Muon import thread_model
+from Muon.GUI.Common import thread_model
class MaxEntPresenter(object):
@@ -23,6 +23,10 @@ class MaxEntPresenter(object):
self.view.cancelSignal.connect(self.cancel)
self.view.phaseSignal.connect(self.handlePhase)
+ @property
+ def widget(self):
+ return self.view
+
# functions
def getWorkspaceNames(self):
final_options = self.load.getGroupedWorkspaceNames()
diff --git a/scripts/Muon/maxent_view.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_view.py
similarity index 94%
rename from scripts/Muon/maxent_view.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_view.py
index 1a5b238206b38a4373394d2ec6ada6f68413cc3a..a082b6768d2f0604c2811354f20eab191247d9d0 100644
--- a/scripts/Muon/maxent_view.py
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_view.py
@@ -2,7 +2,7 @@ from __future__ import (absolute_import, division, print_function)
from PyQt4 import QtCore, QtGui
-from Muon import table_utils
+from Muon.GUI.Common import table_utils
class MaxEntView(QtGui.QWidget):
@@ -19,6 +19,10 @@ class MaxEntView(QtGui.QWidget):
def __init__(self, parent=None):
super(MaxEntView, self).__init__(parent)
self.grid = QtGui.QVBoxLayout(self)
+
+ # add splitter for resizing
+ splitter = QtGui.QSplitter(QtCore.Qt.Vertical)
+
self.run = None
# make table
self.table = QtGui.QTableWidget(self)
@@ -126,16 +130,7 @@ class MaxEntView(QtGui.QWidget):
# this is if complex data is unhidden
self.table.setMinimumSize(40, 203)
self.tableA.setMinimumSize(40, 207)
- self.horizontalSpacer1 = QtGui.QSpacerItem(
- 20,
- 30,
- QtGui.QSizePolicy.Expanding,
- QtGui.QSizePolicy.Expanding)
- self.horizontalSpacer2 = QtGui.QSpacerItem(
- 20,
- 70,
- QtGui.QSizePolicy.Expanding,
- QtGui.QSizePolicy.Expanding)
+
# make buttons
self.button = QtGui.QPushButton('Calculate MaxEnt', self)
self.button.setStyleSheet("background-color:lightgrey")
@@ -151,13 +146,15 @@ class MaxEntView(QtGui.QWidget):
self.buttonLayout.addWidget(self.button)
self.buttonLayout.addWidget(self.cancel)
# add to layout
- self.grid.addWidget(self.table)
- self.grid.addItem(self.horizontalSpacer1)
- self.grid.addWidget(self.advancedLabel)
- self.grid.addWidget(self.tableA)
- self.grid.addItem(self.horizontalSpacer2)
+ splitter.addWidget(self.table)
+ splitter.addWidget(self.advancedLabel)
+ splitter.addWidget(self.tableA)
+ self.grid.addWidget(splitter)
self.grid.addLayout(self.buttonLayout)
+ def getLayout(self):
+ return self.grid
+
# add data to view
def addItems(self, options):
self.ws.clear()
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_widget.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..246c76d9393b6363af7ff1c5d06accf4bc4db202
--- /dev/null
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/MaxEnt/maxent_widget.py
@@ -0,0 +1,29 @@
+from __future__ import (absolute_import, division, print_function)
+
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt.maxent_view import MaxEntView
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt.maxent_presenter import MaxEntPresenter
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt.maxent_model import MaxEntModel, MaxEntWrapper
+
+from PyQt4 import QtGui
+
+
+class MaxEntWidget(QtGui.QWidget):
+
+ def __init__(self, load, parent=None):
+ super(MaxEntWidget, self).__init__(parent)
+ view = MaxEntView(parent)
+
+ maxEnt = MaxEntModel()
+ model = MaxEntWrapper(maxEnt)
+ self._presenter = MaxEntPresenter(view, model, load)
+
+ @property
+ def presenter(self):
+ return self._presenter
+
+ @property
+ def widget(self):
+ return self._presenter.widget
+
+ def closeEvent(self, event):
+ self._presenter.cancel()
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/__init__.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/transform_view.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/transform_view.py
similarity index 71%
rename from scripts/Muon/transform_view.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/transform_view.py
index 035e93920bfbfa0f9ec53a49d5b6ad4e7df05547..57449884ec25910b296949abcc4b67136d95d83d 100644
--- a/scripts/Muon/transform_view.py
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/transform_view.py
@@ -4,19 +4,21 @@ from PyQt4 import QtGui
class TransformView(QtGui.QWidget):
+
"""
Creates the view for the transformation tab.
At the top is the transform selection widget
and below it is the selected GUI (FFT or MaxEnt)
"""
- def __init__(self,groupedViews,parent=None):
- super(TransformView,self).__init__(parent)
+
+ def __init__(self, selectorView, groupedViews, parent=None):
+ super(TransformView, self).__init__(parent)
# set selector
- self.selection = groupedViews.getTransformSelection()
+ self.selection = selectorView
self.Layout = QtGui.QGridLayout()
- self.Layout.addWidget(self.selection,1,0)
+ self.Layout.addWidget(self.selection, 1, 0)
# add the transform widgets to the tab
- self.methods = groupedViews.getTransformMethods()
+ self.methods = groupedViews
for key in self.methods:
self.Layout.addWidget(self.methods[key])
self.setLayout(self.Layout)
@@ -24,6 +26,9 @@ class TransformView(QtGui.QWidget):
methods = list(self.methods.keys())
self.show(methods[0])
+ def getLayout(self):
+ return self.grid
+
def getMethods(self):
return [key for key in self.methods]
@@ -31,8 +36,8 @@ class TransformView(QtGui.QWidget):
for key in self.methods:
self.methods[key].hide()
- def show(self,name):
+ def show(self, name):
self.methods[name].show()
- def getView(self,name):
+ def getView(self, name):
return self.methods[name]
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/transform_widget.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/transform_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..547b12d3904be4dda1d0bf7c8546e4abf5e4e33d
--- /dev/null
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/Transform/transform_widget.py
@@ -0,0 +1,45 @@
+from __future__ import (absolute_import, division, print_function)
+
+from Muon.GUI.FrequencyDomainAnalysis.Transform.transform_view import TransformView
+
+from Muon.GUI.FrequencyDomainAnalysis.FFT.fft_widget import FFTWidget
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt.maxent_widget import MaxEntWidget
+from Muon.GUI.FrequencyDomainAnalysis.TransformSelection.transform_selection_widget import TransformSelectionWidget
+
+from PyQt4 import QtGui
+
+
+class TransformWidget(QtGui.QWidget):
+ def __init__(self, load, parent=None):
+ super(TransformWidget,self).__init__(parent)
+ self._fft = FFTWidget(load=load,parent=self)
+ self._maxent = MaxEntWidget(load=load,parent=self)
+ self._selector = TransformSelectionWidget(parent=self)
+
+ groupedViews = self.getViews()
+
+ self._view = TransformView(self._selector.widget, groupedViews,parent)
+
+ self._selector.setSelectionConnection(self.updateDisplay)
+
+ @property
+ def widget(self):
+ return self._view
+
+ def mockWidget(self, mockView):
+ self._view = mockView
+
+ def closeEvent(self,event):
+ self._selector.closeEvent(event)
+ self._fft.closeEvent(event)
+ self._maxent.closeEvent(event)
+
+ def updateDisplay(self,method):
+ self._view.hideAll()
+ self._view.show(method)
+
+ def getViews(self):
+ groupedViews = {}
+ groupedViews["FFT"] = self._fft.widget
+ groupedViews["MaxEnt"] = self._maxent.widget
+ return groupedViews
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/__init__.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/transform_selection_presenter.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_presenter.py
similarity index 60%
rename from scripts/Muon/transform_selection_presenter.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_presenter.py
index c3bff2f796a18a6cda7cc581d94a2bf8bb436420..ec565273c8a5622fd8de7d578047a95afcf382d5 100644
--- a/scripts/Muon/transform_selection_presenter.py
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_presenter.py
@@ -2,12 +2,18 @@ from __future__ import (absolute_import, division, print_function)
class TransformSelectionPresenter(object):
+
"""
The widget for selecting the widget
shown in the transformation tab
"""
- def __init__(self,view):
- self.view=view
- def setMethodsCombo(self,options):
+ def __init__(self, view):
+ self.view = view
+
+ @property
+ def widget(self):
+ return self.view
+
+ def setMethodsCombo(self, options):
self.view.setMethodsCombo(options)
diff --git a/scripts/Muon/transform_selection_view.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_view.py
similarity index 72%
rename from scripts/Muon/transform_selection_view.py
rename to scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_view.py
index 5aa08de1ce173bf15e91efb15d86c8ae9e47284f..d07d510e5355f17902d7e39b2f942d5a7faa92fb 100644
--- a/scripts/Muon/transform_selection_view.py
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_view.py
@@ -4,6 +4,7 @@ from PyQt4 import QtCore, QtGui
class TransformSelectionView(QtGui.QWidget):
+
"""
Create the transformation selection widget's appearance
"""
@@ -15,15 +16,18 @@ class TransformSelectionView(QtGui.QWidget):
self.grid = QtGui.QGridLayout(self)
self.methods = QtGui.QComboBox()
# default to FFT
- options=["FFT"]
+ options = ["FFT", "MaxEnt"]
self.methods.addItems(options)
self.grid.addWidget(self.methods)
self.methods.currentIndexChanged.connect(self.sendSignal)
- # sets the methods in the selection widget
- def setMethodsCombo(self,options):
+ def getLayout(self):
+ return self.grid
+
+ # sets the methods in the selection widget
+ def setMethodsCombo(self, options):
self.methods.clear()
self.methods.addItems(options)
- def sendSignal(self,index):
- self.changeMethodSignal.emit(index)
+ def sendSignal(self):
+ self.changeMethodSignal.emit(self.methods.currentText())
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_widget.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a379289b10bd71c973280efbee5a0ba5da30798
--- /dev/null
+++ b/scripts/Muon/GUI/FrequencyDomainAnalysis/TransformSelection/transform_selection_widget.py
@@ -0,0 +1,26 @@
+from __future__ import (absolute_import, division, print_function)
+
+from Muon.GUI.FrequencyDomainAnalysis.TransformSelection.transform_selection_view import TransformSelectionView
+from Muon.GUI.FrequencyDomainAnalysis.TransformSelection.transform_selection_presenter import TransformSelectionPresenter
+
+from PyQt4 import QtGui
+
+
+class TransformSelectionWidget(QtGui.QWidget):
+
+ def __init__(self, parent=None):
+ super(TransformSelectionWidget, self).__init__(parent)
+ view = TransformSelectionView(parent)
+ self._presenter = TransformSelectionPresenter(view)
+
+ def setSelectionConnection(self, slot):
+ view = self.widget
+ view.changeMethodSignal.connect(slot)
+
+ @property
+ def presenter(self):
+ return self._presenter
+
+ @property
+ def widget(self):
+ return self._presenter.widget
diff --git a/scripts/Muon/GUI/FrequencyDomainAnalysis/__init__.py b/scripts/Muon/GUI/FrequencyDomainAnalysis/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/GUI/MuonAnalysis/__init__.py b/scripts/Muon/GUI/MuonAnalysis/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/GUI/MuonAnalysis/dock/__init__.py b/scripts/Muon/GUI/MuonAnalysis/dock/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/scripts/Muon/GUI/dock/dock_widget.py b/scripts/Muon/GUI/MuonAnalysis/dock/dock_widget.py
similarity index 88%
rename from scripts/Muon/GUI/dock/dock_widget.py
rename to scripts/Muon/GUI/MuonAnalysis/dock/dock_widget.py
index 3866a008addb454228ac86392bb21ec3620f276b..28ccae93e6c9a7ad8be023ec493be2f6cf27a432 100644
--- a/scripts/Muon/GUI/dock/dock_widget.py
+++ b/scripts/Muon/GUI/MuonAnalysis/dock/dock_widget.py
@@ -2,9 +2,9 @@ from __future__ import (absolute_import, division, print_function)
from PyQt4 import QtGui
-from Muon.GUI.dummy.dummy_widget import DummyWidget
-from Muon.GUI.dummy_label.dummy_label_widget import DummyLabelWidget
-from Muon.GUI.dock.dock_view import DockView
+from Muon.GUI.Common.dummy.dummy_widget import DummyWidget
+from Muon.GUI.Common.dummy_label.dummy_label_widget import DummyLabelWidget
+from Muon.GUI.Common.dock.dock_view import DockView
class DockWidget(QtGui.QWidget):
diff --git a/scripts/Muon/fft_model.py b/scripts/Muon/fft_model.py
deleted file mode 100644
index 40b0d90d72b640ddead228cc4728b2d1e41cab49..0000000000000000000000000000000000000000
--- a/scripts/Muon/fft_model.py
+++ /dev/null
@@ -1,137 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-from six import iteritems
-
-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):
- self.name = "FFT"
- self.model = FFT
-
- def loadData(self,inputs):
- """
- store the data in the wrapper for later
- """
- if "phaseTable" in inputs:
- self.phaseTable = inputs["phaseTable"]
- else:
- self.phaseTable = None
- if "preRe" in inputs:
- self.preRe = inputs["preRe"]
- else:
- self.preRe = None
- if "preIm" in inputs:
- self.preIm = inputs["preIm"]
- else:
- self.preIm = None
- if "FFT" in inputs:
- self.FFT = inputs["FFT"]
- else:
- self.FFT = None
- self.model.setRun(inputs["Run"])
-
- def execute(self):
- """
- 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.preRe is not None:
- self.model.preAlg(self.preRe)
-
- if self.preIm is not None:
- self.model.preAlg(self.preIm)
-
- if self.FFT is not None:
- self.model.FFTAlg(self.FFT)
- except:
- pass
-
- def output(self):
- return
-
-
-class FFTModel(object):
- """
- A simple class which executes
- the relevant algorithms for
- the analysis.
- """
- def __init__(self):
- self.name = "FFT"
-
- def setRun(self,run):
- self.runName=run
-
- 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):
- """
- 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")
- group = mantid.AnalysisDataService.retrieve(self.runName)
- group.add(ws)
-
- 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)
-
- 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()
-
- def getName(self):
- return self.name
diff --git a/scripts/Muon/model_constructor.py b/scripts/Muon/model_constructor.py
deleted file mode 100644
index 91392d7a38867aecd4911d0590a6d106f23ac51e..0000000000000000000000000000000000000000
--- a/scripts/Muon/model_constructor.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-from Muon import maxent_model
-
-from Muon import fft_model
-
-
-class ModelConstructor(object):
-
- """
- simple class to create a single object
- containing all of the models.
- Only need to pass a single object to all
- presenters
- """
- def __init__(self,includeTransform):
- # construct transformation memebers
- if includeTransform:
- self.transformModels={}
- # generate the models
- MaxEnt =maxent_model.MaxEntModel()
- MaxEntWrapper =maxent_model.MaxEntWrapper(MaxEnt)
- FFT =fft_model.FFTModel()
- FFTWrapper=fft_model.FFTWrapper(FFT)
- # adds the models to the transformation tab
- self.transformModels[MaxEnt.getName()]=MaxEntWrapper
- self.transformModels[FFT.getName()]=FFTWrapper
-
- # gets the model
- def getModel(self,name):
- return self.transformModels[name]
diff --git a/scripts/Muon/transform_presenter.py b/scripts/Muon/transform_presenter.py
deleted file mode 100644
index 58511798914fb96e2f23c593fe0d0a24f2bc4d8a..0000000000000000000000000000000000000000
--- a/scripts/Muon/transform_presenter.py
+++ /dev/null
@@ -1,38 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-from Muon import fft_presenter
-from Muon import load_utils
-from Muon import maxent_presenter
-from Muon import transform_selection_presenter
-
-
-class TransformPresenter(object):
- """
- The widget for controlling which method to display
- in the transformation tab
- """
- def __init__(self,view,model):
- self.view=view
- self.load=load_utils.LoadUtils()
- if not self.load.MuonAnalysisExists():
- return
-
- # create presenters for the views
- self.FFTPresenter=fft_presenter.FFTPresenter(self.view.getView("FFT"),model.getModel("FFT"),self.load)
- self.MaxEntPresenter=maxent_presenter.MaxEntPresenter(self.view.getView("MaxEnt"),model.getModel("MaxEnt"),self.load)
- # get the transform selection view
- self.selectionPresenter=transform_selection_presenter.TransformSelectionPresenter(self.view.selection)
- # gets a list of the views/methods
- self.methodsList=self.view.getMethods()
- # sets the transform selection view to have the correct options
- self.selectionPresenter.setMethodsCombo(self.methodsList)
- # connect
- self.view.selection.changeMethodSignal.connect(self.updateDisplay)
-
- def close(self):
- self.MaxEntPresenter.cancel()
-
- #switch the view
- def updateDisplay(self,index):
- self.view.hideAll()
- self.view.show(self.methodsList[index])
diff --git a/scripts/Muon/view_constructor.py b/scripts/Muon/view_constructor.py
deleted file mode 100644
index 44970df2b816b4ee3c2cbb18be5eb4bb65b7fdb1..0000000000000000000000000000000000000000
--- a/scripts/Muon/view_constructor.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-from Muon import fft_view
-from Muon import maxent_view
-from Muon import transform_selection_view
-
-
-class ViewConstructor(object):
- """
- simple class to create a single object
- containing all of the views.
- Only need to pass a single object to all
- presenters
- """
-
- def __init__(self,includeTransform,parent=None ):
- # construct transformation memebers
- if includeTransform:
- self.transformMethods = {}
- self.transformMethods["FFT"] = fft_view.FFTView(parent)
- self.transformMethods["MaxEnt"] = maxent_view.MaxEntView(parent)
- # create default transform selection widget
- self.transformSelector = transform_selection_view.TransformSelectionView(parent)
-
- def getTransformMethods(self):
- return self.transformMethods
-
- def getTransformSelection(self):
- return self.transformSelector
diff --git a/scripts/Muon_Analysis_2.py b/scripts/Muon_Analysis_2.py
index a355cb5766d624248055c33c56b438065f883801..74284382f744613147277c229d202d0dd7f54b15 100644
--- a/scripts/Muon_Analysis_2.py
+++ b/scripts/Muon_Analysis_2.py
@@ -6,8 +6,8 @@ import sys
import PyQt4.QtGui as QtGui
import PyQt4.QtCore as QtCore
-from Muon.GUI.dummy_label.dummy_label_widget import DummyLabelWidget
-from Muon.GUI.dock.dock_widget import DockWidget
+from Muon.GUI.Common.dummy_label.dummy_label_widget import DummyLabelWidget
+from Muon.GUI.MuonAnalysis.dock.dock_widget import DockWidget
class MuonAnalysis2Gui(QtGui.QMainWindow):
diff --git a/scripts/test/Muon/CMakeLists.txt b/scripts/test/Muon/CMakeLists.txt
index 5eb15b0b9eac3ad3ec99c39a1d61584062c62fe4..cf8bd05406a1a0e5e3b15b5f0b1fa3b9f4686e06 100644
--- a/scripts/test/Muon/CMakeLists.txt
+++ b/scripts/test/Muon/CMakeLists.txt
@@ -7,7 +7,7 @@ set ( TEST_PY_FILES
FFTModel_test.py
MaxEntPresenter_test.py
MaxEntModel_test.py
- transformPresenter_test.py
+ transformWidget_test.py
)
check_tests_valid ( ${CMAKE_CURRENT_SOURCE_DIR} ${TEST_PY_FILES} )
diff --git a/scripts/test/Muon/FFTModel_test.py b/scripts/test/Muon/FFTModel_test.py
index 68de091be30a4f90a68d6441819575fd993b1df9..0e6513e02357ee3a7e12c938a781f98916b37d34 100644
--- a/scripts/test/Muon/FFTModel_test.py
+++ b/scripts/test/Muon/FFTModel_test.py
@@ -1,6 +1,6 @@
import sys
-from Muon import fft_model
+from Muon.GUI.FrequencyDomainAnalysis.FFT import fft_model
import unittest
diff --git a/scripts/test/Muon/FFTPresenter_test.py b/scripts/test/Muon/FFTPresenter_test.py
index 7d30be8b4f2e182600ab925e02ac5fad3594b619..846fd9886c1674570ac08b0205556035121c6b16 100644
--- a/scripts/test/Muon/FFTPresenter_test.py
+++ b/scripts/test/Muon/FFTPresenter_test.py
@@ -1,10 +1,10 @@
import sys
-from Muon import load_utils
-from Muon import fft_presenter
-from Muon import fft_view
-from Muon import fft_model
-from Muon import thread_model
+from Muon.GUI.Common import load_utils
+from Muon.GUI.Common import thread_model
+from Muon.GUI.FrequencyDomainAnalysis.FFT import fft_presenter
+from Muon.GUI.FrequencyDomainAnalysis.FFT import fft_view
+from Muon.GUI.FrequencyDomainAnalysis.FFT import fft_model
import unittest
diff --git a/scripts/test/Muon/MaxEntModel_test.py b/scripts/test/Muon/MaxEntModel_test.py
index ebb0884d359efc70fd88461d78b37eb62d811cdd..80b0eb5ad54d50a6c2cadecbcff180ee8520e76c 100644
--- a/scripts/test/Muon/MaxEntModel_test.py
+++ b/scripts/test/Muon/MaxEntModel_test.py
@@ -1,6 +1,6 @@
import sys
-from Muon import maxent_model
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt import maxent_model
import unittest
diff --git a/scripts/test/Muon/MaxEntPresenter_test.py b/scripts/test/Muon/MaxEntPresenter_test.py
index 73156d0ddb10409d486854c657b72216e2445e45..15e73d7830bb285d7d63e94848c7f8dfa2e51e75 100644
--- a/scripts/test/Muon/MaxEntPresenter_test.py
+++ b/scripts/test/Muon/MaxEntPresenter_test.py
@@ -2,11 +2,11 @@ from __future__ import (absolute_import, division, print_function)
import sys
-from Muon import load_utils
-from Muon import maxent_presenter
-from Muon import maxent_view
-from Muon import maxent_model
-from Muon import thread_model
+from Muon.GUI.Common import load_utils
+from Muon.GUI.Common import thread_model
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt import maxent_presenter
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt import maxent_view
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt import maxent_model
import unittest
if sys.version_info.major == 3:
diff --git a/scripts/test/Muon/transformPresenter_test.py b/scripts/test/Muon/transformPresenter_test.py
deleted file mode 100644
index b184745a590a14e7b0f443af3332b3e371b93207..0000000000000000000000000000000000000000
--- a/scripts/test/Muon/transformPresenter_test.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import sys
-
-import mantid #noqa
-from Muon import fft_presenter
-from Muon import load_utils
-from Muon import transform_presenter
-from Muon import transform_view
-from Muon import transform_selection_view
-from Muon import maxent_presenter
-from Muon import model_constructor
-
-import unittest
-if sys.version_info.major == 3:
- from unittest import mock
-else:
- import mock
-
-
-class FFTTransformTest(unittest.TestCase):
- def setUp(self):
- load_utils.LoadUtils=mock.Mock()
- fft_presenter.FFTPresenter=mock.Mock()
- maxent_presenter.MaxEntPresenter=mock.Mock()
- self.view=mock.create_autospec(transform_view.TransformView,spec_set=False)
- self.view.getView=mock.Mock()
- self.view.getMethods=mock.Mock(return_value=["FFT","MaxEnt"])
- self.view.hideAll=mock.Mock()
- self.view.show=mock.Mock()
- self.view.selection=mock.create_autospec(transform_selection_view.TransformSelectionView,spec_set=True)
- self.view.selection.changeMethodSignal=mock.Mock()
- self.model=mock.create_autospec(model_constructor.ModelConstructor)
- self.model.getModel=mock.Mock()
- #set presenter
- self.presenter=transform_presenter.TransformPresenter(self.view,self.model)
-
- def test_changeDisplay(self):
- self.presenter.updateDisplay(1)
- assert(self.view.hideAll.call_count==1)
- assert(self.view.show.call_count==1)
-
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/scripts/test/Muon/transformWidget_test.py b/scripts/test/Muon/transformWidget_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..94c78456a0b014bf7f858b74453ef776cbe06b93
--- /dev/null
+++ b/scripts/test/Muon/transformWidget_test.py
@@ -0,0 +1,46 @@
+import sys
+
+from Muon.GUI.Common import mock_widget
+from Muon.GUI.Common import load_utils
+from Muon.GUI.FrequencyDomainAnalysis.FFT import fft_presenter
+from Muon.GUI.FrequencyDomainAnalysis.Transform import transform_widget
+from Muon.GUI.FrequencyDomainAnalysis.Transform import transform_view
+from Muon.GUI.FrequencyDomainAnalysis.TransformSelection import transform_selection_view
+from Muon.GUI.FrequencyDomainAnalysis.MaxEnt import maxent_presenter
+
+
+# need to update this
+import unittest
+if sys.version_info.major == 3:
+ from unittest import mock
+else:
+ import mock
+
+class FFTTransformTest(unittest.TestCase):
+ def setUp(self):
+ self._qapp = mock_widget.mockQapp()
+ self.load= mock.create_autospec( load_utils.LoadUtils,spec_set=True)
+ self.fft= mock.create_autospec( fft_presenter.FFTPresenter,spec_Set=True)
+ self.maxent=mock.create_autospec( maxent_presenter.MaxEntPresenter,spec_set=True)
+
+ # create widget
+ self.widget=transform_widget.TransformWidget(self.load)
+ # create the view
+ self.view=mock.create_autospec(transform_view.TransformView,spec_set=False)
+ self.view.getView=mock.Mock()
+ self.view.getMethods=mock.Mock(return_value=["FFT","MaxEnt"])
+ self.view.hideAll=mock.Mock()
+ self.view.show=mock.Mock()
+ self.view.selection=mock.create_autospec(transform_selection_view.TransformSelectionView,spec_set=True)
+ self.view.selection.changeMethodSignal=mock.Mock()
+ # set the mocked view to the widget
+ self.widget.mockWidget(self.view)
+
+ def test_changeDisplay(self):
+ self.widget.updateDisplay(1)
+ assert(self.view.hideAll.call_count==1)
+ assert(self.view.show.call_count==1)
+
+
+if __name__ == '__main__':
+ unittest.main()