diff --git a/Testing/SystemTests/tests/analysis/ISIS_WISHPowderReductionTest.py b/Testing/SystemTests/tests/analysis/ISIS_WISHPowderReductionTest.py
index fd758cdc4aed75bbc14e466b4f21314bbcf178bb..f38dd06bda78060ac778c152743686f4afac86c2 100644
--- a/Testing/SystemTests/tests/analysis/ISIS_WISHPowderReductionTest.py
+++ b/Testing/SystemTests/tests/analysis/ISIS_WISHPowderReductionTest.py
@@ -51,7 +51,7 @@ class WISHPowderReductionTest(MantidSystemTest):
def runTest(self):
os.makedirs(output_dir)
- wish_test = Wish(calibration_dir + "/", output_dir + "/", True, input_dir + "/", False)
+ wish_test = Wish(calibration_dir, output_dir, True, input_dir + "/", False)
runs = [40503]
wish_test.reduce(runs, panels)
@@ -86,7 +86,7 @@ class WISHPowderReductionNoAbsorptionTest(MantidSystemTest):
def runTest(self):
os.makedirs(output_dir)
- wish_test = Wish(calibration_dir + "/", output_dir + "/", True, input_dir + "/")
+ wish_test = Wish(calibration_dir, output_dir, True, input_dir + "/")
runs = [40503]
wish_test.reduce(runs, panels)
@@ -120,7 +120,7 @@ class WISHPowderReductionCreateVanadiumTest(MantidSystemTest):
def runTest(self):
os.makedirs(output_dir)
- wish_test = Wish(calibration_dir + "/", output_dir + "/", True, input_dir +"/")
+ wish_test = Wish(calibration_dir, output_dir, True, input_dir + "/")
wish_test.create_vanadium_run(19612, 19618, panels)
def validate(self):
@@ -128,6 +128,5 @@ class WISHPowderReductionCreateVanadiumTest(MantidSystemTest):
for panel in [x for x in panels if x < 6]:
validation_files = validation_files + ["w19612-{}foc".format(panel),
"vana19612-{}foc-SF-SS.nxs".format(panel)]
- print(validation_files)
return validation_files
diff --git a/scripts/wish/reduce.py b/scripts/wish/reduce.py
index a8bdf929db3af2b1c7b5757d4beed98afb25ebb8..63c4dd8db317724b0a528531dd111f1285ef210f 100644
--- a/scripts/wish/reduce.py
+++ b/scripts/wish/reduce.py
@@ -24,17 +24,17 @@ class Wish:
self.userdatadir = None
self.userdataprocessed = None
self.return_panel = {
- 1: (6, 19461),
- 2: (19462, 38917),
- 3: (38918, 58373),
- 4: (58374, 77829),
- 5: (77830, 97285),
- 6: (97286, 116741),
- 7: (116742, 136197),
- 8: (136198, 155653),
- 9: (155654, 175109),
+ 1: (6, 19461),
+ 2: (19462, 38917),
+ 3: (38918, 58373),
+ 4: (58374, 77829),
+ 5: (77830, 97285),
+ 6: (97286, 116741),
+ 7: (116742, 136197),
+ 8: (136198, 155653),
+ 9: (155654, 175109),
10: (175110, 194565),
- 0: (6, 194565)
+ 0: (6, 194565)
}
self.return_panel_van = {
1: (6, 19461),
@@ -48,6 +48,21 @@ class Wish:
9: (19462, 38917),
10: (6, 19461)
}
+ # update to reflect new cycles
+ self.cycle_mapping = [("09_2", (586, 774)), ("09_3", (774, 1728)), ("09_4", (1728, 3334)),
+ ("09_5", (3334, 16777)), ("10_1", (16777, 17322)), ("10_2", (17322, 17339)),
+ ("10_3", (17340, 17692)), ("11_1", (17692, 18051)), ("11_2", (18053, 18572)),
+ ("11_3", (18572, 19608)), ("11_4", (19608, 20420)), ("11_5", (20420, 21111)),
+ ("12_1", (21117, 21919)), ("12_2", (21919, 22437)), ("12_3", (22438, 23128)),
+ ("12_4", (23128, 23548)), ("12_5", (23548, 24086)), ("13_1", (24086, 24819)),
+ ("13_2", (24820, 25317)), ("13_3", (25318, 26148)), ("13_4", (26149, 26661)),
+ ("13_5", (26661, 27805)), ("14_1", (27806, 28904)), ("14_2", (28904, 29587)),
+ ("14_3", (29587, 30528)), ("15_1", (30528, 31669)), ("15_2", (31669, 32520)),
+ ("15_3", (32520, 33278)), ("15_4", (33278, 34171)), ("16_1", (34171, 35222)),
+ ("16_2", (35222, 35830)), ("16_3", (35830, 36442)), ("16_4", (36442, 37035)),
+ ("16_5", (37035, 38247)), ("17_1", (38247, 38837)), ("17_2", (38837, 39326)),
+ ("17_4", (39326, 40469)), ("18_1", (40469, 41846)), ("18_2", (41846, 42708)),
+ ("18_3", (42708, 43124))]
def set_user_name(self, username):
self.username = username
@@ -59,20 +74,26 @@ class Wish:
self.user_directory = directory
def startup(self, cycle='14_3'):
- user_data_directory = self.use_folder + cycle + '/'
+ user_data_directory = os.path.normpath(self.use_folder + cycle)
self.set_data_directory(user_data_directory)
print("Raw Data in : ", user_data_directory)
user_data_processed = self.out_folder
self.set_user_directory(directory=user_data_processed)
print("Processed Data in : ", user_data_processed)
+ def get_cycle(self, run_number):
+ for cycle_pair in self.cycle_mapping:
+ if run_number in range(cycle_pair[1][0], cycle_pair[1][1]):
+ return cycle_pair[0]
+ print("Failed to find cycle")
+
# Returns the calibration filename
def get_cal(self):
- return self.cal_dir + "WISH_cycle_15_4_noends_10to10_dodgytube_removed_feb2016.cal"
+ return os.path.join(self.cal_dir, "WISH_cycle_15_4_noends_10to10_dodgytube_removed_feb2016.cal")
# Returns the grouping filename
def get_group_file(self):
- return self.cal_dir + "WISH_cycle_15_4_noends_10to10_dodgytube_removed_feb2016.cal"
+ return os.path.join(self.cal_dir, "WISH_cycle_15_4_noends_10to10_dodgytube_removed_feb2016.cal")
def get_vanadium(self, panel, cycle="09_4"):
vanadium_string = {
@@ -85,7 +106,7 @@ class Wish:
"11_3": "vana18590-{}foc-SS-new.nxs",
"11_4": "vana19612-{}foc-SF-SS.nxs",
}
- return self.cal_dir + vanadium_string.get(cycle).format(panel)
+ return os.path.join(self.cal_dir, vanadium_string.get(cycle).format(panel))
def get_file_name(self, run_number, extension):
if extension[0] != 's':
@@ -104,7 +125,6 @@ class Wish:
if type(number) is int:
filename = self.datafile
print("will be reading filename...", filename)
-
spectra_min, spectra_max = self.return_panel_van.get(panel) if self.is_vanadium else \
self.return_panel.get(panel)
if panel != 0:
@@ -115,21 +135,17 @@ class Wish:
if extension == "nxs_event":
mantid.LoadEventNexus(Filename=filename, OutputWorkspace=output, LoadMonitors='1')
self.read_event_nexus(number, output, panel)
- print("full nexus eventfile loaded")
if extension[:10] == "nxs_event_":
label, tmin, tmax = split_string_event(extension)
output = output + "_" + label
if tmax == "end":
mantid.LoadEventNexus(Filename=filename, OutputWorkspace=output, FilterByTimeStart=tmin,
- LoadMonitors='1',
- MonitorsAsEvents='1', FilterMonByTimeStart=tmin)
+ LoadMonitors='1', MonitorsAsEvents='1', FilterMonByTimeStart=tmin)
else:
mantid.LoadEventNexus(Filename=filename, OutputWorkspace=output, FilterByTimeStart=tmin,
- FilterByTimeStop=tmax,
- LoadMonitors='1', MonitorsAsEvents='1', FilterMonByTimeStart=tmin,
- FilterMonByTimeStop=tmax)
+ FilterByTimeStop=tmax, LoadMonitors='1', MonitorsAsEvents='1',
+ FilterMonByTimeStart=tmin, FilterMonByTimeStop=tmax)
self.read_event_nexus(number, output, panel)
- print("nexus event file chopped")
else:
num_1, num_2 = split_string(number)
output = "w{0}_{1}-{2}".format(num_1, num_2, panel)
@@ -146,19 +162,15 @@ class Wish:
monitor = self.process_incidentmon(number, extension, spline_terms=70)
else:
monitor = mantid.mtd[monitor_run]
- print("first norm to be done")
mantid.NormaliseToMonitor(InputWorkspace=output, OutputWorkspace=output + "norm1", MonitorWorkspace=monitor)
- print("second norm to be done")
mantid.NormaliseToMonitor(InputWorkspace=output + "norm1", OutputWorkspace=output + "norm2",
- MonitorWorkspace=monitor,
- IntegrationRangeMin=0.7, IntegrationRangeMax=10.35)
+ MonitorWorkspace=monitor, IntegrationRangeMin=0.7, IntegrationRangeMax=10.35)
mantid.DeleteWorkspace(output)
mantid.DeleteWorkspace(output + "norm1")
mantid.RenameWorkspace(InputWorkspace=output + "norm2", OutputWorkspace=output)
mantid.ConvertUnits(InputWorkspace=output, OutputWorkspace=output, Target="TOF", EMode="Elastic")
mantid.ReplaceSpecialValues(InputWorkspace=output, OutputWorkspace=output, NaNValue=0.0, NaNError=0.0,
- InfinityValue=0.0,
- InfinityError=0.0)
+ InfinityValue=0.0, InfinityError=0.0)
return output
def load_multi_run_part(self, extension, run, panel):
@@ -203,11 +215,9 @@ class Wish:
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)
- print("file read and normalized")
if absorb:
absorption_corrections(attenuation, height, number_density, radius, scattering, ws_to_focus)
focused_ws = self.focus(ws_to_focus, panel)
- print("focussing done!")
panel_crop = {
1: (0.8, 53.3),
@@ -223,28 +233,26 @@ class Wish:
}
d_min, d_max = panel_crop.get(panel)
mantid.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 i in range(Wish.NUM_PANELS):
- focused_ws = "w{0}-{1}foc".format(number, i)
+ for panel_i in range(Wish.NUM_PANELS):
+ focused_ws = "w{0}-{1}foc".format(number, panel_i)
mantid.CropWorkspace(InputWorkspace=focused_ws, OutputWorkspace=focused_ws, XMin=d_min, XMax=d_max)
- print("will try to load a vanadium with the name:", self.get_vanadium(i, cycle_vana))
- self.apply_vanadium_corrections(cycle_vana, i, focused_ws)
+ print("will try to load a vanadium with the name:", self.get_vanadium(panel_i, cycle_vana))
+ self.apply_vanadium_corrections(cycle_vana, panel_i, focused_ws)
mantid.SaveGSS(InputWorkspace=focused_ws,
- Filename="{0}{1}-{2}{3}.gss".format(self.user_directory, number, i, extension),
+ Filename=save_location.format(number, panel_i, extension, "gss"),
Append=False, Bank=1)
- mantid.SaveFocusedXYE(focused_ws, "{0}{1}-{2}{3}.dat".format(self.user_directory, number, i, extension))
- mantid.SaveNexusProcessed(focused_ws, "{0}{1}-{2}{3}.nxs".format(self.user_directory, number, i,
- extension))
+ mantid.SaveFocusedXYE(focused_ws, save_location.format(number, panel_i, extension, "dat"))
+ mantid.SaveNexusProcessed(focused_ws, save_location.format(number, panel_i, extension, "nxs"))
else:
print("will try to load a vanadium with the name:", self.get_vanadium(panel, cycle_vana))
self.apply_vanadium_corrections(cycle_vana, panel, focused_ws)
mantid.SaveGSS(InputWorkspace=focused_ws,
- Filename="{0}{1}-{2}{3}.gss".format(self.user_directory, number, panel, extension),
+ Filename=save_location.format(number, panel, extension, "gss"),
Append=False, Bank=1)
- mantid.SaveFocusedXYE(focused_ws, "{0}{1}-{2}{3}.dat".format(self.user_directory, number, panel, extension))
- mantid.SaveNexusProcessed(focused_ws, "{0}{1}-{2}{3}.nxs".format(self.user_directory, number, panel,
- extension))
+ mantid.SaveFocusedXYE(focused_ws, save_location.format(number, panel, extension, "dat"))
+ mantid.SaveNexusProcessed(focused_ws, save_location.format(number, panel, extension, "nxs"))
return focused_ws
def apply_vanadium_corrections(self, cyclevana, i, focused_ws):
@@ -276,29 +284,29 @@ class Wish:
vanfoc = self.focus(vanadium_ws, panel)
panel_crop = {
- 1: (0.95, 53.3),
- 2: (0.58, 13.1),
- 3: (0.44, 7.77),
- 4: (0.38, 5.86),
- 5: (0.35, 4.99),
- 6: (0.35, 4.99),
- 7: (0.38, 5.86),
- 8: (0.44, 7.77),
- 9: (0.58, 13.1),
+ 1: (0.95, 53.3),
+ 2: (0.58, 13.1),
+ 3: (0.44, 7.77),
+ 4: (0.38, 5.86),
+ 5: (0.35, 4.99),
+ 6: (0.35, 4.99),
+ 7: (0.38, 5.86),
+ 8: (0.44, 7.77),
+ 9: (0.58, 13.1),
10: (0.95, 53.3)
}
d_min, d_max = panel_crop.get(panel)
mantid.CropWorkspace(InputWorkspace=vanfoc, OutputWorkspace=vanfoc, XMin=d_min, XMax=d_max)
spline_coefficient = {
- 1: 120,
- 2: 120,
- 3: 120,
- 4: 130,
- 5: 140,
- 6: 140,
- 7: 130,
- 8: 120,
- 9: 120,
+ 1: 120,
+ 2: 120,
+ 3: 120,
+ 4: 130,
+ 5: 140,
+ 6: 140,
+ 7: 130,
+ 8: 120,
+ 9: 120,
10: 120
}
mantid.SplineBackground(InputWorkspace=vanfoc, OutputWorkspace=vanfoc, NCoeff=spline_coefficient.get(panel))
@@ -308,8 +316,11 @@ class Wish:
def create_vanadium_run(self, van_run_number, empty_run_number, panels):
self.is_vanadium = True
+ vanadium_cycle = self.get_cycle(van_run_number)
+ empty_cycle = self.get_cycle(empty_run_number)
for panel in panels:
- self.process_vanadium(van_run_number, empty_run_number, panel, 4, 0.14999999999999999, "11_4", "11_4")
+ self.process_vanadium(van_run_number, empty_run_number, panel, 4, 0.14999999999999999, vanadium_cycle,
+ empty_cycle)
monitor_runs = "monitor{}"
mantid.DeleteWorkspace(monitor_runs.format(van_run_number))
mantid.DeleteWorkspace(monitor_runs.format(empty_run_number))
@@ -358,12 +369,11 @@ class Wish:
mantid.SmoothData(InputWorkspace=works, OutputWorkspace=works, NPoints=40)
mantid.ConvertFromDistribution(works)
return works
-
- def reduce(self, run_numbers, panels):
- self.startup("18_1")
+ def reduce(self, run_numbers, panels):
self.is_vanadium = False
for run in run_numbers:
+ self.startup(self.get_cycle(run))
self.datafile = self.get_file_name(run, "raw")
for panel in panels:
wout = self.process_run(run, panel, "raw", "11_4", absorb=self.absorb, number_density=0.025,
@@ -396,7 +406,7 @@ class Wish:
mantid.RebinToWorkspace(WorkspaceToRebin=input_ws2, WorkspaceToMatch=input_ws1, OutputWorkspace=input_ws2,
PreserveEvents='0')
- mantid.Plus(LHSWorkspace=input_ws1, RHSWorkspace=input_ws2, OutputWorkspace=combined_ws)
+ mantid.Plus(LHSWorkspace=input_ws1, RHSWorkspace=input_ws2, OutputWorkspace=combined_ws)
mantid.ConvertUnits(InputWorkspace=combined_ws, OutputWorkspace=combined_ws + "-d", Target="dSpacing",
EMode="Elastic")
@@ -420,18 +430,18 @@ def absorption_corrections(attenuation, height, number_density, radius, scatteri
def split(focus):
for i in range(Wish.NUM_PANELS):
- out = "{0}-{1}foc".format(focus[0:len(focus) - 3], i+1)
+ out = "{0}-{1}foc".format(focus[0:len(focus) - 3], i + 1)
mantid.ExtractSingleSpectrum(InputWorkspace=focus, OutputWorkspace=out, WorkspaceIndex=i)
mantid.DeleteWorkspace(focus)
-def split_string(t):
+def split_string(string):
indxp = 0
- for i in range(0, len(t)):
- if t[i] == "+":
+ for i in range(0, len(string)):
+ if string[i] == "+":
indxp = i
if indxp != 0:
- return int(t[0:indxp]), int(t[indxp + 1:len(t)])
+ return int(string[0:indxp]), int(string[indxp + 1:len(string)])
def split_string_event(input_string):
@@ -443,16 +453,15 @@ def split_string_event(input_string):
return label, t_min, t_max
-def shared_load_files(extension, filename, output, spectrum_max, spectrum_min, is_monitor):
+def shared_load_files(extension, filename, ws, spectrum_max, spectrum_min, is_monitor):
if not (extension == "nxs" or extension == "raw" or extension[0] == "s"):
return False
if extension == "nxs":
- mantid.Load(Filename=filename, OutputWorkspace=output, SpectrumMin=spectrum_min,
- SpectrumMax=spectrum_min)
+ mantid.Load(Filename=filename, OutputWorkspace=ws, SpectrumMin=spectrum_min, SpectrumMax=spectrum_min)
else:
- mantid.LoadRaw(Filename=filename, OutputWorkspace=output, SpectrumMin=spectrum_min, SpectrumMax=spectrum_max,
+ mantid.LoadRaw(Filename=filename, OutputWorkspace=ws, SpectrumMin=spectrum_min, SpectrumMax=spectrum_max,
LoadLogFiles="0")
- mantid.Rebin(InputWorkspace=output, OutputWorkspace=output, Params='6000,-0.00063,110000')
+ mantid.Rebin(InputWorkspace=ws, OutputWorkspace=ws, Params='6000,-0.00063,110000')
if not is_monitor:
- mantid.MaskBins(InputWorkspace=output, OutputWorkspace=output, XMin=99900, XMax=106000)
+ mantid.MaskBins(InputWorkspace=ws, OutputWorkspace=ws, XMin=99900, XMax=106000)
return True