def test_nwb_extractor(self):
        path1 = self.test_dir + '/test.nwb'
        se.NwbRecordingExtractor.write_recording(self.RX, path1)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        del RX_nwb
        se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        # append sorting to existing file
        se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path1, overwrite=False)

        path2 = self.test_dir + "/firings_true.nwb"
        se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path2)
        se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path2)
        SX_nwb = se.NwbSortingExtractor(path2)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling unit property descriptions argument
        property_descriptions = dict(stability="This is a description of stability.")
        se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True)
        se.NwbSortingExtractor.write_sorting(
            sorting=self.SX,
            save_path=path1,
            property_descriptions=property_descriptions
        )
        SX_nwb = se.NwbSortingExtractor(path1)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling skip_properties argument
        se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True)
        se.NwbSortingExtractor.write_sorting(
            sorting=self.SX,
            save_path=path1,
            skip_properties=['stability']
        )
        SX_nwb = se.NwbSortingExtractor(path1)
        assert 'stability' not in SX_nwb.get_shared_unit_property_names()
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling skip_features argument
        se.NwbRecordingExtractor.write_recording(recording=self.RX, save_path=path1, overwrite=True)
        se.NwbSortingExtractor.write_sorting(
            sorting=self.SX2,
            save_path=path1,
            skip_features=['widths']
        )
        SX_nwb = se.NwbSortingExtractor(path1)
        assert 'widths' not in SX_nwb.get_shared_unit_spike_feature_names()
        check_sortings_equal(self.SX2, SX_nwb)
        check_dumping(SX_nwb)
Example #2
0
    def test_write_sorting(self):
        path = self.test_dir + '/test.nwb'
        sf = self.RX.get_sampling_frequency()

        # Append sorting to existing file
        write_recording(recording=self.RX, save_path=path, overwrite=True)
        write_sorting(sorting=self.SX, save_path=path, overwrite=False)
        SX_nwb = se.NwbSortingExtractor(path)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling unit property descriptions argument
        property_descriptions = dict(stability="This is a description of stability.")
        write_sorting(
            sorting=self.SX,
            save_path=path,
            property_descriptions=property_descriptions,
            overwrite=True
        )
        SX_nwb = se.NwbSortingExtractor(path, sampling_frequency=sf)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling skip_properties argument
        write_sorting(
            sorting=self.SX,
            save_path=path,
            skip_properties=['stability'],
            overwrite=True
        )
        SX_nwb = se.NwbSortingExtractor(path, sampling_frequency=sf)
        assert 'stability' not in SX_nwb.get_shared_unit_property_names()
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling skip_features argument
        # SX2 has timestamps, so loading it back from Nwb will not recover the same spike frames. Set use_times=False
        write_sorting(
            sorting=self.SX2,
            save_path=path,
            skip_features=['widths'],
            use_times=False,
            overwrite=True
        )
        SX_nwb = se.NwbSortingExtractor(path, sampling_frequency=sf)
        assert 'widths' not in SX_nwb.get_shared_unit_spike_feature_names()
        check_sortings_equal(self.SX2, SX_nwb)
        check_dumping(SX_nwb)
    def test_nwb_extractor(self):
        path1 = self.test_dir + '/test.nwb'
        se.NwbRecordingExtractor.write_recording(self.RX, path1)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        del RX_nwb
        # overwrite
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path1,
                                                 overwrite=True)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        # add sorting to existing
        se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path1)
        # create new
        path2 = self.test_dir + '/firings_true.nwb'
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path2)
        se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path2)
        SX_nwb = se.NwbSortingExtractor(path2)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling unit property descriptions argument
        property_descriptions = {
            'stability': 'this is a description of stability'
        }
        se.NwbSortingExtractor.write_sorting(
            sorting=self.SX,
            save_path=path1,
            property_descriptions=property_descriptions)
        # create new
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path2,
                                                 overwrite=True)
        se.NwbSortingExtractor.write_sorting(
            sorting=self.SX,
            save_path=path2,
            property_descriptions=property_descriptions)
        SX_nwb = se.NwbSortingExtractor(path2)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)
Example #4
0
    def test_nwb_extractor(self):
        path1 = self.test_dir + '/test.nwb'
        se.NwbRecordingExtractor.write_recording(self.RX, path1)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        del RX_nwb
        # overwrite
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path1)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        # add sorting to existing
        se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path1)
        # create new
        path2 = self.test_dir + '/firings_true.nwb'
        se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path2)
        SX_nwb = se.NwbSortingExtractor(path1)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)
Example #5
0
        def test_convert_sorting_extractor_to_nwb(self, se_class, dataset_path, se_kwargs):
            print(f"\n\n\n TESTING {se_class.extractor_name}...")
            dataset_stem = Path(dataset_path).stem
            self.dataset.get(dataset_path)

            sorting = se_class(**se_kwargs)
            sf = sorting.get_sampling_frequency()
            if sf is None:  # need to set dummy sampling frequency since no associated acquisition in file
                sf = 30000
                sorting.set_sampling_frequency(sf)

            if test_nwb:
                nwb_save_path = self.savedir / f"{se_class.__name__}_test_{dataset_stem}.nwb"
                se.NwbSortingExtractor.write_sorting(sorting, nwb_save_path)
                nwb_sorting = se.NwbSortingExtractor(nwb_save_path, sampling_frequency=sf)
                check_sortings_equal(sorting, nwb_sorting)

            if test_caching:
                sort_cache = se.CacheSortingExtractor(sorting)
                check_sortings_equal(sorting, sort_cache)
Example #6
0
    def test_nwb_extractor(self):
        path1 = self.test_dir + '/test.nwb'
        se.NwbRecordingExtractor.write_recording(self.RX, path1)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        del RX_nwb
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path1,
                                                 overwrite=True)
        RX_nwb = se.NwbRecordingExtractor(path1)
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)

        # append sorting to existing file
        se.NwbSortingExtractor.write_sorting(sorting=self.SX,
                                             save_path=path1,
                                             overwrite=False)

        path2 = self.test_dir + "/firings_true.nwb"
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path2)
        se.NwbSortingExtractor.write_sorting(sorting=self.SX, save_path=path2)
        SX_nwb = se.NwbSortingExtractor(path2)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling unit property descriptions argument
        property_descriptions = dict(
            stability="This is a description of stability.")
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path1,
                                                 overwrite=True)
        se.NwbSortingExtractor.write_sorting(
            sorting=self.SX,
            save_path=path1,
            property_descriptions=property_descriptions)
        SX_nwb = se.NwbSortingExtractor(path1)
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling skip_properties argument
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path1,
                                                 overwrite=True)
        se.NwbSortingExtractor.write_sorting(sorting=self.SX,
                                             save_path=path1,
                                             skip_properties=['stability'])
        SX_nwb = se.NwbSortingExtractor(path1)
        assert 'stability' not in SX_nwb.get_shared_unit_property_names()
        check_sortings_equal(self.SX, SX_nwb)
        check_dumping(SX_nwb)

        # Test for handling skip_features argument
        se.NwbRecordingExtractor.write_recording(recording=self.RX,
                                                 save_path=path1,
                                                 overwrite=True)
        # SX2 has timestamps, so loading it back from Nwb will not recover the same spike frames. USe use_times=False
        se.NwbSortingExtractor.write_sorting(sorting=self.SX2,
                                             save_path=path1,
                                             skip_features=['widths'],
                                             use_times=False)
        SX_nwb = se.NwbSortingExtractor(path1)
        assert 'widths' not in SX_nwb.get_shared_unit_spike_feature_names()
        check_sortings_equal(self.SX2, SX_nwb)
        check_dumping(SX_nwb)

        # Test writting multiple recordings using metadata
        metadata = get_default_nwbfile_metadata()
        path_nwb = self.test_dir + '/test_multiple.nwb'
        se.NwbRecordingExtractor.write_recording(
            recording=self.RX,
            save_path=path_nwb,
            metadata=metadata,
            write_as='raw',
            es_key='ElectricalSeries_raw',
        )
        se.NwbRecordingExtractor.write_recording(
            recording=self.RX2,
            save_path=path_nwb,
            metadata=metadata,
            write_as='processed',
            es_key='ElectricalSeries_processed',
        )
        se.NwbRecordingExtractor.write_recording(
            recording=self.RX3,
            save_path=path_nwb,
            metadata=metadata,
            write_as='lfp',
            es_key='ElectricalSeries_lfp',
        )

        RX_nwb = se.NwbRecordingExtractor(file_path=path_nwb,
                                          electrical_series_name='raw_traces')
        check_recording_return_types(RX_nwb)
        check_recordings_equal(self.RX, RX_nwb)
        check_dumping(RX_nwb)
        del RX_nwb