def setUp(self):
config['default.facility'] = 'ILL'
config['default.instrument'] = 'D11'
config['logging.loggers.root.level'] = 'Warning'
config.appendDataSearchSubDir('ILL/D11/')
# prepare mask for instrument edges first:
MaskBTP(Instrument='D11', Tube='0-6,250-256')
RenameWorkspace(InputWorkspace='D11MaskBTP',
OutputWorkspace='mask_vertical')
MaskBTP(Instrument='D11', Pixel='0-6,250-256')
Plus(LHSWorkspace='mask_vertical',
RHSWorkspace='D11MaskBTP',
OutputWorkspace='edge_masks')
# the edges mask can be used as a default mask for all distances and wavelengths
MaskBTP(Instrument='D11', Tube='114-142,', Pixel='114-142')
RenameWorkspace(InputWorkspace='D11MaskBTP',
OutputWorkspace='mask_8m_4_6A_center')
MaskBTP(Instrument='D11', Tube='3-14', Pixel='240-256')
Plus(LHSWorkspace='D11MaskBTP',
RHSWorkspace='mask_8m_4_6A_center',
OutputWorkspace='mask_8m_4_6A')
MaskBTP(Instrument='D11', Tube='103-147', Pixel='103-147')
RenameWorkspace(InputWorkspace='D11MaskBTP',
OutputWorkspace='mask_1m_4_6A_center')
MaskBTP(Instrument='D11', Tube='3-14', Pixel='240-256')
Plus(LHSWorkspace='D11MaskBTP',
RHSWorkspace='mask_1m_4_6A_center',
OutputWorkspace='mask_1m_4_6A')
def __accumulate(self, chunkname, sumname, chunkunfocusname, sumuunfocusname, firstrun, removelogs=False):
"""accumulate newdata `wkspname` into sum `sumwkspname` and delete `wkspname`"""
# the first call to accumulate to a specific target should be a simple rename
self.log().debug('__accumulate({}, {}, {}, {}, {})'.format(chunkname, sumname, chunkunfocusname,
sumuunfocusname, firstrun))
if chunkname == sumname:
return # there is nothing to be done
if not firstrun:
# if the sum workspace doesn't already exist, just rename
if not mtd.doesExist(sumname):
firstrun = True
if firstrun:
if chunkname != sumname:
RenameWorkspace(InputWorkspace=chunkname, OutputWorkspace=sumname)
if chunkunfocusname and chunkunfocusname != sumuunfocusname:
RenameWorkspace(InputWorkspace=chunkunfocusname, OutputWorkspace=sumuunfocusname)
else:
if removelogs:
RemoveLogs(Workspace=chunkname) # accumulation has them already
RebinToWorkspace(WorkspaceToRebin=chunkname, WorkspaceToMatch=sumname,
OutputWorkspace=chunkname)
Plus(LHSWorkspace=sumname, RHSWorkspace=chunkname, OutputWorkspace=sumname,
ClearRHSWorkspace=self.kwargs['PreserveEvents'])
DeleteWorkspace(Workspace=chunkname)
self.__compressEvents(sumname) # could be smarter about when to run
if chunkunfocusname and chunkunfocusname != sumuunfocusname:
if removelogs:
RemoveLogs(Workspace=chunkunfocusname) # accumulation has them already
Plus(LHSWorkspace=sumuunfocusname, RHSWorkspace=chunkunfocusname, OutputWorkspace=sumuunfocusname,
ClearRHSWorkspace=self.kwargs['PreserveEvents'])
DeleteWorkspace(Workspace=chunkunfocusname)
self.__compressEvents(sumuunfocusname) # could be smarter about when to run
def norm(sample, blank, masks):
"""
Normalise the neutron polarisation on a tube by tube basis
Parameters
----------
sample: string
The name of the sample to be normalised. The individual tubes are
assumed to be in workspaces with names like sample_2
blank: string
The name of the blank to be normalised agains. The individual tubes are
assumed to be in workspaces with names like blank_2
masks: list of string
The file names for the masks used for the individual tubes.
"""
for t, _ in enumerate(masks):
wtemp = mtd[sample + "_{}".format(t)] / \
mtd[blank + "_{}".format(t)]
y = mtd[blank + "_{}".format(t)].extractY()
e = wtemp.extractE()
e[np.abs(y) < 0.2] *= 1e9
wtemp.setE(0, e[0])
RenameWorkspace("wtemp", sample + "_{}_norm".format(t))
wtemp = WeightedMean(sample + "_0_norm", sample + "_1_norm")
for tube in range(2, len(masks)):
wtemp = WeightedMean(wtemp, sample + "_{}_norm".format(tube))
RenameWorkspace(wtemp, OutputWorkspace=sample + "_Norm")
DeleteWorkspaces(
["{}_{}_norm".format(sample, tube) for tube, _ in enumerate(masks)])
def sumToShim(rnum, output_dir=None):
"""
Combine both spin states into a single workspace
Parameters
----------
rnum : int
The run number to be shimmed
output_dir : string
If given, the folder where the workspace should be saved
"""
try:
wtemp = Load(BASE.format(rnum), LoadMonitors=True)
RebinToWorkspace('wtemp_1',
'wtemp_monitors_1',
PreserveEvents=False,
OutputWorkspace='wtemp_1')
RebinToWorkspace('wtemp_2',
'wtemp_monitors_1',
PreserveEvents=False,
OutputWorkspace='wtemp_2')
wtemp_1 = ConjoinWorkspaces('wtemp_monitors_1', 'wtemp_1')
wtemp_2 = ConjoinWorkspaces('wtemp_monitors_2', 'wtemp_2')
except:
wtemp_monitors = Load(BASE.format(rnum))
wtempShim = mtd['wtemp_monitors_1'] + mtd['wtemp_monitors_2']
RenameWorkspace(wtempShim, 'LARMOR{:08d}'.format(rnum))
if output_dir:
SaveNexusProcessed(
'LARMOR{:08d}'.format(rnum),
os.path.join(output_dir, "LARMOR{:08d}-add.nxs".format(rnum)))
RenameWorkspace('LARMOR{:08d}'.format(rnum),
'LARMOR{:08d}-add'.format(rnum))
def fit_multiple_peaks(self, peak_tags, x_mins, x_maxs):
'''Fit multiple peaks across subruns. This will return a :py:obj:`FitResult`
Concrete instances may instantiate this as needed'''
x_mins, x_maxs = self._check_fit_range(x_mins, x_maxs)
assert len(peak_tags) == len(x_mins) == len(x_maxs), 'All inputs must have same number of values'
# fit each peak separately
peakcollections = []
fitted = None
for peak_tag, x_min, x_max in zip(peak_tags, x_mins, x_maxs):
# fit an individual peak
individual = self.fit_peaks(peak_tag, x_min, x_max)
# collect information
peakcollections.extend(individual.peakcollections)
if fitted:
fitted += individual.fitted
DeleteWorkspace(individual.fitted)
else:
fitted = individual.fitted
fitted = RenameWorkspace(InputWorkspace=fitted,
OutputWorkspace='{}_fitted'.format(peak_tags[0]))
# original difference isn't needed
DeleteWorkspace(individual.difference)
# calculate the difference
difference = self._mtd_wksp - fitted
difference = RenameWorkspace(InputWorkspace=difference, OutputWorkspace=peak_tags[0]+'_diff')
return FitResult(peakcollections=peakcollections, fitted=fitted, difference=difference)
def calibrate_tube(workspace: WorkspaceTypes,
tube_name: str,
output_peak_table: str = 'PeakTable',
output_parameters_table: str = 'ParametersTable',
output_peak_y_table: str = 'PeakYTable',
shadow_height: float = 1000,
shadow_width: float = 4,
fit_domain: float = 7) -> TableWorkspace:
r"""
Calibration table for one tube of CORELLI
This function creates TableWorkspace 'CalibTable', TableWorkspace 'PeakTable',
and WorkspaceGroup 'ParametersTable' containing TableWorkspace 'ParametersTableI'
where 'I' is the tube number.
:param workspace: string or handle to ~mantid.dataobjects.Workspace2D
:param tube_name: string uniquely representing one tube e.g. 'bank88/sixteenpack/tube3'
:param output_peak_table:
:param output_parameters_table:
:param output_peak_y_table:
:param shadow_height: estimated dip in the background intensity. Dips typical of Cd-wire runs are around 1000
neutron counts.
:param shadow_width: estimated width of the shadow cast by the wire, in pixel units. The Cd-wire typically
cast a shadow over four pixels.
:param fit_domain: estimated range, in pixel units, over which to carry out the fit. An appropriate value
is about twice the shadow width
:return: table containing detector ID and position vector
"""
message = f'Cannot process workspace {workspace}. Pass the name of an existing workspace or a workspace handle'
assert isinstance(workspace, (str, Workspace2D)), message
assert shadow_height > 0, 'shadow height must be positive'
for marker in ('bank', 'sixteenpack', 'tube'):
assert marker in tube_name, f'{tube_name} does not uniquely specify one tube'
peak_height, peak_width = -shadow_height, shadow_width
# Initial guess for the peak positions, assuming:
# - the center of the the wire mesh coincides with the center ot the tube_calib_fit_params
# - wires cast a shadow on a perfectly calibrated tube
fit_extent = (fit_domain / PIXELS_PER_TUBE) * TUBE_LENGTH # fit domain in meters
assert fit_extent < WIRE_GAP, 'The fit domain cannot be larger than the distance between consecutive wires'
wire_pixel_positions = wire_positions(units='pixels')[1: -1]
fit_par = TubeCalibFitParams(wire_pixel_positions, height=peak_height, width=peak_width, margin=fit_domain)
fit_par.setAutomatic(True)
# Generate the calibration table, the peak table, and the parameters table
peaks_form = [1] * len(wire_pixel_positions) # signals we'll be fitting dips (peaks with negative heights)
calibration_table, _ = tube.calibrate(workspace, tube_name, wire_positions(units='meters')[1: -1], peaks_form,
fitPar=fit_par, outputPeak=True,
parameters_table_group='ParametersTableGroup')
calibration_table = trim_calibration_table(calibration_table) # discard X and Z coordinates
# Additional workspaces
# Table with shadow positions along the tube, in pixel units
if output_peak_table != 'PeakTable': # 'PeakTable' is output by tube.calibrate
RenameWorkspace(InputWorkspace='PeakTable', OutputWorkspace=output_peak_table)
# Table with shadow positions along the vertical axis
calculate_peak_y_table(output_peak_table, 'ParametersTableGroup', output_workspace=output_peak_y_table)
# Table with optimized parameters for the polynomial coefficients A0, A1, A2, and chi-square
RenameWorkspace(InputWorkspace=mtd['ParametersTableGroup'].getItem(0), OutputWorkspace=output_parameters_table)
UnGroupWorkspace(InputWorkspace='ParametersTableGroup')
return calibration_table
def PyExec(self):
# get parameter values
wsString = self.getPropertyValue("InputWorkspace").strip()
#internal values
wsOutput = "__OutputWorkspace"
wsTemp = "__Sort_temp"
#get the workspace list
wsNames = []
for wsName in wsString.split(","):
ws = mtd[wsName.strip()]
if type(ws) == WorkspaceGroup:
wsNames.extend(ws.getNames())
else:
wsNames.append(wsName)
if wsOutput in mtd:
DeleteWorkspace(Workspace=wsOutput)
sortStat = []
for wsName in wsNames:
if "qvectors" in wsName:
#extract the spectrum
ws = mtd[wsName.strip()]
for s in range(0, ws.getNumberHistograms()):
y_s = ws.readY(s)
tuple = (self.GetXValue(y_s), s)
sortStat.append(tuple)
sortStat.sort()
if len(sortStat) == 0:
raise RuntimeError("Cannot find file with qvectors, aborting")
#sort spectra using norm of q
for wsName in wsNames:
ws = mtd[wsName.strip()]
yUnit = ws.getAxis(1).getUnit().unitID()
transposed = False
if ws.getNumberHistograms() < len(sortStat):
Transpose(InputWorkspace=wsName, OutputWorkspace=wsName)
transposed = True
for norm, spec in sortStat:
ExtractSingleSpectrum(InputWorkspace=wsName, OutputWorkspace=wsTemp, WorkspaceIndex=spec)
if wsOutput in mtd:
ConjoinWorkspaces(InputWorkspace1=wsOutput,InputWorkspace2=wsTemp,CheckOverlapping=False)
if wsTemp in mtd:
DeleteWorkspace(Workspace=wsTemp)
else:
RenameWorkspace(InputWorkspace=wsTemp, OutputWorkspace=wsOutput)
#put norm as y value and copy units from input
loopIndex = 0
wsOut = mtd[wsOutput]
for norm, spec in sortStat:
wsOut.getSpectrum(loopIndex).setSpectrumNo(int(norm*1000))
loopIndex = loopIndex + 1
if len(yUnit) > 0:
wsOut.getAxis(1).setUnit(yUnit)
if transposed:
Transpose(InputWorkspace=wsOutput, OutputWorkspace=wsOutput)
RenameWorkspace(InputWorkspace=wsOutput, OutputWorkspace=wsName)
def __init__(self, ws_name, ws_unit):
if ws_unit == MHz:
self._freq = ws_name+UNIT+MHz
self._field = convert_to_field(ws_name, ws_name+UNIT+GAUSS)
RenameWorkspace(InputWorkspace=ws_name, OutputWorkspace=self._freq)
elif ws_unit == GAUSS:
self._field = ws_name+UNIT+GAUSS
self._freq = convert_to_freq(ws_name, ws_name+UNIT+MHz)
RenameWorkspace(InputWorkspace=ws_name, OutputWorkspace=self._field)
def _renameWorkspaceBasedOnRunNumber(self, workspace_name, isTrans):
"""Rename the given workspace based on its run number and a standard prefix"""
new_name = self._prefixedName(_getRunNumberAsString(workspace_name), isTrans)
if new_name != workspace_name:
RenameWorkspace(InputWorkspace=workspace_name, OutputWorkspace=new_name)
# Also rename the monitor workspace, if there is one
if AnalysisDataService.doesExist(_monitorWorkspace(workspace_name)):
RenameWorkspace(InputWorkspace=_monitorWorkspace(workspace_name),
OutputWorkspace=_monitorWorkspace(new_name))
return new_name
def setUp(self):
self._input_name = 'iris26176_graphite002_conv_1L_s0_to_17_Result'
self._single_fit_name = 'iris26176_graphite002_conv_1L_s1_Result'
self._result_group_name = 'iris26176_graphite002_conv_1L_s0_to_17_Results'
self._output_name = 'iris26176_graphite002_conv_1L_s0_to_17_Result_Edit'
red_name = 'iris26176_graphite002_red'
res_name = 'iris26173_graphite002_res'
fit_function = 'composite=Convolution,FixResolution=true,NumDeriv=true;name=Resolution, ' \
'Workspace=__ConvFitResolution0,WorkspaceIndex=0,X=(),Y=();name=Lorentzian,'
start_x = '-0.54761329492537092'
end_x = '0.54325428563315703'
convolve_members = True
max_iterations = '5000'
# Perform fits to produce the result workspaces to use for a data replacement
LoadNexus(Filename=red_name + '.nxs', OutputWorkspace=red_name)
LoadNexus(Filename=res_name + '.nxs', OutputWorkspace=res_name)
LoadNexus(Filename='conv_fit_resolution.nxs',
OutputWorkspace='__ConvFitResolution0')
ConvolutionFitSequential(
Input=get_sequential_input_string(red_name, 18),
Function=fit_function + 'Amplitude=1,PeakCentre=0,FWHM=0.0175',
MaxIterations=max_iterations,
ConvolveMembers=convolve_members,
PassWSIndexToFunction='1',
StartX=start_x,
EndX=end_x,
OutputWorkspace=self._result_group_name,
OutputParameterWorkspace=
'iris26176_graphite002_conv_1L_s0_to_17_Parameters',
OutputWorkspaceGroup=
'iris26176_graphite002_conv_1L_s0_to_17_Workspaces')
ConvolutionFitSimultaneous(
InputWorkspace=red_name,
Function=fit_function +
'Amplitude=4.96922,PeakCentre=-0.000735068,FWHM=0.0671319',
MaxIterations=max_iterations,
ConvolveMembers=convolve_members,
WorkspaceIndex='1',
StartX=start_x,
EndX=end_x,
OutputWorkspace=self._single_fit_name + 's',
OutputParameterWorkspace=
'iris26176_graphite002_conv_1L_s1_Parameters',
OutputWorkspaceGroup='iris26176_graphite002_conv_1L_s1_Workspaces')
RenameWorkspace(InputWorkspace=self._input_name + 's_1',
OutputWorkspace=self._input_name)
RenameWorkspace(InputWorkspace=self._single_fit_name + 's_1',
OutputWorkspace=self._single_fit_name)
self._input_workspace = get_ads_workspace(self._input_name)
self._single_fit_workspace = get_ads_workspace(self._single_fit_name)
self._result_group = get_ads_workspace(self._result_group_name)
def _load_runs(self, runs, w_name):
"""
Load all run event Nexus files into a single `EventWorkspace`
Parameters
----------
runs: str
Run numbers to be reduced. Symbol `;` separates the runs into
substrings. Each substring represents a set of runs to be
reduced together
w_name: str
Name of output workspace
Returns
-------
Mantid.EventsWorkspace
"""
rl = self._run_list(runs)
#
# Load files together
#
_t_all_w = None
_t_all_w_name = tws('aggregate_load_run')
_t_w_name = tws('load_run')
for run in rl:
_t_w = self._load_single_run(run, _t_w_name)
if _t_all_w is None:
_t_all_w = CloneWorkspace(_t_w, OutputWorkspace=_t_all_w_name)
else:
_t_all_w = Plus(_t_all_w, _t_w, OutputWorkspace=_t_all_w_name)
RenameWorkspace(_t_all_w, OutputWorkspace=w_name)
return _t_all_w
def _load_runs(self, runs, w_name):
"""
Load all run event Nexus files into a single `EventWorkspace`
Parameters
----------
runs: str
Run numbers to be reduced. Symbol `;` separates the runs into
substrings. Each substring represents a set of runs to be
reduced together
w_name: str
Name of output workspace
Returns
-------
Mantid.EventsWorkspace
"""
rl = self._run_lists(runs)
#
# Load files together
#
_t_all_w = None
for run in rl:
file_name = "{0}_{1}_event.nxs".format(self._short_inst, str(run))
_t_w = LoadEventNexus(Filename=file_name,
NXentryName='entry-diff',
SingleBankPixelsOnly=False)
if _t_all_w is None:
_t_all_w = CloneWorkspace(_t_w)
else:
_t_all_w += _t_w
RenameWorkspace(_t_all_w, OutputWorkspace=w_name)
return _t_all_w
def monitorTransfit(self, files, foilType, divE):
isFirstFile = True
isSingleFile = len(files) == 1
firstFileName = ""
for file in files:
discard, fileName = path.split(file)
fnNoExt = path.splitext(fileName)[0]
if isFirstFile:
firstFileName = fnNoExt
fileName_Raw = fnNoExt + '_raw'
fileName_3 = fnNoExt + '_3'
LoadRaw(Filename=file, OutputWorkspace=fileName_Raw)
CropWorkspace(InputWorkspace=fileName_Raw, OutputWorkspace=fileName_Raw, XMin=100, XMax=19990)
NormaliseByCurrent(InputWorkspace=fileName_Raw, OutputWorkspace=fileName_Raw)
ExtractSingleSpectrum(InputWorkspace=fileName_Raw, OutputWorkspace=fileName_3, WorkspaceIndex=3)
DeleteWorkspace(fileName_Raw)
ConvertUnits(InputWorkspace=fileName_3, Target='Energy', OutputWorkspace=fileName_3)
self.TransfitRebin(fileName_3, fileName_3, foilType, divE)
if not isFirstFile:
Plus(LHSWorkspace=firstFileName + '_3', RHSWorkspace=fileName_3, OutputWorkspace=firstFileName + '_3')
DeleteWorkspace(fileName_3)
else:
isFirstFile = False
if isSingleFile:
RenameWorkspace(InputWorkspace=firstFileName + '_3', OutputWorkspace=firstFileName + '_monitor')
else:
noFiles = len(files) ** (-1)
CreateSingleValuedWorkspace(OutputWorkspace='scale', DataValue=noFiles)
Multiply(LHSWorkspace=firstFileName + '_3', RHSWorkspace='scale',
OutputWorkspace=firstFileName + '_monitor')
DeleteWorkspace('scale')
DeleteWorkspace(firstFileName + '_3')
def sel(sample, const):
"""
Convert workspace into normalised spin echo units
Parameters
----------
sample : str
The name of the workspace to be converted
const : float
The spin echo length of a one angstrom neutron in nanometers
Returns
-------
The name of a workspace with the x coordinate in proper spin echo
units and the y coordinate in log(P/P₀)/λ²
"""
wtemp = mtd[sample]
x = wtemp.extractX()
y = wtemp.extractY()
e = wtemp.extractE()
dx = (x[:, 1:] + x[:, :-1]) / 2
wtemp = ConvertUnits(sample, "SpinEchoLength", EFixed=const)
wenv = CreateWorkspace(wtemp.extractX(),
np.log(y) / dx**2,
e / y / dx**2,
UnitX="SpinEchoLength",
YUnitLabel="Counts")
RenameWorkspace(wenv, OutputWorkspace=sample + "_sel")
def test_renaming_in_ads_calls_any_change_handle(self):
CreateSampleWorkspace(OutputWorkspace="ws1")
self.project.anyChangeHandle = mock.MagicMock()
RenameWorkspace(InputWorkspace="ws1", OutputWorkspace="ws2")
# Called twice because first workspace is removed and second is added
self.assertEqual(2, self.project.anyChangeHandle.call_count)
def _rename_workspace(self, input_name: str, workspace_name: str) -> str:
"""Renames a resulting workspace from a simultaneous fit."""
new_name, _ = create_fitted_workspace_name(
input_name, self.fitting_context.function_name)
new_name += '; Simultaneous'
RenameWorkspace(InputWorkspace=workspace_name,
OutputWorkspace=new_name)
return new_name
def test_observeRename_calls_renameHandle_when_set_on_ads_and_a_workspace_is_renamed(self):
CreateSampleWorkspace(OutputWorkspace="ws")
self.fake_class.observeRename(True)
self.fake_class.renameHandle = mock.MagicMock()
RenameWorkspace(InputWorkspace="ws", OutputWorkspace="ws1")
self.assertEqual(self.fake_class.renameHandle.call_count, 1)
def fit_peaks(self, peak_tag, x_min, x_max):
x_min, x_max = self._check_fit_range(x_min, x_max)
# Create output workspace names
r_positions_ws_name = 'fitted_peak_positions_{0}'.format(
self._mtd_wksp)
r_param_table_name = 'param_m_{0}'.format(self._mtd_wksp)
r_error_table_name = 'param_e_{0}'.format(self._mtd_wksp)
r_model_ws_name = 'model_full_{0}'.format(self._mtd_wksp)
# estimate the peak center
peak_center = self._guess_center(x_min, x_max)
# add in extra parameters for starting values
kwargs = {}
if self._peak_function == PeakShape.PSEUDOVOIGT:
kwargs[
'PeakParameterNames'] = 'Mixing' # FWHM and Intensity also available
kwargs['PeakParameterValues'] = '0.6' # mixing agreed upon default
# Fit peak by Mantid.FitPeaks
fit_return = FitPeaks(
InputWorkspace=self._mtd_wksp,
PeakFunction=str(self._peak_function),
BackgroundType=str(self._background_function),
FindBackgroundSigma=1,
HighBackground=True,
PeakCenters=peak_center,
FitWindowBoundaryList=(x_min, x_max),
# ConstrainPeakPositions=True, TODO should this be turned on?
RawPeakParameters=True,
OutputWorkspace=r_positions_ws_name, # peak centers
OutputPeakParametersWorkspace=r_param_table_name, # peak parameters
OutputParameterFitErrorsWorkspace=
r_error_table_name, # peak parameter uncertainties
FittedPeaksWorkspace=r_model_ws_name, # peaks calculated from model
MaxFitIterations=50, # TODO increase to 500
**kwargs)
# r is a class containing multiple outputs (workspaces)
if fit_return is None:
raise RuntimeError('return from FitPeaks cannot be None')
# convert the output tables into a pyrs.peaks.PeakCollection
peak_collection = self.__tables_to_peak_collection(
peak_tag, fit_return.OutputPeakParametersWorkspace,
fit_return.OutputParameterFitErrorsWorkspace)
DeleteWorkspace(fit_return.OutputPeakParametersWorkspace)
DeleteWorkspace(fit_return.OutputParameterFitErrorsWorkspace)
# create the difference workspace
difference = self._mtd_wksp - fit_return.FittedPeaksWorkspace
difference = RenameWorkspace(InputWorkspace=difference,
OutputWorkspace=peak_tag + '_diff')
# return the final results
return FitResult(peakcollections=(peak_collection, ),
fitted=fit_return.FittedPeaksWorkspace,
difference=difference)
def test_view_title_did_not_change_other_workspace_rename(self):
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
title = pres.model.get_title()
other_workspace = CreateSampleWorkspace()
other_renamed = RenameWorkspace(other_workspace) # noqa F841
self.assertEqual(pres.model.get_title(), title)
self.assertEqual(pres.view.windowTitle(), pres.model.get_title())
def setUp(self):
config['default.facility'] = 'ILL'
config['default.instrument'] = 'D11'
config['logging.loggers.root.level'] = 'Warning'
config.appendDataSearchSubDir('ILL/D11/')
# prepare mask for instrument edges first:
MaskBTP(Instrument='D11', Tube='1-3,253-256')
RenameWorkspace(InputWorkspace='D11MaskBTP', OutputWorkspace='mask_vertical')
MaskBTP(Instrument='D11', Pixel='1-3,253-256')
Plus(LHSWorkspace='mask_vertical', RHSWorkspace='D11MaskBTP', OutputWorkspace='edge_masks')
# the edges mask can be used as a default mask for all distances and wavelengths
MaskBTP(Instrument='D11', Tube='116-139', Pixel='90-116')
RenameWorkspace(InputWorkspace='D11MaskBTP', OutputWorkspace='mask_39m_10A')
MaskBTP(Instrument='D11', Tube='115-140', Pixel='115-140')
RenameWorkspace(InputWorkspace='D11MaskBTP', OutputWorkspace='mask_8m_4_6A')
MaskBTP(Instrument='D11', Tube='105-145', Pixel='105-145')
RenameWorkspace(InputWorkspace='D11MaskBTP', OutputWorkspace='mask_1m_4_6A')
def setUp(self):
config['default.facility'] = 'ILL'
config['default.instrument'] = 'D22'
config['logging.loggers.root.level'] = 'Warning'
config.appendDataSearchSubDir('ILL/D22/')
MaskBTP(Instrument='D22', Pixel='0-12,245-255')
MaskBTP(Workspace='D22MaskBTP', Tube='54-75', Pixel='108-150')
RenameWorkspace(InputWorkspace='D22MaskBTP', OutputWorkspace='D22_mask_central')
def update_log_group_name(self):
run_info = ADS.retrieve('run_info')
if run_info.rowCount() > 0:
runs = run_info.column('Run')
name = f"{run_info.row(0)['Instrument']}_{min(runs)}-{max(runs)}_logs"
if not name == self._log_workspaces.name():
RenameWorkspace(InputWorkspace=self._log_workspaces.name(), OutputWorkspace=name)
else:
self.clear_logs()
def _regularize_output_names(output_ws):
"""Regularizes the workspace names in the output group, according to the group name
and workspace index in the group. Only needed for workspace groups, otherwise the name
is already correct."""
if isinstance(mtd[output_ws], WorkspaceGroup):
for entry_no, entry in enumerate(mtd[output_ws]):
ordered_name = "{}_{}".format(output_ws, entry_no)
RenameWorkspace(InputWorkspace=entry,
OutputWorkspace=ordered_name)
def runTest(self):
UseCompatibilityMode()
SANS2D()
MaskFile('MaskSANS2DReductionGUI.txt')
AssignSample('22048')
AssignCan('22023')
TransmissionSample('22041', '22024')
TransmissionCan('22024', '22024')
reduced = WavRangeReduction()
RenameWorkspace(reduced, OutputWorkspace='trans_test_rear')
def runTest(self):
HelperTestingClass.__init__(self)
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
title = pres.model.get_title()
other_workspace = CreateSampleWorkspace()
other_renamed = RenameWorkspace(other_workspace) # noqa F841
self.assertEqual(pres.model.get_title(), title)
self.assertEqual(pres.view.windowTitle(), pres.model.get_title())
def remove_unwanted_workspaces(workspace_name, temp_workspace_name, period):
# Delete all entries except for the period which is requested
workspaces_to_keep = temp_workspace_name + "_" + str(period)
group_workspace = mtd[temp_workspace_name]
workspace_names_to_remove = [element.name() for element in group_workspace if element.name() != workspaces_to_keep]
for to_remove in workspace_names_to_remove:
DeleteWorkspace(to_remove)
# We need to ungroup the group workspace which only contains now a single workspace
UnGroupWorkspace(group_workspace)
RenameWorkspace(InputWorkspace=workspaces_to_keep, OutputWorkspace=workspace_name)
def name(self, full_name):
new_workspace_name = full_name.split("/")[-1]
if not new_workspace_name:
return
if not self.is_hidden:
if len(new_workspace_name) > 0 and self._workspace_name != str(new_workspace_name):
RenameWorkspace(InputWorkspace=self._workspace_name, OutputWorkspace=new_workspace_name)
self._directory_structure = "/".join(full_name.split("/")[0:-1])
self._workspace_name = new_workspace_name
def test_ensure_that_the_ads_observer_calls_rename_handle(self, _):
presenter = PeaksViewerCollectionPresenter(MagicMock())
presenter.rename_handle = MagicMock()
self.assertTrue(isinstance(presenter._ads_observer, SliceViewerADSObserver))
presenter._ads_observer = SliceViewerADSObserver(presenter.replace_handle, presenter.rename_handle,
presenter.clear_handle, presenter.delete_handle)
CreateSampleWorkspace(OutputWorkspace="ws")
RenameWorkspace(InputWorkspace="ws", OutputWorkspace="ws1")
presenter.rename_handle.assert_called_once_with("ws", "ws1")
def runTest(self):
UseCompatibilityMode()
SANS2D()
MaskFile(MASKFILE)
AssignSample('22048')
AssignCan('22023')
TransmissionSample('22041', '22024')
TransmissionCan('22024', '22024')
SetEventSlices("0.0-450, 5-10")
reduced = WavRangeReduction()
RenameWorkspace(reduced, OutputWorkspace='trans_test_rear')
def TransfitRebin(self, inputWS, outputWSName, foilType, divE):
ws2D = mtd[inputWS]
# Expand the limits for rebinning to prevent potential issues at the boundaries
startE = self.ResParamsDict[foilType + '_startE']
endE = self.ResParamsDict[foilType + '_endE']
startEp = 0.99 * startE
endEp = 1.01 * endE
CropWorkspace(InputWorkspace=ws2D,
OutputWorkspace=ws2D,
XMin=1000 * startEp,
XMax=1000 * endEp)
numPts = np.int(((endEp - startEp) / divE) + 1)
xData_out = []
xData_in = ws2D.readX(0)
yData_in = ws2D.readY(0)
# Deals with issues in Mantid where Xdata mark start of bin, not true x position
# calculates the bin width and then takes middle of bin as x value
current_bin_widths = []
xActual = []
for x in range(0, len(xData_in) - 1):
current_bin_widths.append(xData_in[x + 1] - xData_in[x])
xActual.append(xData_in[x] + 0.5 * (xData_in[x + 1] - xData_in[x]))
# Make xData with uniform binning defined by divE
for j in range(numPts):
xData_out.append(1000 * (startEp + j * divE))
yData_out = [0] * (len(xData_out))
# Normalise output ydata accordingly based on surrounding values
yNorm = [0] * (len(xData_out))
for j in range(0, len(yData_in)):
currentBin = np.int((xActual[j] - startEp * 1000) / (divE * 1000))
scale1 = 1 - ((xActual[j] - xData_out[currentBin]) / (divE * 1000))
yData_out[currentBin] += yData_in[j] * scale1
yNorm[currentBin] += scale1
if currentBin < (len(xData_out) - 1):
yData_out[currentBin + 1] += yData_in[j] * (1 - scale1)
yNorm[currentBin + 1] += 1 - scale1
# Apply the normalisation, with a catch for any potential divide by zero errors
for i in range(len(yData_out)):
if yNorm[i] != 0:
yData_out[i] = yData_out[i] / yNorm[i]
else:
print('Empty bin')
outputWS = CreateWorkspace(DataX=xData_out,
DataY=yData_out,
NSpec=1,
UnitX='meV')
CropWorkspace(InputWorkspace=outputWS,
OutputWorkspace=outputWS,
XMin=1000 * startE,
XMax=1000 * endE)
RenameWorkspace(InputWorkspace=outputWS, OutputWorkspace=outputWSName)
def test_renameWorkspace(self):
RenameWorkspace(self._raw_ws,'name1',RenameMonitors=True)
self.assertTrue('name1' in mtd)
self.assertTrue('name1_monitors' in mtd)
#
#ws = mtd['name1']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name1_monitors')
RenameWorkspace(InputWorkspace='name1',OutputWorkspace='name2',RenameMonitors=True)
self.assertFalse('name1' in mtd)
self.assertFalse('name1_monitors' in mtd)
self.assertTrue('name2' in mtd)
self.assertTrue('name2_monitors' in mtd)
#
#ws = mtd['name2']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name2_monitors')
RenameWorkspace('name2','name3',True)
self.assertFalse('name2' in mtd)
self.assertFalse('name2_monitors' in mtd)
self.assertTrue('name3' in mtd)
self.assertTrue('name3_monitors' in mtd)
#
#ws = mtd['name3']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name3_monitors')
RenameWorkspace('name3','name4')
self.assertFalse('name3' in mtd)
self.assertTrue('name3_monitors' in mtd)
self.assertTrue('name4' in mtd)
self.assertFalse('name4_monitors' in mtd)
#
#ws = mtd['name4']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name3_monitors')
RenameWorkspace('name3_monitors','name4_monitors',True)
self.assertFalse('name3_monitors' in mtd)
self.assertTrue('name4_monitors' in mtd)
#
#ws = mtd['name4']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name4_monitors')
name5=RenameWorkspace('name4')
self.assertFalse('name4' in mtd)
self.assertTrue('name4_monitors' in mtd)
self.assertTrue('name5' in mtd)
self.assertFalse('name5_monitors' in mtd)
#
#monWs1 = name5.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name4_monitors')
name6=RenameWorkspace('name5',True)
self.assertFalse('name5' in mtd)
self.assertFalse('name4_monitors' in mtd)
self.assertTrue('name6' in mtd)
self.assertTrue('name6_monitors' in mtd)
#
#monWs1 = name6.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name6_monitors')
name7=RenameWorkspace('name6',RenameMonitors=True)
self.assertFalse('name6' in mtd)
self.assertFalse('name6_monitors' in mtd)
self.assertTrue('name7' in mtd)
self.assertTrue('name7_monitors' in mtd)
#
#monWs1 = name7.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name7_monitors')
ws = RenameWorkspace(name7,OutputWorkspace='name8',RenameMonitors=True)
self.assertEqual(ws.name(),'name8')
self.assertFalse('name7' in mtd)
self.assertFalse('name7_monitors' in mtd)
self.assertTrue('name8' in mtd)
self.assertTrue('name8_monitors' in mtd)
#
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name8_monitors')
# test with the logging keyword
try:
name9 = RenameWorkspace('name8', EnableLogging=False)
self.assertTrue('name9' in mtd)
self.assertTrue(name9)
self.assertFalse('name8' in mtd)
except RuntimeError as e:
self.fail('Magic keyword not recognised '+e.what())
# test trying to disable ADS
try:
name10 = RenameWorkspace('name9', StoreInADS=False)
self.fail('Disabling on ADS did not throw for RenameWorkspace')
except KeyError:
pass
# test text value for disabling
try:
name10 = RenameWorkspace('name9', StoreInADS='disable')
self.fail('Disabling on ADS did not throw for RenameWorkspace')
except KeyError:
pass
def test_renameWorkspace(self):
RenameWorkspace(self._raw_ws, "name1", RenameMonitors=True)
self.assertTrue("name1" in mtd)
self.assertTrue("name1_monitors" in mtd)
#
# ws = mtd['name1']
# monWs1 = ws.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name1_monitors')
RenameWorkspace(InputWorkspace="name1", OutputWorkspace="name2", RenameMonitors=True)
self.assertFalse("name1" in mtd)
self.assertFalse("name1_monitors" in mtd)
self.assertTrue("name2" in mtd)
self.assertTrue("name2_monitors" in mtd)
#
# ws = mtd['name2']
# monWs1 = ws.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name2_monitors')
RenameWorkspace("name2", "name3", True)
self.assertFalse("name2" in mtd)
self.assertFalse("name2_monitors" in mtd)
self.assertTrue("name3" in mtd)
self.assertTrue("name3_monitors" in mtd)
#
# ws = mtd['name3']
# monWs1 = ws.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name3_monitors')
RenameWorkspace("name3", "name4")
self.assertFalse("name3" in mtd)
self.assertTrue("name3_monitors" in mtd)
self.assertTrue("name4" in mtd)
self.assertFalse("name4_monitors" in mtd)
#
# ws = mtd['name4']
# monWs1 = ws.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name3_monitors')
RenameWorkspace("name3_monitors", "name4_monitors", True)
self.assertFalse("name3_monitors" in mtd)
self.assertTrue("name4_monitors" in mtd)
#
# ws = mtd['name4']
# monWs1 = ws.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name4_monitors')
name5 = RenameWorkspace("name4")
self.assertFalse("name4" in mtd)
self.assertTrue("name4_monitors" in mtd)
self.assertTrue("name5" in mtd)
self.assertFalse("name5_monitors" in mtd)
#
# monWs1 = name5.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name4_monitors')
name6 = RenameWorkspace("name5", True)
self.assertFalse("name5" in mtd)
self.assertFalse("name4_monitors" in mtd)
self.assertTrue("name6" in mtd)
self.assertTrue("name6_monitors" in mtd)
#
# monWs1 = name6.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name6_monitors')
name7 = RenameWorkspace("name6", RenameMonitors=True)
self.assertFalse("name6" in mtd)
self.assertFalse("name6_monitors" in mtd)
self.assertTrue("name7" in mtd)
self.assertTrue("name7_monitors" in mtd)
#
# monWs1 = name7.getMonitorWorkspace()
# self.assertEqual(monWs1.name(),'name7_monitors')
ws = RenameWorkspace(name7, OutputWorkspace="name8", RenameMonitors=True)
self.assertEqual(ws.name(), "name8")
self.assertFalse("name7" in mtd)
self.assertFalse("name7_monitors" in mtd)
self.assertTrue("name8" in mtd)
self.assertTrue("name8_monitors" in mtd)
def test_renameWorkspace(self):
RenameWorkspace(self._raw_ws,'name1',RenameMonitors=True)
self.assertTrue('name1' in mtd)
self.assertTrue('name1_monitors' in mtd)
#
#ws = mtd['name1']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name1_monitors')
RenameWorkspace(InputWorkspace='name1',OutputWorkspace='name2',RenameMonitors=True)
self.assertFalse('name1' in mtd)
self.assertFalse('name1_monitors' in mtd)
self.assertTrue('name2' in mtd)
self.assertTrue('name2_monitors' in mtd)
#
#ws = mtd['name2']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name2_monitors')
RenameWorkspace('name2','name3',True)
self.assertFalse('name2' in mtd)
self.assertFalse('name2_monitors' in mtd)
self.assertTrue('name3' in mtd)
self.assertTrue('name3_monitors' in mtd)
#
#ws = mtd['name3']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name3_monitors')
RenameWorkspace('name3','name4')
self.assertFalse('name3' in mtd)
self.assertTrue('name3_monitors' in mtd)
self.assertTrue('name4' in mtd)
self.assertFalse('name4_monitors' in mtd)
#
#ws = mtd['name4']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name3_monitors')
RenameWorkspace('name3_monitors','name4_monitors',True)
self.assertFalse('name3_monitors' in mtd)
self.assertTrue('name4_monitors' in mtd)
#
#ws = mtd['name4']
#monWs1 = ws.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name4_monitors')
name5=RenameWorkspace('name4')
self.assertFalse('name4' in mtd)
self.assertTrue('name4_monitors' in mtd)
self.assertTrue('name5' in mtd)
self.assertFalse('name5_monitors' in mtd)
#
#monWs1 = name5.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name4_monitors')
name6=RenameWorkspace('name5',True)
self.assertFalse('name5' in mtd)
self.assertFalse('name4_monitors' in mtd)
self.assertTrue('name6' in mtd)
self.assertTrue('name6_monitors' in mtd)
#
#monWs1 = name6.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name6_monitors')
name7=RenameWorkspace('name6',RenameMonitors=True)
self.assertFalse('name6' in mtd)
self.assertFalse('name6_monitors' in mtd)
self.assertTrue('name7' in mtd)
self.assertTrue('name7_monitors' in mtd)
#
#monWs1 = name7.getMonitorWorkspace()
#self.assertEqual(monWs1.name(),'name7_monitors')
ws = RenameWorkspace(name7,OutputWorkspace='name8',RenameMonitors=True)
self.assertEqual(ws.name(),'name8')
self.assertFalse('name7' in mtd)
self.assertFalse('name7_monitors' in mtd)
self.assertTrue('name8' in mtd)
self.assertTrue('name8_monitors' in mtd)
