Merge pull request #927 from alejoe91/mearecio

Implemented MEArecIO

Author: samuelgarcia

.circleci/config.yml

@@ -40,6 +40,8 @@ jobs:
             pip install -r requirements.txt
             pip install -r .circleci/requirements_testing.txt
             pip install .
+            # install packages that depend on neo
+            pip install MEArec
             pip freeze
 
       - save_cache:

doc/source/authors.rst

@@ -53,6 +53,7 @@ and may not be the current affiliation of a contributor.
 * Hugo van Kemenade
 * Aitor Morales-Gregorio [13]
 * Peter N Steinmetz [22]
+* Alessio Buccino [23]
 
 1. Centre de Recherche en Neuroscience de Lyon, CNRS UMR5292 - INSERM U1028 - Universite Claude Bernard Lyon 1
 2. Unité de Neuroscience, Information et Complexité, CNRS UPR 3293, Gif-sur-Yvette, France
@@ -76,6 +77,7 @@ and may not be the current affiliation of a contributor.
 20. Harden Technologies, LLC
 21. Institut des Neurosciences Paris-Saclay, CNRS UMR 9197 - Université Paris-Sud, Gif-sur-Yvette, France
 22. Neurtex Brain Research Institute, Dallas, TX, USAs
+23. Bio Engineering Laboratory, DBSSE, ETH, Basel, Switzerland
 
 If we've somehow missed you off the list we're very sorry - please let us know.
 

neo/io/__init__.py

@@ -30,6 +30,7 @@
 * :attr:`ElanIO`
 * :attr:`IgorIO`
 * :attr:`IntanIO`
+* :attr:`MEArecIO`
 * :attr:`KlustaKwikIO`
 * :attr:`KwikIO`
 * :attr:`MicromedIO`
@@ -132,6 +133,10 @@
 
     .. autoattribute:: extensions
 
+.. autoclass:: neo.io.MEArecIO
+
+    .. autoattribute:: extensions
+
 .. autoclass:: neo.io.MicromedIO
 
     .. autoattribute:: extensions
@@ -261,6 +266,7 @@
 from neo.io.intanio import IntanIO
 from neo.io.klustakwikio import KlustaKwikIO
 from neo.io.kwikio import KwikIO
+from neo.io.mearecio import MEArecIO
 from neo.io.micromedio import MicromedIO
 from neo.io.hdf5io import NeoHdf5IO
 from neo.io.neomatlabio import NeoMatlabIO
@@ -306,6 +312,7 @@
     IntanIO,
     KlustaKwikIO,
     KwikIO,
+    MEArecIO,
     MicromedIO,
     NixIO,  # place NixIO before NeoHdf5IO to make it the default for .h5 files
     NeoHdf5IO,

neo/io/mearecio.py

@@ -0,0 +1,11 @@
+from neo.io.basefromrawio import BaseFromRaw
+from neo.rawio.mearecrawio import MEArecRawIO
+
+
+class MEArecIO(MEArecRawIO, BaseFromRaw):
+    __doc__ = MEArecRawIO.__doc__
+    mode = 'file'
+
+    def __init__(self, filename):
+        MEArecRawIO.__init__(self, filename=filename)
+        BaseFromRaw.__init__(self, filename)

neo/rawio/__init__.py

@@ -18,6 +18,7 @@
 * :attr:`BrainVisionRawIO`
 * :attr:`ElanRawIO`
 * :attr:`IntanRawIO`
+* :attr:`MEArecRawIO`
 * :attr:`MicromedRawIO`
 * :attr:`NeuralynxRawIO`
 * :attr:`NeuroExplorerRawIO`
@@ -58,6 +59,10 @@
 
     .. autoattribute:: extensions
 
+.. autoclass:: neo.rawio.MEArecRawIO
+
+    .. autoattribute:: extensions
+
 .. autoclass:: neo.rawio.MicromedRawIO
 
     .. autoattribute:: extensions
@@ -124,6 +129,7 @@
 from neo.rawio.elanrawio import ElanRawIO
 from neo.rawio.examplerawio import ExampleRawIO
 from neo.rawio.intanrawio import IntanRawIO
+from neo.rawio.mearecrawio import MEArecRawIO
 from neo.rawio.micromedrawio import MicromedRawIO
 from neo.rawio.neuralynxrawio.neuralynxrawio import NeuralynxRawIO
 from neo.rawio.neuroexplorerrawio import NeuroExplorerRawIO
@@ -147,6 +153,7 @@
     ElanRawIO,
     IntanRawIO,
     MicromedRawIO,
+    MEArecRawIO,
     NeuralynxRawIO,
     NeuroExplorerRawIO,
     NeuroScopeRawIO,

neo/rawio/mearecrawio.py

@@ -0,0 +1,160 @@
+"""
+Class for reading data from a MEArec simulated data.
+
+See:
+https://mearec.readthedocs.io/en/latest/
+https://github.com/alejoe91/MEArec
+https://link.springer.com/article/10.1007/s12021-020-09467-7
+
+Author : Alessio Buccino
+"""
+
+from .baserawio import (BaseRawIO, _signal_channel_dtype, _unit_channel_dtype,
+                        _event_channel_dtype)
+
+import numpy as np
+from copy import deepcopy
+
+
+class MEArecRawIO(BaseRawIO):
+    """
+    Class for "reading" fake data from a MEArec file.
+
+    Usage:
+        >>> import neo.rawio
+        >>> r = neo.rawio.MEArecRawIO(filename='mearec.h5')
+        >>> r.parse_header()
+        >>> print(r)
+        >>> raw_chunk = r.get_analogsignal_chunk(block_index=0, seg_index=0,
+                            i_start=0, i_stop=1024,  channel_names=channel_names)
+        >>> float_chunk = reader.rescale_signal_raw_to_float(raw_chunk, dtype='float64',
+                            channel_indexes=[0, 3, 6])
+        >>> spike_timestamp = reader.spike_timestamps(unit_index=0, t_start=None, t_stop=None)
+        >>> spike_times = reader.rescale_spike_timestamp(spike_timestamp, 'float64')
+
+    """
+    extensions = ['h5']
+    rawmode = 'one-file'
+
+    def __init__(self, filename=''):
+        BaseRawIO.__init__(self)
+        self.filename = filename
+
+    def _source_name(self):
+        return self.filename
+
+    def _parse_header(self):
+        try:
+            import MEArec as mr
+            HAVE_MEAREC = True
+        except ImportError:
+            HAVE_MEAREC = False
+        assert HAVE_MEAREC, 'MEArec is not installed'
+        self._recgen = mr.load_recordings(recordings=self.filename, return_h5_objects=True,
+                                          check_suffix=False,
+                                          load=['recordings', 'spiketrains', 'channel_positions'],
+                                          load_waveforms=False)
+        self._sampling_rate = self._recgen.info['recordings']['fs']
+        self._recordings = self._recgen.recordings
+        self._num_frames, self._num_channels = self._recordings.shape
+        sig_channels = []
+        for c in range(self._num_channels):
+            ch_name = 'ch{}'.format(c)
+            chan_id = c + 1
+            sr = self._sampling_rate  # Hz
+            dtype = self._recordings.dtype
+            units = 'uV'
+            gain = 1.
+            offset = 0.
+            group_id = 0
+            sig_channels.append((ch_name, chan_id, sr, dtype, units, gain, offset, group_id))
+        sig_channels = np.array(sig_channels, dtype=_signal_channel_dtype)
+
+        # creating units channels
+        unit_channels = []
+        self._spiketrains = self._recgen.spiketrains
+        for c in range(len(self._spiketrains)):
+            unit_name = 'unit{}'.format(c)
+            unit_id = '#{}'.format(c)
+            # if spiketrains[c].waveforms is not None:
+            wf_units = ''
+            wf_gain = 1.
+            wf_offset = 0.
+            wf_left_sweep = 0
+            wf_sampling_rate = self._sampling_rate
+            unit_channels.append((unit_name, unit_id, wf_units, wf_gain,
+                                  wf_offset, wf_left_sweep, wf_sampling_rate))
+        unit_channels = np.array(unit_channels, dtype=_unit_channel_dtype)
+
+        event_channels = []
+        event_channels = np.array(event_channels, dtype=_event_channel_dtype)
+
+        self.header = {}
+        self.header['nb_block'] = 1
+        self.header['nb_segment'] = [1]
+        self.header['signal_channels'] = sig_channels
+        self.header['unit_channels'] = unit_channels
+        self.header['event_channels'] = event_channels
+
+        self._generate_minimal_annotations()
+        for block_index in range(1):
+            bl_ann = self.raw_annotations['blocks'][block_index]
+            bl_ann['mearec_info'] = deepcopy(self._recgen.info)
+
+    def _segment_t_start(self, block_index, seg_index):
+        all_starts = [[0.]]
+        return all_starts[block_index][seg_index]
+
+    def _segment_t_stop(self, block_index, seg_index):
+        t_stop = self._num_frames / self._sampling_rate
+        all_stops = [[t_stop]]
+        return all_stops[block_index][seg_index]
+
+    def _get_signal_size(self, block_index, seg_index, channel_indexes=None):
+        return self._num_frames
+
+    def _get_signal_t_start(self, block_index, seg_index, channel_indexes):
+        return self._segment_t_start(block_index, seg_index)
+
+    def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop, channel_indexes):
+        if i_start is None:
+            i_start = 0
+        if i_stop is None:
+            i_stop = self._num_frames
+
+        if channel_indexes is None:
+            channel_indexes = slice(self._num_channels)
+
+        raw_signals = self._recgen.recordings[i_start:i_stop, channel_indexes]
+        return raw_signals
+
+    def _spike_count(self, block_index, seg_index, unit_index):
+        return len(self._spiketrains[unit_index])
+
+    def _get_spike_timestamps(self, block_index, seg_index, unit_index, t_start, t_stop):
+        spike_timestamps = self._spiketrains[unit_index].times.magnitude
+        if t_start is None:
+            t_start = self._segment_t_start(block_index, seg_index)
+        if t_stop is None:
+            t_stop = self._segment_t_stop(block_index, seg_index)
+        timestamp_idxs = np.where((spike_timestamps >= t_start) & (spike_timestamps < t_stop))
+
+        return spike_timestamps[timestamp_idxs]
+
+    def _rescale_spike_timestamp(self, spike_timestamps, dtype):
+        return spike_timestamps.astype(dtype)
+
+    def _get_spike_raw_waveforms(self, block_index, seg_index, unit_index, t_start, t_stop):
+        return None
+
+    def _event_count(self, block_index, seg_index, event_channel_index):
+        return None
+
+    def _get_event_timestamps(self, block_index, seg_index, event_channel_index, t_start, t_stop):
+        return None
+
+    def _rescale_event_timestamp(self, event_timestamps, dtype):
+        return None
+
+    def _rescale_epoch_duration(self, raw_duration, dtype):
+        return None

neo/test/iotest/test_mearecio.py

@@ -0,0 +1,18 @@
+"""
+Tests of neo.io.mearecio
+"""
+
+import unittest
+
+from neo.io import MEArecIO
+from neo.test.iotest.common_io_test import BaseTestIO
+
+
+class TestMEArecIO(BaseTestIO, unittest.TestCase):
+    files_to_test = ['mearec_test_10s.h5']
+    files_to_download = ['mearec_test_10s.h5']
+    ioclass = MEArecIO
+
+
+if __name__ == "__main__":
+    unittest.main()

neo/test/rawiotest/test_mearecrawio.py

@@ -0,0 +1,20 @@
+"""
+Tests of neo.rawio.mearecrawio
+
+"""
+
+import unittest
+
+from neo.rawio.mearecrawio import MEArecRawIO
+
+from neo.test.rawiotest.common_rawio_test import BaseTestRawIO
+
+
+class TestMEArecRawIO(BaseTestRawIO, unittest.TestCase, ):
+    rawioclass = MEArecRawIO
+    files_to_download = ['mearec_test_10s.h5']
+    entities_to_test = ['mearec_test_10s.h5']
+
+
+if __name__ == "__main__":
+    unittest.main()