use modern nest notations

Author: Helveg

testsuite/pytests/sli2py_neurons/test_iaf_ps_dc_accuracy.py

@@ -34,22 +34,9 @@
         "iaf_psc_exp_ps_lossless",
     ],
 )
-@pytest.mark.parametrize("resolution", [2**i for i in range(0, -14, -1)])
-@pytest.mark.parametrize(
-    "params",
-    [
-        {
-            "E_L": 0.0,  # resting potential in mV
-            "V_m": 0.0,  # initial membrane potential in mV
-            "V_th": 2000.0,  # spike threshold in mV
-            "I_e": 1000.0,  # DC current in pA
-            "tau_m": 10.0,  # membrane time constant in ms
-            "C_m": 250.0,  # membrane capacity in pF
-        }
-    ],
-)
+@pytest.mark.parametrize("resolution", [2 ** i for i in range(0, -14, -1)])
 @pytest.mark.parametrize("duration, tolerance", [(5.0, 1e-13), (500.0, 1e-9)])
-def test_iaf_ps_dc_accuracy(model, resolution, params, duration, tolerance):
+def test_iaf_ps_dc_accuracy(model, resolution, duration, tolerance):
     """
     A DC current is injected for a finite duration. The membrane potential at
     the end of the simulated interval is compared to the theoretical value for
@@ -71,15 +58,23 @@ def test_iaf_ps_dc_accuracy(model, resolution, params, duration, tolerance):
     to function print_details.
     """
     nest.ResetKernel()
-    nest.SetKernelStatus({"tics_per_ms": 2**14, "resolution": resolution})
+    nest.set(tics_per_ms=2 ** 14, resolution=resolution)
+
+    params = {
+        "E_L": 0.0,  # resting potential in mV
+        "V_m": 0.0,  # initial membrane potential in mV
+        "V_th": 2000.0,  # spike threshold in mV
+        "I_e": 1000.0,  # DC current in pA
+        "tau_m": 10.0,  # membrane time constant in ms
+        "C_m": 250.0,  # membrane capacity in pF
+    }
 
     neuron = nest.Create(model, params=params)
     nest.Simulate(duration)
 
-    V_m = nest.GetStatus(neuron, "V_m")[0]
-    expected_V_m = params["I_e"] * params["tau_m"] / params["C_m"] * (1.0 - math.exp(-duration / params["tau_m"]))
+    expected_vm = params["I_e"] * params["tau_m"] / params["C_m"] * (1.0 - math.exp(-duration / params["tau_m"]))
 
-    assert math.fabs(V_m - expected_V_m) < tolerance
+    assert neuron.V_m - pytest.approx(expected_vm, abs=tolerance)
 
 
 @pytest.mark.parametrize(
@@ -91,22 +86,9 @@ def test_iaf_ps_dc_accuracy(model, resolution, params, duration, tolerance):
         "iaf_psc_exp_ps_lossless",
     ],
 )
-@pytest.mark.parametrize("resolution", [2**i for i in range(0, -14, -1)])
-@pytest.mark.parametrize(
-    "params",
-    [
-        {
-            "E_L": 0.0,  # resting potential in mV
-            "V_m": 0.0,  # initial membrane potential in mV
-            "V_th": 15.0,  # spike threshold in mV
-            "I_e": 1000.0,  # DC current in pA
-            "tau_m": 10.0,  # membrane time constant in ms
-            "C_m": 250.0,  # membrane capacity in pF
-        }
-    ],
-)
+@pytest.mark.parametrize("resolution", [2 ** i for i in range(0, -14, -1)])
 @pytest.mark.parametrize("duration, tolerance", [(5.0, 1e-13)])
-def test_iaf_ps_dc_t_accuracy(model, resolution, params, duration, tolerance):
+def test_iaf_ps_dc_t_accuracy(model, resolution, duration, tolerance):
     """
     A DC current is injected for a finite duration. The time of the first
     spike is compared to the theoretical value for different computation
@@ -124,18 +106,27 @@ def test_iaf_ps_dc_t_accuracy(model, resolution, params, duration, tolerance):
     call to function print_details.
     """
     nest.ResetKernel()
-    nest.SetKernelStatus({"tics_per_ms": 2**14, "resolution": resolution})
+    nest.set(tics_per_ms=2 ** 14, resolution=resolution)
+
+    params = {
+        "E_L": 0.0,  # resting potential in mV
+        "V_m": 0.0,  # initial membrane potential in mV
+        "V_th": 15.0,  # spike threshold in mV
+        "I_e": 1000.0,  # DC current in pA
+        "tau_m": 10.0,  # membrane time constant in ms
+        "C_m": 250.0,  # membrane capacity in pF
+    }
 
     neuron = nest.Create(model, params=params)
     spike_recorder = nest.Create("spike_recorder")
     nest.Connect(neuron, spike_recorder)
 
     nest.Simulate(duration)
 
-    spike_times = nest.GetStatus(spike_recorder, "events")[0]["times"]
+    spike_times = spike_recorder.get("events", "times")
     assert len(spike_times) == 1, "Neuron did not spike exactly once."
 
     t_spike = spike_times[0]
     expected_t = -params["tau_m"] * math.log(1.0 - (params["C_m"] * params["V_th"]) / (params["tau_m"] * params["I_e"]))
 
-    assert math.fabs(t_spike - expected_t) < tolerance
+    assert t_spike == pytest.approx(expected_t, abs=tolerance)

testsuite/pytests/sli2py_neurons/test_iaf_psc_alpha.py

@@ -235,7 +235,7 @@ def test_iaf_psc_alpha_i0_refractory(resolution):
     duration = 8.0
 
     nest.ResetKernel()
-    nest.SetKernelStatus({"resolution": resolution})
+    nest.resolution = resolution
 
     neuron = nest.Create("iaf_psc_alpha", params={"I_e": 1450.0})
     voltmeter = nest.Create("voltmeter", params={"interval": resolution})
@@ -246,9 +246,8 @@ def test_iaf_psc_alpha_i0_refractory(resolution):
 
     nest.Simulate(duration)
 
-    events = voltmeter.events
-    times = events["times"]
-    V_m = events["V_m"]
+    times = voltmeter.events["times"]
+    V_m = voltmeter.events["V_m"]
     results = np.column_stack((times, V_m))
 
     actual, expected = testutil.get_comparable_timesamples(

testsuite/pytests/sli2py_neurons/test_iaf_psc_alpha_fudge.py

@@ -69,14 +69,17 @@ def test_iaf_psc_alpha_fudge():
     C_m = 250.0
 
     # Set neuron parameters
-    nest.SetStatus(neuron, {"tau_m": tau_m, "tau_syn_ex": tau_syn, "tau_syn_in": tau_syn, "C_m": C_m})
+    neuron.tau_m = tau_m
+    neuron.tau_syn_ex = tau_syn
+    neuron.tau_syn_in = tau_syn
+    neuron.C_m = C_m
 
     # Compute fudge factors
     a = tau_m / tau_syn
     b = 1.0 / tau_syn - 1.0 / tau_m
     t_max = (1.0 / b) * (-lambertw(-math.exp(-1.0 / a) / a, k=-1) - 1.0 / a).real
 
-    V_max = (
+    v_max = (
         math.exp(1)
         / (tau_syn * C_m * b)
         * ((math.exp(-t_max / tau_m) - math.exp(-t_max / tau_syn)) / b - t_max * math.exp(-t_max / tau_syn))
@@ -92,16 +95,16 @@ def test_iaf_psc_alpha_fudge():
     )
 
     # Connect spike generator to neuron
-    nest.Connect(spike_gen, neuron, syn_spec={"weight": float(1.0 / V_max), "delay": delay})
+    nest.Connect(spike_gen, neuron, syn_spec={"weight": float(1.0 / v_max), "delay": delay})
 
     # Simulate
     nest.Simulate(duration)
 
     # Extract membrane potential trace
     volt_data = voltmeter.events
     times = volt_data["times"]
-    V_m = volt_data["V_m"]
-    results = np.column_stack((times, V_m))
+    v_m = volt_data["V_m"]
+    results = np.column_stack((times, v_m))
 
     # Find time of peak voltage
     actual_t_max = results[np.argmax(results[:, 1]), 0]