def sum_files(inst_name, accumulator, files):
""" Custom sum for multiple runs
Left for compartibility as internal summation had some unspecified problems.
Will go in a future
"""
accum_name = accumulator
if isinstance(accum_name,api.Workspace): # it is actually workspace
accum_name = accumulator.name()
if type(files) == list:
#tmp_suffix = '_plus_tmp'
for filename in files:
print 'Summing run ',filename,' to workspace ',accumulator
temp = common.load_run(inst_name,filename, force=False,load_with_workspace=Reducer.load_monitors_with_workspace)
if accum_name in mtd: # add current workspace to the existing one
if not isinstance(accumulator,api.Workspace):
accumulator = mtd[accum_name]
accumulator+= temp
DeleteWorkspace(Workspace=temp)
else:
print 'Create output workspace: '
accumulator=RenameWorkspace(InputWorkspace=temp,OutputWorkspace=accum_name)
return accumulator
else:
temp = common.load_run(inst_name,files, force=False,load_with_workspace=Reducer.load_monitors_with_workspace)
accumulator=RenameWorkspace(InputWorkspace=temp,OutputWorkspace=accum_name)
return accumulator;
def do_bleed_test(sample_run, max_framerate, ignored_pixels):
"""Runs the CreatePSDBleedMask algorithm
Input:
sample_run - The run number of the sample
max_framerate - The maximum allowed framerate in a tube. If None, the instrument defaults are used.
ignored_pixels - The number of central pixels to ignore. If None, the instrument defaults are used.
"""
logger.notice('Running PSD bleed test')
# Load the sample run
data_ws = common.load_run(sample_run)
if max_framerate is None:
max_framerate = float(data_ws.getInstrument().getNumberParameter('max-tube-framerate')[0])
if ignored_pixels is None:
ignored_pixels = int(data_ws.getInstrument().getNumberParameter('num-ignored-pixels')[0])
else:
# Make sure it is an int
ignored_pixels = int(ignored_pixels)
# What shall we call the output
lhs_names = lhs_info('names')
if len(lhs_names) > 0:
ws_name = lhs_names[0]
else:
ws_name = '__do_bleed__test'
bleed_test, num_failed = CreatePSDBleedMask(InputWorkspace=data_ws, OutputWorkspace=ws_name,
MaxTubeFramerate=max_framerate,
NIgnoredCentralPixels=ignored_pixels)
return bleed_test, num_failed
def _do_bleed_test(sample_run, max_framerate, ignored_pixels):
"""Runs the CreatePSDBleedMask algorithm
Input:
sample_run - The run number of the sample
max_framerate - The maximum allowed framerate in a tube. If None, the instrument defaults are used.
ignored_pixels - The number of central pixels to ignore. If None, the instrument defaults are used.
"""
mtd.sendLogMessage('Running PSD bleed test')
# Load the sample run
data_ws = common.load_run(sample_run)
if max_framerate is None:
max_framerate = float(data_ws.getInstrument().getNumberParameter('max-tube-framerate')[0])
if ignored_pixels is None:
ignored_pixels = int(data_ws.getInstrument().getNumberParameter('num-ignored-pixels')[0])
# What shall we call the output
lhs_names = lhs_info('names')
if len(lhs_names) > 0:
ws_name = lhs_names[0]
else:
ws_name = '__do_bleed__test'
bleed_test = CreatePSDBleedMask(data_ws, ws_name, MaxTubeFramerate=max_framerate,\
NIgnoredCentralPixels=ignored_pixels)
num_failed = bleed_test['NumberOfFailures'].value
return bleed_test.workspace(), num_failed
def sum_files(accumulator, files): if type(files) == list: tmp_suffix = '_plus_tmp' for filename in files: print 'Summing run ',filename,' to workspace ',accumulator temp = common.load_run(filename, force=False) if mtd.workspaceExists(accumulator)==False: #check for existance of output workpsace if false clone and zero print 'create output file' CloneWorkspace(temp,accumulator) CreateSingleValuedWorkspace(OutputWorkspace="tmp",DataValue="0",ErrorValue="0") Multiply(LHSWorkspace=accumulator,RHSWorkspace="tmp",OutputWorkspace=accumulator) Plus(accumulator, temp, accumulator) return accumulator
def diagnose(white_run, sample_run=None, other_white=None, remove_zero=None,
tiny=None, large=None, median_lo=None, median_hi=None, signif=None,
bkgd_threshold=None, bkgd_range=None, variation=None,
bleed_test=False, bleed_maxrate=None, bleed_pixels=None,
hard_mask=None, print_results=False, inst_name=None):
"""
Run diagnostics on the provided run and white beam files.
There are 4 possible tests, depending on the input given:
White beam diagnosis
Background tests
Second white beam
Bleed test
Required inputs:
white_run - The run number or filepath of the white beam run
Optional inputs:
sample_run - The run number or filepath of the sample run for the background test (default = None)
other_white - If provided an addional set of tests is performed on this file. (default = None)
remove_zero - If true then zeroes in the data will count as failed (default = False)
tiny - Minimum threshold for acceptance (default = 1e-10)
large - Maximum threshold for acceptance (default = 1e10)
median_lo - Fraction of median to consider counting low (default = 0.1)
median_hi - Fraction of median to consider counting high (default = 3.0)
signif - Counts within this number of multiples of the
standard dev will be kept (default = 3.3)
bkgd_threshold - High threshold for background removal in multiples of median (default = 5.0)
bkgd_range - The background range as a list of 2 numbers: [min,max].
If not present then they are taken from the parameter file. (default = None)
variation - The number of medians the ratio of the first/second white beam can deviate from
the average by (default=1.1)
bleed_test - If true then the CreatePSDBleedMask algorithm is run
bleed_maxrate - If the bleed test is on then this is the maximum framerate allowed in a tube
bleed_pixels - If the bleed test is on then this is the number of pixels ignored within the
bleed test diagnostic
hard_mask - A file specifying those spectra that should be masked without testing
print_results - If True then the results are printed to std out
inst_name - The name of the instrument to perform the diagnosis.
If it is not provided then the default instrument is used (default = None)
"""
# Set the default instrument so that Mantid can search for the runs correctly,
# but switch it back at the end
def_inst = mtd.settings["default.instrument"]
if inst_name == None:
inst_name = def_inst
elif inst_name != def_inst:
mtd.settings["default.instrument"] = inst_name
else: pass
# Load the hard mask file if necessary
hard_mask_spectra = ''
if hard_mask is not None:
hard_mask_spectra = common.load_mask(hard_mask)
# Map the test number to the results
# Each element is the mask workspace name then the number of failures
test_results = [ [None, None], [None, None], [None, None], [None, None]]
##
## Accumulate the masking on this workspace
##
# What shall we call the output
lhs_names = lhs_info('names')
if len(lhs_names) > 0:
diag_total_mask = lhs_names[0]
else:
diag_total_mask = 'diag_total_mask'
##
## White beam Test
##
white_counts = None
if white_run is not None and str(white_run) != '':
# Load and integrate
data_ws = common.load_run(white_run)
# Make sure we have a matrix workspace otherwise Integration() returns all zeros.
ConvertToMatrixWorkspace(data_ws, data_ws)
white_counts = Integration(data_ws, "__counts_white-beam").workspace()
MaskDetectors(white_counts, SpectraList=hard_mask_spectra)
# Run first white beam tests
__white_masks, num_failed = \
_do_white_test(white_counts, tiny, large, median_lo, median_hi, signif)
test_results[0] = [str(__white_masks), num_failed]
diag_total_mask = CloneWorkspace(__white_masks, diag_total_mask).workspace()
else:
raise RuntimeError('Invalid input for white run "%s"' % str(white_run))
##
## Second white beam Test
##
second_white_counts = None
if other_white is not None and str(other_white) != '':
# Load and integrate
data_ws = common.load_run(other_white)
second_white_counts = Integration(data_ws, "__counts_white-beam2").workspace()
MaskDetectors(white_counts, SpectraList=hard_mask_spectra)
# Run tests
__second_white_masks, num_failed = \
_do_second_white_test(white_counts, second_white_counts,
tiny, large, median_lo, median_hi,
signif,variation)
test_results[1] = [str(__second_white_masks), num_failed]
# Accumulate
diag_total_mask += __second_white_masks
##
## Tests on the sample(s)
##
if sample_run is not None and sample_run != '':
if type(sample_run) != list:
sample_run = [sample_run]
__bkgd_masks = None
__bleed_masks = None
bkgd_failures = 0
bleed_failures = 0
for sample in sample_run:
## Background test
__bkgd_masks_i, failures = _do_background_test(sample, white_counts, second_white_counts,
bkgd_range, bkgd_threshold, remove_zero, signif,
hard_mask_spectra)
bkgd_failures += failures
__bkgd_masks = _accumulate(__bkgd_masks,__bkgd_masks_i)
## PSD Bleed Test
if type(bleed_test) == bool and bleed_test == True:
__bleed_masks_i, failures = _do_bleed_test(sample, bleed_maxrate, bleed_pixels)
bleed_failures += failures
__bleed_masks = _accumulate(__bleed_masks, __bleed_masks_i)
## End of sample loop
test_results[2] = [str(__bkgd_masks), bkgd_failures]
diag_total_mask += __bkgd_masks
if __bleed_masks is not None:
test_results[3] = [str(__bleed_masks), bleed_failures]
diag_total_mask += __bleed_masks
## End of background test
# Remove temporary workspaces
mtd.deleteWorkspace(str(white_counts))
if second_white_counts is not None:
mtd.deleteWorkspace(str(second_white_counts))
# Revert our default instrument changes if necessary
if inst_name != def_inst:
mtd.settings["default.instrument"] = def_inst
if print_results:
print_test_summary(test_results)
# This will be a MaskWorkspace which contains the accumulation of all of the masks
return diag_total_mask
