def _focus_mode_groups(cycle_information, output_file_paths, save_range,
calibrated_spectra):
output_list = []
to_save = _sum_groups_of_three_ws(calibrated_spectra, output_file_paths)
workspaces_4_to_9_name = output_file_paths["output_name"] + "_mods4-9"
workspaces_4_to_9 = mantid.Plus(LHSWorkspace=to_save[1],
RHSWorkspace=to_save[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:
if cycle_information["instrument_version"] == "new":
mantid.SaveGSS(InputWorkspace=ws,
Filename=output_file_paths["gss_filename"],
Append=append,
Bank=index)
elif cycle_information["instrument_version"] == "new2":
mantid.SaveGSS(InputWorkspace=ws,
Filename=output_file_paths["gss_filename"],
Append=False,
Bank=index)
workspace_names = ws.name()
dspacing_ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=workspace_names,
Target="dSpacing")
remove_intermediate_workspace(ws)
output_list.append(dspacing_ws)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=dspacing_ws,
Append=append)
append = True
index += 1
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)
mantid.SaveGSS(InputWorkspace=to_save,
Filename=output_file_paths["gss_filename"],
Append=True,
Bank=i + 5)
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
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 save_focused_data(d_spacing_group, tof_group, output_paths):
"""
Saves out focused data into nxs, GSAS and .dat formats. Requires the grouped workspace
in TOF and dSpacing and the dictionary of output paths generated by abstract_inst.
:param d_spacing_group: The focused workspace group in dSpacing
:param tof_group: The focused workspace group in TOF
:param output_paths: A dictionary containing the full paths to save to
:return: None
"""
def ensure_dir_exists(filename):
dirname = os.path.dirname(filename)
if not os.path.exists(dirname):
os.makedirs(dirname)
return filename
mantid.SaveGSS(InputWorkspace=tof_group,
Filename=ensure_dir_exists(output_paths["gss_filename"]),
SplitFiles=False,
Append=False)
mantid.SaveNexusProcessed(InputWorkspace=tof_group,
Filename=ensure_dir_exists(
output_paths["nxs_filename"]),
Append=False)
_save_xye(ws_group=d_spacing_group,
filename_template=ensure_dir_exists(
output_paths["dspacing_xye_filename"]))
_save_xye(ws_group=tof_group,
filename_template=ensure_dir_exists(
output_paths["tof_xye_filename"]))
def _focus_mode_mods(output_file_paths, calibrated_spectra):
append = False
output_list = []
for index, ws in enumerate(calibrated_spectra):
output_name = output_file_paths["output_name"] + "_mod" + str(index +
1)
tof_ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=output_name,
Target=WORKSPACE_UNITS.tof)
mantid.SaveFocusedXYE(InputWorkspace=tof_ws,
Filename=output_file_paths["tof_xye_filename"],
Append=False,
IncludeHeader=False)
mantid.SaveGSS(InputWorkspace=tof_ws,
Filename=output_file_paths["gss_filename"],
Append=append,
Bank=index + 1)
dspacing_ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=output_name,
Target=WORKSPACE_UNITS.d_spacing)
output_list.append(dspacing_ws)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=dspacing_ws,
Append=append)
append = True
return output_list
def _save_out(run_number, focus_directory, focus_general, output, enginx_file_name_format, bank_id):
"""
save out the files required for the focus
@param run_number :: the run number of the focused run
@param focus_directory :: the user directory to save to
@param focus_general :: the general folder to copy the saved out files to
@param output :: the workspace to save
@param enginx_file_name_format :: the naming scheme of the files
@param bank_id :: the bank being saved
"""
# work out where to save the files
dat_name, genie_filename, gss_name, hdf5_name, nxs_name = _find_focus_file_location(bank_id, focus_directory,
enginx_file_name_format,
run_number)
if not str(bank_id).isnumeric():
bank_id = 0
# save the files out to the user directory
simple.SaveFocusedXYE(InputWorkspace=output, Filename=dat_name, SplitFiles=False,
StartAtBankNumber=bank_id)
simple.SaveGSS(InputWorkspace=output, Filename=gss_name, SplitFiles=False, Bank=bank_id)
simple.SaveOpenGenieAscii(InputWorkspace=output, Filename=genie_filename, OpenGenieFormat="ENGIN-X Format")
simple.SaveNexus(InputWorkspace=output, Filename=nxs_name)
simple.ExportSampleLogsToHDF5(InputWorkspace=output, Filename=hdf5_name, Blacklist="bankid")
if not focus_general == focus_directory:
if not os.path.exists(focus_general):
os.makedirs(focus_general)
# copy the files to the general directory
copy2(dat_name, focus_general)
copy2(gss_name, focus_general)
copy2(genie_filename, focus_general)
copy2(nxs_name, focus_general)
copy2(hdf5_name, focus_general)
def write_gss_file(ws_name_list, gss_file_name):
"""
Write a MatrixWorkspace to a GSAS file
Args:
workspace:
gss_file_name:
Returns:
"""
# check
assert isinstance(ws_name_list, list) and len(ws_name_list) > 1, \
'There must be at least 2 workspaces for conjoining operation.'
assert isinstance(gss_file_name, str)
# write with appending
append_mode = False
for i_ws, ws_name in enumerate(ws_name_list):
simpleapi.SaveGSS(InputWorkspace=ws_name,
Filename=gss_file_name,
Format='SLOG',
Bank=1,
Append=append_mode)
append_mode = True
# END-FOR
return
def save_combined_panel(self, run, panel):
panel_combination = {5: 6, 4: 7, 3: 8, 2: 9, 1: 10}
input_ws1 = "w{0}-{1}foc".format(run, panel)
input_ws2 = "w{0}-{1}foc".format(run, panel_combination.get(panel))
combined = "{0}{1}-{2}_{3}foc{4}".format("{0}", run, panel,
panel_combination.get(panel),
"{1}")
combined_save = combined.format("", "{}")
combined_ws = combined.format("w", "")
simple.RebinToWorkspace(WorkspaceToRebin=input_ws2,
WorkspaceToMatch=input_ws1,
OutputWorkspace=input_ws2,
PreserveEvents='0')
simple.Plus(LHSWorkspace=input_ws1,
RHSWorkspace=input_ws2,
OutputWorkspace=combined_ws)
simple.ConvertUnits(InputWorkspace=combined_ws,
OutputWorkspace=combined_ws + "-d",
Target="dSpacing",
EMode="Elastic")
simple.SaveGSS(combined_ws,
os.path.join(self.user_directory,
combined_save.format("raw.gss")),
Append=False,
Bank=1)
simple.SaveFocusedXYE(
combined_ws,
os.path.join(self.user_directory, combined_save.format("raw.dat")))
simple.SaveNexusProcessed(
combined_ws,
os.path.join(self.user_directory, combined_save.format("raw.nxs")))
def _focus_mode_all(output_file_paths, calibrated_spectra):
first_spectrum = calibrated_spectra[0]
summed_spectra = mantid.CloneWorkspace(InputWorkspace=first_spectrum)
for i in range(1, 9): # TODO why is this 1-8
summed_spectra = mantid.Plus(LHSWorkspace=summed_spectra,
RHSWorkspace=calibrated_spectra[i])
summed_spectra_name = output_file_paths["output_name"] + "_mods1-9"
summed_spectra = mantid.Scale(InputWorkspace=summed_spectra,
Factor=0.111111111111111,
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, 3):
spectra_index = (
i + 9
) # We want workspaces 10/11/12 so compensate for 0 based index
ws_to_save = calibrated_spectra[
spectra_index] # Save out workspaces 10/11/12
output_name = output_file_paths["output_name"] + "_mod" + str(
spectra_index + 1)
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")
output_list.append(ws_to_save)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=ws_to_save,
Append=True)
return output_list
def _focus_mode_trans(output_file_paths, atten, instrument,
calibrated_spectra):
summed_ws = mantid.CloneWorkspace(InputWorkspace=calibrated_spectra[0])
for i in range(1, 9): # Add workspaces 2-9 to workspace 1
summed_ws = mantid.Plus(LHSWorkspace=summed_ws,
RHSWorkspace=calibrated_spectra[i])
summed_ws = mantid.Scale(InputWorkspace=summed_ws,
Factor=0.111111111111111)
if atten:
# Clone a workspace which is not attenuated
no_att = output_file_paths["output_name"] + "_noatten"
mantid.CloneWorkspace(InputWorkspace=summed_ws, OutputWorkspace=no_att)
summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws,
Target="dSpacing")
summed_ws = instrument._attenuate_workspace(summed_ws)
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_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 save_mantid_gsas(gsas_ws_name, gda_file_name, binning_parameters):
"""
Save temporary GSAS file
:param gsas_ws_name:
:param gda_file_name:
:param binning_parameters:
:return:
"""
temp1_ws = ADS.retrieve(gsas_ws_name)
print('[DB...BAT] Before aligned {0}.. vec x: {1}... is histograms? {2}'
''.format(type(temp1_ws),
temp1_ws.readX(2)[0], temp1_ws.isHistogramData()))
aligned_gss_ws_name = '{0}_temp'.format(gsas_ws_name)
if isinstance(binning_parameters, numpy.ndarray):
# align to VDRIVE
align_to_vdrive_bin(gsas_ws_name, binning_parameters,
aligned_gss_ws_name)
elif binning_parameters is not None:
api.Rebin(InputWorkspace=gsas_ws_name,
OutputWorkspace=aligned_gss_ws_name,
Params=binning_parameters)
# END-IF (rebin)
aws = ADS.retrieve(aligned_gss_ws_name)
print('[DB...INFO] Save Mantid GSS: {} is histogram: {}'.format(
aligned_gss_ws_name, aws.isHistogramData()))
# Convert from PointData to Histogram
api.ConvertToHistogram(InputWorkspace=aligned_gss_ws_name,
OutputWorkspace=aligned_gss_ws_name)
# Save
print('[DB...VERY IMPORTANT] Save to GSAS File {0} as a temporary output'.
format(gda_file_name))
curr_ws = ADS.retrieve(aligned_gss_ws_name)
print(
'[DB...INFO] Into SaveGSS: number of histograms = {}, Bank 1/2 size = {}, Bank3 size = {}'
''.format(curr_ws.getNumberHistograms(), len(curr_ws.readX(0)),
len(curr_ws.readX(2))))
print('[DB...INFO] B1[0] = {}, B1[-1] = {}, B3[0] = {}, B3[-1] = {}'
''.format(
curr_ws.readX(0)[0],
curr_ws.readX(0)[-1],
curr_ws.readX(2)[0],
curr_ws.readX(2)[-1]))
api.SaveGSS(InputWorkspace=aligned_gss_ws_name,
Filename=gda_file_name,
SplitFiles=False,
Append=False,
Format="SLOG",
MultiplyByBinWidth=False,
ExtendedHeader=False,
UseSpectrumNumberAsBankID=True)
return gda_file_name
def _save_output_files(focus_dirs,
sample_ws_foc,
calibration,
van_run,
rb_num=None):
# set bankid for use in fit tab
foc_suffix = calibration.get_foc_ws_suffix()
xunit = sample_ws_foc.getDimension(0).name
xunit_suffix = XUNIT_SUFFIXES[xunit]
sample_run_no = sample_ws_foc.run().get('run_number').value
# save all spectra to single ASCII files
ascii_fname = _generate_output_file_name(calibration.get_instrument(),
sample_run_no,
van_run,
calibration.get_group_suffix(),
xunit_suffix,
ext='')
for focus_dir in focus_dirs:
if not path.exists(focus_dir):
makedirs(focus_dir)
mantid.SaveGSS(InputWorkspace=sample_ws_foc,
Filename=path.join(focus_dir, ascii_fname + '.gss'),
SplitFiles=False,
UseSpectrumNumberAsBankID=True)
mantid.SaveFocusedXYE(InputWorkspace=sample_ws_foc,
Filename=path.join(focus_dir,
ascii_fname + ".abc"),
SplitFiles=False,
Format="TOPAS")
# Save nxs per spectrum
nxs_paths = []
mantid.AddSampleLog(Workspace=sample_ws_foc,
LogName="Vanadium Run",
LogText=van_run)
for ispec in range(sample_ws_foc.getNumberHistograms()):
# add a bankid and vanadium to log that is read by fitting model
bankid = foc_suffix if sample_ws_foc.getNumberHistograms(
) == 1 else f'{foc_suffix}_{ispec + 1}'
mantid.AddSampleLog(Workspace=sample_ws_foc,
LogName="bankid",
LogText=bankid.replace('_', ' ')) # overwrites
# save spectrum as nexus
filename = _generate_output_file_name(calibration.get_instrument(),
sample_run_no,
van_run,
bankid,
xunit_suffix,
ext=".nxs")
nxs_path = path.join(focus_dir, filename)
mantid.SaveNexus(InputWorkspace=sample_ws_foc,
Filename=nxs_path,
WorkspaceIndexList=[ispec])
nxs_paths.append(nxs_path)
return nxs_paths # from last focus_dir only
def _saveGSAS(self, gsaws, gdafilename):
""" Save file
"""
# Convert from PointData to Histogram
gsaws = api.ConvertToHistogram(InputWorkspace=gsaws,
OutputWorkspace=str(gsaws))
# Save
api.SaveGSS(InputWorkspace=gsaws, Filename=gdafilename, SplitFiles=False, Append=False,\
Format="SLOG", MultiplyByBinWidth=False, ExtendedHeader=False, UseSpectrumNumberAsBankID=True)
return gsaws
def savePDFile(self, exp, scan, filetype, sfilename):
""" Save a reduced workspace to gsas/fullprof/topaz data file
"""
# get workspace
wsmanager = self.getWorkspace(exp, scan, raiseexception=True)
if wsmanager.reducedws is None:
raise NotImplementedError(
"Unable to rebin the data for exp=%d, scan=%d because \
either data MD workspace and monitor MD workspace is not present."
% (exp, scan))
else:
wksp = wsmanager.reducedws
# save
filetype = filetype.lower()
if "gsas" in filetype:
if sfilename.endswith('.dat') is True:
sfilename.replace('.dat', '.gsa')
api.SaveGSS(InputWorkspace=wksp,
Filename=sfilename,
SplitFiles=False,
Append=False,
MultiplyByBinWidth=False,
Bank=1,
Format="SLOG",
ExtendedHeader=True)
# ENDIF
if "fullprof" in filetype:
if sfilename.endswith('.gsa') is True:
sfilename.replace('.gsa', '.dat')
api.SaveFocusedXYE(InputWorkspace=wksp,
StartAtBankNumber=1,
Filename=sfilename)
# ENDIF
if "topas" in filetype:
sfilename = sfilename[:-4] + ".xye"
api.SaveFocusedXYE(InputWorkspace=wksp,
StartAtBankNumber=info["bank"],
Filename=sfilename,
Format="TOPAS")
# ENDIF
return
def save_gsas(self, output_workspace, gsas_file_name, ipts_number,
parm_file_name):
"""
save (rebinned) workspace to GSAS file
:param output_workspace:
:param gsas_file_name:
:param ipts_number:
:param parm_file_name:
:return:
"""
# check that workspace shall be point data
if output_workspace.isHistogramData():
raise RuntimeError(
'Output workspace shall be point data at this stage.')
# construct the headers
vulcan_gsas_header = self.create_vulcan_gsas_header(
output_workspace, gsas_file_name, ipts_number, parm_file_name)
vulcan_bank_headers = list()
for ws_index in range(output_workspace.getNumberHistograms()):
bank_id = output_workspace.getSpectrum(ws_index).getSpectrumNo()
bank_header = self.create_bank_header(
bank_id, output_workspace.readX(ws_index))
vulcan_bank_headers.append(bank_header)
# END-F
# Save
try:
api.SaveGSS(InputWorkspace=output_workspace,
Filename=gsas_file_name,
SplitFiles=False,
Append=False,
Format="SLOG",
MultiplyByBinWidth=False,
ExtendedHeader=False,
UserSpecifiedGSASHeader=vulcan_gsas_header,
UserSpecifiedBankHeader=vulcan_bank_headers,
UseSpectrumNumberAsBankID=True,
SLOGXYEPrecision=[1, 1, 2])
except RuntimeError as run_err:
raise RuntimeError(
'Failed to call SaveGSS() due to {0}'.format(run_err))
return
def _save_out(run_number, focus_directory, focus_general, output, join_string,
bank_id):
"""
save out the files required for the focus
@param run_number :: the run number of the focused run
@param focus_directory :: the user directory to save to
@param focus_general :: the general folder to copy the saved out files to
@param output :: the workspace to save
@param join_string :: the nameing scheme of the files
@param bank_id :: the bank being saved
"""
# work out where to save the files
filename = os.path.join(focus_directory,
join_string.format(run_number, bank_id))
hdf5_name = os.path.join(focus_directory, run_number + ".hdf5")
if not unicode(bank_id).isnumeric():
bank_id = 0
# save the files out to the user directory
simple.SaveFocusedXYE(InputWorkspace=output,
Filename=filename + ".dat",
SplitFiles=False,
StartAtBankNumber=bank_id)
simple.SaveGSS(InputWorkspace=output,
Filename=filename + ".gss",
SplitFiles=False,
Bank=bank_id)
simple.SaveOpenGenieAscii(InputWorkspace=output,
Filename=filename + ".his",
OpenGenieFormat="ENGIN-X Format")
simple.SaveNexus(InputWorkspace=output, Filename=filename + ".nxs")
simple.ExportSampleLogsToHDF5(InputWorkspace=output,
Filename=hdf5_name,
Blacklist="bankid")
if not focus_general == focus_directory:
if not os.path.exists(focus_general):
os.makedirs(focus_general)
# copy the files to the general directory
copy2(filename + ".dat", focus_general)
copy2(filename + ".gss", focus_general)
copy2(filename + ".his", focus_general)
copy2(filename + ".nxs", focus_general)
copy2(hdf5_name, focus_general)
def save_focused_data(d_spacing_group, tof_group, output_paths,
run_number_string, inst_prefix, file_ext):
"""
Saves out focused data into nxs, GSAS and .dat formats. Requires the grouped workspace
in TOF and dSpacing, the a dictionary of output paths generated by abstract_inst,
the user inputted run number string and the prefix of the instrument.
:param d_spacing_group: The focused workspace group in dSpacing
:param tof_group: The focused workspace group in TOF
:param output_paths: A dictionary containing the full paths to save to
:param run_number_string: The user input run number(s) as a string to generate output name
:param inst_prefix: The instrument prefix to generate output name
:return: None
"""
mantid.SaveGSS(InputWorkspace=tof_group,
Filename=output_paths["gss_filename"],
SplitFiles=False,
Append=False)
mantid.SaveNexusProcessed(InputWorkspace=tof_group,
Filename=output_paths["nxs_filename"],
Append=False)
dat_folder_name = "dat_files"
dat_file_destination = os.path.join(output_paths["output_folder"],
dat_folder_name)
if not os.path.exists(dat_file_destination):
os.makedirs(dat_file_destination)
_save_xye(ws_group=d_spacing_group,
ws_units="d",
run_number=run_number_string,
output_folder=dat_file_destination,
inst_prefix=inst_prefix,
file_ext=file_ext)
_save_xye(ws_group=tof_group,
ws_units="TOF",
run_number=run_number_string,
output_folder=dat_file_destination,
inst_prefix=inst_prefix,
file_ext=file_ext)
def _focus_mode_mods(output_file_paths, calibrated_spectra):
index = 1
append = False
output_list = []
for ws in calibrated_spectra:
mantid.SaveGSS(InputWorkspace=ws,
Filename=output_file_paths["gss_filename"],
Append=append,
Bank=index)
output_name = output_file_paths["output_name"] + "_mod" + str(index)
dspacing_ws = mantid.ConvertUnits(InputWorkspace=ws,
OutputWorkspace=output_name,
Target="dSpacing")
output_list.append(dspacing_ws)
mantid.SaveNexus(Filename=output_file_paths["nxs_filename"],
InputWorkspace=dspacing_ws,
Append=append)
append = True
index += 1
return output_list
def process_run(self,
number,
panel,
extension,
cycle_vana="09_4",
absorb=False,
number_density=0.0,
scattering=0.0,
attenuation=0.0,
height=0.0,
radius=0.0):
ws_to_focus = self.read(number, panel, extension)
if absorb:
absorption_corrections(attenuation, height, number_density, radius,
scattering, ws_to_focus)
focused_ws = self.focus(ws_to_focus, panel)
panel_crop = {
1: (0.8, 53.3),
2: (0.5, 13.1),
3: (0.5, 7.77),
4: (0.4, 5.86),
5: (0.35, 4.99),
6: (0.35, 4.99),
7: (0.4, 5.86),
8: (0.5, 7.77),
9: (0.5, 13.1),
10: (0.8, 53.3)
}
d_min, d_max = panel_crop.get(panel)
simple.CropWorkspace(InputWorkspace=focused_ws,
OutputWorkspace=focused_ws,
XMin=d_min,
XMax=d_max)
save_location = os.path.join(self.user_directory, "{0}-{1}{2}.{3}")
if panel == 0:
for panel_i in range(Wish.NUM_PANELS):
focused_ws = "w{0}-{1}foc".format(number, panel_i)
simple.CropWorkspace(InputWorkspace=focused_ws,
OutputWorkspace=focused_ws,
XMin=d_min,
XMax=d_max)
logger.notice(
"will try to load a vanadium with the name: {}".format(
self.get_vanadium(panel_i, cycle_vana)))
self.apply_vanadium_corrections(cycle_vana, panel_i,
focused_ws)
simple.SaveGSS(InputWorkspace=focused_ws,
Filename=save_location.format(
number, panel_i, extension, "gss"),
Append=False,
Bank=1)
simple.SaveFocusedXYE(
focused_ws,
save_location.format(number, panel_i, extension, "dat"))
simple.SaveNexusProcessed(
focused_ws,
save_location.format(number, panel_i, extension, "nxs"))
else:
logger.notice(
"will try to load a vanadium with the name: {}".format(
self.get_vanadium(panel, cycle_vana)))
self.apply_vanadium_corrections(cycle_vana, panel, focused_ws)
simple.SaveGSS(InputWorkspace=focused_ws,
Filename=save_location.format(
number, panel, extension, "gss"),
Append=False,
Bank=1)
simple.SaveFocusedXYE(
focused_ws,
save_location.format(number, panel, extension, "dat"))
simple.SaveNexusProcessed(
focused_ws,
save_location.format(number, panel, extension, "nxs"))
return focused_ws
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
