Beispiel #1
0
    def test_that_individual_monitors_can_be_selected(self):
        # Arrange
        test_ws = self._load_workspace_with_monitors()
        ws = mtd[test_ws]
        remover = DarkRunMonitorAndDetectorRemover()

        zero_reference = np.copy(ws.dataY(0)) * 0
        dataY0_reference = np.copy(ws.dataY(0))
        dataE0_reference = np.copy(ws.dataE(0))
        number_histograms_reference = ws.getNumberHistograms()

        monitor_selection = [1]  # We select the monitor with detector ID 1
        # which is workspace index 0 for this workspace

        # Act
        dark_run_corrected = remover.set_pure_monitor_dark_run(
            ws, monitor_selection)

        # Assert
        self.assertEqual(dark_run_corrected.getNumberHistograms(),
                         number_histograms_reference,
                         "The number of histograms should not have changed")

        self._assert_items_are_equal(dark_run_corrected.dataY(0),
                                     dataY0_reference,
                                     "First monitor Y data should be 0")

        self._assert_items_are_equal(dark_run_corrected.dataE(0),
                                     dataE0_reference,
                                     "First monitor E data should be 0")

        self._assert_items_are_equal(
            dark_run_corrected.dataY(1), zero_reference,
            "Second monitor Y data should not have changed")
        self._assert_items_are_equal(
            dark_run_corrected.dataE(1), zero_reference,
            "Second monitor E data should not have changed")

        for element in range(2, dark_run_corrected.getNumberHistograms()):
            self._assert_items_are_equal(
                dark_run_corrected.dataY(element), zero_reference,
                "The Y data of non-monitor detectors should be 0")
            self._assert_items_are_equal(
                dark_run_corrected.dataE(element), zero_reference,
                "The E data of non-monitor detectors should be 0")

        # Clean up
        ws_to_clean = [test_ws]
        self._clean_up(ws_to_clean)
Beispiel #2
0
    def test_keep_all_monitors_discard_detectors(self):
        # Arrange
        test_ws = self._load_workspace_with_monitors()
        ws = mtd[test_ws]
        remover = DarkRunMonitorAndDetectorRemover()

        dataY0_reference = np.copy(ws.dataY(0))
        dataE0_reference = np.copy(ws.dataE(0))
        dataY1_reference = np.copy(ws.dataY(1))
        dataE1_reference = np.copy(ws.dataE(1))
        number_histograms_reference = ws.getNumberHistograms()
        zero_reference = dataY0_reference * 0

        # Act
        monitor_selection = []
        dark_run_corrected = remover.set_pure_monitor_dark_run(
            ws, monitor_selection)

        # Assert
        self.assertEqual(dark_run_corrected.getNumberHistograms(),
                         number_histograms_reference,
                         "The number of histograms should not have changed")

        self._assert_items_are_equal(
            dark_run_corrected.dataY(0), dataY0_reference,
            "First monitor Y data should not have changed")
        self._assert_items_are_equal(
            dark_run_corrected.dataE(0), dataE0_reference,
            "First monitor E data should not have changed")

        self._assert_items_are_equal(
            dark_run_corrected.dataY(1), dataY1_reference,
            "Second monitor Y data should not have changed")
        self._assert_items_are_equal(
            dark_run_corrected.dataE(1), dataE1_reference,
            "Second monitor E data should not have changed")

        for element in range(2, dark_run_corrected.getNumberHistograms()):
            self._assert_items_are_equal(
                dark_run_corrected.dataY(element), zero_reference,
                "The Y data of non-monitor detectors should be 0")
            self._assert_items_are_equal(
                dark_run_corrected.dataE(element), zero_reference,
                "The E data of non-monitor detectors should be 0")

        # Clean up
        ws_to_clean = [test_ws]
        self._clean_up(ws_to_clean)
    def test_that_individual_monitors_can_be_selected(self):
        # Arrange
        test_ws = self._load_workspace_with_monitors()
        ws = mtd[test_ws]
        remover = DarkRunMonitorAndDetectorRemover()

        zero_reference = np.copy(ws.dataY(0))*0
        dataY0_reference = np.copy(ws.dataY(0))
        dataE0_reference = np.copy(ws.dataE(0))
        number_histograms_reference = ws.getNumberHistograms()

        monitor_selection = [1] # We select the monitor with detector ID 1
                                # which is workspace index 0 for this workspace

        # Act
        dark_run_corrected = remover.set_pure_monitor_dark_run(ws, monitor_selection)


        # Assert
        self.assertEqual(dark_run_corrected.getNumberHistograms(), number_histograms_reference,
                         "The number of histograms should not have changed")

        self._assert_items_are_equal(dark_run_corrected.dataY(0), dataY0_reference,
                                     "First monitor Y data should be 0")

        self._assert_items_are_equal(dark_run_corrected.dataE(0), dataE0_reference,
                                     "First monitor E data should be 0")

        self._assert_items_are_equal(dark_run_corrected.dataY(1), zero_reference,
                                     "Second monitor Y data should not have changed")
        self._assert_items_are_equal(dark_run_corrected.dataE(1),  zero_reference,
                                     "Second monitor E data should not have changed")

        for element in range(2, dark_run_corrected.getNumberHistograms()):
            self._assert_items_are_equal(dark_run_corrected.dataY(element), zero_reference,
                                     "The Y data of non-monitor detectors should be 0")
            self._assert_items_are_equal(dark_run_corrected.dataE(element), zero_reference,
                                     "The E data of non-monitor detectors should be 0")

        # Clean up
        ws_to_clean = [test_ws]
        self._clean_up(ws_to_clean)
    def test_keep_all_monitors_discard_detectors(self):
        # Arrange
        test_ws = self._load_workspace_with_monitors()
        ws = mtd[test_ws]
        remover = DarkRunMonitorAndDetectorRemover()

        dataY0_reference = np.copy(ws.dataY(0))
        dataE0_reference = np.copy(ws.dataE(0))
        dataY1_reference = np.copy(ws.dataY(1))
        dataE1_reference = np.copy(ws.dataE(1))
        number_histograms_reference = ws.getNumberHistograms()
        zero_reference = dataY0_reference*0

        # Act
        monitor_selection = []
        dark_run_corrected = remover.set_pure_monitor_dark_run(ws, monitor_selection)

        # Assert
        self.assertEqual(dark_run_corrected.getNumberHistograms(), number_histograms_reference,
                         "The number of histograms should not have changed")

        self._assert_items_are_equal(dark_run_corrected.dataY(0), dataY0_reference,
                                     "First monitor Y data should not have changed")
        self._assert_items_are_equal(dark_run_corrected.dataE(0), dataE0_reference,
                                     "First monitor E data should not have changed")


        self._assert_items_are_equal(dark_run_corrected.dataY(1), dataY1_reference,
                                     "Second monitor Y data should not have changed")
        self._assert_items_are_equal(dark_run_corrected.dataE(1), dataE1_reference,
                                     "Second monitor E data should not have changed")

        for element in range(2, dark_run_corrected.getNumberHistograms()):
            self._assert_items_are_equal(dark_run_corrected.dataY(element), zero_reference,
                                     "The Y data of non-monitor detectors should be 0")
            self._assert_items_are_equal(dark_run_corrected.dataE(element), zero_reference,
                                     "The E data of non-monitor detectors should be 0")

        # Clean up
        ws_to_clean = [test_ws]
        self._clean_up(ws_to_clean)