Esempio n. 1
0
 def _crop_banks_to_user_tof(self, focused_banks):
     if self._inst_settings.tt_mode == "custom":
         return common.crop_banks_using_crop_list(
             focused_banks, self._inst_settings.custom_tof_cropping_values)
     else:
         return common.crop_banks_using_crop_list(
             focused_banks, self._inst_settings.tof_cropping_values)
Esempio n. 2
0
    def test_crop_banks_using_crop_list(self):
        bank_list = []
        cropping_value = (0, 1000
                          )  # Crop to 0-1000 microseconds for unit tests
        cropping_value_list = []

        expected_number_of_bins = cropping_value[-1] - cropping_value[0]

        for i in range(0, 3):
            out_name = "crop_banks_in_tof-" + str(i)
            cropping_value_list.append(cropping_value)
            bank_list.append(
                mantid.CreateSampleWorkspace(OutputWorkspace=out_name,
                                             XMin=0,
                                             XMax=1100,
                                             BinWidth=1))

        # Check a list of WS and single cropping value is detected
        with self.assertRaisesRegex(
                ValueError,
                "The cropping values were not in a list or tuple type"):
            common.crop_banks_using_crop_list(bank_list=bank_list,
                                              crop_values_list=1000)

        # Check a list of cropping values and a single workspace is detected
        with self.assertRaisesRegex(RuntimeError,
                                    "Attempting to use list based cropping"):
            common.crop_banks_using_crop_list(
                bank_list=bank_list[0], crop_values_list=cropping_value_list)

        # What about a mismatch between the number of cropping values and workspaces
        with self.assertRaisesRegex(
                RuntimeError,
                "The number of TOF cropping values does not match"):
            common.crop_banks_using_crop_list(
                bank_list=bank_list[1:], crop_values_list=cropping_value_list)

        # Check we can crop a single workspace from the list
        cropped_single_ws_list = common.crop_banks_using_crop_list(
            bank_list=[bank_list[0]], crop_values_list=[cropping_value])
        self.assertEqual(cropped_single_ws_list[0].blocksize(),
                         expected_number_of_bins)
        mantid.DeleteWorkspace(Workspace=cropped_single_ws_list[0])

        # Check we can crop a whole list
        cropped_ws_list = common.crop_banks_using_crop_list(
            bank_list=bank_list[1:], crop_values_list=cropping_value_list[1:])
        for ws in cropped_ws_list[1:]:
            self.assertEqual(ws.blocksize(), expected_number_of_bins)
            mantid.DeleteWorkspace(Workspace=ws)
    def test_crop_banks_using_a_single_fractional_cropping_value(self):
        bank_list = []
        cropping_value = (0.05, 0.95)  # Crop to 0-1000 microseconds for unit tests
        x_min = 500
        x_max = 1000

        expected_number_of_bins = x_max * cropping_value[-1] - x_min * (1+cropping_value[0])

        for i in range(0, 3):
            out_name = "crop_banks_in_tof-" + str(i)
            bank_list.append(mantid.CreateSampleWorkspace(OutputWorkspace=out_name, XMin=x_min, XMax=x_max, BinWidth=1))

        # Check a list of WS and non list or tuple
        with assertRaisesRegex(self, ValueError, "The cropping values were not in a list or tuple type"):
            common.crop_banks_using_crop_list(bank_list=bank_list, crop_values_list=1000)

        # Check a cropping value and a single workspace is detected
        with assertRaisesRegex(self, RuntimeError, "Attempting to use list based cropping"):
            common.crop_banks_using_crop_list(bank_list=bank_list[0], crop_values_list=cropping_value)

        # Check we can crop a single workspace from the list
        cropped_single_ws_list = common.crop_banks_using_crop_list(bank_list=[bank_list[0]],
                                                                   crop_values_list=cropping_value)
        self.assertEqual(cropped_single_ws_list[0].blocksize(), expected_number_of_bins)
        mantid.DeleteWorkspace(Workspace=cropped_single_ws_list[0])

        # Check we can crop a whole list
        cropped_ws_list = common.crop_banks_using_crop_list(bank_list=bank_list[1:],
                                                            crop_values_list=cropping_value)
        for ws in cropped_ws_list[1:]:
            self.assertEqual(ws.blocksize(), expected_number_of_bins)
            mantid.DeleteWorkspace(Workspace=ws)
    def test_crop_banks_using_crop_list(self):
        bank_list = []
        cropping_value = (0, 1000)  # Crop to 0-1000 microseconds for unit tests
        cropping_value_list = []

        expected_number_of_bins = cropping_value[-1] - cropping_value[0]

        for i in range(0, 3):
            out_name = "crop_banks_in_tof-" + str(i)
            cropping_value_list.append(cropping_value)
            bank_list.append(mantid.CreateSampleWorkspace(OutputWorkspace=out_name, XMin=0, XMax=1100, BinWidth=1))

        # Check a list of WS and single cropping value is detected
        with assertRaisesRegex(self, ValueError, "The cropping values were not in a list type"):
            common.crop_banks_using_crop_list(bank_list=bank_list, crop_values_list=cropping_value)

        # Check a list of cropping values and a single workspace is detected
        with assertRaisesRegex(self, RuntimeError, "Attempting to use list based cropping"):
            common.crop_banks_using_crop_list(bank_list=bank_list[0], crop_values_list=cropping_value_list)

        # What about a mismatch between the number of cropping values and workspaces
        with assertRaisesRegex(self, RuntimeError, "The number of TOF cropping values does not match"):
            common.crop_banks_using_crop_list(bank_list=bank_list[1:], crop_values_list=cropping_value_list)

        # Check we can crop a single workspace from the list
        cropped_single_ws_list = common.crop_banks_using_crop_list(bank_list=[bank_list[0]],
                                                                   crop_values_list=[cropping_value])
        self.assertEqual(cropped_single_ws_list[0].blocksize(), expected_number_of_bins)
        mantid.DeleteWorkspace(Workspace=cropped_single_ws_list[0])

        # Check we can crop a whole list
        cropped_ws_list = common.crop_banks_using_crop_list(bank_list=bank_list[1:],
                                                            crop_values_list=cropping_value_list[1:])
        for ws in cropped_ws_list[1:]:
            self.assertEqual(ws.blocksize(), expected_number_of_bins)
            mantid.DeleteWorkspace(Workspace=ws)
Esempio n. 5
0
 def _crop_banks_to_user_tof(self, focused_banks):
     return common.crop_banks_using_crop_list(
         focused_banks, self._inst_settings.tof_cropping_values)
Esempio n. 6
0
 def _crop_van_to_expected_tof_range(self, van_ws_to_crop):
     cropped_ws = common.crop_banks_using_crop_list(
         bank_list=van_ws_to_crop,
         crop_values_list=self._inst_settings.van_crop_values)
     return cropped_ws
Esempio n. 7
0
 def _crop_van_to_expected_tof_range(self, van_ws_to_crop):
     return common.crop_banks_using_crop_list(van_ws_to_crop, self._inst_settings.vanadium_cropping_values)
Esempio n. 8
0
 def _crop_banks_to_user_tof(self, focused_banks):
     return common.crop_banks_using_crop_list(focused_banks, self._inst_settings.focused_cropping_values)