def setUp(self): r"""generate code for neuron and synapse and build NEST user module""" generate_nest_target(input_path=[ "models/neurons/iaf_psc_exp.nestml", "models/synapses/neuromodulated_stdp.nestml" ], target_path="/tmp/nestml-jit", logging_level="INFO", module_name="nestml_jit_module", suffix="_nestml", codegen_opts={ "neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{ "neuron": "iaf_psc_exp", "synapse": "neuromodulated_stdp", "post_ports": ["post_spikes"], "vt_ports": ["mod_spikes"] }] }) generate_nest_target(input_path="models/neurons/iaf_psc_exp.nestml", target_path="/tmp/nestml-non-jit", logging_level="INFO", module_name="nestml_non_jit_module", suffix="_nestml_non_jit", codegen_opts={ "neuron_parent_class": "ArchivingNode", "neuron_parent_class_include": "archiving_node.h" })
def generate_all_models(self): all_synapse_models = [s[:-7] for s in list(os.walk("models/synapses"))[0][2] if s[-7:] == ".nestml"] generate_nest_target(input_path=["models"], target_path="/tmp/nestml-allmodels", logging_level="INFO", module_name="nestml_allmodels_module", suffix="_nestml", codegen_opts={"neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{"neuron": "iaf_psc_exp", "synapse": "neuromodulated_stdp", "post_ports": ["post_spikes"], "vt_ports": ["mod_spikes"]}, {"neuron": "iaf_psc_exp", "synapse": "stdp", "post_ports": ["post_spikes"]}, {"neuron": "iaf_psc_delta", "synapse": "stdp_triplet", "post_ports": ["post_spikes"]}, {"neuron": "iaf_psc_delta", "synapse": "stdp_triplet_nn", "post_ports": ["post_spikes"]}, {"neuron": "iaf_psc_exp", "synapse": "stdp_nn_symm", "post_ports": ["post_spikes"]}, {"neuron": "iaf_psc_exp", "synapse": "stdp_nn_restr_symm", "post_ports": ["post_spikes"]}, {"neuron": "iaf_psc_exp_dend", "synapse": "third_factor_stdp", "post_ports": ["post_spikes", ["I_post_dend", "I_dend"]]}, {"neuron": "iaf_psc_exp", "synapse": "stdp_nn_pre_centered", "post_ports": ["post_spikes"]}]})
def setUp(self): r"""Generate the neuron model code""" # generate the "jit" model (co-generated neuron and synapse), that does not rely on ArchivingNode generate_nest_target( input_path=[ "models/neurons/iaf_psc_exp_dend.nestml", "models/synapses/third_factor_stdp_synapse.nestml" ], target_path="/tmp/nestml-jit", logging_level="INFO", module_name="nestml_jit_module", suffix="_nestml", codegen_opts={ "neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{ "neuron": "iaf_psc_exp_dend", "synapse": "third_factor_stdp", "post_ports": ["post_spikes", ["I_post_dend", "I_dend"]] }] })
def setUp(self): """Generate and build the model code""" generate_nest_target(input_path="models/synapses/noisy_synapse.nestml", target_path="/tmp/nestml-noisy-synapse", logging_level="INFO", module_name="nestml_noisy_synapse_module", suffix="_nestml")
def setUp(self) -> None: """Generate the model code""" # Neuron-Synapse model neuron_path = os.path.join( os.path.realpath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, "models", "neurons", "iaf_psc_exp.nestml"))) synapse_path = os.path.join( os.path.realpath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, "models", "synapses", "stdp_synapse.nestml"))) generate_nest_target(input_path=[neuron_path, synapse_path], target_path=self.neuron_synapse_target, logging_level="INFO", module_name=self.neuron_synapse_module, suffix="_nestml", codegen_opts={"neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{"neuron": "iaf_psc_exp", "synapse": "stdp", "post_ports": ["post_spikes"]}]}) # Neuron model generate_nest_target(input_path=neuron_path, target_path=self.neuron_target, logging_level="INFO", module_name=self.neuron_module, suffix="__nestml", codegen_opts={"neuron_parent_class": "ArchivingNode", "neuron_parent_class_include": "archiving_node.h"})
def setUp(self): """Generate the model code""" # generate the "jit" model (co-generated neuron and synapse), that does not rely on ArchivingNode generate_nest_target(input_path=[ "tests/nest_tests/resources/iaf_psc_exp_resolution_test.nestml", os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "..", "valid", "CoCoResolutionLegallyUsed.nestml"))) ], target_path="target", logging_level="INFO", module_name="nestmlmodule", suffix="_nestml", codegen_opts={ "neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{ "neuron": "iaf_psc_exp_resolution_test", "synapse": "CoCoResolutionLegallyUsed" }] })
def nestml_generate_target(): r"""Generate the neuron model code""" generate_nest_target(input_path=["models/neurons/iaf_psc_delta.nestml", "models/synapses/stdp_triplet_naive.nestml"], target_path="/tmp/nestml-triplet-stdp", logging_level="INFO", module_name="nestml_triplet_pair_module", suffix="_nestml", codegen_opts={"neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{"neuron": "iaf_psc_delta", "synapse": "stdp_triplet", "post_ports": ["post_spikes"]}]})
def test_recordable_variables(self): input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", "RecordableVariables.nestml"))) target_path = "target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install(module_name) neuron = nest.Create("recordable_variables_nestml") sg = nest.Create("spike_generator", params={"spike_times": [20., 80.]}) nest.Connect(sg, neuron) mm = nest.Create('multimeter', params={ 'record_from': ['V_ex', 'V_m', 'V_abs', 'I_kernel__X__spikes'], 'interval': 0.1 }) nest.Connect(mm, neuron) nest.Simulate(100.) # Get the recordable variables events = nest.GetStatus(mm)[0]["events"] V_reset = nest.GetStatus(neuron, "V_reset") V_m = events["V_m"] self.assertIsNotNone(V_m) V_abs = events["V_abs"] self.assertIsNotNone(V_abs) np.testing.assert_allclose(V_m, V_abs + V_reset) V_ex = events["V_ex"] np.testing.assert_almost_equal(V_ex[-1], -10)
def setUp(self): r"""Generate the model code""" generate_nest_target(input_path=["models/neurons/iaf_psc_delta.nestml", "tests/resources/synapse_event_priority_test.nestml", "tests/resources/synapse_event_inv_priority_test.nestml"], target_path="/tmp/nestml-synapse-event-priority-test", logging_level="INFO", module_name="nestml_module", suffix="_nestml", codegen_opts={"neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{"neuron": "iaf_psc_delta", "synapse": "synapse_event_priority_test", "post_ports": ["post_spikes"]}, {"neuron": "iaf_psc_delta", "synapse": "synapse_event_inv_priority_test", "post_ports": ["post_spikes"]}]})
def simulate_OU_noise_neuron(self, resolution): r""" Simulates a single neuron with OU noise conductances. Parameters ---------- resolution : float Resolution of the NEST simulation Returns ------- dict State of the multimeter, which is connected to the neuron. tuple Tuple with the NEST id of the simulated neuron """ seed = np.random.randint(0, 2**32 - 1) print("seed: {}".format(seed)) nest.SetKernelStatus({"resolution": resolution, "rng_seed": seed + 1}) input_path = os.path.join(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..", "models", "neurons", "hh_cond_exp_destexhe.nestml"))) target_path = "target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.Install("nestmlmodule") neuron = nest.Create("hh_cond_exp_destexhe_nestml") multi = nest.Create("multimeter", params={"record_from": self.record_from, "interval": resolution}) nest.Connect(multi, neuron) nest.Simulate(500000) return multi.get("events"), neuron
def test_vectors(self): input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", "Vectors.nestml"))) target_path = "target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install("nestmlmodule") neuron = nest.Create("vectors_nestml") multimeter = nest.Create("multimeter") recordables = list() recordables.extend(["G_IN_" + str(i + 1) for i in range(0, 20)]) recordables.extend(["G_EX_" + str(i + 1) for i in range(0, 10)]) recordables.append("V_m") multimeter.set({"record_from": recordables}) nest.Connect(multimeter, neuron) nest.Simulate(2.0) events = multimeter.get("events") g_in = events["G_IN_1"] g_ex = events["G_EX_2"] print("g_in: {}, g_ex: {}".format(g_in, g_ex)) np.testing.assert_almost_equal(g_in[-1], 11.) np.testing.assert_almost_equal(g_ex[-1], -2.) v_m = multimeter.get("events")["V_m"] print("V_m: {}".format(v_m)) np.testing.assert_almost_equal(v_m[-1], -0.3)
def test_for_and_while_loop(self): files = ["ForLoop.nestml", "WhileLoop.nestml"] input_path = [os.path.join(os.path.realpath(os.path.join(os.path.dirname(__file__), "resources", s))) for s in files] target_path = "target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install("nestmlmodule") nrn = nest.Create("for_loop_nestml") mm = nest.Create("multimeter") mm.set({"record_from": ["V_m"]}) nest.Connect(mm, nrn) nest.Simulate(5.0) v_m = mm.get("events")["V_m"] np.testing.assert_almost_equal(v_m[-1], 16.6) nest.ResetKernel() nrn = nest.Create("while_loop_nestml") mm = nest.Create("multimeter") mm.set({"record_from": ["y"]}) nest.Connect(mm, nrn) nest.Simulate(5.0) y = mm.get("events")["y"] np.testing.assert_almost_equal(y[-1], 5.011)
def setUp(self): """Generate the neuron model code""" # generate the "jit" model (co-generated neuron and synapse), that does not rely on ArchivingNode generate_nest_target(input_path=[ "models/neurons/iaf_psc_exp.nestml", "models/synapses/stdp_nn_symm.nestml" ], target_path="/tmp/nestml-jit", logging_level="INFO", module_name="nestml_jit_module", suffix="_nestml", codegen_opts={ "neuron_parent_class": "StructuralPlasticityNode", "neuron_parent_class_include": "structural_plasticity_node.h", "neuron_synapse_pairs": [{ "neuron": "iaf_psc_exp", "synapse": "stdp_nn_symm", "post_ports": ["post_spikes"] }] }) # generate the "non-jit" model, that relies on ArchivingNode generate_nest_target(input_path="models/neurons/iaf_psc_exp.nestml", target_path="/tmp/nestml-non-jit", logging_level="INFO", module_name="nestml_non_jit_module", suffix="_nestml_non_jit", codegen_opts={ "neuron_parent_class": "ArchivingNode", "neuron_parent_class_include": "archiving_node.h" })
def test_multisynapse(self): input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", "iaf_psc_exp_multisynapse.nestml"))) target_path = "target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install(module_name) # network construction neuron = nest.Create("iaf_psc_exp_multisynapse_neuron_nestml") sg = nest.Create("spike_generator", params={"spike_times": [20., 80.]}) nest.Connect(sg, neuron, syn_spec={ "receptor_type": 1, "weight": 1000., "delay": 0.1 }) sg2 = nest.Create("spike_generator", params={"spike_times": [40., 60.]}) nest.Connect(sg2, neuron, syn_spec={ "receptor_type": 2, "weight": 1000., "delay": 0.1 }) sg3 = nest.Create("spike_generator", params={"spike_times": [30., 70.]}) nest.Connect(sg3, neuron, syn_spec={ "receptor_type": 3, "weight": 500., "delay": 0.1 }) mm = nest.Create("multimeter", params={ "record_from": [ "I_kernel1__X__spikes1", "I_kernel2__X__spikes2", "I_kernel3__X__spikes3" ], "interval": 0.1 }) nest.Connect(mm, neuron) vm_1 = nest.Create("voltmeter") nest.Connect(vm_1, neuron) # simulate nest.Simulate(125.) # analysis V_m_timevec = nest.GetStatus(vm_1)[0]["events"]["times"] V_m = nest.GetStatus(vm_1)[0]["events"]["V_m"] mm = nest.GetStatus(mm)[0]["events"] MAX_ABS_ERROR = 1E-6 print("Final V_m = " + str(V_m[-1])) assert abs(V_m[-1] - -72.89041451202348) < MAX_ABS_ERROR if TEST_PLOTS: fig, ax = plt.subplots(nrows=4) ax[0].plot(V_m_timevec, V_m, label="V_m") ax[0].set_ylabel("voltage") ax[1].plot(mm["times"], mm["I_kernel1__X__spikes1"], label="I_kernel1") ax[1].set_ylabel("current") ax[2].plot(mm["times"], mm["I_kernel2__X__spikes2"], label="I_kernel2") ax[2].set_ylabel("current") ax[3].plot(mm["times"], mm["I_kernel3__X__spikes3"], label="I_kernel3") ax[3].set_ylabel("current") for _ax in ax: _ax.legend(loc="upper right") _ax.set_xlim(0., 125.) _ax.grid(True) for _ax in ax[:-1]: _ax.set_xticklabels([]) ax[-1].set_xlabel("time") plt.show()
def test_non_linear_dendrite(self): MAX_SSE = 1E-12 I_dend_alias_name = "I_dend" # synaptic current I_dend_internal_name = "I_kernel2__X__I_2" # alias for the synaptic current input_path = os.path.join(os.path.realpath(os.path.join(os.path.dirname(__file__), "resources")), "iaf_psc_exp_nonlineardendrite.nestml") target_path = "target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install("nestmlmodule") nrn = nest.Create("iaf_psc_exp_nonlineardendrite_nestml") sg = nest.Create("spike_generator", params={"spike_times": [10., 20., 30.]}) nest.Connect(sg, nrn, syn_spec={"receptor_type": 2, "weight": 30., "delay": 1.}) mm = nest.Create("multimeter") mm.set({"record_from": [I_dend_alias_name, I_dend_internal_name, "V_m", "dend_curr_enabled", "I_dend_ap"]}) nest.Connect(mm, nrn) nest.Simulate(100.0) timevec = mm.get("events")["times"] I_dend_alias_ts = mm.get("events")[I_dend_alias_name] I_dend_internal_ts = mm.get("events")[I_dend_internal_name] if TEST_PLOTS: fig, ax = plt.subplots(3, 1) ax[0].plot(timevec, I_dend_alias_ts, label="aliased I_dend_syn") ax[0].plot(timevec, I_dend_internal_ts, label="internal I_dend_syn") ax[0].legend() ax_ = ax[0].twinx() ax_.plot(timevec, mm.get("events")["dend_curr_enabled"]) ax_.set_ylabel("dend_curr_enabled") ax[1].plot(timevec, mm.get("events")["I_dend_ap"]) ax[1].set_ylabel("I_dend_AP") ax[2].plot(timevec, mm.get("events")["V_m"], label="V_m") for _ax in ax: _ax.legend() _ax.grid() plt.ylabel("Dendritic current $I_{dend}$") plt.suptitle("Reset of synaptic integration after dendritic spike") plt.savefig("/tmp/nestml_triplet_stdp_test.png") assert np.all(I_dend_alias_ts == I_dend_internal_ts), "Variable " + str(I_dend_alias_name) + " and (internal) variable " + str(I_dend_internal_name) + " should measure the same thing, but discrepancy in values occurred." tidx = np.argmin((timevec - 40)**2) assert mm.get("events")["I_dend_ap"][tidx] > 0., "Expected a dendritic action potential around t = 40 ms, but dendritic action potential current is zero" assert mm.get("events")["dend_curr_enabled"][tidx] == 0., "Dendritic synaptic current should be disabled during dendritic action potential" tidx_ap_end = tidx + np.where(mm.get("events")["dend_curr_enabled"][tidx:] == 1.)[0][0] assert np.all(I_dend_alias_ts[tidx_ap_end:] == 0.), "After dendritic spike, dendritic current should be reset to 0 and stay at 0."
def test_installing_module_outside_nest(self): model_name = "iaf_psc_exp" module_name = f"{model_name}module" input_path = os.path.join( os.path.realpath( os.path.join( os.path.dirname(__file__), os.path.join(os.pardir, os.pardir, "models", "neurons", f"{model_name}.nestml")))) install_path = tempfile.mkdtemp(prefix="nest_install", suffix="") target_path = "target" logging_level = "INFO" store_log = False suffix = "_location_test" dev = True codegen_opts = { "templates": { "path": "point_neuron", "model_templates": { "neuron": ["NeuronClass.cpp.jinja2", "NeuronHeader.h.jinja2"], "synapse": ["SynapseHeader.h.jinja2"] }, "module_templates": [ "setup/CMakeLists.txt.jinja2", "setup/ModuleHeader.h.jinja2", "setup/ModuleClass.cpp.jinja2" ] } } generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, store_log=store_log, suffix=suffix, install_path=install_path, dev=dev, codegen_opts=codegen_opts) expected_found_module = f"{install_path}/{module_name}.so" actual_found_module = glob.glob(f"{install_path}/*so") # check if tmp folder contains only one module self.assertEqual(len(actual_found_module), 1) # compare the expected module name with the actual found one self.assertEqual(actual_found_module[0], expected_found_module) # install module nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install(module_name) # check model existence has_model = f"{model_name}{suffix}" in nest.Models() self.assertTrue(has_model) # delete created folder import shutil shutil.rmtree(install_path)
# You should have received a copy of the GNU General Public License # along with NEST. If not, see <http://www.gnu.org/licenses/>. import os import nest import shutil from pynestml.frontend.pynestml_frontend import generate_nest_target input_path = str(os.path.realpath(os.path.join(os.path.dirname(__file__), "PrintVariables.nestml"))) target_path = "../target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install(module_name) neuron = nest.Create("print_variable_nestml") nest.Simulate(0.1) if os.path.exists(target_path): shutil.rmtree(target_path)
def test_biexp_synapse(self): input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", "BiexponentialPostSynapticResponse.nestml"))) logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install(module_name) # network construction neuron = nest.Create("biexp_postsynaptic_response_nestml") sg = nest.Create("spike_generator", params={"spike_times": [10., 30.]}) nest.Connect(sg, neuron, syn_spec={ "receptor_type": 1, "weight": 1000., "delay": 0.1 }) sg2 = nest.Create("spike_generator", params={"spike_times": [20., 40.]}) nest.Connect(sg2, neuron, syn_spec={ "receptor_type": 2, "weight": 1000., "delay": 0.1 }) sg3 = nest.Create("spike_generator", params={"spike_times": [25., 45.]}) nest.Connect(sg3, neuron, syn_spec={ "receptor_type": 3, "weight": 1000., "delay": 0.1 }) sg4 = nest.Create("spike_generator", params={"spike_times": [35., 55.]}) nest.Connect(sg3, neuron, syn_spec={ "receptor_type": 4, "weight": 1000., "delay": 0.1 }) i_1 = nest.Create("multimeter", params={ "record_from": [ "g_gap__X__spikeGap", "g_ex__X__spikeExc", "g_in__X__spikeInh", "g_GABA__X__spikeGABA" ], "interval": .1 }) nest.Connect(i_1, neuron) vm_1 = nest.Create("voltmeter") nest.Connect(vm_1, neuron) # simulate nest.Simulate(125.) # analysis vm_1 = nest.GetStatus(vm_1)[0]["events"] i_1 = nest.GetStatus(i_1)[0]["events"] if TEST_PLOTS: self.plot(vm_1, i_1) # verification final_v_m = vm_1["V_m"][-1] print("final V_m = " + str(final_v_m)) MAX_ABS_ERROR = 1E-6 assert abs(final_v_m - -64.2913308548727) < MAX_ABS_ERROR
def test_fir_filter(self): nestml_model_file = "FIR_filter.nestml" nestml_model_name = "fir_filter_nestml" target_path = "/tmp/fir-filter" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" # Generate the NEST code input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", nestml_model_file))) generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) t_sim = 101. resolution = 0.1 nest.set_verbosity("M_ALL") nest.Install(module_name) nest.ResetKernel() # Create a fir_filter node neuron = nest.Create(nestml_model_name, {"N": 256}) # Create a spike generator spikes = [ 1.0, 1.0, 1.5, 1.5, 1.5, 6.7, 10.0, 10.5, 10.5, 10.5, 10.5, 11.3, 11.3, 11.4, 11.4, 20., 22.5, 30., 40., 42., 42., 42., 50.5, 50.5, 75., 88., 93., 93. ] sg = nest.Create("spike_generator", params={"spike_times": spikes}) nest.Connect(sg, neuron, syn_spec=dict(delay=resolution)) # Get N (order of the filter) n = nest.GetStatus(neuron, "N")[0] print("N: {}".format(n)) # Set filter coefficients h = self.generate_filter_coefficients(n) nest.SetStatus(neuron, {"h": h}) print("h: ", h) # Multimeter multimeter = nest.Create("multimeter") nest.SetStatus(multimeter, {"interval": resolution}) multimeter.set({"record_from": ["y"]}) # output of the filter nest.Connect(multimeter, neuron) # Spike recorder sr = nest.Create("spike_recorder") nest.Connect(sg, sr) nest.Connect(neuron, sr) # Simulate nest.Simulate(t_sim) # Record from multimeter events = multimeter.get("events") y = events["y"] times = events["times"] spike_times = nest.GetStatus(sr, keys="events")[0]["times"] # Scipy filtering spikes, bin_edges = np.histogram(spike_times, np.arange(0, t_sim, resolution)) output = scipy.signal.lfilter(h, 1, spikes) # Plots if TEST_PLOTS: self.plot_output(spike_times, times, y, title="FIR FILTER (NESTML)", filename="fir_filter_output_nestml.png") self.plot_output(spike_times, bin_edges[1:], output, title="FIR FILTER (scipy)", filename="fir_filter_output_scipy.png") np.testing.assert_allclose(y, output)
def test_wb_cond_multisyn(self): if not os.path.exists("target"): os.makedirs("target") input_path = os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "../../models/neurons", "wb_cond_multisyn.nestml"))) target_path = "target" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level="INFO", suffix=suffix, module_name=module_name) nest.Install("nestmlmodule") model = "wb_cond_multisyn_nestml" dt = 0.01 t_simulation = 1000.0 nest.SetKernelStatus({"resolution": dt}) neuron = nest.Create(model) parameters = nest.GetDefaults(model) neuron.set({"I_e": 75.0}) multimeter = nest.Create("multimeter") multimeter.set({"record_from": ["V_m"], "interval": dt}) spike_recorder = nest.Create("spike_recorder") nest.Connect(multimeter, neuron) nest.Connect(neuron, spike_recorder) nest.Simulate(t_simulation) dmm = nest.GetStatus(multimeter)[0] Voltages = dmm["events"]["V_m"] tv = dmm["events"]["times"] dSD = nest.GetStatus(spike_recorder, keys="events")[0] spikes = dSD["senders"] ts = dSD["times"] firing_rate = len(spikes) / t_simulation * 1000 print("firing rate is ", firing_rate) expected_value = np.abs(firing_rate - 50) tolerance_value = 5 # Hz if TEST_PLOTS: fig, ax = plt.subplots(2, figsize=(8, 6), sharex=True) ax[0].plot(tv, Voltages, lw=2, color="k") ax[1].plot(ts, spikes, "ko") ax[1].set_xlabel("Time [ms]") ax[1].set_xlim(0, t_simulation) ax[1].set_ylabel("Spikes") ax[0].set_ylabel("v [ms]") ax[0].set_ylim(-100, 50) for i in ts: ax[0].axvline(x=i, lw=1., ls="--", color="gray") plt.savefig("wb_cond_multisyn.png") # plt.show() self.assertLessEqual(expected_value, tolerance_value)
def test_logarithmic_function(self): MAX_SSE = 1E-12 input_path = [ os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", "LogarithmicFunctionTest.nestml"))), os.path.join( os.path.realpath( os.path.join(os.path.dirname(__file__), "resources", "LogarithmicFunctionTest_invalid.nestml"))) ] target_path = "target" logging_level = "INFO" module_name = "nestmlmodule" suffix = "_nestml" generate_nest_target(input_path, target_path=target_path, logging_level=logging_level, module_name=module_name, suffix=suffix) nest.set_verbosity("M_ALL") nest.ResetKernel() nest.Install("nestmlmodule") nrn = nest.Create("logarithm_function_test_nestml") mm = nest.Create("multimeter") ln_state_specifier = "ln_state" log10_state_specifier = "log10_state" mm.set( {"record_from": [ln_state_specifier, log10_state_specifier, "x"]}) nest.Connect(mm, nrn) nest.Simulate(100.0) timevec = mm.get("events")["x"] ln_state_ts = mm.get("events")[ln_state_specifier] log10_state_ts = mm.get("events")[log10_state_specifier] ref_ln_state_ts = np.log(timevec - 1) ref_log10_state_ts = np.log10(timevec - 1) assert np.all((ln_state_ts - ref_ln_state_ts)**2 < MAX_SSE) assert np.all((log10_state_ts - ref_log10_state_ts)**2 < MAX_SSE) # test that expected failure occurs nest.ResetKernel() nrn = nest.Create("logarithm_function_test_invalid_nestml") mm = nest.Create("multimeter") ln_state_specifier = "ln_state" log10_state_specifier = "log10_state" mm.set( {"record_from": [ln_state_specifier, log10_state_specifier, "x"]}) nest.Connect(mm, nrn) nest.Simulate(100.0) timevec = mm.get("events")["x"] ln_state_ts = mm.get("events")[ln_state_specifier] log10_state_ts = mm.get("events")[log10_state_specifier] ref_ln_state_ts = np.log(timevec - 1) ref_log10_state_ts = np.log10(timevec - 1) assert not np.all((ln_state_ts - ref_ln_state_ts)**2 < MAX_SSE) assert not np.all((log10_state_ts - ref_log10_state_ts)**2 < MAX_SSE)