code cleanup - renamed data -> timeseries

Author: Thinh Nguyen

elements_ephys/ephys.py

@@ -228,7 +228,7 @@ def make(self, key):
             spikeglx_rec_dir = (root_dir / spikeglx_meta_fp).parent
             spikeglx_recording = spikeglx.SpikeGLX(spikeglx_rec_dir)
 
-            lfp = spikeglx_recording.lfdata[:, :-1].T  # exclude the sync channel
+            lfp = spikeglx_recording.lf_timeseries[:, :-1].T  # exclude the sync channel
 
             self.insert1(dict(key,
                               lfp_sampling_rate=spikeglx_recording.lfmeta.meta['imSampRate'],
@@ -252,7 +252,7 @@ def make(self, key):
             sess_dir = pathlib.Path(get_session_directory(key))
             loaded_oe = openephys.OpenEphys(sess_dir)
             oe_probe = loaded_oe.probes[probe_sn]
-            lfp = oe_probe.lfp_data
+            lfp = oe_probe.lfp_timeseries
             lfp_timestamps = oe_probe.lfp_timestamps
 
             self.insert1(dict(key,

elements_ephys/readers/openephys.py

@@ -96,10 +96,9 @@ def __init__(self, processor):
         self.probe_SN = self.probe_info['@probe_serial_number']
 
         # Determine probe-model (TODO: how to determine npx 2.0 SS and MS?)
-        if processor['@pluginName'] == 'Neuropix-PXI':
-            self.probe_model = 'neuropixels 1.0 - 3B'
-        elif processor['@pluginName'] == 'Neuropix-3a':
-            self.probe_model = 'neuropixels 1.0 - 3A'
+        self.probe_model = {
+            "Neuropix-PXI": "neuropixels 1.0 - 3B",
+            "Neuropix-3a": "neuropixels 1.0 - 3A"}[processor['@pluginName']]
 
         self.ap_meta = None
         self.lfp_meta = None
@@ -112,21 +111,21 @@ def __init__(self, processor):
                                'recording_durations': [],
                                'recording_files': []}
 
-        self._ap_data = None
+        self._ap_timeseries = None
         self._ap_timestamps = None
-        self._lfp_data = None
+        self._lfp_timeseries = None
         self._lfp_timestamps = None
 
     @property
-    def ap_data(self):
+    def ap_timeseries(self):
         """
         AP data concatenated across recordings. Shape: (sample x channel)
         Channels' gains (bit_volts) applied - unit: uV
         """
-        if self._ap_data is None:
-            self._ap_data = np.hstack([s.signal for s in self.ap_analog_signals]).T
-            self._ap_data = self._ap_data * self.ap_meta['channels_gains']
-        return self._ap_data
+        if self._ap_timeseries is None:
+            self._ap_timeseries = np.hstack([s.signal for s in self.ap_analog_signals]).T
+            self._ap_timeseries *= self.ap_meta['channels_gains']
+        return self._ap_timeseries
 
     @property
     def ap_timestamps(self):
@@ -135,15 +134,15 @@ def ap_timestamps(self):
         return self._ap_timestamps
 
     @property
-    def lfp_data(self):
+    def lfp_timeseries(self):
         """
         LFP data concatenated across recordings. Shape: (sample x channel)
         Channels' gains (bit_volts) applied - unit: uV
         """
-        if self._lfp_data is None:
-            self._lfp_data = np.hstack([s.signal for s in self.lfp_analog_signals]).T
-            self._lfp_data = self._lfp_data * self.lfp_meta['channels_gains']
-        return self._lfp_data
+        if self._lfp_timeseries is None:
+            self._lfp_timeseries = np.hstack([s.signal for s in self.lfp_analog_signals]).T
+            self._lfp_timeseries *= self.lfp_meta['channels_gains']
+        return self._lfp_timeseries
 
     @property
     def lfp_timestamps(self):
@@ -171,7 +170,7 @@ def extract_spike_waveforms(self, spikes, channel, n_wf=500, wf_win=(-32, 32)):
         if len(spikes) > 0:
             spike_indices = np.searchsorted(self.ap_timestamps, spikes, side="left")
             # waveform at each spike: (sample x channel x spike)
-            spike_wfs = np.dstack([self.ap_data[int(spk + wf_win[0]):int(spk + wf_win[-1]), channel_ind]
+            spike_wfs = np.dstack([self.ap_timeseries[int(spk + wf_win[0]):int(spk + wf_win[-1]), channel_ind]
                                    for spk in spike_indices])
             return spike_wfs
         else:  # if no spike found, return NaN of size (sample x channel x 1)

elements_ephys/readers/spikeglx.py

@@ -23,8 +23,8 @@ def __init__(self, root_dir):
         name & associated meta - no interpretation of g0_t0.imec, etc is
         performed at this layer.
         '''
-        self._apmeta, self._apdata = None, None
-        self._lfmeta, self._lfdata = None, None
+        self._apmeta, self._ap_timeseries = None, None
+        self._lfmeta, self._lf_timeseries = None, None
 
         self.root_dir = pathlib.Path(root_dir)
 
@@ -38,15 +38,15 @@ def apmeta(self):
         return self._apmeta
 
     @property
-    def apdata(self):
+    def ap_timeseries(self):
         """
         AP data: (sample x channel)
         Channels' gains (bit_volts) applied - unit: uV
         """
-        if self._apdata is None:
-            self._apdata = self._read_bin(self.root_dir / (self.root_name + '.ap.bin'))
-            self._apdata = self._apdata * self.get_channel_bit_volts('ap')
-        return self._apdata
+        if self._ap_timeseries is None:
+            self._ap_timeseries = self._read_bin(self.root_dir / (self.root_name + '.ap.bin'))
+            self._ap_timeseries *= self.get_channel_bit_volts('ap')
+        return self._ap_timeseries
 
     @property
     def lfmeta(self):
@@ -55,15 +55,15 @@ def lfmeta(self):
         return self._lfmeta
 
     @property
-    def lfdata(self):
+    def lf_timeseries(self):
         """
         LFP data: (sample x channel)
         Channels' gains (bit_volts) applied - unit: uV
         """
-        if self._lfdata is None:
-            self._lfdata = self._read_bin(self.root_dir / (self.root_name + '.lf.bin'))
-            self._lfdata = self._lfdata * self.get_channel_bit_volts('lf')
-        return self._lfdata
+        if self._lf_timeseries is None:
+            self._lf_timeseries = self._read_bin(self.root_dir / (self.root_name + '.lf.bin'))
+            self._lf_timeseries *= self.get_channel_bit_volts('lf')
+        return self._lf_timeseries
 
     def get_channel_bit_volts(self, band='ap'):
         """
@@ -105,7 +105,7 @@ def extract_spike_waveforms(self, spikes, channel, n_wf=500, wf_win=(-32, 32), b
         :return: waveforms (sample x channel x spike)
         """
 
-        data = self.apdata
+        data = self.ap_timeseries
         channel_idx = [np.where(self.apmeta.recording_channels == chn)[0][0] for chn in channel]
 
         spikes = np.round(spikes * self.apmeta.meta['imSampRate']).astype(int)  # convert to sample