def action_show_minor_ticks_changed(self, state):
ConfigService.setString(PlotProperties.SHOW_MINOR_TICKS.value,
"On" if state == Qt.Checked else "Off")
self.view.show_minor_gridlines.setEnabled(state == Qt.Checked)
if not self.view.show_minor_gridlines.isEnabled():
self.view.show_minor_gridlines.setChecked(False)
def __init__(self,
view,
exit_code: str,
application: str,
traceback: Optional[str] = None):
"""
:param view: A reference to the view managed by this presenter
:param exit_code: A string containing the exit_code of the failing application
:param application: A string containing the failing application name
:param traceback: An optional string containing a traceback dumped as JSON-encoded string
"""
self.error_log = Logger("errorreports")
self._view = view
self._exit_code = exit_code
self._application = application
self._traceback = traceback if traceback else ''
self._view.set_report_callback(self.error_handler)
self._view.moreDetailsButton.clicked.connect(self.show_more_details)
if not traceback:
traceback_file_path = os.path.join(
ConfigService.getAppDataDirectory(),
'{}_stacktrace.txt'.format(application))
try:
if os.path.isfile(traceback_file_path):
with open(traceback_file_path, 'r') as file:
self._traceback = file.readlines()
new_workspace_name = os.path.join(
ConfigService.getAppDataDirectory(),
'{}_stacktrace_sent.txt'.format(application))
os.rename(traceback_file_path, new_workspace_name)
except OSError:
pass
def __init__(self,
view,
exit_code,
application='mantidplot',
traceback=''):
self.error_log = Logger("error")
self._view = view
self._exit_code = exit_code
self._application = application
self._traceback = traceback
self._view.set_report_callback(self.error_handler)
if not traceback:
traceback_file_path = os.path.join(
ConfigService.getAppDataDirectory(),
'{}_stacktrace.txt'.format(application))
try:
if os.path.isfile(traceback_file_path):
with open(traceback_file_path, 'r') as file:
self._traceback = file.readlines()
new_workspace_name = os.path.join(
ConfigService.getAppDataDirectory(),
'{}_stacktrace_sent.txt'.format(application))
os.rename(traceback_file_path, new_workspace_name)
except OSError:
pass
def load_current_setting_values(self):
background = ConfigService.getString(self.AUTO_BACKGROUND).split(
" ", 1)
if self.view.auto_bkg.findText(background[0], Qt.MatchExactly) != -1:
self.view.auto_bkg.setCurrentText(background[0])
else:
self.view.auto_bkg.setCurrentText("LinearBackground")
if len(background) > 1:
self.view.background_args.setText(background[1])
default_peak = ConfigService.getString(self.DEFAULT_PEAK)
if self.view.default_peak.findText(default_peak,
Qt.MatchExactly) != -1:
self.view.default_peak.setCurrentText(default_peak)
else:
self.view.auto_bkg.setCurrentText("Gaussian")
fwhm = ConfigService.getString(self.FWHM)
if fwhm == "":
self.view.findpeaks_fwhm.setValue(7)
else:
self.view.findpeaks_fwhm.setValue(int(fwhm))
tolerance = ConfigService.getString(self.TOLERANCE)
if tolerance == "":
self.view.findpeaks_tol.setValue(4)
else:
self.view.findpeaks_tol.setValue(int(tolerance))
def __init__(self, multifileinterpreter, main_window=None, globalfiguremanager=None):
"""
Project Recovery class is aimed at allowing you to recovery your workbench project should you crash for whatever
reason
:param multifileinterpreter: MultiPythonFileInterpreter; An object that is used in workbench to represent the
python script editor
:param main_window: A reference to the main window object to be used as a parent to the project recovery GUIs
:param globalfiguremanager: Based on the globalfiguremanager object expects an object with a dictionary on
cls/self.figs for the object passed here which contains all of the plots open/needed to be saved
"""
self._recovery_directory = os.path.join(ConfigService.getAppDataDirectory(),
self.recovery_workbench_recovery_name)
self._recovery_directory_hostname = os.path.join(self.recovery_directory, socket.gethostname())
self._recovery_directory_pid = os.path.join(self.recovery_directory_hostname, str(os.getpid()))
self._recovery_order_workspace_history_file = os.path.join(ConfigService.getAppDataDirectory(),
self.recovery_ordered_recovery_file_name)
self.recovery_enabled = ("true" == ConfigService[RECOVERY_ENABLED_KEY].lower())
self.maximum_num_checkpoints = int(ConfigService[NO_OF_CHECKPOINTS_KEY])
self.time_between_saves = int(ConfigService[SAVING_TIME_KEY]) # seconds
# The recovery GUI's presenter is set when needed
self.recovery_presenter = None
self.thread_on = False
# Set to true by workbench on close to kill the thread on completion of project save
self.closing_workbench = False
# Recovery loader and saver
self.loader = ProjectRecoveryLoader(self, multi_file_interpreter=multifileinterpreter, main_window=main_window)
self.saver = ProjectRecoverySaver(self, globalfiguremanager)
def pcolormesh_on_axis(ax, ws, color_norm=None, normalize_by_bin_width=None):
"""
Plot a pcolormesh plot of the given workspace on the given axis
:param ax: A matplotlib axes instance
:param ws: A mantid workspace instance
:param color_norm: A matplotlib.colours Normalize instance (or any of its subclasses)
:param normalize_by_bin_width: Optional keyword argument to pass to imshow in the event of a plot restoration
:return:
"""
ax.clear()
ax.set_title(ws.name())
scale = _get_colorbar_scale() if not color_norm else color_norm
if use_imshow(ws):
pcm = ax.imshow(ws,
cmap=ConfigService.getString("plots.images.Colormap"),
aspect='auto',
origin='lower',
norm=scale,
normalize_by_bin_width=normalize_by_bin_width)
# remove normalize_by_bin_width from cargs if present so that this can be toggled in future
for cargs in pcm.axes.creation_args:
cargs.pop('normalize_by_bin_width')
else:
pcm = ax.pcolormesh(
ws,
cmap=ConfigService.getString("plots.images.Colormap"),
norm=scale)
return pcm
def action_background_args_changed(self):
if self.view.auto_bkg.currentText() == "None":
ConfigService.setString(self.AUTO_BACKGROUND, "")
else:
background_string = self.view.auto_bkg.currentText(
) + " " + self.view.background_args.text()
ConfigService.setString(self.AUTO_BACKGROUND, background_string)
def setup_facilities_group(self):
facilities = ConfigService.getFacilityNames()
if not facilities:
return
self.view.facility.addItems(facilities)
try:
default_facility = ConfigService.getFacility().name()
except RuntimeError:
default_facility = facilities[0]
self.view.facility.setCurrentIndex(
self.view.facility.findText(default_facility))
self.action_facility_changed(default_facility)
self.view.facility.currentTextChanged.connect(
self.action_facility_changed)
try:
default_instrument = ConfigService.getInstrument().name()
self.view.instrument.setCurrentIndex(
self.view.instrument.findText(default_instrument))
except RuntimeError:
default_instrument = self.view.instrument.itemText(0)
self.action_instrument_changed(default_instrument)
self.view.instrument.currentTextChanged.connect(
self.action_instrument_changed)
def __init__(self, multifileinterpreter, main_window=None, globalfiguremanager=None):
"""
Project Recovery class is aimed at allowing you to recovery your workbench project should you crash for whatever
reason
:param multifileinterpreter: MultiPythonFileInterpreter; An object that is used in workbench to represent the
python script editor
:param main_window: A reference to the main window object to be used as a parent to the project recovery GUIs
:param globalfiguremanager: Based on the globalfiguremanager object expects an object with a dictionary on
cls/self.figs for the object passed here which contains all of the plots open/needed to be saved
"""
self._recovery_directory = os.path.join(ConfigService.getAppDataDirectory(),
self.recovery_workbench_recovery_name)
self._recovery_directory_hostname = os.path.join(self.recovery_directory, socket.gethostname())
self._recovery_directory_pid = os.path.join(self.recovery_directory_hostname, str(os.getpid()))
self._recovery_order_workspace_history_file = os.path.join(ConfigService.getAppDataDirectory(),
self.recovery_ordered_recovery_file_name)
self.recovery_enabled = ("true" == ConfigService[RECOVERY_ENABLED_KEY].lower())
self.maximum_num_checkpoints = int(ConfigService[NO_OF_CHECKPOINTS_KEY])
self.time_between_saves = int(ConfigService[SAVING_TIME_KEY]) # seconds
# The recovery GUI's presenter is set when needed
self.recovery_presenter = None
self.thread_on = False
# Set to true by workbench on close to kill the thread on completion of project save
self.closing_workbench = False
# Recovery loader and saver
self.loader = ProjectRecoveryLoader(self, multi_file_interpreter=multifileinterpreter, main_window=main_window)
self.saver = ProjectRecoverySaver(self, globalfiguremanager)
def load_general_setting_values(self):
normalize_to_bin_width = "on" == ConfigService.getString(
self.NORMALIZATION).lower()
show_title = "on" == ConfigService.getString(self.SHOW_TITLE).lower()
self.view.normalize_to_bin_width.setChecked(normalize_to_bin_width)
self.view.show_title.setChecked(show_title)
def should_show_on_startup():
""" Determines if the first time dialog should be shown
:return: True if the dialog should be shown
"""
# first check the facility and instrument
facility = ConfigService.getString(AboutPresenter.FACILITY)
instrument = ConfigService.getString(AboutPresenter.INSTRUMENT)
if not facility:
return True
else:
# check we can get the facility and instrument
try:
facilityInfo = ConfigService.getFacility(facility)
instrumentInfo = ConfigService.getInstrument(instrument)
logger.information("Default facility '{0}', instrument '{1}'\n".format(facilityInfo.name(),
instrumentInfo.name()))
except RuntimeError:
# failed to find the facility or instrument
logger.error("Could not find your default facility '{0}' or instrument '{1}' in facilities.xml, "
+ "showing please select again.\n".format(facility, instrument))
return True
settings = QSettings()
settings.beginGroup(AboutPresenter.DO_NOT_SHOW_GROUP)
doNotShowUntilNextRelease =int(settings.value(AboutPresenter.DO_NOT_SHOW, '0'))
lastVersion = settings.value(AboutPresenter.LAST_VERSION, "")
settings.endGroup()
if not doNotShowUntilNextRelease:
return True
# Now check if the version has changed since last time
version = release_notes_url()
return version != lastVersion
def setUpClass(cls):
ConfigService.Instance().setString("default.facility", "ISIS")
# A small workspace for general tests
test_workspace = LoadNexusProcessed(Filename="LOQ48127")
cls.immutable_test_workspace = test_workspace
# A full workspace on which we can test region of interest selection
region_of_interest_workspace = Load(Filename="LOQ74044")
cls.region_of_interest_workspace = region_of_interest_workspace
# A region of interest xml file
roi_content = ("<?xml version=\"1.0\"?>\n"
"\t<detector-masking>\n"
"\t\t<group>\n"
"\t\t\t<detids>6990-6996</detids>\n"
"\t\t</group>\n"
"\t</detector-masking>\n")
cls.roi_file_path = cls._get_path(cls.roi_file)
cls._save_file(cls.roi_file_path, roi_content)
# A mask file
mask_content = ("<?xml version=\"1.0\"?>\n"
"\t<detector-masking>\n"
"\t\t<group>\n"
"\t\t\t<detids>6991</detids>\n"
"\t\t</group>\n"
"\t</detector-masking>\n")
cls.mask_file_path = cls._get_path(cls.mask_file)
cls._save_file(cls.mask_file_path, mask_content)
ConfigService.Instance().setString("default.facility", " ")
def setup_facilities_group(self):
facilities = sorted(ConfigService.getFacilityNames())
if not facilities:
return
self.view.facility.addItems(facilities)
self.view.instrument = instrumentselector.InstrumentSelector()
self.view.horizontalLayout_4.replaceWidget(self.view.instrument_dummy,
self.view.instrument)
self.view.instrument_dummy.setVisible(False)
try:
default_facility = ConfigService.getFacility().name()
except RuntimeError:
default_facility = facilities[0]
self.view.facility.setCurrentIndex(
self.view.facility.findText(default_facility))
self.action_facility_changed(default_facility)
self.view.facility.currentTextChanged.connect(
self.action_facility_changed)
try:
default_instrument = ConfigService.getInstrument().name()
except RuntimeError:
default_instrument = self.view.instrument.itemText(0)
self.action_instrument_changed(default_instrument)
self.view.instrument.currentTextChanged.connect(
self.action_instrument_changed)
def test_constructor_settings_are_set(self):
# Test the paths set in the constructor that are generated.
self.assertEqual(
self.pr.recovery_directory,
os.path.join(ConfigService.getAppDataDirectory(),
"workbench-recovery"))
self.assertEqual(
self.pr.recovery_directory_hostname,
os.path.join(ConfigService.getAppDataDirectory(),
"workbench-recovery", socket.gethostname()))
self.assertEqual(
self.pr.recovery_directory_pid,
os.path.join(ConfigService.getAppDataDirectory(),
"workbench-recovery", socket.gethostname(),
str(os.getpid())))
self.assertEqual(
self.pr.recovery_order_workspace_history_file,
os.path.join(ConfigService.getAppDataDirectory(),
"ordered_recovery.py"))
# Test config service values
self.assertEqual(self.pr.time_between_saves,
int(ConfigService[SAVING_TIME_KEY]))
self.assertEqual(self.pr.maximum_num_checkpoints,
int(ConfigService[NO_OF_CHECKPOINTS_KEY]))
self.assertEqual(
self.pr.recovery_enabled,
("true" == ConfigService[RECOVERY_ENABLED_KEY].lower()))
def get_plot_fig(overplot=None,
ax_properties=None,
window_title=None,
axes_num=1,
fig=None):
"""
Create a blank figure and axes, with configurable properties.
:param overplot: If true then plotting on figure will plot over previous plotting. If an axis object the overplotting
will be done on the axis passed in
:param ax_properties: A dict of axes properties. E.g. {'yscale': 'log'} for log y-axis
:param window_title: A string denoting the name of the GUI window which holds the graph
:param axes_num: The number of axes to create on the figure
:param fig: An optional figure object
:return: Matplotlib fig and axes objects
"""
import matplotlib.pyplot as plt
if fig and overplot:
fig = fig
elif fig:
fig, _, _, _ = create_subplots(axes_num, fig)
elif overplot:
# The create subplot below assumes no figure was passed in, this is ensured by the elif above
# but add an assert which prevents a future refactoring from breaking this assumption
assert not fig
fig = plt.gcf()
if not fig.axes:
plt.close(fig)
# The user is likely trying to overplot on a non-existent plot, create one for them
fig, _, _, _ = create_subplots(axes_num)
else:
fig, _, _, _ = create_subplots(axes_num)
if not ax_properties and not overplot:
ax_properties = {}
if ConfigService.getString("plots.xAxesScale").lower() == 'log':
ax_properties['xscale'] = 'log'
else:
ax_properties['xscale'] = 'linear'
if ConfigService.getString("plots.yAxesScale").lower() == 'log':
ax_properties['yscale'] = 'log'
else:
ax_properties['yscale'] = 'linear'
if ax_properties:
for axis in fig.axes:
axis.set(**ax_properties)
if window_title:
fig.canvas.set_window_title(window_title)
if not overplot:
if ConfigService.getString("plots.ShowMinorTicks").lower() == "on":
for ax in fig.axes:
ax.minorticks_on()
for ax in fig.axes:
ax.show_minor_gridlines = ConfigService.getString(
"plots.ShowMinorGridlines").lower() == "on"
return fig, fig.axes
def setup_layout(self, load_last=False):
"""
Sets up the instrument-specific part of the UI layout
"""
# Clean up the widgets that have already been created
self.tabWidget.clear()
self.progress_bar.hide()
if self._instrument == '' or self._instrument is None:
return self._change_instrument()
self._update_file_menu()
if self._interface is not None:
self._interface.destroy()
self.general_settings.instrument_name = self._instrument
# Find corresponding facility
if self._facility is None:
for facility in INSTRUMENT_DICT.keys():
if self._instrument in INSTRUMENT_DICT[facility].keys():
self._facility = facility
break
if self._facility is None:
self._facility = ConfigService.Instance().getFacility().name()
self.general_settings.facility_name = self._facility
self._interface = instrument_factory(self._instrument, settings=self.general_settings)
if self._interface is not None:
tab_list = self._interface.get_tabs()
for tab in tab_list:
self.tabWidget.addTab(tab[1], tab[0])
self._set_window_title()
# Show the "advanced interface" check box if needed
if self._interface.has_advanced_version():
self.interface_chk.show()
else:
self.interface_chk.hide()
# Show the parallel reduction button if enabled
if self._interface.is_cluster_enabled() and IS_IN_MANTIDPLOT \
and CLUSTER_ENABLED:
config = ConfigService.Instance()
if config.hasProperty("cluster.submission") \
and config.getString("cluster.submission").lower()=='on':
self.cluster_button.show()
self.connect(self.cluster_button, QtCore.SIGNAL("clicked()"), self.cluster_clicked)
else:
self.cluster_button.hide()
if load_last:
self._interface.load_last_reduction()
else:
print "Could not generate an interface for instrument %s" % self._instrument
self.close()
return True
def test_update_and_set_facility(self):
self.assertFalse("TEST" in config.getFacilityNames())
ConfigService.updateFacilities(
os.path.join(ConfigService.getInstrumentDirectory(),
"IDFs_for_UNIT_TESTING/UnitTestFacilities.xml"))
ConfigService.setFacility("TEST")
self.assertEquals(config.getFacility().name(), "TEST")
self.assertRaises(RuntimeError, config.getFacility, "SNS")
def action_auto_background_changed(self, item_name):
if item_name == "None":
ConfigService.setString(FittingProperties.AUTO_BACKGROUND.value,
"")
return
background_string = item_name + " " + self.view.background_args.text()
ConfigService.setString(FittingProperties.AUTO_BACKGROUND.value,
background_string)
def test_update_and_set_facility(self):
self.assertFalse("TEST" in config.getFacilityNames())
ConfigService.updateFacilities(
os.path.join(ConfigService.getInstrumentDirectory(), "IDFs_for_UNIT_TESTING/UnitTestFacilities.xml")
)
ConfigService.setFacility("TEST")
self.assertEquals(config.getFacility().name(), "TEST")
self.assertRaises(RuntimeError, config.getFacility, "SNS")
def __init__(self):
super(PythonInterfacesStartupTest, self).__init__()
self._app = get_application()
self._interface_directory = ConfigService.getString('mantidqt.python_interfaces_directory')
self._interface_scripts = [interface.split("/")[1] for interface in
ConfigService.getString('mantidqt.python_interfaces').split()
if interface.split("/")[1] not in EXCLUDED_SCRIPTS]
def setup_legend_group(self):
legend_location = ConfigService.getString(
PlotProperties.LEGEND_LOCATION.value)
self.view.legend_location.addItems(self.LEGEND_LOCATION_LIST)
if legend_location in self.LEGEND_LOCATION_LIST:
self.view.legend_location.setCurrentIndex(
self.view.legend_location.findText(legend_location))
legend_font_size = float(
ConfigService.getString(PlotProperties.LEGEND_FONT_SIZE.value))
self.view.legend_font_size.setValue(legend_font_size)
def action_facility_changed(self, new_facility):
"""
When the facility is changed, refreshes all available instruments that can be selected in the dropdown.
:param new_facility: The name of the new facility that was selected
"""
ConfigService.setFacility(new_facility)
# refresh the instrument selection to contain instruments about the selected facility only
self.view.instrument.clear()
self.view.instrument.addItems(
[instr.name() for instr in ConfigService.getFacility(new_facility).instruments()])
def save_on_closing(self):
# make sure the Last Version is updated on closing
settings = QSettings()
settings.beginGroup(self.DO_NOT_SHOW_GROUP)
settings.setValue(self.LAST_VERSION, release_notes_url())
settings.endGroup()
self.store_facility(self.view.cb_facility.currentText())
self.action_instrument_changed(self.view.cb_instrument.currentText())
ConfigService.saveConfig(ConfigService.getUserFilename())
self.parent.config_updated()
def action_close(self):
# make sure the Last Version is updated on closing
settings = QSettings()
settings.beginGroup(self.DO_NOT_SHOW_GROUP)
settings.setValue(self.LAST_VERSION, release_notes_url())
settings.endGroup()
ConfigService.saveConfig(ConfigService.getUserFilename())
self.parent.config_updated()
self.view.close()
def setup_error_bar_group(self):
error_width = float(ConfigService.getString(self.ERROR_WIDTH))
capsize = float(ConfigService.getString(self.CAPSIZE))
cap_thickness = float(ConfigService.getString(self.CAP_THICKNESS))
error_every = int(ConfigService.getString(self.ERROR_EVERY))
self.view.error_width.setValue(error_width)
self.view.capsize.setValue(capsize)
self.view.cap_thickness.setValue(cap_thickness)
self.view.error_every.setValue(error_every)
def test_that_load_dead_time_from_filename_places_table_in_ADS(self):
ConfigService.Instance().setString("default.facility", "ISIS")
filename = 'MUSR00022725.nsx'
name = utils.load_dead_time_from_filename(filename)
dead_time_table = AnalysisDataService.retrieve('MUSR00022725.nsx_deadtime_table')
self.assertEqual(name, 'MUSR00022725.nsx_deadtime_table')
self.assertTrue(isinstance(dead_time_table, ITableWorkspace))
ConfigService.Instance().setString("default.facility", " ")
def _add_default_plot_kwargs_from_settings(plot_kwargs, errors):
if 'linestyle' not in plot_kwargs:
plot_kwargs['linestyle'] = ConfigService.getString("plots.line.Style")
if 'drawstyle' not in plot_kwargs:
plot_kwargs['drawstyle'] = ConfigService.getString(
"plots.line.DrawStyle")
if 'linewidth' not in plot_kwargs:
plot_kwargs['linewidth'] = float(
ConfigService.getString("plots.line.Width"))
if 'marker' not in plot_kwargs:
plot_kwargs['marker'] = MARKER_MAP[ConfigService.getString(
"plots.marker.Style")]
if 'markersize' not in plot_kwargs:
plot_kwargs['markersize'] = float(
ConfigService.getString("plots.marker.Size"))
if errors:
if 'capsize' not in plot_kwargs:
plot_kwargs['capsize'] = float(
ConfigService.getString("plots.errorbar.Capsize"))
if 'capthick' not in plot_kwargs:
plot_kwargs['capthick'] = float(
ConfigService.getString("plots.errorbar.CapThickness"))
if 'errorevery' not in plot_kwargs:
plot_kwargs['errorevery'] = int(
ConfigService.getString("plots.errorbar.errorEvery"))
if 'elinewidth' not in plot_kwargs:
plot_kwargs['elinewidth'] = float(
ConfigService.getString("plots.errorbar.Width"))
def action_usage_data_changed(self, checkedState):
if not checkedState:
response = self.usage_reporting_verification_view.exec()
if not response:
# No was clicked, or no button was clicked
# set the checkbox back to checked
checkedState = Qt.Checked
self.view.chkAllowUsageData.setCheckState(checkedState)
ConfigService.setString(self.USAGE_REPORTING, "1" if checkedState == Qt.Checked else "0")
def test_load_workspace_from_filename_for_existing_file(self):
ConfigService.Instance().setString("default.facility", "ISIS")
filename = 'MUSR00022725.nsx'
load_result, run, filename, _ = utils.load_workspace_from_filename(filename)
self.assertEqual(load_result['DeadTimeTable'], None)
self.assertEqual(load_result['FirstGoodData'], 0.106)
self.assertEqual(load_result['MainFieldDirection'], 'Transverse')
self.assertAlmostEqual(load_result['TimeZero'], 0.55000, 5)
self.assertEqual(run, 22725)
ConfigService.Instance().setString("default.facility", " ")
def setup_line_group(self):
line_style = ConfigService.getString(self.LINE_STYLE)
self.view.line_style.addItems(VALID_LINE_STYLE)
if line_style in VALID_LINE_STYLE:
self.view.line_style.setCurrentIndex(
self.view.line_style.findText(line_style))
else:
self.view.line_style.setCurrentIndex(0)
line_width = float(ConfigService.getString(self.LINE_WIDTH))
self.view.line_width.setValue(line_width)
def setup_marker_group(self):
marker_style = ConfigService.getString(self.MARKER_STYLE)
self.view.marker_style.addItems(MARKER_STYLES)
if marker_style in MARKER_STYLES:
self.view.marker_style.setCurrentIndex(
self.view.marker_style.findText(marker_style))
else:
self.view.marker_style.setCurrentIndex(0)
marker_size = float(ConfigService.getString(self.MARKER_SIZE))
self.view.marker_size.setValue(marker_size)
def action_facility_changed(self, new_facility):
"""
When the facility is changed, refreshes all available instruments that can be selected in the dropdown.
:param new_facility: The name of the new facility that was selected
"""
current_value = ConfigService.getFacility().name()
if new_facility != current_value:
ConfigService.setFacility(new_facility)
# refresh the instrument selection to contain instruments about the selected facility only
self.view.instrument.facility = new_facility
if new_facility != current_value:
self.view.instrument.setCurrentIndex(0)
def setup_marker_group(self):
marker_style = ConfigService.getString(
PlotProperties.MARKER_STYLE.value)
if marker_style in MARKER_STYLES.keys():
self.view.marker_style.setCurrentIndex(
self.view.marker_style.findText(marker_style))
else:
self.view.marker_style.setCurrentIndex(0)
marker_size = float(
ConfigService.getString(PlotProperties.MARKER_SIZE.value))
self.view.marker_size.setValue(marker_size)
def load_current_setting_values(self):
self.view.prompt_save_on_close.setChecked(CONF.get(self.PROMPT_SAVE_ON_CLOSE))
self.view.prompt_save_editor_modified.setChecked(CONF.get(self.PROMPT_SAVE_EDITOR_MODIFIED))
# compare lower-case, because MantidPlot will save it as lower case,
# but Python will have the bool's first letter capitalised
pr_enabled = ("true" == ConfigService.getString(self.PR_RECOVERY_ENABLED).lower())
pr_time_between_recovery = int(ConfigService.getString(self.PR_TIME_BETWEEN_RECOVERY))
pr_number_checkpoints = int(ConfigService.getString(self.PR_NUMBER_OF_CHECKPOINTS))
self.view.project_recovery_enabled.setChecked(pr_enabled)
self.view.time_between_recovery.setValue(pr_time_between_recovery)
self.view.total_number_checkpoints.setValue(pr_number_checkpoints)
def setup_facilities_group(self):
facilities = ConfigService.getFacilityNames()
self.view.facility.addItems(facilities)
default_facility = ConfigService.getFacility().name()
self.view.facility.setCurrentIndex(self.view.facility.findText(default_facility))
self.action_facility_changed(default_facility)
self.view.facility.currentTextChanged.connect(self.action_facility_changed)
default_instrument = ConfigService.getInstrument().name()
self.view.instrument.setCurrentIndex(self.view.instrument.findText(default_instrument))
self.action_instrument_changed(default_instrument)
self.view.instrument.currentTextChanged.connect(self.action_instrument_changed)
def remove_output_files(list_of_names=None):
"""Removes output files created during a test."""
# import ConfigService here to avoid:
# RuntimeError: Pickling of "mantid.kernel._kernel.ConfigServiceImpl"
# instances is not enabled (http://www.boost.org/libs/python/doc/v2/pickle.html)
from mantid.kernel import ConfigService
if not isinstance(list_of_names, list):
raise ValueError("List of names is expected.")
if not all(isinstance(i, str) for i in list_of_names):
raise ValueError("Each name should be a string.")
save_dir_path = ConfigService.getString("defaultsave.directory")
if save_dir_path != "": # default save directory set
all_files = os.listdir(save_dir_path)
else:
all_files = os.listdir(os.getcwd())
for filename in all_files:
for name in list_of_names:
if name in filename:
full_path = os.path.join(save_dir_path, filename)
if os.path.isfile(full_path):
os.remove(full_path)
break
def test_constructor_settings_are_set(self):
# Test the paths set in the constructor that are generated.
self.assertEqual(self.pr.recovery_directory,
os.path.join(ConfigService.getAppDataDirectory(), "workbench-recovery"))
self.assertEqual(self.pr.recovery_directory_hostname,
os.path.join(ConfigService.getAppDataDirectory(), "workbench-recovery", socket.gethostname()))
self.assertEqual(self.pr.recovery_directory_pid,
os.path.join(ConfigService.getAppDataDirectory(), "workbench-recovery", socket.gethostname(),
str(os.getpid())))
self.assertEqual(self.pr.recovery_order_workspace_history_file,
os.path.join(ConfigService.getAppDataDirectory(), "ordered_recovery.py"))
# Test config service values
self.assertEqual(self.pr.time_between_saves, int(ConfigService[SAVING_TIME_KEY]))
self.assertEqual(self.pr.maximum_num_checkpoints, int(ConfigService[NO_OF_CHECKPOINTS_KEY]))
self.assertEqual(self.pr.recovery_enabled, ("true" == ConfigService[RECOVERY_ENABLED_KEY].lower()))
def setup_checkbox_signals(self):
self.view.show_invisible_workspaces.setChecked(
"true" == ConfigService.getString(self.SHOW_INVISIBLE_WORKSPACES).lower())
self.view.show_invisible_workspaces.stateChanged.connect(self.action_show_invisible_workspaces)
self.view.project_recovery_enabled.stateChanged.connect(self.action_project_recovery_enabled)
self.view.time_between_recovery.valueChanged.connect(self.action_time_between_recovery)
self.view.total_number_checkpoints.valueChanged.connect(self.action_total_number_checkpoints)
def test_timezones(self):
# verify that all of the timezones can get converted by pytz
for facility in ConfigService.getFacilities():
if len(facility.timezone()) == 0:
continue # don't test empty strings
tz = pytz.timezone(facility.timezone())
print(facility.name(), tz)
self.assertEquals(str(tz), facility.timezone())
def get_number_of_checkpoints():
"""
:return: int; The maximum number of checkpoints project recovery should allow
"""
try:
return int(ConfigService.getString("projectRecovery.numberOfCheckpoints"))
except Exception as e:
if isinstance(e, KeyboardInterrupt):
raise
# Fail silently and return 5 (the default)
return DEFAULT_NUM_CHECKPOINTS
def getValidInstruments(self):
instruments = ['']
for name in ['SNS', 'HFIR']:
facility = ConfigService.getFacility(name)
facilityInstruments = sorted([item.shortName()
for item in facility.instruments()
if item != 'DAS'])
instruments.extend(facilityInstruments)
return instruments
def get_default_grouping(instrument, main_field_direction):
parameter_name = "Default grouping file"
if instrument == "MUSR":
parameter_name += " - " + main_field_direction
try:
grouping_file = ConfigService.getInstrument(instrument).getStringParameter(parameter_name)[0]
except IndexError:
return [], []
instrument_directory = ConfigServiceImpl.Instance().getInstrumentDirectory()
filename = instrument_directory + grouping_file
new_groups, new_pairs = load_utils.load_grouping_from_XML(filename)
return new_groups, new_pairs
def closeEvent(self, event):
# Check whether or not to save project
if not self.project.saved:
# Offer save
if self.project.offer_save(self):
# Cancel has been clicked
event.ignore()
return
# Close editors
if self.editor.app_closing():
# write out any changes to the mantid config file
ConfigService.saveConfig(ConfigService.getUserFilename())
# write current window information to global settings object
self.writeSettings(CONF)
# Close all open plots
# We don't want this at module scope here
import matplotlib.pyplot as plt # noqa
plt.close('all')
app = QApplication.instance()
if app is not None:
app.closeAllWindows()
# Kill the project recovery thread and don't restart should a save be in progress and clear out current
# recovery checkpoint as it is closing properly
self.project_recovery.stop_recovery_thread()
self.project_recovery.closing_workbench = True
self.project_recovery.remove_current_pid_folder()
self.interface_manager.closeHelpWindow()
event.accept()
else:
# Cancel was pressed when closing an editor
event.ignore()
def __init__(self, input_filename=None, group_name=None):
if isinstance(input_filename, str):
self._input_filename = input_filename
try:
self._hash_input_filename = self.calculate_ab_initio_file_hash()
except IOError as err:
logger.error(str(err))
except ValueError as err:
logger.error(str(err))
# extract name of file from the full path in the platform independent way
filename = os.path.basename(self._input_filename)
if filename.strip() == "":
raise ValueError("Name of the file cannot be an empty string.")
else:
raise ValueError("Invalid name of input file. String was expected.")
if isinstance(group_name, str):
self._group_name = group_name
else:
raise ValueError("Invalid name of the group. String was expected.")
core_name = filename[0:filename.rfind(".")]
save_dir_path = ConfigService.getString("defaultsave.directory")
self._hdf_filename = os.path.join(save_dir_path, core_name + ".hdf5") # name of hdf file
try:
self._advanced_parameters = self._get_advanced_parameters()
except IOError as err:
logger.error(str(err))
except ValueError as err:
logger.error(str(err))
self._attributes = {} # attributes for group
# data for group; they are expected to be numpy arrays or
# complex data sets which have the form of Python dictionaries or list of Python
# dictionaries
self._data = {}
def __updateAlignAndFocusArgs(self, wkspname):
self.log().debug('__updateAlignAndFocusArgs(%s)' % wkspname)
# if the files are missing, there is nothing to do
if (CAL_FILE not in self.kwargs) and (GROUP_FILE not in self.kwargs):
self.log().debug('--> Nothing to do')
return
self.log().debug('--> Updating')
# delete the files from the list of kwargs
if CAL_FILE in self.kwargs:
del self.kwargs[CAL_FILE]
if CAL_FILE in self.kwargs:
del self.kwargs[GROUP_FILE]
# get the instrument name
instr = mtd[wkspname].getInstrument().getName()
instr = ConfigService.getInstrument(instr).shortName()
# use the canonical names if they weren't specifed
for key, ext in zip((CAL_WKSP, GRP_WKSP, MASK_WKSP),
('_cal', '_group', '_mask')):
if key not in self.kwargs:
self.kwargs[key] = instr + ext
def instrument(self):
return ConfigService.getString('default.instrument')
def action_show_invisible_workspaces(self, state):
ConfigService.setString(self.SHOW_INVISIBLE_WORKSPACES, str(bool(state)))
def _get_test_facility(self):
return ConfigService.getFacility("ISIS")
def instrument(self):
inst = ConfigService.getInstrument()
return inst
def _get_test_instrument(self):
facility = ConfigService.getFacility("ISIS")
return facility.instrument("CRISP")
def _get_test_listener(self):
facility = ConfigService.getFacility("ISIS")
return facility.instrument("CRISP").liveListenerInfo()
def action_total_number_checkpoints(self, value):
ConfigService.setString(self.PR_NUMBER_OF_CHECKPOINTS, str(value))
def get_ipf_for_rule_2(path):
# Check if can be found in the instrument folder
directory = ConfigService.getInstrumentDirectory()
return check_for_files(directory, path)
def __init__(self, Ion, Symmetry, **kwargs):
"""
Constructor.
@param Ion: A rare earth ion. Possible values:
Ce, Pr, Nd, Pm, Sm, Eu, Gd, Tb, Dy, Ho, Er, Tm, Yb
@param Symmetry: Symmetry of the field. Possible values:
C1, Ci, C2, Cs, C2h, C2v, D2, D2h, C4, S4, C4h, D4, C4v, D2d, D4h, C3,
S6, D3, C3v, D3d, C6, C3h, C6h, D6, C6v, D3h, D6h, T, Td, Th, O, Oh
@param kwargs: Other field parameters and attributes. Acceptable values include:
ToleranceEnergy: energy tolerance,
ToleranceIntensity: intensity tolerance,
ResolutionModel: A resolution model.
FWHMVariation: Absolute value of allowed variation of a peak width during a fit.
FixAllPeaks: A boolean flag that fixes all parameters of the peaks.
Field parameters:
BmolX: The x-component of the molecular field,
BmolY: The y-component of the molecular field,
BmolZ: The z-component of the molecular field,
BextX: The x-component of the external field,
BextY: The y-component of the external field,
BextZ: The z-component of the external field,
B20: Real part of the B20 field parameter,
B21: Real part of the B21 field parameter,
B22: Real part of the B22 field parameter,
B40: Real part of the B40 field parameter,
B41: Real part of the B41 field parameter,
B42: Real part of the B42 field parameter,
B43: Real part of the B43 field parameter,
B44: Real part of the B44 field parameter,
B60: Real part of the B60 field parameter,
B61: Real part of the B61 field parameter,
B62: Real part of the B62 field parameter,
B63: Real part of the B63 field parameter,
B64: Real part of the B64 field parameter,
B65: Real part of the B65 field parameter,
B66: Real part of the B66 field parameter,
IB21: Imaginary part of the B21 field parameter,
IB22: Imaginary part of the B22 field parameter,
IB41: Imaginary part of the B41 field parameter,
IB42: Imaginary part of the B42 field parameter,
IB43: Imaginary part of the B43 field parameter,
IB44: Imaginary part of the B44 field parameter,
IB61: Imaginary part of the B61 field parameter,
IB62: Imaginary part of the B62 field parameter,
IB63: Imaginary part of the B63 field parameter,
IB64: Imaginary part of the B64 field parameter,
IB65: Imaginary part of the B65 field parameter,
IB66: Imaginary part of the B66 field parameter,
Each of the following parameters can be either a single float or an array of floats.
They are either all floats or all arrays of the same size.
IntensityScaling: A scaling factor for the intensity of each spectrum.
FWHM: A default value for the full width at half maximum of the peaks.
Temperature: A temperature "of the spectrum" in Kelvin
"""
# This is to make sure that Lorentzians get evaluated properly
ConfigService.setString('curvefitting.peakRadius', str(100))
from .function import PeaksFunction
self._ion = Ion
self._symmetry = Symmetry
self._toleranceEnergy = 1e-10
self._toleranceIntensity = 1e-1
self._fieldParameters = {}
self._fieldTies = {}
self._fieldConstraints = []
self._temperature = None
self._FWHM = None
self._intensityScaling = 1.0
self._resolutionModel = None
self._fwhmVariation = None
self._fixAllPeaks = False
for key in kwargs:
if key == 'ToleranceEnergy':
self._toleranceEnergy = kwargs[key]
elif key == 'ToleranceIntensity':
self._toleranceIntensity = kwargs[key]
elif key == 'IntensityScaling':
self._intensityScaling = kwargs[key]
elif key == 'FWHM':
self._FWHM = kwargs[key]
elif key == 'ResolutionModel':
self.ResolutionModel = kwargs[key]
elif key == 'Temperature':
self._temperature = kwargs[key]
elif key == 'FWHMVariation':
self._fwhmVariation = kwargs[key]
elif key == 'FixAllPeaks':
self._fixAllPeaks = kwargs[key]
else:
# Crystal field parameters
self._fieldParameters[key] = kwargs[key]
if isinstance(self._temperature, list) or isinstance(self._temperature, np.ndarray):
self.peaks = [PeaksFunction(firstIndex=1) for _ in self._temperature]
else:
self.peaks = PeaksFunction()
self.background = None
# Eigensystem
self._dirty_eigensystem = True
self._eigenvalues = None
self._eigenvectors = None
self._hamiltonian = None
# Peak lists
self._dirty_peaks = True
self._peakList = None
# Spectra
self._dirty_spectra = True
self._spectra = {}
self._plot_window = {}
self._setDefaultTies()
self.chi2 = None
def action_project_recovery_enabled(self, state):
ConfigService.setString(self.PR_RECOVERY_ENABLED, str(bool(state)))
def action_time_between_recovery(self, value):
ConfigService.setString(self.PR_TIME_BETWEEN_RECOVERY, str(value))
def __init__(self, initial_type):
self._save_directory = ConfigService.getString('defaultsave.directory')
self._type_factory_dict = {BinningType.SaveAsEventData: SaveAsEventData(),
BinningType.Custom: CustomBinning(),
BinningType.FromMonitors: BinningFromMonitors()}
self._settings, self._type = self._settings_from_type(initial_type)
def action_instrument_changed(self, new_instrument):
ConfigService.setString(self.INSTRUMENT, new_instrument)
def save_directory(self):
return ConfigService.getString('defaultsave.directory')
def test_properties_documented(self):
# location of the rst file relative to this file this will break if either moves
doc_filename = os.path.split(inspect.getfile(self.__class__))[0]
doc_filename = os.path.join(doc_filename, '../../../../../../docs/source/concepts/PropertiesFile.rst')
doc_filename = os.path.abspath(doc_filename)
# read in the user documentation
print ('Parsing', doc_filename)
documented_keys = []
with open(doc_filename) as handle:
text = handle.read()
# these will be ignored - the list should get shorter over time
hidden_prefixes = ['CheckMantidVersion.DownloadURL', # shouldn't be changed by users
'CheckMantidVersion.GitHubReleaseURL', # shouldn't be changed by users
'UpdateInstrumentDefinitions.URL', # shouldn't be changed by users
'docs.html.root', # shouldn't be changed by users
'errorreports.rooturl', # shouldn't be changed by users
'usagereports.rooturl', # shouldn't be changed by users
'workspace.sendto.SansView.arguments', 'workspace.sendto.SansView.saveusing', # related to SASview in menu
'workspace.sendto.SansView.target', 'workspace.sendto.SansView.visible', # related to SASview in menu
'workspace.sendto.name.SansView', # related to SASview in menu
'catalog.oncat.token.accessToken', 'catalog.oncat.token.expiresIn', 'catalog.oncat.token.refreshToken', 'catalog.oncat.token.scope', 'catalog.oncat.token.tokenType', # Shouldn't be changed by users.
########## TODO should be documented!
'filefinder.casesensitive',
'graph1d.autodistribution',
'groupingFiles.directory',
'icatDownload.directory', 'icatDownload.mountPoint',
'instrument.view.geometry',
'interfaces.categories.hidden',
'loading.multifile', 'loading.multifilelimit',
'maskFiles.directory',
'pythonalgorithms.refresh.allowed',
'sliceviewer.nonorthogonal',
'usersearch.directories',
########## TODO should these be documented?
'curvefitting.defaultPeak', 'curvefitting.findPeaksFWHM', 'curvefitting.findPeaksTolerance', 'curvefitting.guiExclude',
'logging.channels.consoleChannel.class', 'logging.channels.consoleChannel.formatter', 'logging.formatters.f1.class', 'logging.formatters.f1.pattern', 'logging.formatters.f1.times', 'logging.loggers.root.channel.channel1', 'logging.loggers.root.channel.class',
'MantidOptions.ReusePlotInstances',
'mantidqt.python_interfaces', 'mantidqt.python_interfaces_directory',
'paraview.ignore', 'paraview.path', 'paraview.pythonpaths', 'pvplugins.directory',
'python.plugins.directories',
]
# create the list of things
undocumented = []
properties_defined = ConfigService.keys()
for property in properties_defined:
property_tag = '``{}``'.format(property)
if property_tag not in text:
for hidden in hidden_prefixes:
if property.startswith(hidden):
break
else:
undocumented.append(property)
# everything should be documented
if len(undocumented) > 0:
raise AssertionError('{} undocumented properties: {}'.format(len(undocumented), undocumented))
