def find_input_workspace_property(self, algorithm):
algm_manager = AlgorithmManager.Instance()
alg_instance = algm_manager.createUnmanaged(algorithm[0], algorithm[1])
alg_instance.initialize()
for prop in alg_instance.getProperties():
if isinstance(prop, IWorkspaceProperty) and prop.direction in [Direction.Input, Direction.InOut]:
return prop.name
return None
def create_mantid_algorithm(self, algorithm_name, version=-1):
"""
Create and initializes a Mantid algorithm.
Args:
algorithm_name (str): The name of the algorithm to use for the title.
version (int): Version of the algorithm to create
Returns:
algorithm: An instance of a Mantid algorithm.
"""
if version == -1:
version = AlgorithmFactory.Instance().highestVersion(
algorithm_name)
alg = AlgorithmManager.Instance().createUnmanaged(
algorithm_name, version)
alg.initialize()
return alg
def _create_parameters(self, alg_name):
from mantid.api import AlgorithmManager
alg_object = AlgorithmManager.Instance().createUnmanaged(alg_name)
alg_object.initialize()
from inspect import Parameter
pos_or_keyword = Parameter.POSITIONAL_OR_KEYWORD
parameters = []
for name in alg_object.mandatoryProperties():
prop = alg_object.getProperty(name)
# Mandatory parameters are those for which the default value is not valid
if isinstance(prop.isValid, str):
valid_str = prop.isValid
else:
valid_str = prop.isValid()
if len(valid_str) > 0:
parameters.append(Parameter(name, pos_or_keyword))
else:
# None is not quite accurate here, but we are reproducing the
# behavior found in the C++ code for SimpleAPI.
parameters.append(Parameter(name, pos_or_keyword,
default=None))
# Add a self parameter since these are called from a class.
parameters.insert(0, Parameter("self", Parameter.POSITIONAL_ONLY))
return parameters
def closeEvent(self, event):
if self.project is not None:
if self.project.is_saving or self.project.is_loading:
event.ignore()
self.project.inform_user_not_possible()
return
# 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 is None or 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')
# Cancel all running (managed) algorithms
AlgorithmManager.Instance().cancelAll()
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
if self.project_recovery is not None:
self.project_recovery.stop_recovery_thread()
self.project_recovery.closing_workbench = True
# Cancel memory widget thread
if self.memorywidget is not None:
self.memorywidget.presenter.cancel_memory_update()
if self.interface_manager is not None:
self.interface_manager.closeHelpWindow()
if self.workspacecalculator is not None:
self.workspacecalculator.view.closeEvent(event)
if self.project_recovery is not None:
# Do not merge this block with the above block that
# starts with the same check.
# We deliberately split the call to stop the recovery
# thread and removal of the checkpoints folder to
# allow for the maximum amount of time for the recovery
# thread to finish. Any errors here are ignored as exceptions
# on shutdown cannot be handled in a meaningful way.
# Future runs of project recovery will clean any stale points
# after a month
self.project_recovery.remove_current_pid_folder(
ignore_errors=True)
event.accept()
else:
# Cancel was pressed when closing an editor
event.ignore()
