def _add_log_to_workspace(self, ws, log_name, log_value):
if isinstance(log_value, list):
ws.mutableRun()[log_name] = self._create_time_series_log(
log_name, log_value)
else:
mantid.AddSampleLog(
Workspace=ws,
LogName=log_name,
LogText=str(log_value),
LogType="String" if isinstance(log_value, str) else "Number")
def test_subtract_summed_runs_throw_on_tof_mismatch(self):
# Create a sample workspace which will have mismatched TOF range
sample_ws = mantid.CreateSampleWorkspace()
mantid.AddSampleLog(Workspace=sample_ws, LogName='gd_prtn_chrg', LogText="10.0", LogType='Number')
ws_file_name = "100" # Load POL100
# This should throw as the TOF ranges do not match
with assertRaisesRegex(self, ValueError, "specified for this file do not have matching binning. Do the "):
common.subtract_summed_runs(ws_to_correct=sample_ws, instrument=ISISPowderMockInst(),
empty_sample_ws_string=ws_file_name)
mantid.DeleteWorkspace(sample_ws)
def test_DNSSameNormalization(self):
outputWorkspaceName = "DNSMergeRunsTest_Test2"
ws = api.AnalysisDataService.retrieve(self.workspaces[0])
api.AddSampleLog(ws,
LogName='normalized',
LogText='no',
LogType='String')
self.assertRaises(RuntimeError,
DNSMergeRuns,
WorkspaceNames=self.workspaces,
OutputWorkspace=outputWorkspaceName)
return
def test_DNSSameWavelength(self):
outputWorkspaceName = "DNSMergeRunsTest_Test1"
ws = api.AnalysisDataService.retrieve(self.workspaces[0])
api.AddSampleLog(ws,
LogName='wavelength',
LogText=str(5.0),
LogType='Number',
LogUnit='Angstrom')
self.assertRaises(RuntimeError,
DNSMergeRuns,
WorkspaceNames=self.workspaces,
OutputWorkspace=outputWorkspaceName)
return
def test_run_normalise_by_current(self):
initial_value = 17
prtn_charge = '10.0'
expected_value = initial_value / float(prtn_charge)
# Create two workspaces
ws = mantid.CreateWorkspace(DataX=0, DataY=initial_value)
# Add Good Proton Charge Log
mantid.AddSampleLog(Workspace=ws, LogName='gd_prtn_chrg', LogText=prtn_charge, LogType='Number')
self.assertEqual(initial_value, ws.dataY(0)[0])
common.run_normalise_by_current(ws)
self.assertAlmostEqual(expected_value, ws.dataY(0)[0], delta=1e-8)
def test_unitAreAddedIfPresent(self):
input_ws = self._create_sample_workspace()
mantid.AddSampleLog(Workspace=input_ws,
LogName="TestLog",
LogText="1",
LogType="Number",
LogUnit="uAmps")
run_algorithm(self.ALG_NAME,
InputWorkspace=input_ws,
Filename=self.TEMP_FILE_NAME)
with h5py.File(self.TEMP_FILE_NAME, "r") as output_file:
logs_group = output_file["Sample Logs"]
self.assertEqual(logs_group["TestLog"].attrs["Units"], "uAmps")
def test_DNSPolarisationValid(self):
outputWorkspaceName = "DNSFlippingRatioCorrTest_Test3"
api.AddSampleLog(Workspace=self.__nsf_nicrws,
LogName='polarisation',
LogText='y',
LogType='String')
self.assertRaises(RuntimeError,
DNSFlippingRatioCorr,
SFDataWorkspace=self.__sf_nicrws.getName(),
NSFDataWorkspace=self.__nsf_nicrws.getName(),
SFNiCrWorkspace=self.__sf_nicrws.getName(),
NSFNiCrWorkspace=self.__nsf_nicrws.getName(),
SFBkgrWorkspace=self.__sf_bkgrws.getName(),
NSFBkgrWorkspace=self.__nsf_bkgrws.getName(),
SFOutputWorkspace=outputWorkspaceName + 'SF',
NSFOutputWorkspace=outputWorkspaceName + 'NSF')
return
def test_no_warning_raised_explicitly_dimensionless_run_log(self):
import mantid.simpleapi as mantid
target = mantid.CloneWorkspace(self.base_event_ws)
with warnings.catch_warnings(record=True) as caught_warnings:
scn.mantid.convert_EventWorkspace_to_data_array(target, False)
original_number_of_warnings = len(caught_warnings)
# Add an explicitly dimensionless log
mantid.AddSampleLog(Workspace=target,
LogName='dimensionless_log',
LogText='1',
LogType='Number',
LogUnit='dimensionless')
with warnings.catch_warnings(record=True) as caught_warnings:
scn.mantid.convert_EventWorkspace_to_data_array(target, False)
assert len(caught_warnings) == original_number_of_warnings,\
"Expected no extra warning about unrecognised units " \
"from explicitly dimensionless log"
def test_subtract_summed_runs(self):
# Load a vanadium workspace for this test
sample_empty_number = "100"
ws_file_name = "POL" + sample_empty_number
original_ws = mantid.Load(ws_file_name)
# add a current to ensure subtract_summed_runs gets past initial check
mantid.AddSampleLog(Workspace=original_ws,
LogName='gd_prtn_chrg',
LogText="10.0",
LogType='Number')
no_scale_ws = mantid.CloneWorkspace(InputWorkspace=original_ws)
empty_ws = mantid.CloneWorkspace(InputWorkspace=original_ws)
empty_ws = empty_ws * 0.3
returned_ws = common.subtract_summed_runs(ws_to_correct=no_scale_ws,
empty_sample=empty_ws)
y_values = returned_ws.readY(0)
original_y_values = original_ws.readY(0)
for i in range(returned_ws.blocksize()):
self.assertAlmostEqual(y_values[i], original_y_values[i] * 0.7)
mantid.DeleteWorkspace(no_scale_ws)
mantid.DeleteWorkspace(empty_ws)
mantid.DeleteWorkspace(returned_ws)
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 PyExec(self):
# Input
filename = self.getPropertyValue("Filename")
outws_name = self.getPropertyValue("OutputWorkspace")
norm = self.getPropertyValue("Normalization")
# load data array from the given file
data_array = np.loadtxt(filename)
if not data_array.size:
message = "File " + filename + " does not contain any data!"
self.log().error(message)
raise RuntimeError(message)
# sample logs
logs = {"names": [], "values": [], "units": []}
# load run information
metadata = DNSdata()
try:
metadata.read_legacy(filename)
except RuntimeError as err:
message = "Error of loading of file " + filename + ": " + str(err)
self.log().error(message)
raise RuntimeError(message)
tmp = api.LoadEmptyInstrument(InstrumentName='DNS')
self.instrument = tmp.getInstrument()
api.DeleteWorkspace(tmp)
# load polarisation table and determine polarisation
poltable = self.get_polarisation_table()
pol = self.get_polarisation(metadata, poltable)
if not pol:
pol = ['0', 'undefined']
self.log().warning("Failed to determine polarisation for " +
filename +
". Values have been set to undefined.")
ndet = 24
unitX = "Wavelength"
if metadata.tof_channel_number < 2:
dataX = np.zeros(2 * ndet)
dataX.fill(metadata.wavelength + 0.00001)
dataX[::2] -= 0.000002
else:
unitX = "TOF"
# get instrument parameters
l1 = np.linalg.norm(self.instrument.getSample().getPos() -
self.instrument.getSource().getPos())
self.log().notice("L1 = {} m".format(l1))
dt_factor = float(
self.instrument.getStringParameter("channel_width_factor")[0])
# channel width
dt = metadata.tof_channel_width * dt_factor
# calculate tof1
velocity = h / (m_n * metadata.wavelength * 1e-10) # m/s
tof1 = 1e+06 * l1 / velocity # microseconds
self.log().debug("TOF1 = {} microseconds".format(tof1))
self.log().debug("Delay time = {} microsecond".format(
metadata.tof_delay_time))
# create dataX array
x0 = tof1 + metadata.tof_delay_time
self.log().debug("TOF1 = {} microseconds".format(tof1))
dataX = np.linspace(x0, x0 + metadata.tof_channel_number * dt,
metadata.tof_channel_number + 1)
# sample logs
logs["names"].extend(
["channel_width", "TOF1", "delay_time", "tof_channels"])
logs["values"].extend([
dt, tof1, metadata.tof_delay_time, metadata.tof_channel_number
])
logs["units"].extend(
["microseconds", "microseconds", "microseconds", ""])
if metadata.tof_elastic_channel:
logs["names"].append("EPP")
logs["values"].append(metadata.tof_elastic_channel)
logs["units"].append("")
if metadata.chopper_rotation_speed:
logs["names"].append("chopper_speed")
logs["values"].append(metadata.chopper_rotation_speed)
logs["units"].append("Hz")
if metadata.chopper_slits:
logs["names"].append("chopper_slits")
logs["values"].append(metadata.chopper_slits)
logs["units"].append("")
# data normalization
factor = 1.0
yunit = "Counts"
ylabel = "Intensity"
if norm == 'duration':
factor = metadata.duration
yunit = "Counts/s"
ylabel = "Intensity normalized to duration"
if factor <= 0:
raise RuntimeError("Duration is invalid for file " + filename +
". Cannot normalize.")
if norm == 'monitor':
factor = metadata.monitor_counts
yunit = "Counts/monitor"
ylabel = "Intensity normalized to monitor"
if factor <= 0:
raise RuntimeError("Monitor counts are invalid for file " +
filename + ". Cannot normalize.")
# set values for dataY and dataE
dataY = data_array[0:ndet, 1:] / factor
dataE = np.sqrt(data_array[0:ndet, 1:]) / factor
# create workspace
api.CreateWorkspace(OutputWorkspace=outws_name,
DataX=dataX,
DataY=dataY,
DataE=dataE,
NSpec=ndet,
UnitX=unitX)
outws = api.AnalysisDataService.retrieve(outws_name)
api.LoadInstrument(outws, InstrumentName='DNS', RewriteSpectraMap=True)
run = outws.mutableRun()
if metadata.start_time and metadata.end_time:
run.setStartAndEndTime(DateAndTime(metadata.start_time),
DateAndTime(metadata.end_time))
# add name of file as a run title
fname = os.path.splitext(os.path.split(filename)[1])[0]
run.addProperty('run_title', fname, True)
# rotate the detector bank to the proper position
api.RotateInstrumentComponent(outws,
"bank0",
X=0,
Y=1,
Z=0,
Angle=metadata.deterota)
# add sample log Ei and wavelength
logs["names"].extend(["Ei", "wavelength"])
logs["values"].extend([metadata.incident_energy, metadata.wavelength])
logs["units"].extend(["meV", "Angstrom"])
# add other sample logs
logs["names"].extend([
"deterota", "mon_sum", "duration", "huber", "omega", "T1", "T2",
"Tsp"
])
logs["values"].extend([
metadata.deterota, metadata.monitor_counts, metadata.duration,
metadata.huber, metadata.huber - metadata.deterota, metadata.temp1,
metadata.temp2, metadata.tsp
])
logs["units"].extend([
"Degrees", "Counts", "Seconds", "Degrees", "Degrees", "K", "K", "K"
])
# flipper, coil currents and polarisation
flipper_status = 'OFF' # flipper OFF
if abs(metadata.flipper_precession_current) > sys.float_info.epsilon:
flipper_status = 'ON' # flipper ON
logs["names"].extend([
"flipper_precession", "flipper_z_compensation", "flipper", "C_a",
"C_b", "C_c", "C_z", "polarisation", "polarisation_comment"
])
logs["values"].extend([
metadata.flipper_precession_current,
metadata.flipper_z_compensation_current, flipper_status,
metadata.a_coil_current, metadata.b_coil_current,
metadata.c_coil_current, metadata.z_coil_current,
str(pol[0]),
str(pol[1])
])
logs["units"].extend(["A", "A", "", "A", "A", "A", "A", "", ""])
# slits
logs["names"].extend([
"slit_i_upper_blade_position", "slit_i_lower_blade_position",
"slit_i_left_blade_position", "slit_i_right_blade_position"
])
logs["values"].extend([
metadata.slit_i_upper_blade_position,
metadata.slit_i_lower_blade_position,
metadata.slit_i_left_blade_position,
metadata.slit_i_right_blade_position
])
logs["units"].extend(["mm", "mm", "mm", "mm"])
# add information whether the data are normalized (duration/monitor/no):
api.AddSampleLog(outws,
LogName='normalized',
LogText=norm,
LogType='String')
api.AddSampleLogMultiple(outws,
LogNames=logs["names"],
LogValues=logs["values"],
LogUnits=logs["units"])
outws.setYUnit(yunit)
outws.setYUnitLabel(ylabel)
self.setProperty("OutputWorkspace", outws)
self.log().debug('LoadDNSLegacy: data are loaded to the workspace ' +
outws_name)
return
def PyExec(self):
if not self._use_corrections:
logger.information('Not using corrections')
if not self._use_can:
logger.information('Not using container')
prog_container = Progress(self, start=0.0, end=0.2, nreports=4)
prog_container.report('Starting algorithm')
# Units should be wavelength
sample_unit = self._sample_workspace.getAxis(0).getUnit().unitID()
sample_ws_wavelength = self._convert_units_wavelength(
self._sample_workspace)
container_ws_wavelength = (self._process_container_workspace(
self._container_workspace, prog_container)
if self._use_can else None)
prog_corr = Progress(self, start=0.2, end=0.6, nreports=2)
if self._use_corrections:
prog_corr.report('Preprocessing corrections')
if self._use_can:
# Use container factors
prog_corr.report('Correcting sample and container')
factor_workspaces = self._get_factor_workspaces()
output_workspace = self._correct_sample_can(
sample_ws_wavelength, container_ws_wavelength,
factor_workspaces)
correction_type = 'sample_and_can_corrections'
else:
# Use sample factor only
output_workspace = self._correct_sample(
sample_ws_wavelength, self._corrections_workspace[0])
correction_type = 'sample_corrections_only'
# Add corrections filename to log values
prog_corr.report('Correcting sample')
s_api.AddSampleLog(Workspace=output_workspace,
LogName='corrections_filename',
LogType='String',
LogText=self._corrections_ws_name)
else:
# Do simple subtraction
output_workspace = self._subtract(sample_ws_wavelength,
container_ws_wavelength)
correction_type = 'can_subtraction'
# Add container filename to log values
can_base = self.getPropertyValue("CanWorkspace")
can_base = can_base[:can_base.index('_')]
prog_corr.report('Adding container filename')
s_api.AddSampleLog(Workspace=output_workspace,
LogName='container_filename',
LogType='String',
LogText=can_base)
prog_wrkflow = Progress(self, 0.6, 1.0, nreports=5)
# Record the container scale factor
if self._use_can and self._scale_can:
prog_wrkflow.report('Adding container scaling')
s_api.AddSampleLog(Workspace=output_workspace,
LogName='container_scale',
LogType='Number',
LogText=str(self._can_scale_factor))
# Record the container shift amount
if self._use_can and self._shift_can:
prog_wrkflow.report('Adding container shift')
s_api.AddSampleLog(Workspace=output_workspace,
LogName='container_shift',
LogType='Number',
LogText=str(self._can_shift_factor))
# Record the type of corrections applied
prog_wrkflow.report('Adding correction type')
s_api.AddSampleLog(Workspace=output_workspace,
LogName='corrections_type',
LogType='String',
LogText=correction_type)
# Add original sample as log entry
sam_base = self.getPropertyValue("SampleWorkspace")
if '_' in sam_base:
sam_base = sam_base[:sam_base.index('_')]
prog_wrkflow.report('Adding sample filename')
s_api.AddSampleLog(Workspace=output_workspace,
LogName='sample_filename',
LogType='String',
LogText=sam_base)
# Convert Units back to original
emode = str(output_workspace.getEMode())
efixed = 0.0
if emode == "Indirect":
efixed = self._get_e_fixed(output_workspace)
output_workspace = self._convert_units(output_workspace, sample_unit,
emode, efixed)
self.setProperty('OutputWorkspace', output_workspace)
prog_wrkflow.report('Algorithm Complete')
def PyExec(self):
# Input
filename = self.getPropertyValue("Filename")
outws_name = self.getPropertyValue("OutputWorkspace")
norm = self.getPropertyValue("Normalization")
# load data array from the given file
data_array = np.loadtxt(filename)
if not data_array.size:
message = "File " + filename + " does not contain any data!"
self.log().error(message)
raise RuntimeError(message)
# load run information
metadata = DNSdata()
try:
metadata.read_legacy(filename)
except RuntimeError as err:
message = "Error of loading of file " + filename + ": " + str(err)
self.log().error(message)
raise RuntimeError(message)
# load polarisation table and determine polarisation
poltable = self.get_polarisation_table()
pol = self.get_polarisation(metadata, poltable)
if not pol:
pol = ['0', 'undefined']
self.log().warning("Failed to determine polarisation for " + filename +
". Values have been set to undefined.")
ndet = 24
# this needed to be able to use ConvertToMD
dataX = np.zeros(2*ndet)
dataX.fill(metadata.wavelength + 0.00001)
dataX[::2] -= 0.000002
# data normalization
factor = 1.0
yunit = "Counts"
ylabel = "Intensity"
if norm == 'duration':
factor = metadata.duration
yunit = "Counts/s"
ylabel = "Intensity normalized to duration"
if factor <= 0:
raise RuntimeError("Duration is invalid for file " + filename + ". Cannot normalize.")
if norm == 'monitor':
factor = metadata.monitor_counts
yunit = "Counts/monitor"
ylabel = "Intensity normalized to monitor"
if factor <= 0:
raise RuntimeError("Monitor counts are invalid for file " + filename + ". Cannot normalize.")
# set values for dataY and dataE
dataY = data_array[0:ndet, 1:]/factor
dataE = np.sqrt(data_array[0:ndet, 1:])/factor
# create workspace
api.CreateWorkspace(OutputWorkspace=outws_name, DataX=dataX, DataY=dataY,
DataE=dataE, NSpec=ndet, UnitX="Wavelength")
outws = api.AnalysisDataService.retrieve(outws_name)
api.LoadInstrument(outws, InstrumentName='DNS', RewriteSpectraMap=True)
run = outws.mutableRun()
if metadata.start_time and metadata.end_time:
run.setStartAndEndTime(DateAndTime(metadata.start_time),
DateAndTime(metadata.end_time))
# add name of file as a run title
fname = os.path.splitext(os.path.split(filename)[1])[0]
run.addProperty('run_title', fname, True)
# rotate the detector bank to the proper position
api.RotateInstrumentComponent(outws, "bank0", X=0, Y=1, Z=0, Angle=metadata.deterota)
# add sample log Ei and wavelength
api.AddSampleLog(outws, LogName='Ei', LogText=str(metadata.incident_energy),
LogType='Number', LogUnit='meV')
api.AddSampleLog(outws, LogName='wavelength', LogText=str(metadata.wavelength),
LogType='Number', LogUnit='Angstrom')
# add other sample logs
api.AddSampleLog(outws, LogName='deterota', LogText=str(metadata.deterota),
LogType='Number', LogUnit='Degrees')
api.AddSampleLog(outws, 'mon_sum',
LogText=str(float(metadata.monitor_counts)), LogType='Number')
api.AddSampleLog(outws, LogName='duration', LogText=str(metadata.duration),
LogType='Number', LogUnit='Seconds')
api.AddSampleLog(outws, LogName='huber', LogText=str(metadata.huber),
LogType='Number', LogUnit='Degrees')
api.AddSampleLog(outws, LogName='omega', LogText=str(metadata.huber - metadata.deterota),
LogType='Number', LogUnit='Degrees')
api.AddSampleLog(outws, LogName='T1', LogText=str(metadata.temp1),
LogType='Number', LogUnit='K')
api.AddSampleLog(outws, LogName='T2', LogText=str(metadata.temp2),
LogType='Number', LogUnit='K')
api.AddSampleLog(outws, LogName='Tsp', LogText=str(metadata.tsp),
LogType='Number', LogUnit='K')
# flipper
api.AddSampleLog(outws, LogName='flipper_precession',
LogText=str(metadata.flipper_precession_current),
LogType='Number', LogUnit='A')
api.AddSampleLog(outws, LogName='flipper_z_compensation',
LogText=str(metadata.flipper_z_compensation_current),
LogType='Number', LogUnit='A')
flipper_status = 'OFF' # flipper OFF
if abs(metadata.flipper_precession_current) > sys.float_info.epsilon:
flipper_status = 'ON' # flipper ON
api.AddSampleLog(outws, LogName='flipper',
LogText=flipper_status, LogType='String')
# coil currents
api.AddSampleLog(outws, LogName='C_a', LogText=str(metadata.a_coil_current),
LogType='Number', LogUnit='A')
api.AddSampleLog(outws, LogName='C_b', LogText=str(metadata.b_coil_current),
LogType='Number', LogUnit='A')
api.AddSampleLog(outws, LogName='C_c', LogText=str(metadata.c_coil_current),
LogType='Number', LogUnit='A')
api.AddSampleLog(outws, LogName='C_z', LogText=str(metadata.z_coil_current),
LogType='Number', LogUnit='A')
# type of polarisation
api.AddSampleLog(outws, 'polarisation', LogText=pol[0], LogType='String')
api.AddSampleLog(outws, 'polarisation_comment', LogText=str(pol[1]), LogType='String')
# slits
api.AddSampleLog(outws, LogName='slit_i_upper_blade_position',
LogText=str(metadata.slit_i_upper_blade_position),
LogType='Number', LogUnit='mm')
api.AddSampleLog(outws, LogName='slit_i_lower_blade_position',
LogText=str(metadata.slit_i_lower_blade_position),
LogType='Number', LogUnit='mm')
api.AddSampleLog(outws, LogName='slit_i_left_blade_position',
LogText=str(metadata.slit_i_left_blade_position),
LogType='Number', LogUnit='mm')
api.AddSampleLog(outws, 'slit_i_right_blade_position',
LogText=str(metadata.slit_i_right_blade_position),
LogType='Number', LogUnit='mm')
# data normalization
# add information whether the data are normalized (duration/monitor/no):
api.AddSampleLog(outws, LogName='normalized', LogText=norm, LogType='String')
outws.setYUnit(yunit)
outws.setYUnitLabel(ylabel)
self.setProperty("OutputWorkspace", outws)
self.log().debug('LoadDNSLegacy: data are loaded to the workspace ' + outws_name)
return
def PyExec(self):
self._setup()
if not self._use_corrections:
logger.information('Not using corrections')
if not self._use_can:
logger.information('Not using container')
prog_container = Progress(self, start=0.0, end=0.2, nreports=4)
prog_container.report('Starting algorithm')
# Units should be wavelength
sample_unit = s_api.mtd[self._sample_ws_name].getAxis(
0).getUnit().unitID()
self._convert_units_wavelength(sample_unit, self._sample_ws_name,
self._sample_ws_wavelength,
"Wavelength")
if self._use_can:
# Appy container shift if needed
if self._shift_can:
# Use temp workspace so we don't modify data
prog_container.report('Shifting can')
s_api.ScaleX(InputWorkspace=self._can_ws_name,
OutputWorkspace=self._shifted_container,
Factor=self._can_shift_factor,
Operation='Add')
logger.information('Container data shifted by %f' %
self._can_shift_factor)
else:
prog_container.report('Cloning Workspace')
s_api.CloneWorkspace(InputWorkspace=self._can_ws_name,
OutputWorkspace=self._shifted_container)
# Apply container scale factor if needed
if self._scale_can:
# Use temp workspace so we don't modify original data
prog_container.report('Scaling can')
s_api.Scale(InputWorkspace=self._shifted_container,
OutputWorkspace=self._scaled_container,
Factor=self._can_scale_factor,
Operation='Multiply')
logger.information('Container scaled by %f' %
self._can_scale_factor)
else:
prog_container.report('Cloning Workspace')
s_api.CloneWorkspace(InputWorkspace=self._shifted_container,
OutputWorkspace=self._scaled_container)
# Units should be wavelength
can_unit = s_api.mtd[self._scaled_container].getAxis(
0).getUnit().unitID()
self._convert_units_wavelength(can_unit, self._scaled_container,
self._scaled_container_wavelength,
"Wavelength")
prog_corr = Progress(self, start=0.2, end=0.6, nreports=2)
if self._use_corrections:
prog_corr.report('Preprocessing corrections')
self._pre_process_corrections()
if self._use_can:
# Use container factors
prog_corr.report('Correcting sample and can')
self._correct_sample_can()
correction_type = 'sample_and_can_corrections'
else:
# Use sample factor only
self._correct_sample()
correction_type = 'sample_corrections_only'
# Add corrections filename to log values
prog_corr.report('Correcting sample')
s_api.AddSampleLog(Workspace=self._output_ws_name,
LogName='corrections_filename',
LogType='String',
LogText=self._corrections_ws_name)
else:
# Do simple subtraction
self._subtract()
correction_type = 'can_subtraction'
# Add container filename to log values
can_cut = self._can_ws_name.index('_')
can_base = self._can_ws_name[:can_cut]
prog_corr.report('Adding container filename')
s_api.AddSampleLog(Workspace=self._output_ws_name,
LogName='container_filename',
LogType='String',
LogText=can_base)
prog_wrkflow = Progress(self, 0.6, 1.0, nreports=5)
# Record the container scale factor
if self._use_can and self._scale_can:
prog_wrkflow.report('Adding container scaling')
s_api.AddSampleLog(Workspace=self._output_ws_name,
LogName='container_scale',
LogType='Number',
LogText=str(self._can_scale_factor))
# Record the container shift amount
if self._use_can and self._shift_can:
prog_wrkflow.report('Adding container shift')
s_api.AddSampleLog(Workspace=self._output_ws_name,
LogName='container_shift',
LogType='Number',
LogText=str(self._can_shift_factor))
# Record the type of corrections applied
prog_wrkflow.report('Adding correction type')
s_api.AddSampleLog(Workspace=self._output_ws_name,
LogName='corrections_type',
LogType='String',
LogText=correction_type)
# Add original sample as log entry
sam_cut = self._sample_ws_name.index('_')
sam_base = self._sample_ws_name[:sam_cut]
prog_wrkflow.report('Adding sample filename')
s_api.AddSampleLog(Workspace=self._output_ws_name,
LogName='sample_filename',
LogType='String',
LogText=sam_base)
# Convert Units back to original
self._convert_units_wavelength(sample_unit, self._output_ws_name,
self._output_ws_name, sample_unit)
self.setPropertyValue('OutputWorkspace', self._output_ws_name)
# Remove temporary workspaces
prog_wrkflow.report('Deleting Workspaces')
if self._corrections in s_api.mtd:
s_api.DeleteWorkspace(self._corrections)
if self._scaled_container in s_api.mtd:
s_api.DeleteWorkspace(self._scaled_container)
if self._shifted_container in s_api.mtd:
s_api.DeleteWorkspace(self._shifted_container)
if self._scaled_container_wavelength in s_api.mtd:
s_api.DeleteWorkspace(self._scaled_container_wavelength)
if self._sample_ws_wavelength in s_api.mtd:
s_api.DeleteWorkspace(self._sample_ws_wavelength)
prog_wrkflow.report('Algorithm Complete')
