Ejemplo n.º 1
0
    def setUp(self, mock_method):
        self.mock_prepare_output_tables = mock_method
        self.cluster = sentinel.cluster
        self.data = sentinel.data
        self.output_path = sentinel.output_path
        self.n = sentinel.n

        self.simulation = BaseSimulation(self.cluster,
                                         self.data,
                                         self.output_path,
                                         self.n,
                                         progress=False)
Ejemplo n.º 2
0
    def test_init_raises_runtimeerror_if_output_exists(self,
                                                       os_path_split_mock):
        os_path_split_mock.return_value = self.output_head, self.output_tail

        self.data.__contains__.return_value = True
        with self.assertRaises(RuntimeError):
            BaseSimulation(self.cluster, self.data, self.output, self.R,
                           self.N)
Ejemplo n.º 3
0
    def setUp(self, mock_method):
        self.mock_prepare_output_tables = mock_method
        self.cluster = sentinel.cluster
        self.data = sentinel.data
        self.output_path = sentinel.output_path
        self.N = sentinel.N

        self.simulation = BaseSimulation(self.cluster, self.data,
                                         self.output_path, self.N,
                                         progress=False)
Ejemplo n.º 4
0
    def test_init_remove_output_if_output_exists_and_force(
            self, os_path_split_mock):
        os_path_split_mock.return_value = self.output_head, self.output_tail

        self.data.__contains__.return_value = True
        BaseSimulation(self.cluster,
                       self.data,
                       self.output,
                       self.R,
                       self.N,
                       force=True)
        self.data.removeNode.assert_called_with(self.output, recursive=True)
Ejemplo n.º 5
0
    def setUp(self, os_path_split_mock):
        self.output_head, self.output_tail = (sentinel.output_head,
                                              sentinel.output_tail)
        os_path_split_mock.return_value = self.output_head, self.output_tail
        self.output = sentinel.output

        self.cluster = sentinel.cluster
        self.data = MagicMock(name='data')
        self.R = sentinel.R
        self.N = sentinel.N

        self.simulation = BaseSimulation(self.cluster, self.data, self.output,
                                         self.R, self.N)
Ejemplo n.º 6
0
class BaseSimulationTest(unittest.TestCase):
    @patch.object(BaseSimulation, '_prepare_output_tables')
    def setUp(self, mock_method):
        self.mock_prepare_output_tables = mock_method
        self.cluster = sentinel.cluster
        self.data = sentinel.data
        self.output_path = sentinel.output_path
        self.n = sentinel.n

        self.simulation = BaseSimulation(self.cluster,
                                         self.data,
                                         self.output_path,
                                         self.n,
                                         progress=False)

    def test_init_sets_attributes(self):
        self.assertIs(self.simulation.cluster, self.cluster)
        self.assertIs(self.simulation.data, self.data)
        self.assertIs(self.simulation.output_path, self.output_path)
        self.assertIs(self.simulation.n, self.n)

    def test_init_calls_prepare_output_tables(self):
        self.mock_prepare_output_tables.assert_called_once_with()

    @patch.object(BaseSimulation, '_prepare_coincidence_tables')
    @patch.object(BaseSimulation, '_prepare_station_tables')
    @patch.object(BaseSimulation, '_store_station_index')
    def test_prepare_output_tables_calls(self, mock_method3, mock_method2,
                                         mock_method1):
        self.simulation._prepare_output_tables()
        mock_method1.assert_called_once_with()
        mock_method2.assert_called_once_with()
        mock_method3.assert_called_once_with()

    @patch.object(BaseSimulation, 'generate_shower_parameters')
    @patch.object(BaseSimulation, 'simulate_events_for_shower')
    @patch.object(BaseSimulation, 'store_coincidence')
    def test_run(self, mock_store, mock_simulate, mock_generate):
        mock_generate.return_value = [sentinel.params1, sentinel.params2]
        mock_simulate.return_value = sentinel.events
        self.simulation.run()

        # test simulate_events_for_shower called two times with
        # shower_parameters
        expected = [call(sentinel.params1), call(sentinel.params2)]
        self.assertEqual(mock_simulate.call_args_list, expected)

        # test store_coincidence called 2nd time with shower_id 1,
        # parameters and events
        mock_store.assert_called_with(1, sentinel.params2, sentinel.events)

    def test_generate_shower_parameters(self):
        self.simulation.n = 10
        output = self.simulation.generate_shower_parameters()
        self.assertIsInstance(output, types.GeneratorType)

        output = list(output)
        self.assertEqual(len(output), 10)

        expected = {
            'core_pos': (None, None),
            'zenith': None,
            'azimuth': None,
            'size': None,
            'energy': None,
            'ext_timestamp': None
        }
        self.assertEqual(output[0], expected)

    @patch.object(BaseSimulation, 'simulate_station_response')
    @patch.object(BaseSimulation, 'store_station_observables')
    def test_simulate_events_for_shower(self, mock_store, mock_simulate):
        self.simulation.cluster = Mock()
        self.simulation.cluster.stations = [
            sentinel.station1, sentinel.station2, sentinel.station3
        ]

        mock_simulate.side_effect = [(True, sentinel.obs1), (False, None),
                                     (True, sentinel.obs3)]
        mock_store.side_effect = [sentinel.index1, sentinel.index2]
        events = self.simulation.simulate_events_for_shower(sentinel.params)

        # test simulate_station_response called for each station, with
        # shower parameters
        expected = [
            call(sentinel.station1, sentinel.params),
            call(sentinel.station2, sentinel.params),
            call(sentinel.station3, sentinel.params)
        ]
        self.assertEqual(mock_simulate.call_args_list, expected)

        # test store_station_observables called only for triggered
        # stations, with observables
        expected = [call(0, sentinel.obs1), call(2, sentinel.obs3)]
        self.assertEqual(mock_store.call_args_list, expected)

        # test returned events consists of list of station indexes and
        # stored event indexes
        self.assertEqual(events, [(0, sentinel.index1), (2, sentinel.index2)])

    @patch.object(BaseSimulation, 'simulate_all_detectors')
    @patch.object(BaseSimulation, 'simulate_trigger')
    @patch.object(BaseSimulation, 'process_detector_observables')
    @patch.object(BaseSimulation, 'simulate_gps')
    def test_simulate_station_response(self, mock_gps, mock_process,
                                       mock_trigger, mock_detectors):
        mock_detectors.return_value = sentinel.detector_observables
        mock_trigger.return_value = sentinel.has_triggered
        mock_process.return_value = sentinel.station_observables
        mock_gps.return_value = sentinel.gps_observables

        mock_station = Mock()
        mock_station.detectors = sentinel.detectors

        has_triggered, station_observables = \
            self.simulation.simulate_station_response(mock_station,
                                                      sentinel.parameters)

        # Tests
        mock_detectors.assert_called_once_with(sentinel.detectors,
                                               sentinel.parameters)
        mock_trigger.assert_called_once_with(sentinel.detector_observables)
        mock_process.assert_called_once_with(sentinel.detector_observables)
        mock_gps.assert_called_once_with(sentinel.station_observables,
                                         sentinel.parameters, mock_station)
        self.assertIs(has_triggered, sentinel.has_triggered)
        self.assertIs(station_observables, sentinel.gps_observables)

    @patch.object(BaseSimulation, 'simulate_detector_response')
    def test_simulate_all_detectors(self, mock_response):
        detectors = [sentinel.detector1, sentinel.detector2]
        mock_response.side_effect = [
            sentinel.observables1, sentinel.observables2
        ]

        observables = self.simulation.simulate_all_detectors(
            detectors, sentinel.parameters)

        expected = [
            call(sentinel.detector1, sentinel.parameters),
            call(sentinel.detector2, sentinel.parameters)
        ]
        self.assertEqual(mock_response.call_args_list, expected)

        self.assertEqual(observables,
                         [sentinel.observables1, sentinel.observables2])

    def test_simulate_detector_response(self):
        observables = self.simulation.simulate_detector_response(
            Mock(), Mock())
        self.assertIsInstance(observables, dict)
        self.assertIn('n', observables)
        self.assertIn('t', observables)

    def test_simulate_trigger(self):
        has_triggered = self.simulation.simulate_trigger(Mock())
        self.assertIsInstance(has_triggered, bool)

    def test_simulate_gps(self):
        mock_observables = Mock()
        self.simulation.simulate_gps(mock_observables, Mock(), Mock())
        self.assertEqual(mock_observables.update.call_count, 1)
        args, kwargs = mock_observables.update.call_args
        gps_dict = args[0]
        self.assertIsInstance(gps_dict, dict)
        self.assertIn('ext_timestamp', gps_dict)
        self.assertIn('timestamp', gps_dict)
        self.assertIn('nanoseconds', gps_dict)

    def test_process_detector_observables(self):
        detector_observables = [{
            'n': 1.,
            't': 2.,
            'pulseheights': 3.,
            'integrals': 4.
        }, {
            'n': 5.,
            't': 6.,
            'pulseheights': 7.,
            'integrals': 8.
        }, {
            'foo': -999.
        }]

        expected = {
            'n1': 1.,
            'n2': 5.,
            't1': 2.,
            't2': 6.,
            'pulseheights': [3., 7., -1., -1.],
            'integrals': [4., 8., -1, -1]
        }
        actual = self.simulation.process_detector_observables(
            detector_observables)

        self.assertEqual(expected, actual)

    def test_store_station_observables(self):
        station_groups = MagicMock()
        self.simulation.station_groups = station_groups
        table = station_groups.__getitem__.return_value.events
        table.nrows = 123

        observables = {'key1': 1., 'key2': 2.}
        table.colnames = ['key1', 'key2']
        idx = self.simulation.store_station_observables(
            sentinel.station_id, observables)

        # tests
        station_groups.__getitem__.assert_called_once_with(sentinel.station_id)

        calls = [
            call('event_id', table.nrows),
            call('key2', 2.),
            call('key1', 1.)
        ]
        station_groups.asser_has_calls(calls, any_order=True)
        table.row.append.assert_called_once_with()
        table.flush.assert_called_once_with()
        self.assertEqual(idx, table.nrows - 1)

    def test_store_station_observables_raises_warning(self):
        station_groups = MagicMock()
        self.simulation.station_groups = station_groups
        table = station_groups.__getitem__.return_value.events
        observables = {'key1': 1., 'key2': 2.}
        table.colnames = ['key1']

        with warnings.catch_warnings(record=True) as warned:
            warnings.simplefilter('always')
            self.simulation.store_station_observables(sentinel.station_id,
                                                      observables)
        self.assertEqual(len(warned), 1)

    @unittest.skip("WIP")
    def test_store_coincidence(self, shower_id, shower_parameters,
                               station_events):
        pass

    @unittest.skip("WIP")
    def test_prepare_coincidence_tables(self):
        pass

    @unittest.skip("WIP")
    def test_prepare_station_tables(self):
        pass

    @unittest.skip("WIP")
    def test_store_station_index(self):
        pass

    @unittest.skip("Does not test this unit")
    def test_init_creates_coincidences_output_group(self):
        self.data.create_group.assert_any_call(self.output_path,
                                               'coincidences',
                                               createparents=True)
        self.data.create_table.assert_called_with(
            self.simulation.coincidence_group, 'coincidences',
            storage.Coincidence)
        self.assertEqual(self.data.create_vlarray.call_count, 2)
        self.data.create_vlarray.assert_any_call(
            self.simulation.coincidence_group, 'c_index',
            tables.UInt32Col(shape=2))

    @unittest.skip("Does not test this unit")
    def test_init_creates_cluster_output_group(self):
        self.data.create_group.assert_any_call(self.output_path,
                                               'cluster_simulations',
                                               createparents=True)
        # The following tests need a better mock of cluster in order to work.
        # self.data.create_group.assert_any_call(self.simulation.cluster_group, 'station_0')
        # self.data.create_table.assert_any_call(
        #     station_group, 'events', storage.ProcessedHisparcEvent, expectedrows=self.n)

    @unittest.skip("Does not test this unit")
    def test_init_stores_cluster_in_attrs(self):
        self.assertIs(self.simulation.coincidence_group._v_attrs.cluster,
                      self.cluster)
Ejemplo n.º 7
0
class BaseSimulationTest(unittest.TestCase):

    @patch.object(BaseSimulation, '_prepare_output_tables')
    def setUp(self, mock_method):
        self.mock_prepare_output_tables = mock_method
        self.cluster = sentinel.cluster
        self.data = sentinel.data
        self.output_path = sentinel.output_path
        self.N = sentinel.N

        self.simulation = BaseSimulation(self.cluster, self.data,
                                         self.output_path, self.N,
                                         progress=False)

    def test_init_sets_attributes(self):
        self.assertIs(self.simulation.cluster, self.cluster)
        self.assertIs(self.simulation.data, self.data)
        self.assertIs(self.simulation.output_path, self.output_path)
        self.assertIs(self.simulation.N, self.N)

    def test_init_calls_prepare_output_tables(self):
        self.mock_prepare_output_tables.assert_called_once_with()

    @patch.object(BaseSimulation, '_prepare_coincidence_tables')
    @patch.object(BaseSimulation, '_prepare_station_tables')
    @patch.object(BaseSimulation, '_store_station_index')
    def test_prepare_output_tables_calls(self, mock_method3, mock_method2,
                                         mock_method1):
        self.simulation._prepare_output_tables()
        mock_method1.assert_called_once_with()
        mock_method2.assert_called_once_with()
        mock_method3.assert_called_once_with()

    @patch.object(BaseSimulation, 'generate_shower_parameters')
    @patch.object(BaseSimulation, 'simulate_events_for_shower')
    @patch.object(BaseSimulation, 'store_coincidence')
    def test_run(self, mock_store, mock_simulate, mock_generate):
        mock_generate.return_value = [sentinel.params1, sentinel.params2]
        mock_simulate.return_value = sentinel.events
        self.simulation.run()

        # test simulate_events_for_shower called two times with
        # shower_parameters
        expected = [call(sentinel.params1), call(sentinel.params2)]
        self.assertEqual(mock_simulate.call_args_list, expected)

        # test store_coincidence called 2nd time with shower_id 1,
        # parameters and events
        mock_store.assert_called_with(1, sentinel.params2,
                                      sentinel.events)

    def test_generate_shower_parameters(self):
        self.simulation.N = 10
        output = self.simulation.generate_shower_parameters()
        self.assertIsInstance(output, types.GeneratorType)

        output = list(output)
        self.assertEqual(len(output), 10)

        expected = {'core_pos': (None, None), 'zenith': None, 'azimuth': None,
                    'size': None, 'energy': None, 'ext_timestamp': None}
        self.assertEqual(output[0], expected)

    @patch.object(BaseSimulation, 'simulate_station_response')
    @patch.object(BaseSimulation, 'store_station_observables')
    def test_simulate_events_for_shower(self, mock_store, mock_simulate):
        self.simulation.cluster = Mock()
        self.simulation.cluster.stations = [sentinel.station1,
                                            sentinel.station2,
                                            sentinel.station3]

        mock_simulate.side_effect = [(True, sentinel.obs1), (False, None),
                                     (True, sentinel.obs3)]
        mock_store.side_effect = [sentinel.index1, sentinel.index2]
        events = self.simulation.simulate_events_for_shower(
            sentinel.params)

        # test simulate_station_response called for each station, with
        # shower parameters
        expected = [call(sentinel.station1, sentinel.params),
                    call(sentinel.station2, sentinel.params),
                    call(sentinel.station3, sentinel.params)]
        self.assertEqual(mock_simulate.call_args_list, expected)

        # test store_station_observables called only for triggered
        # stations, with observables
        expected = [call(0, sentinel.obs1), call(2, sentinel.obs3)]
        self.assertEqual(mock_store.call_args_list, expected)

        # test returned events consists of list of station indexes and
        # stored event indexes
        self.assertEqual(events, [(0, sentinel.index1),
                                  (2, sentinel.index2)])

    @patch.object(BaseSimulation, 'simulate_all_detectors')
    @patch.object(BaseSimulation, 'simulate_trigger')
    @patch.object(BaseSimulation, 'process_detector_observables')
    @patch.object(BaseSimulation, 'simulate_gps')
    def test_simulate_station_response(self, mock_gps, mock_process,
                                       mock_trigger, mock_detectors):
        mock_detectors.return_value = sentinel.detector_observables
        mock_trigger.return_value = sentinel.has_triggered
        mock_process.return_value = sentinel.station_observables
        mock_gps.return_value = sentinel.gps_observables

        mock_station = Mock()
        mock_station.detectors = sentinel.detectors

        has_triggered, station_observables = \
            self.simulation.simulate_station_response(mock_station,
                                                      sentinel.parameters)

        # Tests
        mock_detectors.assert_called_once_with(sentinel.detectors,
                                               sentinel.parameters)
        mock_trigger.assert_called_once_with(sentinel.detector_observables)
        mock_process.assert_called_once_with(sentinel.detector_observables)
        mock_gps.assert_called_once_with(sentinel.station_observables,
                                         sentinel.parameters,
                                         mock_station)
        self.assertIs(has_triggered, sentinel.has_triggered)
        self.assertIs(station_observables, sentinel.gps_observables)

    @patch.object(BaseSimulation, 'simulate_detector_response')
    def test_simulate_all_detectors(self, mock_response):
        detectors = [sentinel.detector1, sentinel.detector2]
        mock_response.side_effect = [sentinel.observables1,
                                     sentinel.observables2]

        observables = self.simulation.simulate_all_detectors(
            detectors, sentinel.parameters)

        expected = [call(sentinel.detector1, sentinel.parameters),
                    call(sentinel.detector2, sentinel.parameters)]
        self.assertEqual(mock_response.call_args_list, expected)

        self.assertEqual(observables, [sentinel.observables1,
                                       sentinel.observables2])

    def test_simulate_detector_response(self):
        observables = self.simulation.simulate_detector_response(Mock(),
                                                                 Mock())
        self.assertIsInstance(observables, dict)
        self.assertIn('n', observables)
        self.assertIn('t', observables)

    def test_simulate_trigger(self):
        has_triggered = self.simulation.simulate_trigger(Mock())
        self.assertIsInstance(has_triggered, bool)

    def test_simulate_gps(self):
        mock_observables = Mock()
        self.simulation.simulate_gps(mock_observables, Mock(), Mock())
        self.assertEqual(mock_observables.update.call_count, 1)
        args, kwargs = mock_observables.update.call_args
        gps_dict = args[0]
        self.assertIsInstance(gps_dict, dict)
        self.assertIn('ext_timestamp', gps_dict)
        self.assertIn('timestamp', gps_dict)
        self.assertIn('nanoseconds', gps_dict)

    def test_process_detector_observables(self):
        detector_observables = [{'n': 1., 't': 2., 'pulseheights': 3.,
                                 'integrals': 4.},
                                {'n': 5., 't': 6., 'pulseheights': 7.,
                                 'integrals': 8.},
                                {'foo': -999.}]

        expected = {'n1': 1., 'n2': 5., 't1': 2., 't2': 6.,
                    'pulseheights': [3., 7., -1., -1.],
                    'integrals': [4., 8., -1, -1]}
        actual = self.simulation.process_detector_observables(
            detector_observables)

        self.assertEqual(expected, actual)

    def test_store_station_observables(self):
        station_groups = MagicMock()
        self.simulation.station_groups = station_groups
        table = station_groups.__getitem__.return_value.events
        table.nrows = 123

        observables = {'key1': 1., 'key2': 2.}
        table.colnames = ['key1', 'key2']
        idx = self.simulation.store_station_observables(
            sentinel.station_id, observables)

        # tests
        station_groups.__getitem__.assert_called_once_with(sentinel.station_id)

        calls = [call('event_id', table.nrows), call('key2', 2.),
                 call('key1', 1.)]
        station_groups.asser_has_calls(calls, any_order=True)
        table.row.append.assert_called_once_with()
        table.flush.assert_called_once_with()
        self.assertEqual(idx, table.nrows - 1)

    def test_store_station_observables_raises_warning(self):
        station_groups = MagicMock()
        self.simulation.station_groups = station_groups
        table = station_groups.__getitem__.return_value.events
        observables = {'key1': 1., 'key2': 2.}
        table.colnames = ['key1']

        with warnings.catch_warnings(record=True) as warned:
            warnings.simplefilter('always')
            self.simulation.store_station_observables(sentinel.station_id,
                                                      observables)
        self.assertEqual(len(warned), 1)

    @unittest.skip("WIP")
    def test_store_coincidence(self, shower_id, shower_parameters, station_events):
        pass

    @unittest.skip("WIP")
    def test_prepare_coincidence_tables(self):
        pass

    @unittest.skip("WIP")
    def test_prepare_station_tables(self):
        pass

    @unittest.skip("WIP")
    def test_store_station_index(self):
        pass

    @unittest.skip("Does not test this unit")
    def test_init_creates_coincidences_output_group(self):
        self.data.create_group.assert_any_call(
            self.output_path, 'coincidences', createparents=True)
        self.data.create_table.assert_called_with(
            self.simulation.coincidence_group, 'coincidences', storage.Coincidence)
        self.assertEqual(self.data.create_vlarray.call_count, 2)
        self.data.create_vlarray.assert_any_call(
            self.simulation.coincidence_group, 'c_index', tables.UInt32Col(shape=2))

    @unittest.skip("Does not test this unit")
    def test_init_creates_cluster_output_group(self):
        self.data.create_group.assert_any_call(
            self.output_path, 'cluster_simulations', createparents=True)
        # The following tests need a better mock of cluster in order to work.
        # self.data.create_group.assert_any_call(self.simulation.cluster_group, 'station_0')
        # self.data.create_table.assert_any_call(
        #     station_group, 'events', storage.ProcessedHisparcEvent, expectedrows=self.N)

    @unittest.skip("Does not test this unit")
    def test_init_stores_cluster_in_attrs(self):
        self.assertIs(self.simulation.coincidence_group._v_attrs.cluster, self.cluster)