def _activate_hln(self, sim, block_interval, firing_rate):
next_block_tstart = (block_interval[1] +
1) * sim.dt # The next time-step
next_block_tstop = next_block_tstart + sim.nsteps_block * sim.dt # The time-step when the next block ends
# This is where you can use the firing-rate of the low-level neurons to generate a set of spike times for the
# next block
psg = PoissonSpikeGenerator()
psg.add(node_ids=[0],
firing_rate=firing_rate,
times=(next_block_tstart, next_block_tstop))
self._spike_events = psg.get_times(0)
# Update firing rate of bladder afferent neurons
for gid in self._high_level_neurons:
nc = self._netcons[gid]
for t in self._spike_events:
nc.event(t)
# If pressure is maxxed, update firing rate of EUS motor neurons
# Guarding reflex
press_change = self._prev_glob_press - self._glob_press
if self._glob_press > press_thres or press_change > change_thres:
psg = PoissonSpikeGenerator()
psg.add(node_ids=[0],
firing_rate=150,
times=(next_block_tstart, next_block_tstop))
self._spike_events = psg.get_times(0)
for gid in self._eus_neurons:
nc = self._netcons[gid]
for t in self._spike_events:
nc.event(t)
def single_proc():
print('--NEW VERSION--')
psg = PoissonSpikeGenerator(population='v1', seed=10)
psg.add(node_ids=np.arange(N), firing_rate=30.0, times=3.0)
tmph5 = tempfile.NamedTemporaryFile(suffix='.h5')
mem = memory_usage((write_sonata, (tmph5.name, psg)))
print(max(mem))
tmph5 = tempfile.NamedTemporaryFile(suffix='.h5')
start = timer()
write_sonata(tmph5.name, psg)
print(timer() - start)
print('--OLD VERSION--')
psg = PoissonSpikeGenerator(population='v1',
seed=10,
buffer_dir='tmp_spikes')
psg.add(node_ids=np.arange(N), firing_rate=30.0, times=3.0)
tmph5 = tempfile.NamedTemporaryFile(suffix='.h5')
mem = memory_usage((write_sonata_old, (tmph5.name, psg)))
print(max(mem))
tmph5 = tempfile.NamedTemporaryFile(suffix='.h5')
start = timer()
write_sonata_old(tmph5.name, psg)
print(timer() - start)
def _activate_hln(self, sim, block_interval, firing_rate):
next_block_tstart = (block_interval[1] + 1) * sim.dt # The next time-step
next_block_tstop = next_block_tstart + sim.nsteps_block*sim.dt # The time-step when the next block ends
# This is where you can use the firing-rate of the low-level neurons to generate a set of spike times for the
# next block
psg = PoissonSpikeGenerator()
psg.add(node_ids=[0], firing_rate=firing_rate/1000, times=(next_block_tstart, next_block_tstop))
self._spike_events = psg.get_times(0)
if self._spike_events.shape[0]==0:
self._spike_events = np.array((next_block_tstart+0.2,))
# Update firing rate of bladder afferent neurons
for gid in self._high_level_neurons:
nc = self._netcons[gid]
for t in self._spike_events:
nc.event(t)
def test_psg_variable():
times = np.linspace(0.0, 3.0, 1000)
fr = np.exp(-np.power(times - 1.0, 2) / (2 * np.power(.5, 2))) * 5
psg = PoissonSpikeGenerator(population='test', seed=0.0)
psg.add(node_ids=range(10), firing_rate=fr, times=times)
assert (psg.populations == ['test'])
assert (np.all(psg.node_ids() == list(range(10))))
assert (psg.n_spikes() == 59)
assert (np.allclose(psg.time_range(),
(0.13932107933711294, 2.9013003727909172)))
assert (psg.to_dataframe().shape == (59, 3))
assert (np.allclose(psg.get_times(node_id=0),
[0.442, 0.520, 0.640, 1.099, 1.393, 1.725],
atol=1.0e-3))
assert (np.allclose(psg.get_times(node_id=9),
[0.729, 0.885, 1.047, 1.276, 1.543, 1.669, 1.881],
atol=1.0e-3))
def _activate_hln(self, sim, block_interval, firing_rate):
next_block_tstart = (block_interval[1] +
1) * sim.dt # The next time-step
next_block_tstop = next_block_tstart + sim.nsteps_block * sim.dt # The time-step when the next block ends
# TODO: See if we've reached the end of the simulation
# This is where you can use the firing-rate of the low-level neurons to generate a set of spike times for the
# next block. For this case I'm just setting the high-level neuron to start bursting
#if firing_rate > firing_rate_threshold:
#self._spike_events = np.linspace(next_block_tstart, next_block_tstop, 500)
psg = PoissonSpikeGenerator()
psg.add(node_ids=[0],
firing_rate=firing_rate,
times=(next_block_tstart, next_block_tstop))
self._spike_events = psg.get_times(0)
for gid in self._high_level_neurons:
nc = self._netcons[gid]
for t in self._spike_events:
nc.event(t)
def test_psg_fixed():
psg = PoissonSpikeGenerator(population='test', seed=0.0)
psg.add(node_ids=range(10), firing_rate=10.0, times=(0.0, 10.0))
assert(psg.populations == ['test'])
assert(psg.nodes() == list(range(10)))
time_range = psg.time_range()
assert(0 <= time_range[0] < 1.0)
assert(9.0 < time_range[1] <= 10.0)
# This may fail on certain versions
assert(psg.get_times(node_id=5).size > 10)
assert(0 < psg.get_times(node_id=8).size < 300)
for i in range(10):
spikes = psg.get_times(i)
assert(np.max(spikes) > 0.1)
def test_psg_variable():
times = np.linspace(0.0, 3.0, 1000)
fr = np.exp(-np.power(times - 1.0, 2) / (2 * np.power(.5, 2))) * 5
psg = PoissonSpikeGenerator(population='test', seed=0.0)
psg.add(node_ids=range(10), firing_rate=fr, times=times)
assert (psg.populations == ['test'])
assert (np.all(psg.node_ids() == list(range(10))))
assert (psg.n_spikes() == 59)
assert (np.allclose(psg.time_range(),
(139.32107933711294, 2901.3003727909172)))
assert (psg.to_dataframe().shape == (59, 3))
assert (np.allclose(
psg.get_times(node_id=0),
[442.8378, 520.3624, 640.3880, 1099.0661, 1393.0794, 1725.6109],
atol=1.0e-3))
assert (np.allclose(psg.get_times(node_id=9), [
729.6267, 885.2469, 1047.7728, 1276.3554, 1543.6557, 1669.9070,
1881.3605
],
atol=1.0e-3))
def build_spike_trains(N=N_LIF_exc + N_LIF_inh):
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
from bmtk.utils.reports.spike_trains import sort_order
# Steadily increase the firing rate of each virtual cell from 1.0 Hz (node 0) to 50.0 Hz (node 12499)
firing_rates = 500 * np.ones(N)
psg = PoissonSpikeGenerator(population='external')
for i in range(N):
# create a new spike-train for each node.
psg.add(node_ids=i, firing_rate=firing_rates[i], times=(0.0, 3.0))
psg.to_sonata('inputs/injective_500hz.h5', sort_order=sort_order.by_id)
def test_psg_variable():
times = np.linspace(0.0, 10.0, 1000)
fr = np.exp(-np.power(times - 5.0, 2) / (2*np.power(.5, 2)))*5
psg = PoissonSpikeGenerator(population='test', seed=0.0)
psg.add(node_ids=range(10), firing_rate=fr, times=times)
assert(psg.populations == ['test'])
assert(psg.nodes() == list(range(10)))
for i in range(10):
spikes = psg.get_times(i)
assert(len(spikes) > 0)
assert(1.0 < np.min(spikes))
assert(np.max(spikes) < 9.0)
def _activate_hln(self, sim, block_interval, firing_rate):
block_length = sim.nsteps_block * sim.dt / 1000.0
next_block_tstart = (block_interval[1] +
1) * sim.dt / 1000.0 # The next time-step
next_block_tstop = next_block_tstart + block_length # The time-step when the next block ends
# This is where you can use the firing-rate of the low-level neurons to generate a set of spike times for the
# next block
if firing_rate > 0.0:
psg = PoissonSpikeGenerator()
# # Use homogeneous input
# psg.add(node_ids=[0], firing_rate=firing_rate, times=(next_block_tstart, next_block_tstop)) # sec
# spikes = psg.get_times([0])*1000 # convert sec to ms
# n_spikes = len(spikes)
# io.log_info(' _activate_hln firing rate: {:.2f} Hz'.format(n_spikes/block_length))
# if n_spikes > 0:
# # Update firing rate of bladder afferent neurons
# for gid in self._high_level_neurons:
# self._spike_events[gid] = np.concatenate((self._spike_events[gid],spikes))
# nc = self._netcons[gid]
# for t in spikes:
# nc.event(t)
# io.log_info('Last spike: {:.1f} ms'.format(spikes[-1]))
# Use inhomogeneous input
n = len(self._high_level_neurons)
psg.add(node_ids=self._high_level_neurons,
firing_rate=firing_rate,
times=(next_block_tstart, next_block_tstop))
n_spikes = np.zeros(n)
last_spike = 0.0
for i, gid in enumerate(self._high_level_neurons):
spikes = psg.get_times(gid) * 1000
n_spikes[i] = len(spikes)
if n_spikes[i] > 0:
self._spike_events[gid] = np.concatenate(
(self._spike_events[gid], spikes))
nc = self._netcons[gid]
for t in spikes:
nc.event(t)
last_spike = max(last_spike, spikes[-1])
io.log_info(
' _activate_hln firing rate: ' +
','.join(["%.2f" % (ns / block_length)
for ns in n_spikes]) + ' Hz')
if last_spike > 0:
io.log_info('Last spike: {:.1f} ms'.format(last_spike))
else:
io.log_info(' _activate_hln firing rate: 0')
# If pressure is maxxed, update firing rate of EUS motor neurons
# Guarding reflex
# press_change = self._prev_glob_press - self._glob_press
# if self._glob_press > press_thres or press_change > change_thres:
# psg = PoissonSpikeGenerator()
# eus_fr = self._glob_press*10 + press_change*10 # Assumption: guarding reflex
# # depends on current pressure
# # and change from last pressure
# psg.add(node_ids=[0], firing_rate=eus_fr, times=(next_block_tstart, next_block_tstop))
# self._spike_events = psg.get_times(0)
# for gid in self._eus_neurons:
# nc = self._netcons[gid]
# for t in self._spike_events:
# nc.event(t)
################ Activate higher order based on pressure threshold ##############################
# if block_interval[1] % 2000 == 1000: # For fast testing, only add events to every other block
# if False: # For testing
# if self._glob_press > self.press_thres:
# io.log_info(' updating pag input')
# psg = PoissonSpikeGenerator()
# print(self.press_thres)
#
# pag_fr = self.press_thres #change
# psg.add(node_ids=[0], firing_rate=pag_fr, times=(next_block_tstart/1000.0, next_block_tstop/1000.0))
# if psg.n_spikes() <= 0:
# io.log_info(' no psg spikes generated by Poisson distritubtion')
# self._spike_events = psg.get_times(0)
# for gid in self._pag_neurons:
# nc = self._netcons[gid]
# for t in self._spike_events:
# nc.event(t)
################ Activate higher order based on afferent firing rate ##############################
if firing_rate > 10:
pag_fr = 15
psg = PoissonSpikeGenerator()
# # Use homogeneous input
# psg.add(node_ids=[0], firing_rate=pag_fr, times=(next_block_tstart, next_block_tstop))
# spikes = psg.get_times([0])*1000
# n_spikes = len(spikes)
# io.log_info(' pag firing rate: {:.2f} Hz'.format(n_spikes/block_length))
# if n_spikes>0:
# io.log_info('Last spike: {:.1f} ms'.format(spikes[-1]))
# for gid in self._pag_neurons:
# self._spike_events[gid] = np.concatenate((self._spike_events[gid],spikes))
# nc = self._netcons[gid]
# for t in spikes:
# nc.event(t)
# Use inhomogeneous input
n = len(self._pag_neurons)
psg.add(node_ids=self._pag_neurons,
firing_rate=pag_fr,
times=(next_block_tstart, next_block_tstop))
n_spikes = np.zeros(n)
last_spike = 0.0
for i, gid in enumerate(self._pag_neurons):
spikes = psg.get_times(gid) * 1000
n_spikes[i] = len(spikes)
if n_spikes[i] > 0:
self._spike_events[gid] = np.concatenate(
(self._spike_events[gid], spikes))
nc = self._netcons[gid]
for t in spikes:
nc.event(t)
last_spike = max(last_spike, spikes[-1])
io.log_info(
' pag firing rate: ' +
','.join(["%.2f" % (ns / block_length)
for ns in n_spikes]) + ' Hz')
if last_spike > 0:
io.log_info('Last spike: {:.1f} ms'.format(last_spike))
io.log_info('\n')
thalamus.save_edges(output_dir='network')
print("External nodes and edges built")
# Build and save our network
from bmtk.utils.sim_setup import build_env_bionet
build_env_bionet(
base_dir='./',
network_dir='./network',
tstop=1000.0,
dt=0.1,
spikes_inputs=[(
'mthalamus', # Name of population which spikes will be generated for
'mthalamus_spikes.h5')],
report_vars=['v'], # Record membrane potential and calcium (default soma)
components_dir='biophys_components',
compile_mechanisms=True)
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
psg = PoissonSpikeGenerator(population='mthalamus')
psg.add(
node_ids=range(numL5PNA + numL5PNC +
numBask), # Have nodes to match mthalamus
firing_rate=
15.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
times=(0.0, 3.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('mthalamus_spikes.h5')
def test_psg_fixed():
psg = PoissonSpikeGenerator(population='test', seed=100)
psg.add(node_ids=range(10), firing_rate=5.0, times=(0.0, 3.0))
assert (psg.populations == ['test'])
assert (np.all(psg.node_ids() == list(range(10))))
assert (psg.n_spikes() == 143)
assert (psg.n_spikes(population='test') == 143)
assert (np.allclose(psg.time_range(),
(5.380662350673328, 2986.5205688893295)))
df = psg.to_dataframe()
assert (df.shape == (143, 3))
assert (np.allclose(psg.get_times(node_id=0), [
156.7916, 222.0400, 332.5493, 705.1267, 706.0727, 731.9963, 954.1834,
1303.7542, 1333.1543, 1504.3314, 1948.2045, 1995.1471, 2036.1411,
2059.0835, 2108.6982, 2877.7935
],
atol=1.0e-3))
assert (np.allclose(psg.get_times(node_id=9, population='test'), [
23.3176, 241.7332, 390.1951, 428.2215, 1001.0229, 1056.4003, 2424.8442,
2599.6312, 2640.1228, 2737.9504, 2780.0140, 2885.8020
],
atol=1.0e-3))
#st.write(path)
if (path != "streamlit"):
os.chdir("streamlit")
if os.path.isdir('biophys_components/mechanisms/x86_64'):
shutil.rmtree('biophys_components/mechanisms/x86_64')
os.chdir('biophys_components/mechanisms')
os.system('nrnivmodl modfiles')
os.chdir("../..")
st.write("Building model")
build_model()
st.write("Done building")
bg_pn = st.slider('Generate PN background')
if st.button("Push to Generate"):
os.remove('2_cell_inputs/bg_pn_c_spikes.h5')
psg = PoissonSpikeGenerator(population='bg_pn_c')
psg.add(
node_ids=range(1), # need same number as cells
firing_rate=bg_pn, # 1 spike every 1 second Hz
times=(0.0, 40000 / 1000)) # time is in seconds for some reason
psg.to_sonata('2_cell_inputs/bg_pn_c_spikes.h5')
st.write('Generated background of PN at : {} Hz'.format(bg_pn))
if st.button("Push to run model"):
st.write("running model")
run(config_file='config.json')
st.write("done running")
if st.button("Plot results"):
_ = plot_traces(config_file='config.json',
node_ids=[0],
# Build and save our networks
net.build()
net.save_nodes(output_dir='network')
net.save_edges(output_dir='network')
exc_stim.build()
exc_stim.save_nodes(output_dir='network')
inh_stim.build()
inh_stim.save_nodes(output_dir='network')
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
from bmtk.utils.reports.spike_trains.spikes_file_writers import write_csv
exc_psg = PoissonSpikeGenerator(population='exc_stim')
exc_psg.add(node_ids=range(np.sum(num_exc)),
firing_rate=int(exc_fr) / 1000,
times=(200.0, 1200.0))
exc_psg.to_sonata('exc_stim_spikes.h5')
inh_psg = PoissonSpikeGenerator(population='inh_stim')
inh_psg.add(node_ids=range(np.sum(num_inh)),
firing_rate=int(inh_fr) / 1000,
times=(200.0, 1200.0))
inh_psg.to_sonata('inh_stim_spikes.h5')
from bmtk.utils.sim_setup import build_env_bionet
build_env_bionet(base_dir='./',
network_dir='./network',
def build_input(t_sim,
numPN_A=569,
numPN_C=231,
numBask=93,
numSOM=51,
numCR=56):
print("Building input for " + str(t_sim) + " (ms)")
psg = PoissonSpikeGenerator(population='vpsi_pyr')
psg.add(
node_ids=range(numPN_A + numPN_C), # Have nodes to match mthalamus
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numPN_A + numPN_C, 2, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('vpsi_pyr_spikes.h5')
psg = PoissonSpikeGenerator(population='vpsi_pv')
psg.add(
node_ids=range(numBask), # Have nodes to match mthalamus
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numBask, 2, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('vpsi_pv_spikes.h5')
# THALAMUS
psg = PoissonSpikeGenerator(population='thalamus_pyr')
psg.add(
node_ids=range(numPN_A + numPN_C), # Have nodes to match
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numPN_A + numPN_C, 4, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('thalamus_pyr_spikes.h5')
psg = PoissonSpikeGenerator(population='thalamus_pv')
psg.add(
node_ids=range(numBask), # Have nodes to match
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numBask, 2, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('thalamus_pv_spikes.h5')
psg = PoissonSpikeGenerator(population='thalamus_som')
psg.add(
node_ids=range(numSOM), # Have nodes to match
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numSOM, 2, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('thalamus_som_spikes.h5')
psg = PoissonSpikeGenerator(population='thalamus_cr')
psg.add(
node_ids=range(numCR), # Have nodes to match
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numCR, 2, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('thalamus_cr_spikes.h5')
print("Done")
def _activate_hln(self, sim, block_interval, firing_rate):
next_block_tstart = (block_interval[1] + 1) * sim.dt # The next time-step
next_block_tstop = next_block_tstart + sim.nsteps_block*sim.dt # The time-step when the next block ends
# This is where you can use the firing-rate of the low-level neurons to generate a set of spike times for the
# next block
if firing_rate != 0.0:
psg = PoissonSpikeGenerator()
psg.add(node_ids=[0], firing_rate=firing_rate, times=(next_block_tstart/1000.0, next_block_tstop/1000.0))
if psg.n_spikes() <= 0:
io.log_info(' _activate_hln: firing rate {} did not produce any spikes'.format(firing_rate))
else:
self._spike_events = psg.get_times(0)
# Update firing rate of bladder afferent neurons
for gid in self._high_level_neurons:
nc = self._netcons[gid]
for t in self._spike_events:
nc.event(t)
else:
io.log_info(' _activate_hln: firing rate 0')
# If pressure is maxxed, update firing rate of EUS motor neurons
# Guarding reflex
# press_change = self._prev_glob_press - self._glob_press
# if self._glob_press > press_thres or press_change > change_thres:
# psg = PoissonSpikeGenerator()
# eus_fr = self._glob_press*10 + press_change*10 # Assumption: guarding reflex
# # depends on current pressure
# # and change from last pressure
# psg.add(node_ids=[0], firing_rate=eus_fr, times=(next_block_tstart, next_block_tstop))
# self._spike_events = psg.get_times(0)
# for gid in self._eus_neurons:
# nc = self._netcons[gid]
# for t in self._spike_events:
# nc.event(t)
################ Activate higher order based on pressure threshold ##############################
# if block_interval[1] % 2000 == 1000: # For fast testing, only add events to every other block
# if False: # For testing
if self._glob_press > self.press_thres:
io.log_info(' updating pag input')
psg = PoissonSpikeGenerator()
print(self.press_thres)
pag_fr = self.press_thres #change
psg.add(node_ids=[0], firing_rate=pag_fr, times=(next_block_tstart/1000.0, next_block_tstop/1000.0))
if psg.n_spikes() <= 0:
io.log_info(' no psg spikes generated by Poisson distritubtion')
self._spike_events = psg.get_times(0)
for gid in self._pag_neurons:
nc = self._netcons[gid]
for t in self._spike_events:
nc.event(t)
import os
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
if not os.path.exists('inputs'):
os.mkdir('inputs')
psg = PoissonSpikeGenerator(population='external')
psg.add(
node_ids=range(100),
firing_rate=10.0,
)
psg.add(node_ids=range(100), firing_rate=10.0, times=(0.0, 3.0))
psg.to_sonata('inputs/external_spike_trains.h5')
target=net.nodes(pop_name=['Int']),
connection_rule=1,
syn_weight=1,
delay=2.0,
weight_function=None,
target_sections=['somatic'],
distance_range=[0.0, 150.0],
dynamics_params='AMPA_ExcToExc.json',
model_template='exp2syn')
net.build()
net.save(output_dir='network')
thalamus.build()
thalamus.save(output_dir='network')
psg = PoissonSpikeGenerator(population='mthalamus')
psg.add(
node_ids=1, # Have 5 nodes to match mthalamus
firing_rate=8, # 2 Hz
times=(0.0, 1)) # time is in seconds for some reason
psg.to_sonata('virtual_spikes.h5')
print('Number of background spikes: {}'.format(psg.n_spikes()))
from bmtk.utils.sim_setup import build_env_bionet
build_env_bionet(
base_dir='../',
network_dir='./network',
tstop=1000.0,
dt=0.1,
report_vars=['v'],
spikes_inputs=[('mthalamus', 'virtual_spikes.h5')],
def test_psg_fixed():
psg = PoissonSpikeGenerator(population='test', seed=100)
psg.add(node_ids=range(10), firing_rate=5.0, times=(0.0, 3.0))
assert (psg.populations == ['test'])
assert (np.all(psg.node_ids() == list(range(10))))
assert (psg.n_spikes() == 143)
assert (psg.n_spikes(population='test') == 143)
assert (np.allclose(psg.time_range(),
(0.005380662350673328, 2.9865205688893295)))
df = psg.to_dataframe()
assert (df.shape == (143, 3))
assert (np.allclose(psg.get_times(node_id=0), [
0.156, 0.222, 0.332, 0.705, 0.706, 0.731, 0.954, 1.303, 1.333, 1.504,
1.948, 1.995, 2.036, 2.059, 2.108, 2.877
],
atol=1.0e-3))
assert (np.allclose(psg.get_times(node_id=9, population='test'), [
0.0233, 0.241, 0.390, 0.428, 1.001, 1.056, 2.424, 2.599, 2.640, 2.737,
2.780, 2.885
],
atol=1.0e-3))
distance_range=[0.0, 150.0],
# Set the parameters of the synpases
dynamics_params=
'AMPA_ExcToExc.json', # AMPA type synaptic model with an Excitatory connection
model_template='exp2syn')
# Build thalamus (saving nodes and edges)
thalamus.build()
thalamus.save_nodes(output_dir='%s/network' % (savedir))
thalamus.save_edges(output_dir='%s/network' % (savedir))
# Set spike trains
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
spikesFilename = '%s/inputs/mthalamus_spikes.h5' % (savedir)
psg = PoissonSpikeGenerator(population='mthalamus')
psg.add(
node_ids=range(10), # Have 10 nodes to match mthalamus
firing_rate=
15.0, # 10 Hz, we can also pass in a nonhomoegenous function/array
times=(0.0, 3.0)) # Firing starts at 0 s up to 3 s
if not (os.path.isfile(spikesFilename)):
psg.to_sonata(spikesFilename)
# ----------------------------------------------------
# 2. Set up the BioNet environment
# ----------------------------------------------------
'''Before running a simulation, we will need to create the runtime environment, including parameter files, run-script
and configuration files. This will also compile mechanisms'''
# Mechanisms need to be compiled?
import os
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
from bmtk.utils.reports.spike_trains import SpikeTrains
import matplotlib.pyplot as plt
import numpy as np
if os.path.exists('inputs/ramping_spikes.h5'):
os.remove('inputs/ramping_spikes.h5')
# Create PGN firing rate
time_range = np.linspace(0.0, 10.0, 20000)
psg = PoissonSpikeGenerator(mode='w')
psg.add(node_ids=[0],
firing_rate=np.linspace(1.0, 10.0, 30000),
population='external',
times=time_range)
psg.to_sonata('inputs/ramping_spikes.h5')
#st = SpikeTrains.from_sonata('inputs/ramping_spikes.h5')
#print(st.get_times(0))
#spikes = np.zeros(100001, dtype=np.int)
#spikes[(st.get_times(0) / 0.1).astype(np.int)] = 1
#plt.plot(spikes)
#plt.show()
from bmtk.utils.reports.spike_trains import SpikeTrains, PoissonSpikeGenerator
# A constant firing rate of 10 Hz from 0 to 3 seconds
times = (0.0, 3.0)
firing_rate = 10.0
## Uncomment to model the input firing rates on a sin wave
# times = np.linspace(0.0, 3.0, 1000)
# firing_rate = 10.0*np.sin(times) + 10.0
psg = PoissonSpikeGenerator() # Uses 'seed' to ensure same results every time
psg.add(node_ids='network/thalamus_nodes.h5', firing_rate=firing_rate, times=times, population='thalamus')
psg.to_sonata('thalamus.h5')
psg.to_csv('thalamus.csv')
def build_input(t_sim, numPN_A=640, numPN_C=260, numBask=100):
print("Building input for " + str(t_sim) + " (ms)")
psg = PoissonSpikeGenerator(population='mthalamus')
psg.add(
node_ids=range(numPN_A + numPN_C), # Have nodes to match mthalamus
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numPN_A + numPN_C, 2, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('mthalamus_spikes.h5')
psg = PoissonSpikeGenerator(population='exc_bg_bask')
psg.add(
node_ids=range(numBask), # Have nodes to match mthalamus
# firing_rate=2.0, # 15 Hz, we can also pass in a nonhomoegenous function/array
firing_rate=lognorm_fr_list(numBask, 2, 1),
times=(0.0, t_sim / 1000.0)) # Firing starts at 0 s up to 3 s
psg.to_sonata('exc_bg_bask_spikes.h5')
print("Done")
# fr_df['gid'] = [i for i in range(N)]
# fr_df['fr_mean'] = exc_means
# fr_df['fr_std'] = exc_stds
# fr_df['fr_max'] = exc_maxs
#fr_df.to_csv('frs_temp.csv', index=False)
seconds = 1
def generate_spikes(psg, group, fr, times):
psg.add(node_ids=range(group.start_id, group.start_id + len(group.cells)),
firing_rate=fr,
times=times)
exc_psg = PoissonSpikeGenerator(population='exc_stim')
exc_psg.add(node_ids=range(num_apic_exc + num_dend_exc),
firing_rate=0.01,
times=(0.0 * 1000, seconds * 1000))
exc_psg.to_sonata('exc_stim_spikes.h5')
# exc_psg = PoissonSpikeGenerator(population='exc_stim')
# for i in range(num_exc):
# exc_psg.add(node_ids=[i],
# firing_rate=exc_frs[i]/1000,
# times=(0.0*1000, seconds*1000))
# exc_psg.to_sonata('exc_stim_spikes.h5')
# inh_psg = PoissonSpikeGenerator(population='inh_stim')
# inh_psg.add(node_ids=range(num_inh),
# firing_rate=inh_fr/1000,
# times=(0.0*1000, seconds*1000))
from bmtk.utils.sim_setup import build_env_bionet
build_env_bionet(base_dir='./',
network_dir='./network',
tstop=t_sim, dt=0.1,
spikes_inputs=[('mthalamus', 'mthalamus_spikes.h5'),
('exc_bg_bask', 'exc_bg_bask_spikes.h5'),
('exc_bg_chn', 'exc_bg_chn_spikes.h5')],
components_dir='biophys_components',
compile_mechanisms=True)
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
#
psg = PoissonSpikeGenerator(population='mthalamus')
psg.add(node_ids=range(numPN_A + numPN_C), # Have nodes to match mthalamus
firing_rate=0.2, # 15 Hz, we can also pass in a nonhomoegenous function/array
times=(0.0, t_sim)) # Firing starts at 0 s up to 3 s
psg.to_sonata('mthalamus_spikes.h5')
psg = PoissonSpikeGenerator(population='exc_bg_bask')
psg.add(node_ids=range(numBask), # Have nodes to match mthalamus
firing_rate=0.2, # 15 Hz, we can also pass in a nonhomoegenous function/array
times=(0.0, t_sim)) # Firing starts at 0 s up to 3 s
psg.to_sonata('exc_bg_bask_spikes.h5')
psg = PoissonSpikeGenerator(population='exc_bg_chn')
psg.add(node_ids=range(numAAC), # Have nodes to match mthalamus
firing_rate=0.2, # 15 Hz, we can also pass in a nonhomoegenous function/array
times=(0.0, t_sim)) # Firing starts at 0 s up to 3 s
net.build()
net.save(output_dir='network')
# SPIKE TRAINS
t_sim = 40000
#build_env_bionet(base_dir='./',
# network_dir='./network',
# tstop=t_sim, dt=0.1,
# report_vars=['v'],
# components_dir='biophys_components',
# config_file='config.json',
# spikes_inputs=[('bg_pn_c', '2_cell_inputs/bg_pn_c_spikes.h5'),
# ('bg_pv', '2_cell_inputs/bg_pv_spikes.h5')],
# compile_mechanisms=False)
psg = PoissonSpikeGenerator(population='bg_pn_c')
psg.add(
node_ids=range(1), # need same number as cells
firing_rate=6, # 1 spike every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('2_cell_inputs/bg_pn_c_spikes.h5')
print('Number of background spikes for PN_C: {}'.format(psg.n_spikes()))
psg = PoissonSpikeGenerator(population='bg_pv')
psg.add(
node_ids=range(1), # need same number as cells
firing_rate=7.7, # 8 spikes every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('2_cell_inputs/bg_pv_spikes.h5')
exc_means.append(np.mean(frs))
exc_stds.append(np.std(frs))
exc_maxs.append(np.max(frs))
exc_frs = exc_dend_frs + exc_apic_frs
fr_df = pd.DataFrame()
#fr_df['gid'] = [i + num_exc+num_inh for i in range(N)]
fr_df['gid'] = [i for i in range(N)]
fr_df['fr_mean'] = exc_means
fr_df['fr_std'] = exc_stds
fr_df['fr_max'] = exc_maxs
fr_df.to_csv('frs_temp.csv', index=False)
exc_psg = PoissonSpikeGenerator(population='exc_stim')
for i in range(num_exc):
exc_psg.add(node_ids=[i],
firing_rate=float(exc_frs[i]/1000),
times=(1.0*1000, 4.0*1000))
exc_psg.to_sonata('exc_stim_spikes.h5')
inh_psg = PoissonSpikeGenerator(population='inh_stim')
inh_psg.add(node_ids=range(num_inh),
firing_rate=inh_fr/1000,
times=(1.0*1000, 4.0*1000))
inh_psg.to_sonata('inh_stim_spikes.h5')
from bmtk.utils.sim_setup import build_env_bionet
def build_model():
if os.path.isdir('network'):
shutil.rmtree('network')
if os.path.isdir('2_cell_inputs'):
shutil.rmtree('2_cell_inputs')
seed = 967
random.seed(seed)
np.random.seed(seed)
load()
syn = syn_params_dicts()
# Initialize our network
net = NetworkBuilder("biophysical")
num_inh = [1]
num_exc = [1]
##################################################################################
###################################BIOPHY#########################################
# PN
net.add_nodes(N=1,
pop_name='PyrC',
mem_potential='e',
model_type='biophysical',
model_template='hoc:Cell_C',
morphology=None)
# PV
net.add_nodes(N=1,
pop_name="PV",
mem_potential='e',
model_type='biophysical',
model_template='hoc:basket',
morphology=None)
backgroundPN_C = NetworkBuilder('bg_pn_c')
backgroundPN_C.add_nodes(N=1,
pop_name='tON',
potential='exc',
model_type='virtual')
backgroundPV = NetworkBuilder('bg_pv')
backgroundPV.add_nodes(N=2,
pop_name='tON',
potential='exc',
model_type='virtual')
# if neuron is sufficiently depolorized enough post synaptic calcium then synaptiic weight goes up
# pyr->pyr & pyr->PV
# PV->pyr PV->PV
def one_to_all(source, target):
sid = source.node_id
tid = target.node_id
print("connecting bio cell {} to bio cell {}".format(sid, tid))
return 1
def BG_to_PN_C(source, target):
sid = source.node_id
tid = target.node_id
if sid == tid:
print("connecting BG {} to PN_C{}".format(sid, tid))
return 1
else:
return 0
def BG_to_PV(source, target):
sid = source.node_id
tid = target.node_id
sid = sid + 1
if sid == tid:
print("connecting BG {} to PV{}".format(sid, tid))
return 1
else:
return 0
conn = net.add_edges(source=net.nodes(pop_name='PyrC'),
target=net.nodes(pop_name="PV"),
connection_rule=one_to_all,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='PN2PV.json',
model_template=syn['PN2PV.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(1, 0.9),
dtypes=[np.int32, np.float])
conn = net.add_edges(source=net.nodes(pop_name='PV'),
target=net.nodes(pop_name="PyrC"),
connection_rule=one_to_all,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='PV2PN.json',
model_template=syn['PV2PN.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(1, 0.9),
dtypes=[np.int32, np.float])
conn = net.add_edges(source=backgroundPN_C.nodes(),
target=net.nodes(pop_name='PyrC'),
connection_rule=BG_to_PN_C,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='BG2PNC.json',
model_template=syn['BG2PNC.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(2, 0.9),
dtypes=[np.int32,
np.float]) # places syn on apic at 0.9
conn = net.add_edges(source=backgroundPV.nodes(),
target=net.nodes(pop_name='PV'),
connection_rule=BG_to_PV,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='BG2PV.json',
model_template=syn['BG2PV.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(1, 0.9),
dtypes=[np.int32, np.float])
backgroundPN_C.build()
backgroundPN_C.save_nodes(output_dir='network')
backgroundPV.build()
backgroundPV.save_nodes(output_dir='network')
net.build()
net.save(output_dir='network')
# SPIKE TRAINS
t_sim = 40000
# build_env_bionet(base_dir='./',
# network_dir='./network',
# tstop=t_sim, dt=0.1,
# report_vars=['v'],
# components_dir='biophys_components',
# config_file='config.json',
# spikes_inputs=[('bg_pn_c', '2_cell_inputs/bg_pn_c_spikes.h5'),
# ('bg_pv', '2_cell_inputs/bg_pv_spikes.h5')],
# compile_mechanisms=False)
psg = PoissonSpikeGenerator(population='bg_pn_c')
psg.add(
node_ids=range(1), # need same number as cells
firing_rate=6, # 1 spike every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('2_cell_inputs/bg_pn_c_spikes.h5')
print('Number of background spikes for PN_C: {}'.format(psg.n_spikes()))
psg = PoissonSpikeGenerator(population='bg_pv')
psg.add(
node_ids=range(1), # need same number as cells
firing_rate=7.7, # 8 spikes every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('2_cell_inputs/bg_pv_spikes.h5')
print('Number of background spikes for PV: {}'.format(psg.n_spikes()))
print("stim time is set to %s" % t_sim)
#build_env_bionet(base_dir='./',
# network_dir='./network',
# tstop=t_sim, dt=0.1,
# report_vars=['v'],
# spikes_inputs=[('tone', './12_cell_inputs/tone_spikes.csv'),
# ('shock', './12_cell_inputs/shock_spikes.csv'),
# ('bg_pn', '12_cell_inputs/bg_pn_spikes.h5'),
# ('bg_pv', '12_cell_inputs/bg_pv_spikes.h5'),
# ('bg_olm', '12_cell_inputs/bg_olm_spikes.h5')],
# components_dir='biophys_components',
# config_file='config.json',
# compile_mechanisms=False)
psg = PoissonSpikeGenerator(population='bg_pn')
psg.add(
node_ids=range(8), # need same number as cells
firing_rate=1, # 1 spike every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('12_cell_inputs/bg_pn_spikes.h5')
print('Number of background spikes for pn: {}'.format(psg.n_spikes()))
psg = PoissonSpikeGenerator(population='bg_pv')
psg.add(
node_ids=range(2), # need same number as cells
firing_rate=8, # 8 spikes every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('12_cell_inputs/bg_pv_spikes.h5')
from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator
psg = PoissonSpikeGenerator(population='LGN')
psg.add(
node_ids=range(0, 100),
firing_rate=8.0, # we can also pass in a nonhomoegenous function/array
times=(0.0, 2.0) # Firing starts at 0 s up to 3 s
)
psg.to_sonata('inputs/lgn_spikes.poisson.h5')
psg.to_csv('inputs/lgn_spikes.poisson.csv')