Merge pull request #32 from AurelienJaquier/lfpy-add-tests

Add tests to the new LFPy classes and functions

Author: alejoe91

bluepyopt/ephys/objectives.py

@@ -85,7 +85,7 @@ def __str__(self):
         """String representation"""
 
         return '( %s )' % self.features[0]
-    
+
 
 class SingletonWeightObjective(EFeatureObjective):
 

bluepyopt/ephys/parameters.py

@@ -252,8 +252,8 @@ class NrnPointProcessParameter(NrnParameter, DictMixin):
 
     """Parameter of a section"""
     SERIALIZED_FIELDS = ('name', 'value', 'frozen', 'bounds', 'param_name',
-                         'value_scaler', 'locations', 'param_name', 
-                         'param_dependencies')
+                         'value_scaler', 'locations', 'param_name',
+                         'param_dependancies')
 
     def __init__(
             self,

bluepyopt/ephys/parameterscalers.py

@@ -92,7 +92,7 @@ def __str__(self):
 class NrnSegmentSectionDistanceScaler(ParameterScaler, DictMixin):
 
     """Scaler based on distance from soma"""
-    SERIALIZED_FIELDS = ('name', 'comment', 'distribution', 
+    SERIALIZED_FIELDS = ('name', 'comment', 'distribution',
                          "distribution", "dist_param_names",
                          "ref_sec", "ref_location",)
 

bluepyopt/tests/test_ephys/test_extra_features_utils.py

@@ -0,0 +1,139 @@
+"""Tests for ephys.extra_features_utils"""
+
+import os
+
+import numpy
+import pytest
+
+from bluepyopt import ephys
+
+
+testdata_dir = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), 'testdata'
+)
+waveforms_fpath = os.path.join(testdata_dir, 'mean_waveforms.dat')
+waveforms = numpy.loadtxt(waveforms_fpath)
+waveform = numpy.array([waveforms[0]])
+sampling_freq = 10000
+
+
+@pytest.mark.unit
+def test_peak_to_valley():
+    """ephys.extra_features_utils: Test peak_to_valley"""
+    ptv = ephys.extra_features_utils.peak_to_valley(waveform, sampling_freq)
+    assert len(ptv) == 1
+    assert ptv[0] == pytest.approx(0.0013)
+
+
+@pytest.mark.unit
+def test_peak_trough_ratio():
+    """ephys.extra_features_utils: Test peak_trough_ratio"""
+    ptratio = ephys.extra_features_utils.peak_trough_ratio(waveform)
+    assert len(ptratio) == 1
+    print(ptratio)
+    assert ptratio[0] == pytest.approx(0.53804035)
+
+
+@pytest.mark.unit
+def test_halfwidth():
+    """ephys.extra_features_utils: Test halfwidth"""
+    ret = ephys.extra_features_utils.halfwidth(waveform, sampling_freq, True)
+    assert len(ret) == 3
+
+    hw = ephys.extra_features_utils.halfwidth(waveform, sampling_freq)
+    assert len(hw) == 1
+    assert hw[0] == pytest.approx(0.0015)
+
+
+@pytest.mark.unit
+def test_repolarization_slope():
+    """ephys.extra_features_utils: Test repolarization_slope"""
+    ret = ephys.extra_features_utils.repolarization_slope(
+        waveform, sampling_freq, True
+    )
+    assert len(ret) == 2
+
+    rslope = ephys.extra_features_utils.repolarization_slope(
+        waveform, sampling_freq
+    )
+    assert len(rslope) == 1
+    assert rslope[0] == pytest.approx(73.12572131)
+
+
+@pytest.mark.unit
+def test_recovery_slope():
+    """ephys.extra_features_utils: Test recovery_slope"""
+    window = 0.7
+    rslope = ephys.extra_features_utils.recovery_slope(
+        waveform, sampling_freq, window=window
+    )
+    assert len(rslope) == 1
+    assert rslope[0] == pytest.approx(-3.63355521)
+
+
+@pytest.mark.unit
+def test_peak_image():
+    """ephys.extra_features_utils: Test peak_image"""
+    rel_peaks = ephys.extra_features_utils.peak_image(
+        waveforms, sign="negative"
+    )
+    assert len(rel_peaks) == 209
+    assert rel_peaks[0] == pytest.approx(0.06084468)
+
+    rel_peaks = ephys.extra_features_utils.peak_image(
+        waveforms, sign="positive"
+    )
+    assert len(rel_peaks) == 209
+    assert rel_peaks[0] == pytest.approx(0.10850117)
+
+
+@pytest.mark.unit
+def test_relative_amplitude():
+    """ephys.extra_features_utils: Test relative_amplitude"""
+    rel_amp = ephys.extra_features_utils.relative_amplitude(
+        waveforms, sign="negative"
+    )
+    assert len(rel_amp) == 209
+    assert rel_amp[0] == pytest.approx(0.09513392)
+
+    rel_amp = ephys.extra_features_utils.relative_amplitude(
+        waveforms, sign="positive"
+    )
+    assert len(rel_amp) == 209
+    assert rel_amp[0] == pytest.approx(0.2135929)
+
+
+@pytest.mark.unit
+def test_peak_time_diff():
+    """ephys.extra_features_utils: Test peak_time_diff"""
+    peak_t = ephys.extra_features_utils.peak_time_diff(
+        waveforms, sampling_freq, sign="negative"
+    )
+    assert len(peak_t) == 209
+    assert peak_t[0] == pytest.approx(0.0009)
+
+    peak_t = ephys.extra_features_utils.peak_time_diff(
+        waveforms, sampling_freq, sign="positive"
+    )
+    assert len(peak_t) == 209
+    assert peak_t[0] == pytest.approx(0.0007)
+
+
+@pytest.mark.unit
+def test__get_trough_and_peak_idx():
+    """ephys.extra_features_utils: Test _get_trough_and_peak_idx"""
+    t_idx, p_idx = ephys.extra_features_utils._get_trough_and_peak_idx(
+        waveform
+    )
+    assert t_idx == 102
+    assert p_idx == 115
+
+
+@pytest.mark.unit
+def test_calculate_features():
+    """ephys.extra_features_utils: Test calculate_features"""
+    feats = ephys.extra_features_utils.calculate_features(
+        waveforms, sampling_freq
+    )
+    for feature_name in ephys.extra_features_utils.all_1D_features:
+        assert feature_name in feats

bluepyopt/tests/test_ephys/test_features.py

@@ -246,3 +246,72 @@ def test_eFELFeature_serialize():
     assert isinstance(deserialized, efeatures.eFELFeature)
     assert deserialized.stim_start == 700
     assert deserialized.recording_names == recording_names
+
+
+@pytest.mark.unit
+def test_extraFELFeature():
+    """ephys.efeatures: Testing extraFELFeature calculation"""
+    import pandas as pd
+
+    somatic_recording_name = 'soma_response'
+    recording_names = {'': 'lfp_response'}
+    channel_ids = 0
+    extrafel_feature_name = 'halfwidth'
+    name = 'test_extraFELFeature'
+    stim_start = 400
+    stim_end = 1750
+    fs = 10
+    ms_cut = [10, 25]
+
+    # load responses from file
+    testdata_dir = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), 'testdata'
+    )
+    resp_fname = os.path.join(testdata_dir, 'lfpy_response_with_soma.pkl')
+    responses_lst = pd.read_pickle(resp_fname)
+    responses = {
+        somatic_recording_name: responses_lst[0][1],
+        recording_names['']: responses_lst[0][0],
+    }
+
+    # compute for all electrodes
+    efeature = efeatures.extraFELFeature(
+        name=name,
+        extrafel_feature_name=extrafel_feature_name,
+        somatic_recording_name=somatic_recording_name,
+        recording_names=recording_names,
+        channel_ids=None,
+        exp_mean=0.001,
+        exp_std=0.001,
+        stim_start=stim_start,
+        stim_end=stim_end,
+        fs=fs,
+        ms_cut=ms_cut
+    )
+
+    ret = efeature.calculate_feature(responses, raise_warnings=True)
+    assert len(ret) == 209
+
+    # compute for 1 electrode
+    efeature = efeatures.extraFELFeature(
+        name=name,
+        extrafel_feature_name=extrafel_feature_name,
+        somatic_recording_name=somatic_recording_name,
+        recording_names=recording_names,
+        channel_ids=channel_ids,
+        exp_mean=0.001,
+        exp_std=0.001,
+        stim_start=stim_start,
+        stim_end=stim_end,
+        fs=fs,
+        ms_cut=ms_cut
+    )
+
+    ret = efeature.calculate_feature(responses, raise_warnings=True)
+    numpy.testing.assert_almost_equal(ret, 0.0015)
+
+    score = efeature.calculate_score(responses)
+    numpy.testing.assert_almost_equal(score, 0.5)
+
+    assert efeature.name == name
+    assert extrafel_feature_name in str(efeature)

bluepyopt/tests/test_ephys/test_models.py

@@ -180,6 +180,17 @@ def test_CellModel_destroy():
     assert 0 == len(sim.neuron.h.CellModel_destroy)
 
 
+@pytest.mark.unit
+def test_lfpy_create_empty_template():
+    """ephys.models: Test creation of lfpy empty template"""
+    template_name = 'FakeTemplate'
+    hoc_template = ephys.models.LFPyCellModel.create_empty_template(
+        template_name
+    )
+    sim.neuron.h(hoc_template)
+    assert hasattr(sim.neuron.h, template_name)
+
+
 @pytest.mark.unit
 def test_lfpycellmodel():
     """ephys.models: Test LFPyCellModel class"""
@@ -197,6 +208,97 @@ def test_lfpycellmodel():
     assert isinstance(model, ephys.models.LFPyCellModel)
 
 
+@pytest.mark.unit
+def test_lfpycellmodel_namecheck():
+    """ephys.models: Test LFPyCellModel class name checking"""
+
+    # Test valid name
+    for name in ['test3', 'test_3']:
+        ephys.models.LFPyCellModel(name, morph=test_morph, mechs=[])
+
+    # Test invalid names
+    for name in ['3test', '', 'test$', 'test 3']:
+        with pytest.raises(TypeError):
+            ephys.models.LFPyCellModel(name, morph=test_morph, mechs=[])
+
+
+@pytest.mark.unit
+def test_load_lfpy_hoc_template():
+    """ephys.models: Test loading of hoc template with lfpy cell"""
+
+    template_name = 'test_load_hoc'
+    hoc_string = ephys.models.LFPyCellModel.create_empty_template(
+        template_name
+    )
+    ephys.models.HocCellModel.load_hoc_template(sim, hoc_string)
+    assert hasattr(sim.neuron.h, template_name)
+
+
+@pytest.mark.unit
+def test_LFPyCellModel_create_empty_cell():
+    """ephys.models: Test create_empty_cell with lfpy cell"""
+    template_name = 'create_empty_cell'
+    cell = ephys.models.LFPyCellModel.create_empty_cell(template_name, sim)
+    assert callable(cell)
+    assert hasattr(sim.neuron.h, template_name)
+
+
+@pytest.mark.unit
+def test_LFPyCellModel_create_hoc():
+    """ephys.models: Test create_hoc with lfpy cell"""
+
+    morph0 = ephys.morphologies.NrnFileMorphology(
+        simple_morphology_path,
+        do_replace_axon=True
+    )
+
+    cell_model = ephys.models.LFPyCellModel(
+        'LFPyCellModel',
+        morph=morph0,
+        mechs=[],
+        params=[]
+    )
+
+    hoc_string = cell_model.create_hoc({})
+    assert 'begintemplate LFPyCellModel' in hoc_string
+    assert 'proc replace_axon()' in hoc_string
+    cell_model_hoc = ephys.models.HocCellModel(
+        'CellModelHOC',
+        simple_morphology_path,
+        hoc_string=hoc_string)
+
+    assert isinstance(cell_model_hoc, ephys.models.HocCellModel)
+
+
+@pytest.mark.unit
+def test_LFPyCellModel_destroy():
+    """ephys.models: Test LFPyCellModel destroy"""
+    morph0 = ephys.morphologies.NrnFileMorphology(simple_morphology_path)
+    cell_model0 = ephys.models.LFPyCellModel(
+        'LFPyCellModel_destroy', morph=morph0, mechs=[], params=[]
+    )
+    morph1 = ephys.morphologies.NrnFileMorphology(simple_morphology_path)
+    cell_model1 = ephys.models.LFPyCellModel(
+        'LFPyCellModel_destroy', morph=morph1, mechs=[], params=[]
+    )
+
+    assert not hasattr(sim.neuron.h, 'LFPyCellModel_destroy')
+
+    cell_model0.instantiate(sim=sim)
+    assert hasattr(sim.neuron.h, 'LFPyCellModel_destroy')
+    assert 1 == len(sim.neuron.h.LFPyCellModel_destroy)
+
+    cell_model1.instantiate(sim=sim)
+    assert 2 == len(sim.neuron.h.LFPyCellModel_destroy)
+
+    # make sure cleanup works
+    cell_model0.destroy(sim=sim)
+    assert 1 == len(sim.neuron.h.LFPyCellModel_destroy)
+
+    cell_model1.destroy(sim=sim)
+    assert 0 == len(sim.neuron.h.LFPyCellModel_destroy)
+
+
 @pytest.mark.unit
 def test_metaparameter():
     """ephys.models: Test model with MetaParameter"""