def setToolbarsVisible(visible):
"""Show/hide MantidPlot toolbars
Args:
visible: If True, make toolbars visible, if False - hidden
"""
threadsafe_call(_qti.app.setToolbarsVisible, visible)
def moveMouseToCentre(widget):
"""Moves the mouse over the widget
"""
if qtest:
QtCore.QCoreApplication.processEvents()
threadsafe_call(QTest.mouseMove, widget)
QtCore.QCoreApplication.processEvents()
def closeAllSliceViewers():
"""
Closes all currently open SliceViewer windows. This might be useful to
clean up your desktop after opening many windows.
"""
threadsafe_call(mantidqtpython.MantidQt.Factory.WidgetFactory.Instance().
closeAllSliceViewerWindows)
def closeAllSliceViewers():
"""
Closes all currently open SliceViewer windows. This might be useful to
clean up your desktop after opening many windows.
"""
import mantidqtpython
threadsafe_call(mantidqtpython.MantidQt.Factory.WidgetFactory.Instance().closeAllSliceViewerWindows)
def screenshot(widget, filename, description, png_exists=False):
""" Take a screenshot of the widget for displaying in a html report.
The MANTID_SCREENSHOT_REPORT environment variable must be set
to the destination folder. Screenshot taking is skipped otherwise.
:param widget: QWidget to grab.
:param filename: Save to this file (no extension!).
:param description: Short descriptive text of what the screenshot should look like.
:param png_exists: if True, then the 'filename' already exists. Don't grab a screenshot, but add to the report.
"""
dest = get_screenshot_dir()
if dest is not None:
report = os.path.join(dest, "index.html")
if png_exists:
pass
else:
# Find the widget if handled with a proxy
if hasattr(widget, "_getHeldObject"):
widget = widget._getHeldObject()
if widget is not None:
camera = Screenshot()
threadsafe_call(camera.take_picture, widget,
os.path.join(dest, filename + ".png"))
# Modify the section in the HTML page
section_text = '<h2>%s</h2>' % filename
now = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
section_text += '%s (%s)<br />' % (description, now)
section_text += '<img src="%s.png" alt="%s"></img>' % (filename,
description)
_replace_report_text(report, filename, section_text)
def screenshot(widget, filename, description, png_exists=False):
""" Take a screenshot of the widget for displaying in a html report.
The MANTID_SCREENSHOT_REPORT environment variable must be set
to the destination folder. Screenshot taking is skipped otherwise.
:param widget: QWidget to grab.
:param filename: Save to this file (no extension!).
:param description: Short descriptive text of what the screenshot should look like.
:param png_exists: if True, then the 'filename' already exists. Don't grab a screenshot, but add to the report.
"""
dest = get_screenshot_dir()
if not dest is None:
report = os.path.join(dest, "index.html")
if png_exists:
pass
else:
# Find the widget if handled with a proxy
if hasattr(widget, "_getHeldObject"):
widget = widget._getHeldObject()
if widget is not None:
camera = Screenshot()
threadsafe_call(camera.take_picture, widget, os.path.join(dest, filename + ".png"))
# Modify the section in the HTML page
section_text = '<h2>%s</h2>' % filename
now = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
section_text += '%s (%s)<br />' % (description, now)
section_text += '<img src="%s.png" alt="%s"></img>' % (filename, description)
_replace_report_text(report, filename, section_text)
def moveMouseToCentre(widget):
"""Moves the mouse over the widget
"""
if qtest:
QtCore.QCoreApplication.processEvents()
threadsafe_call(QTest.mouseMove, widget)
QtCore.QCoreApplication.processEvents()
def plotTableColumns(table, columns, type = -1):
"""
This plots one or more columns from a table.
Args:
table: a qtiplot or mantid table (not a TableWorkspace)
columns: a list or a tuple of columns names to plot or a string for a single column.
To plot error bars add their column name(s).
type: curve style for plot (-1: unspecified; 0: line, default; 1: scatter/dots)
Returns:
A handle to the created window. None in case of error.
"""
# This function uses qtiplot's methods for plotting tables.
# To be able to plot error bars all column names must be prefixed
# with the table name.
if isinstance(columns, tuple) or isinstance(columns, list):
columns = ['%s_%s' % (table.name(), column) for column in columns]
columns = tuple(columns)
else:
columns = '%s_%s' % (table.name(), columns)
graph = proxies.Graph(threadsafe_call(_qti.app.plot, table._getHeldObject(), columns, type))
threadsafe_call(graph.activeLayer().setTitle, table.windowLabel())
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def stemPlot(source, index, power=None, startPoint=None, endPoint=None):
"""Generate a stem-and-leaf plot from an input table column or workspace spectrum
Args:
source: A reference to a workspace or a table.
index: For a table, the column number or name. For a workspace, the workspace index.
power: The stem unit as a power of 10. If not provided, a dialog will appear with a suggested value.
startPoint: The first point (row or bin) to use (Default: the first one).
endPoint: The last point (row or bin) to use (Default: the last one).
Returns:
A string representation of the stem plot
"""
# Turn the optional arguments into the magic numbers that the C++ expects
if power == None:
power = 1001
if startPoint == None:
startPoint = 0
if endPoint == None:
endPoint = -1
if isinstance(source, proxies.QtProxyObject):
source = source._getHeldObject()
elif hasattr(source, 'getName'):
# If the source is a workspace, create a table from the specified index
wsName = source.getName()
source = threadsafe_call(_qti.app.mantidUI.workspaceToTable.wsName, wsName, [index], False, True)
# The C++ stemPlot method takes the name of the column, so get that
index = source.colName(2)
# Get column name if necessary
if isinstance(index, int):
index = source.colName(index)
# Call the C++ method
return threadsafe_call(_qti.app.stemPlot, source, index, power, startPoint, endPoint)
def setToolbarsVisible(visible):
"""Show/hide MantidPlot toolbars
Args:
visible: If True, make toolbars visible, if False - hidden
"""
threadsafe_call(_qti.app.setToolbarsVisible, visible)
def plotTableColumns(table, columns, type=-1):
"""
This plots one or more columns from a table.
Args:
table: a qtiplot or mantid table (not a TableWorkspace)
columns: a list or a tuple of columns names to plot or a string for a single column.
To plot error bars add their column name(s).
type: curve style for plot (-1: unspecified; 0: line, default; 1: scatter/dots)
Returns:
A handle to the created window. None in case of error.
"""
# This function uses qtiplot's methods for plotting tables.
# To be able to plot error bars all column names must be prefixed
# with the table name.
if isinstance(columns, tuple) or isinstance(columns, list):
columns = ['%s_%s' % (table.name(), column) for column in columns]
columns = tuple(columns)
else:
columns = '%s_%s' % (table.name(), columns)
graph = proxies.Graph(
threadsafe_call(_qti.app.plot, table._getHeldObject(), columns, type))
threadsafe_call(graph.activeLayer().setTitle, table.windowLabel())
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def stemPlot(source, index, power=None, startPoint=None, endPoint=None):
"""Generate a stem-and-leaf plot from an input table column or workspace spectrum
Args:
source: A reference to a workspace or a table.
index: For a table, the column number or name. For a workspace, the workspace index.
power: The stem unit as a power of 10. If not provided, a dialog will appear with a suggested value.
startPoint: The first point (row or bin) to use (Default: the first one).
endPoint: The last point (row or bin) to use (Default: the last one).
Returns:
A string representation of the stem plot
"""
# Turn the optional arguments into the magic numbers that the C++ expects
if power == None:
power = 1001
if startPoint == None:
startPoint = 0
if endPoint == None:
endPoint = -1
if isinstance(source, proxies.QtProxyObject):
source = source._getHeldObject()
elif hasattr(source, 'getName'):
# If the source is a workspace, create a table from the specified index
wsName = source.getName()
source = threadsafe_call(_qti.app.mantidUI.workspaceToTable.wsName, wsName, [index], False, True)
# The C++ stemPlot method takes the name of the column, so get that
index = source.colName(2)
# Get column name if necessary
if isinstance(index, int):
index = source.colName(index)
# Call the C++ method
return threadsafe_call(_qti.app.stemPlot, source, index, power, startPoint, endPoint)
def saveProjectAs(file_name, compress=False):
"""Save a mantid project
This will serialise all associated workspaces and windows
Args:
file_name :: file path to save to
compress :: whether to compress the project after saving
"""
threadsafe_call(_qti.app.saveProjectAs, file_name, compress)
def saveProjectAs(file_name, compress=False):
"""Save a mantid project
This will serialise all associated workspaces and windows
Args:
file_name :: file path to save to
compress :: whether to compress the project after saving
"""
threadsafe_call(_qti.app.saveProjectAs, file_name, compress)
def openProject(file_name, file_version=0):
"""Open a mantid project file.
This will load all associated workspaces and plots.
Args:
file_name :: file path to a mantid project file
file_version :: file version to use when loading (default 0).
"""
working_dir = os.path.dirname(os.path.abspath(file_name))
threadsafe_call(_qti.app.openProject, working_dir, file_name, file_version)
def runPythonScript(code, asynchronous=False, quiet=False, redirect=True):
"""
Redirects the runPythonScript method to the app object
@param code :: A string of code to execute
@param asynchronous :: If the true the code is executed in a separate thread
@param quiet :: If true no messages reporting status are issued
@param redirect :: If true then output is redirected to MantidPlot
"""
if asynchronous and QtCore.QThread.currentThread() != QtGui.qApp.thread():
asynchronous = False
threadsafe_call(_qti.app.runPythonScript, code, asynchronous, quiet, redirect)
def openProject(file_name, file_version=0):
"""Open a mantid project file.
This will load all associated workspaces and plots.
Args:
file_name :: file path to a mantid project file
file_version :: file version to use when loading (default 0).
"""
working_dir = os.path.dirname(os.path.abspath(file_name))
threadsafe_call(_qti.app.openProject, working_dir, file_name, file_version)
def runPythonScript(code, asynchronous=False, quiet=False, redirect=True):
"""
Redirects the runPythonScript method to the app object
@param code :: A string of code to execute
@param asynchronous :: If the true the code is executed in a separate thread
@param quiet :: If true no messages reporting status are issued
@param redirect :: If true then output is redirected to MantidPlot
"""
if asynchronous and QtCore.QThread.currentThread() != QtGui.qApp.thread():
asynchronous = False
threadsafe_call(_qti.app.runPythonScript, code, asynchronous, quiet,
redirect)
def selectMultiPeak(source, showFitPropertyBrowser=True, xmin=None, xmax=None):
"""Switch on the multi-peak selecting tool for fitting with the Fit algorithm.
Args:
source: A reference to a MultiLayer with the data to fit.
showFitPropertyBrowser: Whether to show the FitPropertyBrowser or not.
xmin: An optionall minimum X value to select
xmax: An optionall maximum X value to select
"""
if xmin is not None and xmax is not None:
threadsafe_call(_qti.app.selectMultiPeak, source._getHeldObject(), showFitPropertyBrowser, xmin, xmax)
else:
threadsafe_call(_qti.app.selectMultiPeak, source._getHeldObject(), showFitPropertyBrowser)
def selectMultiPeak(source, showFitPropertyBrowser=True, xmin=None, xmax=None):
"""Switch on the multi-peak selecting tool for fitting with the Fit algorithm.
Args:
source: A reference to a MultiLayer with the data to fit.
showFitPropertyBrowser: Whether to show the FitPropertyBrowser or not.
xmin: An optionall minimum X value to select
xmax: An optionall maximum X value to select
"""
if xmin is not None and xmax is not None:
threadsafe_call(_qti.app.selectMultiPeak, source._getHeldObject(), showFitPropertyBrowser, xmin, xmax)
else:
threadsafe_call(_qti.app.selectMultiPeak, source._getHeldObject(), showFitPropertyBrowser)
def getSliceViewer(source, label=""):
"""Retrieves a handle to a previously-open SliceViewerWindow.
This allows you to get a handle on, e.g., a SliceViewer that was open
by the MultiSlice view in VATES Simple Interface.
Will raise an exception if not found.
Args:
source :: name of the workspace that was open
label :: additional label string that was used to identify the window.
Returns:
a handle to the SliceViewerWindow object that was created before.
"""
import mantidqtpython
workspace_names = getWorkspaceNames(source)
if len(workspace_names) != 1:
raise Exception("Please specify only one workspace.")
else:
svw = threadsafe_call(
mantidqtpython.MantidQt.Factory.WidgetFactory.Instance().
getSliceViewerWindow, workspace_names[0], label)
if svw is not None:
return proxies.SliceViewerWindowProxy(svw)
else:
return None
def plot2D(source, style=DEFAULT_2D_STYLE, window=None):
"""Open a 2D plot of the given workspace(s)
Produces a 2D histogram for each of the given workspaces
Args:
source: workspace or name of a workspace
style: Indicates the type of plot required. Default=ColorMap
window: window used for plotting. If None a new one will be created
Returns:
If a single workspace is specified then the handle is returned, otherwise a list
of handles for each new window is returned
"""
names = getWorkspaceNames(source)
if len(names) == 0:
raise ValueError("No workspace names given to plot")
# Unwrap the window object, if any specified
if window != None:
window = window._getHeldObject()
handles = []
cfunc = _qti.app.mantidUI.drawSingleColorFillPlot
for name in names:
g = proxies.Graph(threadsafe_call(cfunc, name, style, window))
if g:
handles.append(g)
else:
raise RuntimeError("Cannot create graph from workspace '%s'" % name)
if len(handles) == 1:
return handles[0]
else:
return handles
def copyFolder(source, destination):
"""Copy a folder (and its contents) into another.
Returns:
True on success.
"""
return threadsafe_call(_qti.app.copyFolder, source._getHeldObject(), destination._getHeldObject())
def copyFolder(source, destination):
"""Copy a folder (and its contents) into another.
Returns:
True on success.
"""
return threadsafe_call(_qti.app.copyFolder, source._getHeldObject(), destination._getHeldObject())
def plotSubplots(source,
indices,
distribution=mantidqtpython.MantidQt.DistributionDefault,
error_bars=False,
window=None):
"""Open a tiled plot.
This plots one or more spectra, with X as the bin boundaries,
and Y as the counts in each bin.
If one workspace, each spectrum gets its own tile.
Otherwise, each workspace gets its own tile.
Args:
source: list of workspace names
indices: workspace index, or tuple or list of workspace indices to plot
distribution: whether or not to plot as a distribution
error_bars: bool, set to True to add error bars.
window: window used for plotting. If None a new one will be created
Returns:
A handle to window if one was specified, otherwise a handle to the created one. None in case of error.
"""
workspace_names = getWorkspaceNames(source)
# Deal with workspace groups that may contain various types:
# Only want to plot MatrixWorkspaces
to_plot = []
for name in workspace_names:
if isinstance(mantid.api.mtd[name], mantid.api.MatrixWorkspace):
to_plot.append(name)
__checkPlotWorkspaces(to_plot)
# check spectrum indices
index_list = __getWorkspaceIndices(indices)
if len(index_list) == 0:
raise ValueError("No spectrum indices given")
for idx in index_list:
if idx < 0:
raise ValueError("Wrong spectrum index (<0): %d" % idx)
for name in to_plot:
max_spec = workspace(name).getNumberHistograms() - 1
for idx in index_list:
if idx > max_spec:
raise ValueError(
"Wrong spectrum index for workspace '%s': %d, which is bigger than the"
" number of spectra in this workspace - 1 (%d)" %
(name, idx, max_spec))
# Unwrap the window object, if any specified
if window is not None:
window = window._getHeldObject()
graph = proxies.Graph(
threadsafe_call(_qti.app.mantidUI.plotSubplots, to_plot, index_list,
distribution, error_bars, window))
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def plot2D(source, style=DEFAULT_2D_STYLE, window=None):
"""Open a 2D plot of the given workspace(s)
Produces a 2D histogram for each of the given workspaces
Args:
source: workspace or name of a workspace
style: Indicates the type of plot required. Default=ColorMap
window: window used for plotting. If None a new one will be created
Returns:
If a single workspace is specified then the handle is returned, otherwise a list
of handles for each new window is returned
"""
names = getWorkspaceNames(source)
if len(names) == 0:
raise ValueError("No workspace names given to plot")
# Unwrap the window object, if any specified
if window is not None:
window = window._getHeldObject()
handles = []
cfunc = _qti.app.mantidUI.drawSingleColorFillPlot
for name in names:
g = proxies.Graph(threadsafe_call(cfunc, name, style, window))
if g:
handles.append(g)
else:
raise RuntimeError("Cannot create graph from workspace '%s'" %
name)
if len(handles) == 1:
return handles[0]
else:
return handles
def screenshot_to_dir(widget, filename, screenshot_dir):
"""Take a screenshot_to_dir of a widget
@param widget :: QWidget to take an image of
@param filename :: Destination filename for that image
@param screenshot_dir :: Directory to put the screenshots into.
"""
# Find the widget if handled with a proxy
if hasattr(widget, "_getHeldObject"):
widget = widget._getHeldObject()
if widget is not None:
camera = Screenshot()
imgpath = os.path.join(screenshot_dir, filename)
threadsafe_call(camera.take_picture, widget, imgpath)
return imgpath
else:
raise RuntimeError("Unable to retrieve widget. Has it been deleted?")
def screenshot_to_dir(widget, filename, screenshot_dir):
"""Take a screenshot_to_dir of a widget
@param widget :: QWidget to take an image of
@param filename :: Destination filename for that image
@param screenshot_dir :: Directory to put the screenshots into.
"""
# Find the widget if handled with a proxy
if hasattr(widget, "_getHeldObject"):
widget = widget._getHeldObject()
if widget is not None:
camera = Screenshot()
imgpath = os.path.join(screenshot_dir, filename)
threadsafe_call(camera.take_picture, widget, imgpath)
return imgpath
else:
raise RuntimeError("Unable to retrieve widget. Has it been deleted?")
def plotBin(source,
indices,
error_bars=False,
type=-1,
window=None,
clearWindow=False,
waterfall=False):
"""Create a 1D Plot of bin count vs spectrum in a workspace.
This puts the spectrum number as the X variable, and the
count in the particular bin # (in 'indices') as the Y value.
If indices is a tuple or list, then several curves are created, one
for each bin index.
Args:
source: workspace or name of a workspace
indices: bin number(s) to plot
error_bars: bool, set to True to add error bars.
type: Plot style
window: window used for plotting. If None a new one will be created
clearWindow: if is True, the window specified will be cleared before adding new curve
waterfall: if True, plot as a waterfall if there is more than 1 curve
Returns:
A handle to window if one was specified, otherwise a handle to the created one. None in case of error.
"""
workspace_names = getWorkspaceNames(source)
__checkPlotWorkspaces(workspace_names)
index_list = __getWorkspaceIndices(indices)
if len(index_list) == 0:
raise ValueError("No indices given")
for idx in index_list:
if idx < 0:
raise ValueError("Wrong bin index (<0): %d" % idx)
for name in workspace_names:
max_bin = workspace(name).blocksize() - 1
for idx in index_list:
if idx > max_bin:
raise ValueError(
"Wrong bin index for workspace '%s': %d, which is bigger than the"
" number of bins in this workspace - 1 (%d)" %
(name, idx, max_bin))
# Unwrap the window object, if any specified
if window is not None:
window = window._getHeldObject()
graph = proxies.Graph(
threadsafe_call(_qti.app.mantidUI.plot1D, workspace_names, index_list,
False, mantidqtpython.MantidQt.DistributionDefault,
error_bars, type, window, clearWindow, waterfall))
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def changeFolder(folder, force=False):
"""Changes the current folder.
Args:
folder: A reference to the folder to change to.
force: Whether to do stuff even if the new folder is already the active one (default: no).
Returns:
True on success.
"""
return threadsafe_call(_qti.app.changeFolder, folder._getHeldObject(), force)
def changeFolder(folder, force=False):
"""Changes the current folder.
Args:
folder: A reference to the folder to change to.
force: Whether to do stuff even if the new folder is already the active one (default: no).
Returns:
True on success.
"""
return threadsafe_call(_qti.app.changeFolder, folder._getHeldObject(), force)
def plotSpectrum(source,
indices,
distribution=mantidqtpython.MantidQt.DistributionDefault,
error_bars=False,
type=-1,
window=None,
clearWindow=False,
waterfall=False):
"""Open a 1D Plot of a spectrum in a workspace.
This plots one or more spectra, with X as the bin boundaries,
and Y as the counts in each bin.
Args:
source: workspace or name of a workspace
indices: workspace index, or tuple or list of workspace indices to plot
error_bars: bool, set to True to add error bars.
type: curve style for plot (-1: unspecified; 0: line, default; 1: scatter/dots)
window: window used for plotting. If None a new one will be created
clearWindow: if is True, the window specified will be cleared before adding new curve
waterfall: if True, plot as a waterfall if there is more than 1 curve
Returns:
A handle to window if one was specified, otherwise a handle to the created one. None in case of error.
"""
workspace_names = getWorkspaceNames(source)
__checkPlotWorkspaces(workspace_names)
# check spectrum indices
index_list = __getWorkspaceIndices(indices)
if len(index_list) == 0:
raise ValueError("No spectrum indices given")
for idx in index_list:
if idx < 0:
raise ValueError("Wrong spectrum index (<0): %d" % idx)
for name in workspace_names:
max_spec = workspace(name).getNumberHistograms() - 1
for idx in index_list:
if idx > max_spec:
raise ValueError(
"Wrong spectrum index for workspace '%s': %d, which is bigger than the"
" number of spectra in this workspace - 1 (%d)" %
(name, idx, max_spec))
# Unwrap the window object, if any specified
if window is not None:
window = window._getHeldObject()
graph = proxies.Graph(
threadsafe_call(_qti.app.mantidUI.plot1D, workspace_names, index_list,
True, distribution, error_bars, type, window,
clearWindow, waterfall))
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def plotSubplots(source, indices, distribution = mantidqtpython.MantidQt.DistributionDefault, error_bars=False, window=None):
"""Open a tiled plot.
This plots one or more spectra, with X as the bin boundaries,
and Y as the counts in each bin.
If one workspace, each spectrum gets its own tile.
Otherwise, each workspace gets its own tile.
Args:
source: list of workspace names
indices: workspace index, or tuple or list of workspace indices to plot
distribution: whether or not to plot as a distribution
error_bars: bool, set to True to add error bars.
window: window used for plotting. If None a new one will be created
Returns:
A handle to window if one was specified, otherwise a handle to the created one. None in case of error.
"""
workspace_names = getWorkspaceNames(source)
# Deal with workspace groups that may contain various types:
# Only want to plot MatrixWorkspaces
to_plot = []
for name in workspace_names:
if isinstance(mantid.api.mtd[name], mantid.api.MatrixWorkspace):
to_plot.append(name)
__checkPlotWorkspaces(to_plot)
# check spectrum indices
index_list = __getWorkspaceIndices(indices)
if len(index_list) == 0:
raise ValueError("No spectrum indices given")
for idx in index_list:
if idx < 0:
raise ValueError("Wrong spectrum index (<0): %d" % idx)
for name in to_plot:
max_spec = workspace(name).getNumberHistograms() - 1
for idx in index_list:
if idx > max_spec:
raise ValueError("Wrong spectrum index for workspace '%s': %d, which is bigger than the"
" number of spectra in this workspace - 1 (%d)" % (name, idx, max_spec))
# Unwrap the window object, if any specified
if window != None:
window = window._getHeldObject()
graph = proxies.Graph(threadsafe_call(_qti.app.mantidUI.plotSubplots,
to_plot, index_list, distribution, error_bars, window))
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def plotMD(source,
plot_axis=-2,
normalization=DEFAULT_MD_NORMALIZATION,
error_bars=False,
window=None,
clearWindow=False):
"""Open a 1D plot of a MDWorkspace.
Args:
source: Workspace(s) to plot
plot_axis: Index of the plot axis (defaults to auto-select)
normalization: Type of normalization required (defaults to volume, options available:
MDNormalization.NoNormalization, MDNormalization.NumEventsNormalization, and
MDNormalization.VolumeNormalization).
error_bars: Flag for error bar plotting.
window: window used for plotting. If None a new one will be created
clearWindow: if is True, the window specified will be cleared before adding new curve
Returns:
A handle to the matrix containing the image data.
"""
workspace_names = getWorkspaceNames(source)
__checkPlotMDWorkspaces(workspace_names)
for name in workspace_names:
non_integrated_dims = mantid.api.mtd[name].getNonIntegratedDimensions()
if not len(non_integrated_dims) == 1:
raise ValueError(
"'%s' must have a single non-integrated dimension in order to be rendered via plotMD"
% name)
# check axis index
for name in workspace_names:
ws = workspace(name)
if hasattr(ws, "axes"):
max_axis = workspace(name).axes()
# see choice in MantidQwtIMDWorkspaceData::setPlotAxisChoice, -2: auto, -1: distance
if plot_axis < -2 or plot_axis > max_axis:
raise ValueError(
"Incorrect axis index given for workspace '%s': %d, should be < %d"
% (name, plot_axis, max_axis))
# Unwrap the window object, if any specified
if window is not None:
window = window._getHeldObject()
graph = proxies.Graph(
threadsafe_call(_qti.app.mantidUI.plotMDList, workspace_names,
plot_axis, normalization, error_bars, window,
clearWindow))
return graph
def plotBin(source, indices, error_bars=False, type=-1, window=None, clearWindow=False,
waterfall=False):
"""Create a 1D Plot of bin count vs spectrum in a workspace.
This puts the spectrum number as the X variable, and the
count in the particular bin # (in 'indices') as the Y value.
If indices is a tuple or list, then several curves are created, one
for each bin index.
Args:
source: workspace or name of a workspace
indices: bin number(s) to plot
error_bars: bool, set to True to add error bars.
type: Plot style
window: window used for plotting. If None a new one will be created
clearWindow: if is True, the window specified will be cleared before adding new curve
waterfall: if True, plot as a waterfall if there is more than 1 curve
Returns:
A handle to window if one was specified, otherwise a handle to the created one. None in case of error.
"""
workspace_names = getWorkspaceNames(source)
__checkPlotWorkspaces(workspace_names)
index_list = __getWorkspaceIndices(indices)
if len(index_list) == 0:
raise ValueError("No indices given")
for idx in index_list:
if idx < 0:
raise ValueError("Wrong bin index (<0): %d" % idx)
for name in workspace_names:
max_bin = workspace(name).blocksize() - 1
for idx in index_list:
if idx > max_bin:
raise ValueError("Wrong bin index for workspace '%s': %d, which is bigger than the"
" number of bins in this workspace - 1 (%d)" % (name, idx, max_bin))
# Unwrap the window object, if any specified
if window != None:
window = window._getHeldObject()
graph = proxies.Graph(threadsafe_call(_qti.app.mantidUI.plot1D,
workspace_names, index_list, False, mantidqtpython.MantidQt.DistributionDefault, error_bars,
type, window, clearWindow, waterfall))
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def plotSpectrum(source, indices, distribution = mantidqtpython.MantidQt.DistributionDefault, error_bars=False, type=-1, window=None,
clearWindow=False, waterfall=False):
"""Open a 1D Plot of a spectrum in a workspace.
This plots one or more spectra, with X as the bin boundaries,
and Y as the counts in each bin.
Args:
source: workspace or name of a workspace
indices: workspace index, or tuple or list of workspace indices to plot
error_bars: bool, set to True to add error bars.
type: curve style for plot (-1: unspecified; 0: line, default; 1: scatter/dots)
window: window used for plotting. If None a new one will be created
clearWindow: if is True, the window specified will be cleared before adding new curve
waterfall: if True, plot as a waterfall if there is more than 1 curve
Returns:
A handle to window if one was specified, otherwise a handle to the created one. None in case of error.
"""
workspace_names = getWorkspaceNames(source)
__checkPlotWorkspaces(workspace_names)
# check spectrum indices
index_list = __getWorkspaceIndices(indices)
if len(index_list) == 0:
raise ValueError("No spectrum indices given")
for idx in index_list:
if idx < 0:
raise ValueError("Wrong spectrum index (<0): %d" % idx)
for name in workspace_names:
max_spec = workspace(name).getNumberHistograms() - 1
for idx in index_list:
if idx > max_spec:
raise ValueError("Wrong spectrum index for workspace '%s': %d, which is bigger than the"
" number of spectra in this workspace - 1 (%d)" % (name, idx, max_spec))
# Unwrap the window object, if any specified
if window != None:
window = window._getHeldObject()
graph = proxies.Graph(threadsafe_call(_qti.app.mantidUI.plot1D,
workspace_names, index_list, True, distribution, error_bars,
type, window, clearWindow, waterfall))
if graph._getHeldObject() == None:
raise RuntimeError("Cannot create graph, see log for details.")
else:
return graph
def plotMD(source, plot_axis=-2, normalization=DEFAULT_MD_NORMALIZATION, error_bars=False, window=None,
clearWindow=False):
"""Open a 1D plot of a MDWorkspace.
Args:
source: Workspace(s) to plot
plot_axis: Index of the plot axis (defaults to auto-select)
normalization: Type of normalization required (defaults to volume, options available:
MDNormalization.NoNormalization, MDNormalization.NumEventsNormalization, and
MDNormalization.VolumeNormalization).
error_bars: Flag for error bar plotting.
window: window used for plotting. If None a new one will be created
clearWindow: if is True, the window specified will be cleared before adding new curve
Returns:
A handle to the matrix containing the image data.
"""
workspace_names = getWorkspaceNames(source)
__checkPlotMDWorkspaces(workspace_names)
for name in workspace_names:
non_integrated_dims = mantid.api.mtd[name].getNonIntegratedDimensions()
if not len(non_integrated_dims) == 1:
raise ValueError(
"'%s' must have a single non-integrated dimension in order to be rendered via plotMD" % name)
# check axis index
for name in workspace_names:
ws = workspace(name)
if hasattr(ws, "axes"):
max_axis = workspace(name).axes()
# see choice in MantidQwtIMDWorkspaceData::setPlotAxisChoice, -2: auto, -1: distance
if plot_axis < -2 or plot_axis > max_axis:
raise ValueError(
"Incorrect axis index given for workspace '%s': %d, should be < %d" % (name, plot_axis, max_axis))
# Unwrap the window object, if any specified
if window != None:
window = window._getHeldObject()
graph = proxies.Graph(threadsafe_call(_qti.app.mantidUI.plotMDList, workspace_names, plot_axis, normalization,
error_bars, window, clearWindow))
return graph
def getSliceViewer(source, label=""):
"""Retrieves a handle to a previously-open SliceViewerWindow.
This allows you to get a handle on, e.g., a SliceViewer that was open
by the MultiSlice view in VATES Simple Interface.
Will raise an exception if not found.
Args:
source :: name of the workspace that was open
label :: additional label string that was used to identify the window.
Returns:
a handle to the SliceViewerWindow object that was created before.
"""
import mantidqtpython
workspace_names = getWorkspaceNames(source)
if len(workspace_names) != 1:
raise Exception("Please specify only one workspace.")
else:
svw = threadsafe_call(mantidqtpython.MantidQt.Factory.WidgetFactory.Instance().getSliceViewerWindow, workspace_names[0], label)
if svw is not None:
return proxies.SliceViewerWindowProxy(svw)
else:
return None
def setPreferences(layer):
threadsafe_call(_qti.app.setPreferences, layer._getHeldObject())
def setWindowName(window, name):
"""Set the given window to have the given name"""
threadsafe_call(_qti.app.setWindowName, window._getHeldObject(), name)
def saveAsTemplate(window, filename):
"""Save the characteristics of the given window to file"""
threadsafe_call(_qti.app.saveAsTemplate, window._getHeldObject(), filename)
def newProject():
"""Start a new mantid project
This will clear all existing unsaved projects
"""
threadsafe_call(_qti.app.newProject)
def __doSliceViewer(wsname,
label="",
xydim=None,
slicepoint=None,
colormin=None,
colormax=None,
colorscalelog=False,
limits=None,
normalization=1):
"""Open a single SliceViewerWindow for the workspace, and shows it
Args:
wsname :: name of the workspace
See plotSlice() for full list of keyword parameters.
Returns:
A handle to the created SliceViewerWindow widget
"""
import mantidqtpython
from PyQt4 import QtCore
svw = threadsafe_call(
mantidqtpython.MantidQt.Factory.WidgetFactory.Instance().
createSliceViewerWindow, wsname, label)
threadsafe_call(svw.show)
# -- Connect to main window's shut down signal ---
QtCore.QObject.connect(_qti.app, QtCore.SIGNAL("shutting_down()"), svw,
QtCore.SLOT("close()"))
sv = threadsafe_call(svw.getSlicer)
# --- X/Y Dimensions ---
if (xydim is not None):
if len(xydim) != 2:
raise Exception(
"You need to specify two values in the 'xydim' parameter")
else:
threadsafe_call(sv.setXYDim, xydim[0], xydim[1])
# --- Slice point ---
if slicepoint is not None:
for d in range(len(slicepoint)):
try:
val = float(slicepoint[d])
except ValueError:
raise ValueError(
"Could not convert item %d of slicepoint parameter to float (got '%s'"
% (d, slicepoint[d]))
sv.setSlicePoint(d, val)
# Set the normalization before the color scale
threadsafe_call(sv.setNormalization, normalization)
# --- Color scale ---
if (colormin is not None) and (colormax is not None):
threadsafe_call(sv.setColorScale, colormin, colormax, colorscalelog)
else:
if colormin is not None:
threadsafe_call(sv.setColorScaleMin, colormin)
if colormax is not None:
threadsafe_call(sv.setColorScaleMax, colormax)
try:
threadsafe_call(sv.setColorScaleLog, colorscalelog)
except:
print("Log color scale not possible.")
# --- XY limits ---
if limits is not None:
threadsafe_call(sv.setXYLimits, limits[0], limits[1], limits[2],
limits[3])
return svw
def deleteFolder(folder):
"""Delete the referenced folder"""
return threadsafe_call(_qti.app.deleteFolder, folder._getHeldObject())
def disableTools():
"""Disable all the tools from all the graphs within MantidPlot."""
threadsafe_call(_qti.app.disableTools)
def convertToWaterfall(graph):
"""Convert a graph (containing a number of plotted spectra) to a waterfall plot"""
threadsafe_call(_qti.app.mantidUI.convertToWaterfall,
graph._getHeldObject())
def newProject():
"""Start a new mantid project
This will clear all existing unsaved projects
"""
threadsafe_call(_qti.app.newProject)
def disableTools():
"""Disable all the tools from all the graphs within MantidPlot."""
threadsafe_call(_qti.app.disableTools)
def setWindowName(window, name):
"""Set the given window to have the given name"""
threadsafe_call(_qti.app.setWindowName, window._getHeldObject(), name)
def setPreferences(layer):
threadsafe_call(_qti.app.setPreferences, layer._getHeldObject())
def convertToWaterfall(graph):
"""Convert a graph (containing a number of plotted spectra) to a waterfall plot"""
threadsafe_call(_qti.app.mantidUI.convertToWaterfall, graph._getHeldObject())
def createScriptInputDialog(alg_name, preset_values, optional_msg, enabled, disabled):
"""Raises a property input dialog for an algorithm"""
return threadsafe_call(_qti.app.mantidUI.createScriptInputDialog, alg_name, preset_values, optional_msg, enabled,
disabled)
return mantid.AnalysisDataService.Instance()
# -------------------------- Wrapped MantidPlot functions -----------------
def runPythonScript(code, async=False, quiet=False, redirect=True):
"""
Redirects the runPythonScript method to the app object
@param code :: A string of code to execute
@param async :: If the true the code is executed in a separate thread
@param quiet :: If true no messages reporting status are issued
@param redirect :: If true then output is redirected to MantidPlot
"""
if async and QtCore.QThread.currentThread() != QtGui.qApp.thread():
async = False
threadsafe_call(_qti.app.runPythonScript, code, async, quiet, redirect)
# Overload for consistency with qtiplot table(..) & matrix(..) commands
def workspace(name):
"""Get a handle on a workspace.
Args:
name: The name of the workspace in the Analysis Data Service.
"""
return _get_analysis_data_service()[name]
def table(name):
"""Get a handle on a table.
def saveAsTemplate(window, filename):
"""Save the characteristics of the given window to file"""
threadsafe_call(_qti.app.saveAsTemplate, window._getHeldObject(), filename)
def deleteFolder(folder):
"""Delete the referenced folder"""
return threadsafe_call(_qti.app.deleteFolder, folder._getHeldObject())
def __doSliceViewer(wsname, label="", xydim=None, slicepoint=None,
colormin=None, colormax=None, colorscalelog=False,
limits=None, normalization=1):
"""Open a single SliceViewerWindow for the workspace, and shows it
Args:
wsname :: name of the workspace
See plotSlice() for full list of keyword parameters.
Returns:
A handle to the created SliceViewerWindow widget
"""
import mantidqtpython
from PyQt4 import QtCore
svw = threadsafe_call(mantidqtpython.MantidQt.Factory.WidgetFactory.Instance().createSliceViewerWindow, wsname,
label)
threadsafe_call(svw.show)
# -- Connect to main window's shut down signal ---
QtCore.QObject.connect(_qti.app, QtCore.SIGNAL("shutting_down()"),
svw, QtCore.SLOT("close()"))
sv = threadsafe_call(svw.getSlicer)
# --- X/Y Dimensions ---
if (not xydim is None):
if len(xydim) != 2:
raise Exception("You need to specify two values in the 'xydim' parameter")
else:
threadsafe_call(sv.setXYDim, xydim[0], xydim[1])
# --- Slice point ---
if not slicepoint is None:
for d in xrange(len(slicepoint)):
try:
val = float(slicepoint[d])
except ValueError:
raise ValueError(
"Could not convert item %d of slicepoint parameter to float (got '%s'" % (d, slicepoint[d]))
sv.setSlicePoint(d, val)
# Set the normalization before the color scale
threadsafe_call(sv.setNormalization, normalization)
# --- Color scale ---
if (not colormin is None) and (not colormax is None):
threadsafe_call(sv.setColorScale, colormin, colormax, colorscalelog)
else:
if (not colormin is None): threadsafe_call(sv.setColorScaleMin, colormin)
if (not colormax is None): threadsafe_call(sv.setColorScaleMax, colormax)
try:
threadsafe_call(sv.setColorScaleLog, colorscalelog)
except:
print("Log color scale not possible.")
# --- XY limits ---
if not limits is None:
threadsafe_call(sv.setXYLimits, limits[0], limits[1], limits[2], limits[3])
return svw
def createScriptInputDialog(alg_name, preset_values, optional_msg, enabled,
disabled):
"""Raises a property input dialog for an algorithm"""
return threadsafe_call(_qti.app.mantidUI.createScriptInputDialog, alg_name,
preset_values, optional_msg, enabled, disabled)
