def _focus_mode_trans(output_file_paths, attenuation_filepath,
calibrated_spectra):
summed_ws = mantid.MergeRuns(InputWorkspaces=calibrated_spectra[:9])
xList = summed_ws.readX(0)
summed_ws = mantid.CropWorkspace(InputWorkspace=summed_ws,
XMin=xList[1],
Xmax=xList[-2])
summed_ws = mantid.Scale(InputWorkspace=summed_ws,
Factor=0.111111111111111)
if attenuation_filepath:
summed_ws = _attenuate_workspace(
output_file_paths=output_file_paths,
attenuated_ws=summed_ws,
attenuation_filepath=attenuation_filepath)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="TOF")
mantid.SaveGSS(InputWorkspace=summed_ws,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=1)
mantid.SaveFocusedXYE(InputWorkspace=summed_ws,
Filename=output_file_paths["tof_xye_filename"],
Append=False,
IncludeHeader=False)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws,
Target="dSpacing")
# Rename to user friendly name:
summed_ws_name = output_file_paths["output_name"] + "_mods1-9"
summed_ws = mantid.RenameWorkspace(InputWorkspace=summed_ws,
OutputWorkspace=summed_ws_name)
mantid.SaveFocusedXYE(InputWorkspace=summed_ws,
Filename=output_file_paths["dspacing_xye_filename"],
Append=False,
IncludeHeader=False)
mantid.SaveNexus(InputWorkspace=summed_ws,
Filename=output_file_paths["nxs_filename"],
Append=False)
output_list = [summed_ws]
for i in range(0, 9):
workspace_name = output_file_paths["output_name"] + "_mod" + str(i + 1)
to_save = mantid.ConvertUnits(InputWorkspace=calibrated_spectra[i],
Target="dSpacing",
OutputWorkspace=workspace_name)
output_list.append(to_save)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=to_save,
Append=True)
return output_list
def _focus_mode_all(output_file_paths, processed_spectra,
attenuation_filepath):
summed_spectra_name = output_file_paths["output_name"] + "_mods1-9"
summed_spectra = mantid.MergeRuns(InputWorkspaces=processed_spectra[:9],
OutputWorkspace=summed_spectra_name)
summed_spectra = mantid.Scale(InputWorkspace=summed_spectra,
Factor=0.111111111111111,
OutputWorkspace=summed_spectra_name)
if attenuation_filepath:
summed_spectra = _attenuate_workspace(
output_file_paths=output_file_paths,
attenuated_ws=summed_spectra,
attenuation_filepath=attenuation_filepath)
summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra,
Target="TOF",
OutputWorkspace=summed_spectra_name)
mantid.SaveGSS(InputWorkspace=summed_spectra,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=1)
summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra,
Target="dSpacing",
OutputWorkspace=summed_spectra_name)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=summed_spectra,
Append=False)
output_list = [summed_spectra]
for i in range(0, 5):
spectra_index = (i + 9) # Compensate for 0 based index
ws_to_save = processed_spectra[
spectra_index] # Save out workspaces 10/11/12
output_name = output_file_paths["output_name"] + "_mod" + str(
spectra_index + 1)
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save,
OutputWorkspace=ws_to_save,
Target="TOF")
mantid.SaveGSS(InputWorkspace=ws_to_save,
Filename=output_file_paths["gss_filename"],
Append=True,
Bank=i + 2)
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save,
OutputWorkspace=output_name,
Target="dSpacing")
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=ws_to_save,
Append=True)
output_list.append(ws_to_save)
return output_list
def _sum_ws_range(ws_list):
"""
Sums a list of workspaces into a single workspace. This will take the name
of the first and last workspaces in the list and take the form: "summed_<first>_<last>"
:param ws_list: The workspaces as a list to sum into a single workspace
:return: A single summed workspace
"""
# Sum all workspaces
out_ws_name = "summed_" + ws_list[0].name() + '_' + ws_list[-1].name()
summed_ws = mantid.MergeRuns(InputWorkspaces=ws_list, OutputWorkspace=out_ws_name)
return summed_ws
def _sum_groups_of_three_ws(calibrated_spectra, output_file_names):
output_list = []
for i in range(3):
ws_name = output_file_names["output_name"] + "_mods{}-{}".format(
i * 3 + 1, (i + 1) * 3)
summed_spectra = mantid.MergeRuns(
InputWorkspaces=calibrated_spectra[i * 3:(i + 1) * 3],
OutputWorkspace=ws_name)
scaled = mantid.Scale(InputWorkspace=summed_spectra,
Factor=1. / 3,
OutputWorkspace=ws_name)
output_list.append(scaled)
return output_list
def PyExec(self):
""" Main execution body
"""
# get list of input workspaces
input_workspace_list = self._expand_groups()
workspaceCount = len(input_workspace_list)
self.log().information("Workspaces to merge " + str(workspaceCount))
wsOutput = self.getPropertyValue("OutputWorkspace")
if workspaceCount < 2:
api.CloneWorkspace(InputWorkspace=input_workspace_list[0],
OutputWorkspace=wsOutput)
self.log().warning(
"Cannot merge one workspace. Clone is produced.")
self.setProperty("OutputWorkspace", wsOutput)
return
# check whether given workspaces can be merged
self._can_merge(input_workspace_list)
# delete output workspace if it exists
if api.mtd.doesExist(wsOutput):
api.DeleteWorkspace(Workspace=wsOutput)
# Merge runs
api.MergeRuns(InputWorkspaces=input_workspace_list,
OutputWorkspace=wsOutput)
# Merge logs
# MergeRuns by default copies all logs from the first workspace
pdict = {}
for prop in self.properties_to_merge:
pdict[prop] = []
for wsname in input_workspace_list:
wks = api.AnalysisDataService.retrieve(wsname)
run = wks.getRun()
for prop in self.properties_to_merge:
if run.hasProperty(prop):
pdict[prop].append(run.getProperty(prop).value)
# take average for temperatures
nentries = len(pdict['temperature'])
if nentries > 0:
temps = [float(temp) for temp in pdict['temperature']]
tmean = sum(temps) / nentries
api.AddSampleLog(Workspace=wsOutput,
LogName='temperature',
LogText=str(tmean),
LogType='Number',
LogUnit='K')
# sum monitor counts
mcounts = [int(mco) for mco in pdict['monitor_counts']]
# check for zero monitor counts
zeros = np.where(np.array(mcounts) == 0)[0]
if len(zeros) > 0:
for index in zeros:
self.log().warning("Workspace " + input_workspace_list[index] +
" has zero monitor counts.")
# create sample log
api.AddSampleLog(Workspace=wsOutput,
LogName='monitor_counts',
LogText=str(sum(mcounts)),
LogType='Number')
# sum durations
durations = [int(dur) for dur in pdict['duration']]
api.AddSampleLog(Workspace=wsOutput,
LogName='duration',
LogText=str(sum(durations)),
LogType='Number',
LogUnit='s')
# get minimal run_start
fmt = "%Y-%m-%dT%H:%M:%S%z"
run_start = [parse(entry) for entry in pdict['run_start']]
api.AddSampleLog(Workspace=wsOutput,
LogName='run_start',
LogText=min(run_start).strftime(fmt),
LogType='String')
# get maximal run_end
run_end = [parse(entry) for entry in pdict['run_end']]
api.AddSampleLog(Workspace=wsOutput,
LogName='run_end',
LogText=max(run_end).strftime(fmt),
LogType='String')
# list of run_numbers
api.AddSampleLog(Workspace=wsOutput,
LogName='run_number',
LogText=str(pdict['run_number']),
LogType='String')
self.setProperty("OutputWorkspace", wsOutput)
def process_incidentmon(self, number, extension, spline_terms=20):
if type(number) is int:
filename = self.get_file_name(number, extension)
works = "monitor{}".format(number)
shared_load_files(extension, filename, works, 4, 4, True)
if extension[:9] == "nxs_event":
temp = "w{}_monitors".format(number)
works = "w{}_monitor4".format(number)
simple.Rebin(InputWorkspace=temp,
OutputWorkspace=temp,
Params='6000,-0.00063,110000',
PreserveEvents=False)
simple.ExtractSingleSpectrum(InputWorkspace=temp,
OutputWorkspace=works,
WorkspaceIndex=3)
else:
num_1, num_2 = split_run_string(number)
works = "monitor{0}_{1}".format(num_1, num_2)
filename = self.get_file_name(num_1, extension)
works1 = "monitor{}".format(num_1)
simple.LoadRaw(Filename=filename,
OutputWorkspace=works1,
SpectrumMin=4,
SpectrumMax=4,
LoadLogFiles="0")
filename = self.get_file_name(num_2, extension)
works2 = "monitor{}".format(num_2)
simple.LoadRaw(Filename=filename,
OutputWorkspace=works2,
SpectrumMin=4,
SpectrumMax=4,
LoadLogFiles="0")
simple.MergeRuns(InputWorkspaces=works1 + "," + works2,
OutputWorkspace=works)
simple.DeleteWorkspace(works1)
simple.DeleteWorkspace(works2)
simple.ConvertUnits(InputWorkspace=works,
OutputWorkspace=works,
Target="Wavelength",
Emode="Elastic")
lambda_min, lambda_max = Wish.LAMBDA_RANGE
simple.CropWorkspace(InputWorkspace=works,
OutputWorkspace=works,
XMin=lambda_min,
XMax=lambda_max)
ex_regions = np.array([[4.57, 4.76], [3.87, 4.12], [2.75, 2.91],
[2.24, 2.50]])
simple.ConvertToDistribution(works)
for reg in range(0, 4):
simple.MaskBins(InputWorkspace=works,
OutputWorkspace=works,
XMin=ex_regions[reg, 0],
XMax=ex_regions[reg, 1])
simple.SplineBackground(InputWorkspace=works,
OutputWorkspace=works,
WorkspaceIndex=0,
NCoeff=spline_terms)
simple.SmoothData(InputWorkspace=works,
OutputWorkspace=works,
NPoints=40)
simple.ConvertFromDistribution(works)
return works
def read(self, number, panel, extension):
if type(number) is int:
filename = self.datafile
logger.notice("will be reading filename...{}".format(filename))
spectra_min, spectra_max = self.return_panel_van.get(panel) if self.is_vanadium else \
self.return_panel.get(panel)
if panel != 0:
output = "w{0}-{1}".format(number, panel)
else:
output = "w{}".format(number)
shared_load_files(extension, filename, output, spectra_max,
spectra_min, False)
if extension == "nxs_event":
simple.LoadEventNexus(Filename=filename,
OutputWorkspace=output,
LoadMonitors='1')
self.read_event_nexus(number, output, panel)
if extension[:10] == "nxs_event_":
label, tmin, tmax = split_string_event(extension)
output = output + "_" + label
if tmax == "end":
simple.LoadEventNexus(Filename=filename,
OutputWorkspace=output,
FilterByTimeStart=tmin,
LoadMonitors='1',
MonitorsAsEvents='1',
FilterMonByTimeStart=tmin)
else:
simple.LoadEventNexus(Filename=filename,
OutputWorkspace=output,
FilterByTimeStart=tmin,
FilterByTimeStop=tmax,
LoadMonitors='1',
MonitorsAsEvents='1',
FilterMonByTimeStart=tmin,
FilterMonByTimeStop=tmax)
self.read_event_nexus(number, output, panel)
else:
num_1, num_2 = split_run_string(number)
output = "w{0}_{1}-{2}".format(num_1, num_2, panel)
output1 = self.load_multi_run_part(extension, num_1, panel)
output2 = self.load_multi_run_part(extension, num_2, panel)
simple.MergeRuns(output1 + "," + output2, output)
simple.DeleteWorkspace(output1)
simple.DeleteWorkspace(output2)
simple.ConvertUnits(InputWorkspace=output,
OutputWorkspace=output,
Target="Wavelength",
Emode="Elastic")
lmin, lmax = Wish.LAMBDA_RANGE
simple.CropWorkspace(InputWorkspace=output,
OutputWorkspace=output,
XMin=lmin,
XMax=lmax)
monitor_run = "monitor{}".format(number)
if monitor_run not in simple.mtd:
monitor = self.process_incidentmon(number,
extension,
spline_terms=70)
else:
monitor = simple.mtd[monitor_run]
simple.NormaliseToMonitor(InputWorkspace=output,
OutputWorkspace=output + "norm1",
MonitorWorkspace=monitor)
simple.NormaliseToMonitor(InputWorkspace=output + "norm1",
OutputWorkspace=output + "norm2",
MonitorWorkspace=monitor,
IntegrationRangeMin=0.7,
IntegrationRangeMax=10.35)
simple.DeleteWorkspace(output)
simple.DeleteWorkspace(output + "norm1")
simple.RenameWorkspace(InputWorkspace=output + "norm2",
OutputWorkspace=output)
simple.ConvertUnits(InputWorkspace=output,
OutputWorkspace=output,
Target="TOF",
EMode="Elastic")
simple.ReplaceSpecialValues(InputWorkspace=output,
OutputWorkspace=output,
NaNValue=0.0,
NaNError=0.0,
InfinityValue=0.0,
InfinityError=0.0)
return output
def _focus_mode_all(output_file_paths, processed_spectra,
attenuation_filepath):
summed_spectra_name = output_file_paths["output_name"] + "_mods1-9"
summed_spectra = mantid.MergeRuns(InputWorkspaces=processed_spectra[:9],
OutputWorkspace=summed_spectra_name)
xList = summed_spectra.readX(0)
summed_spectra = mantid.CropWorkspace(InputWorkspace=summed_spectra,
XMin=xList[1],
Xmax=xList[-2])
summed_spectra = mantid.Scale(InputWorkspace=summed_spectra,
Factor=0.111111111111111,
OutputWorkspace=summed_spectra_name)
if attenuation_filepath:
summed_spectra = _attenuate_workspace(
output_file_paths=output_file_paths,
attenuated_ws=summed_spectra,
attenuation_filepath=attenuation_filepath)
summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra,
Target="TOF",
OutputWorkspace=summed_spectra_name)
mantid.SaveGSS(InputWorkspace=summed_spectra,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=1)
summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra,
Target="dSpacing",
OutputWorkspace=summed_spectra_name)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=summed_spectra,
Append=False)
mantid.SaveFocusedXYE(InputWorkspace=summed_spectra_name,
Filename=output_file_paths["tof_xye_filename"],
Append=False,
IncludeHeader=False)
output_list = [summed_spectra]
for i in range(0, 5):
spectra_index = (i + 9) # Compensate for 0 based index
ws_to_save = processed_spectra[
spectra_index] # Save out workspaces 10/11/12
output_name = output_file_paths["output_name"] + "_mod" + str(
spectra_index + 1)
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save,
OutputWorkspace=ws_to_save,
Target="TOF")
mantid.SaveGSS(InputWorkspace=ws_to_save,
Filename=output_file_paths["gss_filename"],
Append=True,
Bank=i + 2)
splits = output_file_paths["tof_xye_filename"].split(".")
tof_xye_name = splits[0] + "-" + str(i + 10) + "." + splits[1]
mantid.SaveFocusedXYE(InputWorkspace=ws_to_save,
Filename=tof_xye_name,
Append=False,
IncludeHeader=False)
ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save,
OutputWorkspace=output_name,
Target="dSpacing")
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=ws_to_save,
Append=True)
output_list.append(ws_to_save)
return output_list
def _focus_mode_groups(output_file_paths, calibrated_spectra):
output_list = []
to_save = _sum_groups_of_three_ws(calibrated_spectra=calibrated_spectra,
output_file_names=output_file_paths)
workspaces_4_to_9_name = output_file_paths["output_name"] + "_mods4-9"
workspaces_4_to_9 = mantid.MergeRuns(
InputWorkspaces=calibrated_spectra[3:9],
OutputWorkspace=workspaces_4_to_9_name)
xList = workspaces_4_to_9.readX(0)
workspaces_4_to_9 = mantid.CropWorkspace(InputWorkspace=workspaces_4_to_9,
XMin=xList[1],
Xmax=xList[-2])
workspaces_4_to_9 = mantid.Scale(InputWorkspace=workspaces_4_to_9,
Factor=0.5,
OutputWorkspace=workspaces_4_to_9_name)
to_save.append(workspaces_4_to_9)
append = False
index = 1
for ws in to_save:
ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=ws,
Target="TOF")
mantid.SaveGSS(InputWorkspace=ws,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=index)
mantid.SaveFocusedXYE(InputWorkspace=ws,
Filename=output_file_paths["tof_xye_filename"],
Append=False,
IncludeHeader=False)
workspace_names = ws.name()
ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=workspace_names,
Target="dSpacing")
output_list.append(ws)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=ws,
Append=append)
append = True
index += 1
save_range = 5
for i in range(0, save_range):
monitor_ws_name = output_file_paths["output_name"] + "_mod" + str(i +
10)
monitor_ws = calibrated_spectra[i + 9]
to_save = mantid.CloneWorkspace(InputWorkspace=monitor_ws,
OutputWorkspace=monitor_ws_name)
to_save = mantid.ConvertUnits(InputWorkspace=to_save,
OutputWorkspace=to_save,
Target="TOF")
splits = output_file_paths["tof_xye_filename"].split(".")
tof_xye_name = splits[0] + "-" + str(i + 10) + "." + splits[1]
mantid.SaveGSS(InputWorkspace=to_save,
Filename=output_file_paths["gss_filename"],
Append=True,
Bank=i + 5)
mantid.SaveFocusedXYE(InputWorkspace=to_save,
Filename=tof_xye_name,
Append=False,
IncludeHeader=False)
to_save = mantid.ConvertUnits(InputWorkspace=to_save,
OutputWorkspace=monitor_ws_name,
Target="dSpacing")
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=to_save,
Append=True)
output_list.append(to_save)
return output_list
