def PyExec(self):
""" Main Execution Body
"""
# 1. Setup output workspaces
paramWS = WorkspaceFactory.createTable()
self.setProperty("InstrumentParameterWorkspace", paramWS)
hklWS = WorkspaceFactory.createTable()
self.setProperty("BraggPeakParameterWorkspace", hklWS)
# 2. Get Other Properties
instrument = self.getProperty("Instrument")
reflectionfilename = self.getPropertyValue("ReflectionsFile")
irffilename = self.getPropertyValue("FullprofParameterFile")
# 3. Import reflections list
hkldict = self.importFullProfHKLFile(reflectionfilename)
hkllist = sorted(hkldict.keys())
if _OUTPUTLEVEL == "INFORMATION":
for hkl in hkllist:
print "Import Peak (%d, %d, %d): FWHM = %f" % (hkl[0], hkl[1], hkl[2], hkldict[hkl]["FWHM"])
# 4. Import parameter file (.irf)
peakparamsdict = self.parseFullprofPeakProfileFile(irffilename)
# 5. Set up the table workspaces
self.createPeakParameterWorkspace(peakparamsdict, paramWS)
self.createReflectionWorkspace(hkldict, hklWS)
return
def test_table_is_resized_correctly(self):
table = WorkspaceFactory.createTable()
self.assertEquals(len(table), 0)
table.setRowCount(5)
self.assertEquals(len(table), 5)
self.assertTrue(table.addColumn(type="int",name="index"))
self.assertEquals(table.columnCount(), 1)
def PyExec(self):
""" Main Execution Body
"""
# 1. Get Input properties
inppeakws = self.getProperty("BraggPeakParameterWorkspace").value
inpzscows = self.getProperty("ZscoreWorkspace").value
minpeakheight = float(self.getPropertyValue("MinimumPeakHeight"))
zscorefilterstr = self.getPropertyValue("ZscoreFilter")
print "Input: PeakParameterWorkspace = %s; ZscoreWorkspace = %s" % (inppeakws.name, inpzscows.name)
print " Minimum peak height = %f" % (minpeakheight)
print " Zscore filter: %s" % (zscorefilterstr)
# 3. Parse Zscore table and peak parameters
self.mPeaks = {}
zscoredict = self.parseBraggPeakParameterTable(inpzscows)
self.mPeaks = self.parseBraggPeakParameterTable(inppeakws)
# 4. Filter by peak height
self.filterByPeakHeight(minpeakheight)
# 5. Filter by zscore
zscorefilterdict = self.parseZscoreFilter(zscorefilterstr)
self.filterByZscore(zscoredict, zscorefilterdict)
# 6. Generate the output
paramWS = WorkspaceFactory.createTable()
self.genBraggPeakParameterWorkspace(paramWS)
self.setProperty("OutputBraggPeakParameterWorkspace", paramWS)
return
def _loadFullprofPrfFile(self, prffilename):
""" Load Fullprof .prf file
"""
# 1. Parse the file to dictionary
infodict, data = self._parseFullprofPrfFile(prffilename)
# 2. Export information to table file
tablews = WorkspaceFactory.createTable()
tablews.addColumn("str", "Name")
tablews.addColumn("double", "Value")
for parname in infodict.keys():
parvalue = infodict[parname]
tablews.addRow([parname, parvalue])
# 3. Export the data workspace
datasize = len(data)
print "Data Size = ", datasize
dataws = WorkspaceFactory.create("Workspace2D", 4, datasize, datasize)
for i in xrange(datasize):
for j in xrange(4):
dataws.dataX(j)[i] = data[i][0]
dataws.dataY(j)[i] = data[i][j+1]
dataws.dataE(j)[i] = 1.0
return (tablews, dataws)
def test_adding_table_data_using_numpy(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int",name="index")
self.assertEquals(table.columnCount(), 1)
table.addColumn(type="int",name="value")
self.assertEquals(table.columnCount(), 2)
nextrow = [1, 10]
values32 = numpy.array(nextrow).astype(numpy.int32)
values64 = numpy.array(nextrow).astype(numpy.int64)
table.addRow(values32)
self.assertEquals(len(table), 1)
insertedrow = table.row(0)
self.assertEquals(1, insertedrow['index'])
self.assertEquals(10, insertedrow['value'])
table.addRow(values64)
self.assertEquals(len(table), 2)
insertedrow = table.row(1)
self.assertEquals(1, insertedrow['index'])
self.assertEquals(10, insertedrow['value'])
incorrect_type = numpy.array(['1', '10'])
self.assertRaises(TypeError, table.addRow, incorrect_type)
def test_set_and_extract_v3d_columns(self):
from mantid.kernel import V3D
table = WorkspaceFactory.createTable()
table.addColumn(type='V3D', name='pos')
table.addRow([V3D(1,1,1)])
self.assertEquals(V3D(1,1,1), table.cell(0, 0))
def test_set_and_extract_boolean_columns(self):
table = WorkspaceFactory.createTable()
table.addColumn(type='bool', name='yes_no')
table.addRow([True])
table.addRow([False])
self.assertTrue(table.cell(0, 0))
self.assertFalse(table.cell(1, 0))
def _create_test_table(self):
table = WorkspaceFactory.createTable()
table.addColumn(type='int', name='index')
table.addColumn(type='str', name='name')
table.addRow([0, '1'])
table.addRow([0, '2'])
table.addRow([0, '3'])
return table
def test_set_and_extract_boolean_columns(self):
table = WorkspaceFactory.createTable()
table.addColumn(type='bool', name='yes_no')
table.addRow([True])
table.addRow([False])
self.assertTrue(table.cell(0, 0))
self.assertFalse(table.cell(1, 0))
def _create_test_table(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int", name="index")
table.addColumn(type="str", name="name")
table.addRow([0, "1"])
table.addRow([0, "2"])
table.addRow([0, "3"])
return table
def _create_test_table(self):
table = WorkspaceFactory.createTable()
table.addColumn(type='int', name='index')
table.addColumn(type='str', name='name')
table.addRow([0,'1'])
table.addRow([0,'2'])
table.addRow([0,'3'])
return table
def test_set_and_extract_v3d_columns(self):
from mantid.kernel import V3D
table = WorkspaceFactory.createTable()
table.addColumn(type='V3D', name='pos')
table.addRow([V3D(1,1,1)])
self.assertEquals(V3D(1,1,1), table.cell(0, 0))
def create_results_table():
table = WorkspaceFactory.createTable()
table.addColumn(type='str', name='workspace_name')
table.addColumn(type='float', name='A0')
table.addColumn(type='float', name='A1')
table.addRow(["MUSR62260; Group; bottom; Asymmetry; MA", 0.1, 0.2])
table.addRow(["MUSR62260; Group; top; Asymmetry; MA", 0.3, 0.4])
table.addRow(["MUSR62260; Group; fwd; Asymmetry; MA", 0.5, 0.6])
return table
def test_that_get_workspace_names_to_display_from_context_only_returns_the_names_that_exist_in_the_ADS(
self):
self.model.context.results_context.result_table_names = self.result_table_names
table_workspace = WorkspaceFactory.createTable()
add_ws_to_ads("Result1", table_workspace)
self.assertEqual(
self.model.get_workspace_names_to_display_from_context(),
["Result1"])
def test_set_and_extract_vector_columns(self):
table = WorkspaceFactory.createTable()
table.addColumn(type='vector_int', name='values')
# Settings from general Python list
table.addRow([ [1,2,3,4,5] ])
# Setting from numpy array
table.addRow([ numpy.array([6,7,8,9,10]) ])
self.assertTrue( numpy.array_equal( table.cell(0,0), numpy.array([1,2,3,4,5]) ) )
self.assertTrue( numpy.array_equal( table.cell(1,0), numpy.array([6,7,8,9,10]) ) )
def test_column_types(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int", name="index")
table.addColumn(type="str", name="value")
table.addColumn(type="V3D", name="position")
types = table.columnTypes()
self.assertEqual(types[0], "int")
self.assertEqual(types[1], "str")
self.assertEqual(types[2], "V3D")
def test_set_and_extract_vector_columns(self):
table = WorkspaceFactory.createTable()
table.addColumn(type='vector_int', name='values')
# Settings from general Python list
table.addRow([ [1,2,3,4,5] ])
# Setting from numpy array
table.addRow([ numpy.array([6,7,8,9,10]) ])
self.assertTrue( numpy.array_equal( table.cell(0,0), numpy.array([1,2,3,4,5]) ) )
self.assertTrue( numpy.array_equal( table.cell(1,0), numpy.array([6,7,8,9,10]) ) )
def create_table_workspace(self, table_name):
table = WorkspaceFactory.createTable()
table.addColumn('double', X_COLUMN_LABEL, 1)
table.addColumn('double', Y_COLUMN_LABEL, 2)
for i in range(1, 10):
table.addRow([0.1 * i, 5])
AnalysisDataService.Instance().addOrReplace(table_name, table)
self.fit_browser.getXColumnName.return_value = X_COLUMN_LABEL
self.fit_browser.getYColumnName.return_value = Y_COLUMN_LABEL
self.fit_browser.getErrColumnName.return_value = None
self.fit_browser.startX.return_value = 0.15
self.fit_browser.endX.return_value = 0.95
def test_adding_table_data_using_list(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int", name="index")
self.assertEquals(table.columnCount(), 1)
table.addColumn(type="str", name="value")
self.assertEquals(table.columnCount(), 2)
nextrow = {'index': 1, 'value': '10'}
values = nextrow.values()
table.addRow(nextrow)
self.assertEquals(len(table), 1)
insertedrow = table.row(0)
self.assertEquals(insertedrow, nextrow)
insertedrow = table.row(0)
self.assertEquals(insertedrow, nextrow)
def test_adding_table_data_using_dictionary(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int", name="index")
self.assertEquals(table.columnCount(), 1)
table.addColumn(type="str", name="value")
self.assertEquals(table.columnCount(), 2)
nextrow = {'index': 1, 'value': '10'}
table.addRow(nextrow)
self.assertEquals(len(table), 1)
insertedrow = table.row(0)
self.assertEquals(insertedrow, nextrow)
incorrect_type = {'index': 1, 'value': 10}
self.assertRaises(ValueError, table.addRow, incorrect_type)
def test_adding_table_data_using_dictionary(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int",name="index")
self.assertEquals(table.columnCount(), 1)
table.addColumn(type="str",name="value")
self.assertEquals(table.columnCount(), 2)
nextrow = {'index':1, 'value':'10'}
table.addRow(nextrow)
self.assertEquals(len(table), 1)
insertedrow = table.row(0)
self.assertEquals(insertedrow, nextrow)
incorrect_type = {'index':1, 'value':10}
self.assertRaises(ValueError, table.addRow, incorrect_type)
def test_adding_table_data_using_list(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int",name="index")
self.assertEquals(table.columnCount(), 1)
table.addColumn(type="str",name="value")
self.assertEquals(table.columnCount(), 2)
nextrow = {'index':1, 'value':'10'}
values = nextrow.values()
table.addRow(nextrow)
self.assertEquals(len(table), 1)
insertedrow = table.row(0)
self.assertEquals(insertedrow, nextrow)
insertedrow = table.row(0)
self.assertEquals(insertedrow, nextrow)
def test_adding_table_data_using_tuple(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int", name="index")
self.assertEqual(table.columnCount(), 1)
table.addColumn(type="str", name="value")
self.assertEqual(table.columnCount(), 2)
values = (1, '10')
table.addRow(values)
self.assertEqual(len(table), 1)
insertedrow = table.row(0)
self.assertEqual(1, insertedrow['index'])
self.assertEqual('10', insertedrow['value'])
incorrect_type = (1, 10)
self.assertRaises(TypeError, table.addRow, incorrect_type)
def test_adding_table_data_using_list(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int",name="index")
self.assertEquals(table.columnCount(), 1)
table.addColumn(type="str",name="value")
self.assertEquals(table.columnCount(), 2)
values = [1, '10']
table.addRow(values)
self.assertEquals(len(table), 1)
insertedrow = table.row(0)
self.assertEquals(1, insertedrow['index'])
self.assertEquals('10', insertedrow['value'])
incorrect_type = [1, 10]
self.assertRaises(TypeError, table.addRow, incorrect_type)
def test_plot_guess_plots_for_table_workspaces(self):
table = WorkspaceFactory.createTable()
table.addColumn('double', 'X', 1)
table.addColumn('double', 'Y', 2)
for i in range(1, 10):
table.addRow([0.1 * i, 5])
name = "table_name"
AnalysisDataService.Instance().addOrReplace(name, table)
property_browser = self._create_widget()
property_browser.getFittingFunction = Mock(
return_value='name=FlatBackground')
property_browser.workspaceName = Mock(return_value=name)
property_browser.startX = Mock(return_value=0.15)
property_browser.endX = Mock(return_value=0.95)
property_browser.plot_guess()
self.assertEqual(1, property_browser.get_axes().plot.call_count)
def create_results_table():
table = WorkspaceFactory.createTable()
table.addColumn(type='str', name='workspace_name')
table.addColumn(type='float', name='A0')
table.addColumn(type='float', name='A1')
table.addColumn(type='float', name='Sigma')
table.addColumn(type='float', name='Lambda')
table.addColumn(type='float', name='f1.Sigma')
table.addColumn(type='float', name='f1.Lambda')
table.addRow([
"MUSR62260; Group; bottom; Asymmetry; MA", 0.1, 0.2, 0.3, 0.4, 0.5, 0.6
])
table.addRow(
["MUSR62260; Group; top; Asymmetry; MA", 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])
table.addRow(
["MUSR62260; Group; fwd; Asymmetry; MA", 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
return table
def test_workspaces_removed_from_workspace_list_widget_if_deleted_from_ADS(self):
name = "ws"
fig, canvas_mock, _ = self._create_and_plot_matrix_workspace(name)
property_browser = self._create_widget(canvas=canvas_mock)
property_browser.setOutputName(name)
# create fake fit output results
matrixWorkspace = WorkspaceFactory.Instance().create("Workspace2D", NVectors=3, YLength=5, XLength=5)
AnalysisDataService.Instance().addOrReplace(name + "_Workspace", matrixWorkspace)
tableWorkspace = WorkspaceFactory.createTable()
AnalysisDataService.Instance().addOrReplace(name + "_Parameters", tableWorkspace)
property_browser.fitting_done_slot(name + "_Workspace")
AnalysisDataService.Instance().remove(name + "_Parameters")
property_browser.postDeleteHandle(name + "_Parameters")
wsList = property_browser.getWorkspaceList()
self.assertEqual(1, len(wsList))
def test_pickle_table_workspace(self):
from mantid.kernel import V3D
import pickle
table = WorkspaceFactory.createTable()
table.addColumn(type="int",name="index")
table.addColumn(type="str",name="value")
table.addColumn(type="V3D",name="position")
values = (1, '10', V3D(0, 0, 1))
table.addRow(values)
values = (2, '100', V3D(1, 0, 0))
table.addRow(values)
p = pickle.dumps(table)
table2 = pickle.loads(p)
self.assertEqual(table.toDict(), table2.toDict())
def test_adding_table_data_using_dictionary(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int", name="index")
self.assertEqual(table.columnCount(), 1)
table.addColumn(type="str", name="value")
self.assertEqual(table.columnCount(), 2)
nextrow = {'index': 1, 'value': '10'}
table.addRow(nextrow)
self.assertEqual(len(table), 1)
insertedrow = table.row(0)
self.assertEqual(1, insertedrow['index'])
self.assertEqual('10', insertedrow['value'])
incorrect_type = {'index': 1, 'value': 10}
self.assertRaises(TypeError, table.addRow, incorrect_type)
incorrect_key = {'notindex': 2, 'notvalue': '20'}
self.assertRaises(KeyError, table.addRow, incorrect_key)
def test_set_and_extract_plot_types(self):
table = WorkspaceFactory.createTable()
table.addColumn("int", "index")
table.addColumn("int", "value", 3)
self.assertEqual(table.columnCount(), 2)
self.assertEqual(table.getPlotType(0), -1000) # default plot type
self.assertEqual(table.getPlotType(1), 3)
table.setPlotType(0, 1)
table.setPlotType("value", 2)
self.assertEqual(table.getPlotType("index"), 1)
self.assertEqual(table.getPlotType("value"), 2)
table.addRow([1, 2])
table.addRow([3, 4])
self.assertEqual(table.rowCount(), 2)
def test_set_and_extract_plot_types(self):
table = WorkspaceFactory.createTable()
table.addColumn("int", "index")
table.addColumn("int", "value", 3)
self.assertEquals(table.columnCount(), 2)
self.assertEquals(table.getPlotType(0), -1000) # default plot type
self.assertEquals(table.getPlotType(1), 3)
table.setPlotType(0, 1)
table.setPlotType("value", 2)
self.assertEquals(table.getPlotType("index"), 1)
self.assertEquals(table.getPlotType("value"), 2)
table.addRow([1, 2])
table.addRow([3, 4])
self.assertEquals(table.rowCount(), 2)
def test_convert_to_dict(self):
from mantid.kernel import V3D
expected_output = {
'index': [1, 2],
'value': ['10', '100'],
'position': [V3D(0, 0, 1), V3D(1, 0, 0)]
}
table = WorkspaceFactory.createTable()
table.addColumn(type="int",name="index")
table.addColumn(type="str",name="value")
table.addColumn(type="V3D",name="position")
values = (1, '10', V3D(0, 0, 1))
table.addRow(values)
values = (2, '100', V3D(1, 0, 0))
table.addRow(values)
data = table.toDict()
self.assertEquals(data, expected_output)
def test_fit_result_workspaces_are_added_to_browser_when_fitting_done(self):
name = "ws"
fig, canvas, _ = self._create_and_plot_matrix_workspace(name)
property_browser = self._create_widget(canvas=canvas)
property_browser.setOutputName(name)
# create fake fit output results
matrixWorkspace = WorkspaceFactory.Instance().create("Workspace2D", NVectors=3, YLength=5, XLength=5)
tableWorkspace = WorkspaceFactory.createTable()
AnalysisDataService.Instance().addOrReplace(name + "_Workspace", matrixWorkspace)
AnalysisDataService.Instance().addOrReplace(name + "_Parameters", tableWorkspace)
AnalysisDataService.Instance().addOrReplace(name + "_NormalisedCovarianceMatrix", tableWorkspace)
property_browser.fitting_done_slot(name + "_Workspace")
workspaceList = property_browser.getWorkspaceList()
self.assertEqual(3, workspaceList.count())
self.assertEqual(name + "_NormalisedCovarianceMatrix", workspaceList.item(0).text())
self.assertEqual(name + "_Parameters", workspaceList.item(1).text())
self.assertEqual(name + "_Workspace", workspaceList.item(2).text())
def test_convert_to_dict(self):
from mantid.kernel import V3D
expected_output = {
'index': [1, 2],
'value': ['10', '100'],
'position': [V3D(0, 0, 1), V3D(1, 0, 0)]
}
table = WorkspaceFactory.createTable()
table.addColumn(type="int", name="index")
table.addColumn(type="str", name="value")
table.addColumn(type="V3D", name="position")
values = (1, '10', V3D(0, 0, 1))
table.addRow(values)
values = (2, '100', V3D(1, 0, 0))
table.addRow(values)
data = table.toDict()
self.assertEqual(data, expected_output)
def test_that_all_latest_fits_will_return_the_two_most_recent_unique_fits(
self):
output_ws = WorkspaceFactory.create("Workspace2D",
NVectors=3,
YLength=5,
XLength=5)
table_workspace = WorkspaceFactory.createTable()
output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws)
parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1",
table_workspace)
covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1",
table_workspace)
output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws)
parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2",
table_workspace)
covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2",
table_workspace)
fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1],
parameter_ws_wrap1, covariance_ws_wrap1)
fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2],
parameter_ws_wrap2, covariance_ws_wrap2)
fit3 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1],
parameter_ws_wrap1, covariance_ws_wrap1)
self.fitting_context.tf_asymmetry_mode = True
self.fitting_context.simultaneous_fitting_mode = True
self.fitting_context.active_fit_history = [fit1, fit2, fit3]
self.assertEqual(self.fitting_context.active_fit_history[0], fit1)
self.assertEqual(self.fitting_context.active_fit_history[1], fit2)
self.assertEqual(self.fitting_context.active_fit_history[2], fit3)
self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2)
self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3)
self.fitting_context.tf_asymmetry_mode = False
self.assertEqual(self.fitting_context.active_fit_history, [])
self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2)
self.assertEqual(self.fitting_context.all_latest_fits()[1], fit3)
def test_remove_workspace_by_name_will_remove_a_fit_containing_a_specific_parameter_workspace(self):
output_ws = WorkspaceFactory.create("Workspace2D", NVectors=3, YLength=5, XLength=5)
table_workspace = WorkspaceFactory.createTable()
output_ws_wrap1 = StaticWorkspaceWrapper("Output1", output_ws)
parameter_ws_wrap1 = StaticWorkspaceWrapper("Parameter1", table_workspace)
covariance_ws_wrap1 = StaticWorkspaceWrapper("Covariance1", table_workspace)
output_ws_wrap2 = StaticWorkspaceWrapper("Output2", output_ws)
parameter_ws_wrap2 = StaticWorkspaceWrapper("Parameter2", table_workspace)
covariance_ws_wrap2 = StaticWorkspaceWrapper("Covariance2", table_workspace)
fit1 = FitInformation(["Input1"], "GausOsc", [output_ws_wrap1], parameter_ws_wrap1, covariance_ws_wrap1)
fit2 = FitInformation(["Input2"], "GausOsc", [output_ws_wrap2], parameter_ws_wrap2, covariance_ws_wrap2)
self.fitting_context.simultaneous_fitting_mode = True
self.fitting_context.active_fit_history = [fit1, fit2]
self.fitting_context.remove_workspace_by_name("Parameter1")
self.assertEqual(self.fitting_context.active_fit_history[0], fit2)
self.assertEqual(self.fitting_context.all_latest_fits()[0], fit2)
def test_fit_result_matrix_workspace_in_browser_is_viewed_when_clicked(self):
from mantidqt.widgets.workspacedisplay.table.presenter import TableWorkspaceDisplay
name = "ws"
fig, canvas, _ = self._create_and_plot_matrix_workspace(name)
property_browser = self._create_widget(canvas=canvas)
property_browser.setOutputName(name)
# create fake fit output results
matrixWorkspace = WorkspaceFactory.Instance().create("Workspace2D", NVectors=3, YLength=5, XLength=5)
AnalysisDataService.Instance().addOrReplace(name + "_Workspace", matrixWorkspace)
tableWorkspace = WorkspaceFactory.createTable()
AnalysisDataService.Instance().addOrReplace(name + "_Parameters", tableWorkspace)
property_browser.fitting_done_slot(name + "_Workspace")
wsList = property_browser.getWorkspaceList()
TableWorkspaceDisplay.show_view = Mock()
# click on table workspace
item = wsList.item(0).text()
property_browser.workspaceClicked.emit(item)
self.assertEqual(1, TableWorkspaceDisplay.show_view.call_count)
def _createReflectionWorkspace(self, hkldict):
""" Create TableWorkspace containing reflections and etc.
"""
# 1. Set up columns
tablews = WorkspaceFactory.createTable()
tablews.addColumn("int", "H");
tablews.addColumn("int", "K");
tablews.addColumn("int", "L");
tablews.addColumn("double", "Alpha");
tablews.addColumn("double", "Beta");
tablews.addColumn("double", "Sigma2");
tablews.addColumn("double", "Gamma");
tablews.addColumn("double", "FWHM");
tablews.addColumn("double", "PeakHeight");
# 2. Add rows
for hkl in sorted(hkldict.keys()):
pardict = hkldict[hkl]
tablews.addRow([hkl[0], hkl[1], hkl[2], pardict["alpha"], pardict["beta"], pardict["sigma2"], pardict["gamma2"], pardict["FWHM"], 1.0])
# ENDFOR
return tablews
def test_adding_table_data_using_numpy(self):
table = WorkspaceFactory.createTable()
table.addColumn(type="int",name="index")
self.assertEquals(table.columnCount(), 1)
table.addColumn(type="int",name="value")
self.assertEquals(table.columnCount(), 2)
nextrow = {'index': 1, 'value': 10}
values32 = numpy.array(nextrow.values()).astype(numpy.int32)
values64 = numpy.array(nextrow.values()).astype(numpy.int64)
table.addRow(values32)
self.assertEquals(len(table), 1)
insertedrow = table.row(0)
self.assertEquals(insertedrow, nextrow)
table.addRow(values64)
self.assertEquals(len(table), 2)
insertedrow = table.row(1)
self.assertEquals(insertedrow, nextrow)
incorrect_type = numpy.array(['1', '10'])
self.assertRaises(TypeError, table.addRow, incorrect_type)
def test_log_names_respects_filter(self):
time_series_logs = (('ts_1', (1., )), ('ts_2', (3., )), ('ts_3', [2.]),
('ts_4', [3.]))
fake1 = create_test_workspace(ws_name='fake1',
time_series_logs=time_series_logs[:2])
fake2 = create_test_workspace(ws_name='fake2',
time_series_logs=time_series_logs[2:])
table_workspace = WorkspaceFactory.createTable()
fit1 = FitInformation(
mock.MagicMock(), 'func1',
[StaticWorkspaceWrapper(fake1.name(), fake1)],
StaticWorkspaceWrapper(fake1.name(), table_workspace),
mock.MagicMock())
fit2 = FitInformation(
mock.MagicMock(), 'func1',
[StaticWorkspaceWrapper(fake2.name(), fake2)],
StaticWorkspaceWrapper(fake2.name(), table_workspace),
mock.MagicMock())
self.mock_active_fit_history = mock.PropertyMock(
return_value=[fit1, fit2])
type(self.fitting_context
).active_fit_history = self.mock_active_fit_history
self.fitting_context.all_latest_fits = mock.MagicMock(
return_value=[fit1, fit2])
self.fitting_context.add_fit(fit1)
self.fitting_context.add_fit(fit2)
required_logs = ('ts_2', 'ts_4')
log_names = self.fitting_context.log_names(
filter_fn=lambda log: log.name in required_logs)
self.assertEqual(len(required_logs), len(log_names))
for name in required_logs:
self.assertTrue(name in log_names,
msg="{} not found in log list".format(name))
def _createReflectionWorkspace(self, hkldict):
""" Create TableWorkspace containing reflections and etc.
"""
# 1. Set up columns
tablews = WorkspaceFactory.createTable()
tablews.addColumn("int", "H")
tablews.addColumn("int", "K")
tablews.addColumn("int", "L")
tablews.addColumn("double", "Alpha")
tablews.addColumn("double", "Beta")
tablews.addColumn("double", "Sigma2")
tablews.addColumn("double", "Gamma")
tablews.addColumn("double", "FWHM")
tablews.addColumn("double", "PeakHeight")
# 2. Add rows
for hkl in sorted(hkldict.keys()):
pardict = hkldict[hkl]
tablews.addRow([hkl[0], hkl[1], hkl[2], pardict["alpha"], pardict["beta"],
pardict["sigma2"], pardict["gamma2"], pardict["FWHM"], 1.0])
# ENDFOR
return tablews
def test_fit_curves_removed_when_workspaces_deleted(self):
fig, canvas = self._create_and_plot_matrix_workspace(name="ws")
property_browser = self._create_widget(canvas=canvas)
manager_mock = Mock()
manager_mock.canvas = canvas
observer = FigureManagerADSObserver(manager=manager_mock) # noqa: F841
for plot_diff in [True, False]:
# create fake fit output results
matrixWorkspace = WorkspaceFactory.Instance().create("Workspace2D",
NVectors=3,
YLength=5,
XLength=5)
tableWorkspace = WorkspaceFactory.createTable()
AnalysisDataService.Instance().addOrReplace(
"ws_Workspace", matrixWorkspace)
AnalysisDataService.Instance().addOrReplace(
"ws_Parameters", tableWorkspace)
AnalysisDataService.Instance().addOrReplace(
"ws_NormalisedCovarianceMatrix", tableWorkspace)
property_browser.plotDiff = Mock(return_value=plot_diff)
property_browser.fitting_done_slot("ws_Workspace")
if plot_diff:
self.assertEqual(3, len(fig.get_axes()[0].lines))
else:
self.assertEqual(2, len(fig.get_axes()[0].lines))
AnalysisDataService.Instance().remove("ws_Workspace")
AnalysisDataService.Instance().remove("ws_Parameters")
AnalysisDataService.Instance().remove(
"ws_NormalisedCovarianceMatrix")
self.assertEqual(1, len(fig.get_axes()[0].lines))
def PyExec(self):
""" Main Execution Body
"""
warnings.warn("A message", ModuleDeprecationWarning)
# 1. Get Input properties
inppeakws = self.getProperty("BraggPeakParameterWorkspace").value
inpzscows = self.getProperty("ZscoreWorkspace").value
minpeakheight = float(self.getPropertyValue("MinimumPeakHeight"))
zscorefilterstr = self.getPropertyValue("ZscoreFilter")
print("Input: PeakParameterWorkspace = %s; ZscoreWorkspace = %s" %
(inppeakws.name, inpzscows.name))
print(" Minimum peak height = %f" % (minpeakheight))
print(" Zscore filter: %s" % (zscorefilterstr))
# 3. Parse Zscore table and peak parameters
self.mPeaks = {}
zscoredict = self.parseBraggPeakParameterTable(inpzscows)
self.mPeaks = self.parseBraggPeakParameterTable(inppeakws)
# 4. Filter by peak height
self.filterByPeakHeight(minpeakheight)
# 5. Filter by zscore
zscorefilterdict = self.parseZscoreFilter(zscorefilterstr)
self.filterByZscore(zscoredict, zscorefilterdict)
# 6. Generate the output
paramWS = WorkspaceFactory.createTable()
self.genBraggPeakParameterWorkspace(paramWS)
self.setProperty("OutputBraggPeakParameterWorkspace", paramWS)
return
def PyExec(self):
""" Mantid required
"""
self.log().warning('Poldi Data Analysis ---- add dir')
load_data_at_the_end = False
sample_info_ws_name = ""
try:
sample_info_ws_name = self.getProperty("PoldiAnalysis").value
if(sample_info_ws_name == ""):
sample_info_ws_name = "PoldiAnalysis"
self.log().debug('Poldi Data Analysis ---- %s'%(sample_info_ws_name))
sample_info_ws = mtd["PoldiAnalysis"]
self.log().debug(' ---- workspace loaded')
except:
self.log().debug(' ---- workspace created')
sample_info_ws = WorkspaceFactory.createTable()
sample_info_ws.addColumn("str","spl Name")
sample_info_ws.addColumn("int","year")
sample_info_ws.addColumn("int","number")
sample_info_ws.addColumn("str","data file")
sample_info_ws.addColumn("str","spl log")
sample_info_ws.addColumn("str","spl corr")
sample_info_ws.addColumn("str","spl dead wires")
sample_info_ws.addColumn("str","spl peak")
load_data_at_the_end = True
# self.setProperty("PoldiAnalysis", sample_info_ws)
# self.log().debug('Poldi Data Analysis ---- %s'%(sample_info_ws_name))
# sample_info_ws = mtd[sample_info_ws_name]
directory = self.getProperty("Directory").value
onlyfiles = [ f for f in listdir(directory) if isfile(join(directory,f)) ]
self.log().debug('Poldi - load data')
for dataFile in onlyfiles:
(sample_name, sampleExt) = splitext(dataFile)
file_path = join(directory,dataFile)
# PoldiProjectAddFile(File=file_path)
# , PoldiAnalysis=sample_info_ws)
if("hdf" in sampleExt):
self.log().error('Poldi - samples : %s' %(sample_name))
file_path = join(directory,dataFile)
sample_name_log = "%sLog" %sample_name
sample_name_corr = "%sCorr" %sample_name
sample_name_deadw = "%sDeadWires" %sample_name
(sample_year, sample_numero) = self.interpreteName(sample_name)
sample_name_peak = "%sPeak" %sample_name
sample_info_ws.addRow([sample_name, sample_year, sample_numero, file_path,
sample_name_log,
sample_name_corr,
sample_name_deadw,
sample_name_peak])
nb_of_sample = sample_info_ws.rowCount()
self.log().error('Poldi - %d samples added' %(nb_of_sample))
if(load_data_at_the_end):
self.setProperty("PoldiAnalysis", sample_info_ws)
def PyExec(self):
""" Mantid required
"""
self.log().debug('Poldi Data Analysis ---- start')
sample_info_ws = self.getProperty("InputWorkspace").value
load_data_at_the_end = False
try:
sample_ipp_ws_name = self.getProperty("OutputWorkspace").value
if(sample_ipp_ws_name == ""):
sample_ipp_ws_name = "PoldiIPPmanager"
self.log().debug('Poldi IPP manager ---- %s'%(sample_info_ws_name))
sample_ipp_ws = mtd["PoldiIPPmanager"]
self.log().debug(' ---- workspace ipp loaded')
except:
self.log().debug(' ---- workspace ipp created')
sample_ipp_ws = WorkspaceFactory.createTable()
sample_ipp_ws.addColumn("str","spl Name")
sample_ipp_ws.addColumn("str","ipp version")
load_data_at_the_end = True
wlen_min = self.getProperty("wlenmin").value
wlen_max = self.getProperty("wlenmax").value
bad_wires_threshold = self.getProperty("BadWiresThreshold").value
peak_detect_threshold = self.getProperty("PeakDetectionThreshold").value
self.log().information('Poldi run with parameters')
self.log().information(' - wlen_min : %s' %(wlen_min))
self.log().information(' - wlen_max : %s' %(wlen_max))
self.log().information(' - bad_wires_threshold : %s' %(bad_wires_threshold))
self.log().information(' - peak_detect_threshold : %s' %(peak_detect_threshold))
dictsearch=os.path.join(config['instrumentDefinition.directory'],"nexusdictionaries","poldi.dic")
self.log().information('Poldi instr folder - %s' %(dictsearch))
firstOne=""
self.log().debug('Poldi - load data')
nb_of_sample = sample_info_ws.rowCount()
self.log().information('Poldi - %d samples listed' %(nb_of_sample))
for sample in range(nb_of_sample):
sampleName = sample_info_ws.column("spl Name")[sample]
filePath = sample_info_ws.column("data file")[sample]
sampleNameLog = sample_info_ws.column("spl log")[sample]
sampleDeadWires = sample_info_ws.column("spl dead wires")[sample]
self.log().information('Poldi - sample %s' %(sampleName))
LoadSINQFile(Instrument="POLDI",
Filename=filePath,
OutputWorkspace=sampleName)
sample_output_ws = mtd[sampleName]
PoldiLoadLog(InputWorkspace=sample_output_ws,
Filename=filePath,
Dictionary=dictsearch,
PoldiLog=sampleNameLog)
cfgService = ConfigServiceImpl.Instance()
LoadInstrument(Workspace=sample_output_ws,
Filename=cfgService.getInstrumentDirectory() + "POLDI_Definition_ipp13.xml",
RewriteSpectraMap=True)
self.log().debug('Poldi - set ipp')
sample_instrument = sample_output_ws.getInstrument()
ipp_version = sample_instrument.getStringParameter("ipp")[0]
add_this_ipp = True
for ipp in range(sample_ipp_ws.rowCount()):
if(sample_ipp_ws.column("ipp version")[ipp] == ipp_version):
add_this_ipp = False
if(add_this_ipp):
sample_ipp_ws.addRow([sampleName, ipp_version])
self.log().debug('Poldi - dead wires')
PoldiRemoveDeadWires(InputWorkspace=sample_output_ws,
RemoveExcludedWires=True,
AutoRemoveBadWires=False,
BadWiresThreshold=bad_wires_threshold,
PoldiDeadWires=sampleDeadWires)
nb_of_ipp = sample_ipp_ws.rowCount()
self.log().information('Poldi - %d ipp listed' %(nb_of_ipp))
for ipp in range(nb_of_ipp):
ex_of_sample = sample_ipp_ws.column("spl Name")[ipp]
PoldiIPP = sample_ipp_ws.column("ipp version")[ipp]
ipp_chopper_slits = "%s_Chopper" %PoldiIPP
ipp_Poldi_spectra = "%s_Spectra" %PoldiIPP
ipp_ipp_data = "%s_Data" %PoldiIPP
ex_of_sample_ws = mtd[ex_of_sample]
self.log().debug('Poldi - chopper slits')
PoldiLoadChopperSlits(InputWorkspace=ex_of_sample_ws,
PoldiChopperSlits=ipp_chopper_slits)
self.log().debug('Poldi - spectra')
PoldiLoadSpectra(InputWorkspace=ex_of_sample_ws,
PoldiSpectra=ipp_Poldi_spectra)
self.log().debug('Poldi - IPP')
PoldiLoadIPP(InputWorkspace=ex_of_sample_ws,
PoldiIPP=ipp_ipp_data)
for sample in range(nb_of_sample):
sampleName = sample_info_ws.column("spl Name" )[sample]
filePath = sample_info_ws.column("data file")[sample]
sampleNameLog = sample_info_ws.column("spl log" )[sample]
sampleDeadWires= sample_info_ws.column("spl dead wires" )[sample]
sampleNameCorr = sample_info_ws.column("spl corr" )[sample]
groupedResults = GroupWorkspaces([mtd[sampleName].name(), sampleNameLog, sampleDeadWires])
RenameWorkspace(InputWorkspace=groupedResults,
OutputWorkspace="%s_Metadata" % sampleName)
if(load_data_at_the_end):
self.setProperty("OutputWorkspace", sample_ipp_ws)
def PyExec(self):
self.setProperty("OutputWorkspace", WorkspaceFactory.createTable())
def test_creating_a_tableworkspace(self):
table = WorkspaceFactory.createTable()
self.assertTrue(isinstance(table, ITableWorkspace))
def _loadFullprofDataFile(self, datafilename):
""" Parse a Fullprof (multiple) column file
"""
# Import file
datafile = open(datafilename, "r")
rawlines = datafile.readlines()
datafile.close()
# Parse head
iline = 0
parseheader = True
#title = ""
while iline < len(rawlines) and parseheader is True:
line = rawlines[iline].strip()
if len(line) > 0:
if line.count("BANK") != 0:
# line information
terms = line.split()
if terms[0] != 'BANK':
raise NotImplementedError("First word must be 'BANK', but not %s" % (terms[0]))
#bankid = int(terms[1])
numdata = int(terms[2])
numlines = int(terms[3])
parseheader = False
# ENDIF
# ENDIF
iline += 1
# ENDWHILE (iline)
# Data vectors
vecx = []
vecy = []
vece = []
for i in xrange(iline, len(rawlines)):
line = rawlines[i].strip()
if len(line) == 0:
continue
terms = line.split()
numitems = len(terms)
if numitems % 3 != 0:
print "%d-th line '%s' is not a data line" % (i, line)
continue
numpts = numitems/3
for j in xrange(numpts):
x = float(terms[j*3])
y = float(terms[j*3+1])
e = float(terms[j*3+2])
vecx.append(x)
vecy.append(y)
vece.append(e)
# ENDFOR
# ENDFOR (i)
# Check
self.log().notice("Expected to read %d data points; Exactly read %d data points. " % (numdata*numlines, len(vecx)))
# Create output workspaces
tablews = WorkspaceFactory.createTable()
# Create the data workspace
datasize = len(vecx)
dataws = WorkspaceFactory.create("Workspace2D", 1, datasize, datasize)
for i in xrange(datasize):
dataws.dataX(0)[i] = vecx[i]
dataws.dataY(0)[i] = vecy[i]
dataws.dataE(0)[i] = vece[i]
return (tablews, dataws)
def _loadFullprofDataFile(self, datafilename):
""" Parse a Fullprof (multiple) column file
"""
# Import file
datafile = open(datafilename, "r")
rawlines = datafile.readlines()
datafile.close()
# Parse head
iline = 0
parseheader = True
title = ""
while iline < len(rawlines) and parseheader is True:
line = rawlines[iline].strip()
if len(line) > 0:
if line.count("BANK") == 0:
# header
title += line + ", "
else:
# line information
terms = line.split()
if terms[0] != 'BANK':
raise NotImplementedError(
"First word must be 'BANK', but not %s" %
(terms[0]))
bankid = int(terms[1])
numdata = int(terms[2])
numlines = int(terms[3])
parseheader = False
# ENDIF
# ENDIF
iline += 1
# ENDWHILE (iline)
# Data vectors
vecx = []
vecy = []
vece = []
for i in xrange(iline, len(rawlines)):
line = rawlines[i].strip()
if len(line) == 0:
continue
terms = line.split()
numitems = len(terms)
if numitems % 3 != 0:
print "%d-th line '%s' is not a data line" % (i, line)
continue
numpts = numitems / 3
for j in xrange(numpts):
x = float(terms[j * 3])
y = float(terms[j * 3 + 1])
e = float(terms[j * 3 + 2])
vecx.append(x)
vecy.append(y)
vece.append(e)
# ENDFOR
# ENDFOR (i)
# Check
self.log().notice(
"Expected to read %d data points; Exactly read %d data points. " %
(numdata * numlines, len(vecx)))
# Create output workspaces
tablews = WorkspaceFactory.createTable()
# Create the data workspace
datasize = len(vecx)
dataws = WorkspaceFactory.create("Workspace2D", 1, datasize, datasize)
for i in xrange(datasize):
dataws.dataX(0)[i] = vecx[i]
dataws.dataY(0)[i] = vecy[i]
dataws.dataE(0)[i] = vece[i]
return (tablews, dataws)
def PyExec(self):
tableWS = WorkspaceFactory.createTable()
self.setProperty("OutputWorkspace", tableWS)
def PyExec(self):
tableWS = WorkspaceFactory.createTable()
self.setProperty("OutputWorkspace", tableWS)
