Adds the ability to extract for absolute amplitude in addition to (#114)

relative amplitude

bluepyefe/ecode/DeHyperPol.py

@@ -125,13 +125,5 @@ def compute_relative_amp(self, amp_threshold):
         self.amp2_rel = 100.0 * self.amp2 / amp_threshold
         self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
 
-    def in_target(self, target, tolerance):
-        """Returns a boolean. True if the amplitude of the eCode is close to
-        target and False otherwise."""
-        if numpy.abs(target - self.amp_rel) < tolerance:
-            return True
-        else:
-            return False
-
     def get_plot_amplitude_title(self):
         return " ({:.01f}%/{:.01f}%)".format(self.amp_rel, self.amp2_rel)

bluepyefe/ecode/HyperDePol.py

@@ -126,13 +126,5 @@ def compute_relative_amp(self, amp_threshold):
         self.amp2_rel = 100.0 * self.amp2 / amp_threshold
         self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
 
-    def in_target(self, target, tolerance):
-        """Returns a boolean. True if the amplitude of the eCode is close to
-        target and False otherwise."""
-        if numpy.abs(target - self.amp_rel) < tolerance:
-            return True
-        else:
-            return False
-
     def get_plot_amplitude_title(self):
         return " ({:.01f}%/{:.01f}%)".format(self.amp_rel, self.amp2_rel)

bluepyefe/ecode/SpikeRec.py

@@ -171,12 +171,7 @@ def generate(self):
 
         return t, current
 
-    def compute_relative_amp(self, amp_threshold):
-        """Divide all the amplitude in the stimuli by the spiking amplitude"""
-        self.amp_rel = 100.0 * self.amp / amp_threshold
-        self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
-
-    def in_target(self, target, tolerance):
+    def in_target(self, target, tolerance, absolute_amplitude):
         """Returns a boolean. True if the delta of the eCode is close to
         target and False otherwise."""
         logger.warning(

bluepyefe/ecode/negCheops.py

@@ -126,15 +126,3 @@ def generate(self):
         current[mid:toff] += numpy.linspace(self.amp, 0.0, toff - mid)
 
         return time, current
-
-    def compute_relative_amp(self, amp_threshold):
-        self.amp_rel = 100.0 * self.amp / amp_threshold
-        self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
-
-    def in_target(self, target, tolerance):
-        """Returns a boolean. True if the amplitude of the eCode is close to
-        target and False otherwise."""
-        if numpy.abs(target - self.amp_rel) < tolerance:
-            return True
-        else:
-            return False

bluepyefe/ecode/posCheops.py

@@ -131,15 +131,3 @@ def generate(self):
         current[mid:toff] += numpy.linspace(self.amp, 0.0, toff - mid)
 
         return time, current
-
-    def compute_relative_amp(self, amp_threshold):
-        self.amp_rel = 100.0 * self.amp / amp_threshold
-        self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
-
-    def in_target(self, target, tolerance):
-        """Returns a boolean. True if the amplitude of the eCode is close to
-        target and False otherwise."""
-        if numpy.abs(target - self.amp_rel) < tolerance:
-            return True
-        else:
-            return False

bluepyefe/ecode/ramp.py

@@ -105,16 +105,3 @@ def generate(self):
         )
 
         return t, current
-
-    def compute_relative_amp(self, amp_threshold):
-        """Divide all the amplitude in the stimuli by the spiking amplitude"""
-        self.amp_rel = 100.0 * self.amp / amp_threshold
-        self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
-
-    def in_target(self, target, tolerance):
-        """Returns a boolean. True if the amplitude of the eCode is close to
-        target and False otherwise."""
-        if numpy.abs(target - self.amp_rel) < tolerance:
-            return True
-        else:
-            return False

bluepyefe/ecode/sAHP.py

@@ -135,13 +135,16 @@ def compute_relative_amp(self, amp_threshold):
         self.amp2_rel = 100.0 * self.amp2 / amp_threshold
         self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
 
-    def in_target(self, target, tolerance):
+    def in_target(self, target, tolerance, absolute_amplitude=False):
         """Returns a boolean. True if the amplitude of the eCode is close to
         target and False otherwise."""
-        if numpy.abs(target - self.amp2_rel) < tolerance:
+
+        effective_amp = self.amp2 if absolute_amplitude else self.amp2_rel
+
+        if numpy.abs(target - effective_amp) < tolerance:
             return True
-        else:
-            return False
+
+        return False
 
     def get_plot_amplitude_title(self):
         return " ({:.01f}%/{:.01f}%)".format(self.amp_rel, self.amp2_rel)

bluepyefe/ecode/sineSpec.py

@@ -129,16 +129,3 @@ def generate(self):
         current += self.hypamp
 
         return t, current
-
-    def compute_relative_amp(self, amp_threshold):
-        """Divide all the amplitude in the stimuli by the spiking amplitude"""
-        self.amp_rel = 100.0 * self.amp / amp_threshold
-        self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
-
-    def in_target(self, target, tolerance):
-        """Returns a boolean. True if the amplitude of the eCode is close to
-        target and False otherwise."""
-        if numpy.abs(target - self.amp_rel) < tolerance:
-            return True
-        else:
-            return False

bluepyefe/ecode/step.py

@@ -177,16 +177,3 @@ def generate(self):
         current[ton_idx:toff_idx] += self.amp
 
         return t, current
-
-    def compute_relative_amp(self, amp_threshold):
-        """Divide all the amplitude in the stimuli by the spiking amplitude"""
-        self.amp_rel = 100.0 * self.amp / amp_threshold
-        self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
-
-    def in_target(self, target, tolerance):
-        """Returns a boolean. True if the amplitude of the eCode is close to
-        target and False otherwise."""
-        if numpy.abs(target - self.amp_rel) < tolerance:
-            return True
-        else:
-            return False

bluepyefe/extract.py

@@ -309,7 +309,10 @@ def compute_rheobase(
 
 
 def _build_protocols(
-    targets, global_rheobase, protocol_mode, efel_settings=None
+    targets,
+    global_rheobase,
+    protocol_mode,
+    efel_settings=None
 ):
     """Build a list of Protocols that matches the expected targets"""
 
@@ -355,6 +358,7 @@ def _build_protocols(
 def group_efeatures(
     cells,
     targets,
+    absolute_amplitude=False,
     use_global_rheobase=True,
     protocol_mode='mean',
     efel_settings=None
@@ -380,6 +384,9 @@ def group_efeatures(
                     'Threshold': -10.
                 }
             }]
+        absolute_amplitude (bool): if True, will use the absolute amplitude
+            instead of the relative amplitudes of the recordings when checking
+            if a recording has to be used for a given target.
         use_global_rheobase (bool): As the final amplitude of a target is the
             mean of the amplitude of the cells, a global rheobase can be used
             to avoid issues when a cell matches a target but not another one.
@@ -399,7 +406,7 @@ def group_efeatures(
         efel_settings = {}
 
     global_rheobase = None
-    if use_global_rheobase:
+    if use_global_rheobase and not absolute_amplitude:
         global_rheobase = numpy.nanmean(
             [c.rheobase for c in cells if c.rheobase is not None]
         )
@@ -408,22 +415,23 @@ def group_efeatures(
         targets,
         global_rheobase=global_rheobase,
         protocol_mode=protocol_mode,
-        efel_settings=efel_settings
+        efel_settings=efel_settings,
     )
 
     for protocol in protocols:
         for cell in cells:
 
-            if cell.rheobase is None:
+            if cell.rheobase is None and not absolute_amplitude:
                 continue
 
             for recording in cell.get_recordings_by_protocol_name(
                     protocol.name
             ):
 
                 if recording.in_target(
-                        protocol.amplitude,
-                        protocol.tolerance
+                    protocol.amplitude,
+                    protocol.tolerance,
+                    absolute_amplitude
                 ):
                     protocol.append(recording)
 
@@ -659,6 +667,7 @@ def _extract_with_targets(
     files_metadata,
     targets=None,
     protocols_rheobase=None,
+    absolute_amplitude=False,
     recording_reader=None,
     map_function=map,
     low_memory_mode=False,
@@ -683,16 +692,18 @@ def _extract_with_targets(
             files_metadata, recording_reader, targets, efel_settings
         )
 
-    compute_rheobase(
-        cells,
-        protocols_rheobase=protocols_rheobase,
-        rheobase_strategy=rheobase_strategy,
-        rheobase_settings=rheobase_settings
-    )
+    if not absolute_amplitude:
+        compute_rheobase(
+            cells,
+            protocols_rheobase=protocols_rheobase,
+            rheobase_strategy=rheobase_strategy,
+            rheobase_settings=rheobase_settings
+        )
 
     protocols = group_efeatures(
         cells,
         targets,
+        absolute_amplitude=absolute_amplitude,
         use_global_rheobase=True,
         protocol_mode=protocol_mode,
         efel_settings=efel_settings
@@ -806,6 +817,7 @@ def extract_efeatures(
     targets=None,
     threshold_nvalue_save=1,
     protocols_rheobase=None,
+    absolute_amplitude=False,
     recording_reader=None,
     map_function=map,
     write_files=False,
@@ -839,9 +851,11 @@ def extract_efeatures(
             need to be present in the file metadata of different protocols if
             the path contains data coming from different stimuli (eg: for NWB).
         targets (list): define the efeatures to extract as well as which
-            protocols and current amplitude (expressed in % of the rheobase)
-            they should be extracted. If targets are not provided, automatic
-            targets will be used. Of the form:
+            protocols and current amplitude (expressed either in % of the
+            rheobase if absolute_amplitude if False or in nA if
+            absolute_amplitude is True) they should be extracted.
+            If targets are not provided, automatic targets will be used.
+            Of the form:
             [{
                 "efeature": "AP_amplitude",
                 "protocol": "IDRest",
@@ -857,6 +871,9 @@ def extract_efeatures(
             an efeatures to be averaged and returned in the output.
         protocols_rheobase (list): names of the protocols that will be
             used to compute the rheobase of the cells. E.g: ['IDthresh'].
+        absolute_amplitude (bool): if True, will use the absolute amplitude
+            instead of the relative amplitudes of the recordings when checking
+            if a recording has to be used for a given target.
         recording_reader (function): custom recording reader function. It's
             inner working has to match the metadata entered in files_metadata.
         map_function (function): Function used to map (parallelize) the
@@ -902,7 +919,7 @@ def extract_efeatures(
         )
         efel_settings = DEFAULT_EFEL_SETTINGS.copy()
 
-    if protocols_rheobase is None:
+    if protocols_rheobase is None and not absolute_amplitude:
         logger.warning(
             "protocols_rheobase is None. Default protocol names will be used"
         )
@@ -925,7 +942,10 @@ def extract_efeatures(
     if targets is not None and auto_targets is not None:
         raise Exception("Cannot specify both targets and auto_targets.")
 
-    if targets is None or auto_targets is not None:
+    if (
+        not absolute_amplitude and
+        (targets is None or auto_targets is not None)
+    ):
         cells, protocols, targets = _extract_auto_targets(
             files_metadata,
             protocols_rheobase,
@@ -942,6 +962,7 @@ def extract_efeatures(
             files_metadata,
             targets,
             protocols_rheobase,
+            absolute_amplitude,
             recording_reader,
             map_function,
             low_memory_mode,

bluepyefe/protocol.py

@@ -41,19 +41,21 @@ def __init__(
         tolerance,
         feature_targets=None,
         global_rheobase=None,
-        mode="mean"
+        mode="mean",
     ):
         """Constructor
 
         Args:
             name (str): name of the protocol (ex: 'APWaveform')
             amplitude (float): amplitude of the current stimuli for the
                 present protocol (expressed as a percentage of the
-                threshold amplitude (rheobase))
+                threshold amplitude or in absolute current depending on the
+                setting absolute_amplitude)
             tolerance (float): tolerance around the target amplitude in which
                 an experimental recording will be seen as a hit during
                 efeatures extraction (expressed as a percentage of the
-                threshold amplitude (rheobase))
+                threshold amplitude or in absolute current depending on the
+                setting absolute_amplitude)
             feature_targets (list): list of EFeatureTarget associated to the
                 protocol
             global_rheobase (float): average rheobase across all cells
@@ -187,7 +189,7 @@ def reduce_ecode(self, ecode, operator):
                 amp_rel = operator([c["amp_rel"] for c in params])
                 mean_param = float(amp_rel) * self.global_rheobase / 100.
             else:
-                mean_param = operator([c[key] for c in params])
+                mean_param = operator([numpy.nan if c[key] is None else c[key] for c in params])
 
             setattr(ecode, key, mean_param)
 

bluepyefe/recording.py

@@ -313,6 +313,23 @@ def compute_spikecount(self, efel_settings=None, offset_voltage=20.):
                     "voltage goes higher than the spike detection threshold."
                 )
 
+    def in_target(self, target, tolerance, absolute_amplitude=False):
+        """Returns a boolean. True if the amplitude of the eCode is close to
+        target and False otherwise."""
+
+        effective_amp = self.amp if absolute_amplitude else self.amp_rel
+
+        if numpy.abs(target - effective_amp) < tolerance:
+            return True
+
+        return False
+
+    def compute_relative_amp(self, amp_threshold):
+        """Divide all the amplitude in the stimuli by the spiking amplitude"""
+
+        self.amp_rel = 100.0 * self.amp / amp_threshold
+        self.hypamp_rel = 100.0 * self.hypamp / amp_threshold
+
     def get_plot_amplitude_title(self):
         return " ({:.01f}%)".format(self.amp_rel)