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)
