def add_to_network(self, traj, network, current_subrun, subrun_list,
network_dict):
if current_subrun.v_annotations.order == 0:
prm = PopulationRateMonitor(network_dict['group'])
self.monitors['prm'] = prm
network.add(prm)
elif current_subrun.v_annotations.order == 1:
spm = SpikeMonitor(network_dict['group'])
sm = StateMonitor(network_dict['group'], varname='v', record=True)
self.monitors['spm'] = spm
self.monitors['sm'] = sm
network.add(spm)
network.add(sm)
def __init__(self, network, lfp_source, voxel, sim_params, record_lfp=True, record_voxel=True, record_neuron_state=False,
record_spikes=True, record_firing_rate=True, record_inputs=False, record_connections=None,
save_summary_only=False, clock=defaultclock):
self.network_params=network.params
self.pyr_params=network.pyr_params
self.inh_params=network.inh_params
self.sim_params=sim_params
self.plasticity_params=network.plasticity_params
self.voxel_params=None
if voxel is not None:
self.voxel_params=voxel.params
self.monitors={}
self.save_summary_only=save_summary_only
self.clock=clock
self.record_lfp=record_lfp
self.record_voxel=record_voxel
self.record_neuron_state=record_neuron_state
self.record_spikes=record_spikes
self.record_firing_rate=record_firing_rate
self.record_inputs=record_inputs
self.record_connections=record_connections
self.save_summary_only=save_summary_only
# LFP monitor
if self.record_lfp:
self.monitors['lfp'] = StateMonitor(lfp_source, 'LFP', record=0, clock=clock)
# Voxel monitor
if self.record_voxel:
self.monitors['voxel'] = MultiStateMonitor(voxel, vars=['G_total','G_total_exc','y'],
record=True, clock=clock)
# Network monitor
if self.record_neuron_state:
self.record_idx=[]
for i in range(self.network_params.num_groups):
e_idx=i*int(.8*self.network_params.network_group_size/self.network_params.num_groups)
self.record_idx.append(e_idx)
i_idx=int(.8*self.network_params.network_group_size)
self.record_idx.append(i_idx)
self.monitors['network'] = MultiStateMonitor(network, vars=['vm','g_ampa_r','g_ampa_x','g_ampa_b',
'g_gaba_a', 'g_nmda','I_ampa_r','I_ampa_x',
'I_ampa_b','I_gaba_a','I_nmda'],
record=self.record_idx, clock=clock)
# Population rate monitors
if self.record_firing_rate:
for i,group_e in enumerate(network.groups_e):
self.monitors['excitatory_rate_%d' % i]=PopulationRateMonitor(group_e)
self.monitors['inhibitory_rate']=PopulationRateMonitor(network.group_i)
# Input rate monitors
if record_inputs:
self.monitors['background_rate']=PopulationRateMonitor(network.background_input)
for i,task_input in enumerate(network.task_inputs):
self.monitors['task_rate_%d' % i]=PopulationRateMonitor(task_input)
# Spike monitors
if self.record_spikes:
for i,group_e in enumerate(network.groups_e):
self.monitors['excitatory_spike_%d' % i]=SpikeMonitor(group_e)
self.monitors['inhibitory_spike']=SpikeMonitor(network.group_i)
# Connection monitors
if self.record_connections is not None:
for connection in record_connections:
self.monitors['connection_%s' % connection]=ConnectionMonitor(network.connections[connection], store=True,
clock=Clock(dt=.5*second))
def __init__(self,
background_inputs,
visual_cortex_inputs,
go_input,
brain_network,
left_lfp_source,
right_lfp_source,
left_voxel,
right_voxel,
record_lfp=True,
record_voxel=True,
record_neuron_state=False,
record_spikes=True,
record_pop_firing_rate=True,
record_neuron_firing_rates=False,
record_inputs=False):
self.monitors = []
self.brain_network = brain_network
# LFP monitor
if record_lfp:
self.left_lfp_monitor = StateMonitor(left_lfp_source,
'LFP',
record=0)
self.right_lfp_monitor = StateMonitor(right_lfp_source,
'LFP',
record=0)
self.monitors.append(self.left_lfp_monitor)
self.monitors.append(self.right_lfp_monitor)
else:
self.left_lfp_monitor = None
self.right_lfp_monitor = None
# Voxel monitor
if record_voxel:
self.left_voxel_monitor = MultiStateMonitor(left_voxel,
vars=[
'G_total',
'G_total_exc', 's',
'f_in', 'v',
'f_out', 'q', 'y'
],
record=True)
self.right_voxel_monitor = MultiStateMonitor(right_voxel,
vars=[
'G_total',
'G_total_exc',
's', 'f_in', 'v',
'f_out', 'q', 'y'
],
record=True)
self.monitors.append(self.left_voxel_monitor)
self.monitors.append(self.right_voxel_monitor)
else:
self.left_voxel_monitor = None
self.right_voxel_monitor = None
self.left_voxel_exc_monitor = None
self.right_voxel_exc_monitor = None
# Network monitor
if record_neuron_state:
self.left_record_idx = []
# left
# e_contra_vis
self.left_record_idx.append(1)
# e_contra_mem
self.left_record_idx.append(
brain_network.left_lip.e_contra_vis_size + 1)
# e_ipsi vis
self.left_record_idx.append(brain_network.left_lip.e_contra_size +
1)
# e_ipsi mem
self.left_record_idx.append(
brain_network.left_lip.e_contra_size +
brain_network.left_lip.e_ipsi_vis_size + 1)
# i_contra
self.left_record_idx.append(brain_network.left_lip.e_contra_size +
brain_network.left_lip.e_ipsi_size + 1)
# i ipsi
self.left_record_idx.append(brain_network.left_lip.e_contra_size +
brain_network.left_lip.e_ipsi_size +
brain_network.left_lip.i_contra_size +
1)
self.right_record_idx = []
# right
# e_contra_vis
self.right_record_idx.append(1)
# e_contra_mem
self.right_record_idx.append(
brain_network.right_lip.e_contra_vis_size + 1)
# e_ipsi vis
self.right_record_idx.append(
brain_network.right_lip.e_contra_size + 1)
# e_ipsi mem
self.right_record_idx.append(
brain_network.right_lip.e_contra_size +
brain_network.right_lip.e_ipsi_vis_size + 1)
# i_contra
self.right_record_idx.append(
brain_network.right_lip.e_contra_size +
brain_network.right_lip.e_ipsi_size + 1)
# i ipsi
self.right_record_idx.append(
brain_network.right_lip.e_contra_size +
brain_network.right_lip.e_ipsi_size +
brain_network.right_lip.i_contra_size + 1)
self.left_network_monitor = MultiStateMonitor(
brain_network.left_lip.neuron_group,
vars=[
'vm', 'g_ampa_r', 'g_ampa_x', 'g_ampa_g', 'g_ampa_b',
'g_gaba_a', 'g_gaba_b', 'g_nmda', 'I_ampa_r', 'I_ampa_x',
'I_ampa_b', 'I_ampa_g', 'I_gaba_a', 'I_gaba_b', 'I_nmda'
],
record=self.left_record_idx)
self.right_network_monitor = MultiStateMonitor(
brain_network.right_lip.neuron_group,
vars=[
'vm', 'g_ampa_r', 'g_ampa_x', 'g_ampa_g', 'g_ampa_b',
'g_gaba_a', 'g_gaba_b', 'g_nmda', 'I_ampa_r', 'I_ampa_x',
'I_ampa_b', 'I_ampa_g', 'I_gaba_a', 'I_gaba_b', 'I_nmda'
],
record=self.right_record_idx)
self.monitors.append(self.left_network_monitor)
self.monitors.append(self.right_network_monitor)
else:
self.left_network_monitor = None
self.right_network_monitor = None
# Population rate monitors
if record_pop_firing_rate:
self.population_rate_monitors = {
'left_ec_vis':
PopulationRateMonitor(brain_network.left_lip.e_contra_vis),
'left_ec_mem':
PopulationRateMonitor(brain_network.left_lip.e_contra_mem),
'left_ec':
PopulationRateMonitor(brain_network.left_lip.e_contra),
'left_ei_vis':
PopulationRateMonitor(brain_network.left_lip.e_ipsi_vis),
'left_ei_mem':
PopulationRateMonitor(brain_network.left_lip.e_ipsi_mem),
'left_ei':
PopulationRateMonitor(brain_network.left_lip.e_ipsi),
'left_ic':
PopulationRateMonitor(brain_network.left_lip.i_contra),
'left_ii':
PopulationRateMonitor(brain_network.left_lip.i_ipsi),
'right_ec_vis':
PopulationRateMonitor(brain_network.right_lip.e_contra_vis),
'right_ec_mem':
PopulationRateMonitor(brain_network.right_lip.e_contra_mem),
'right_ec':
PopulationRateMonitor(brain_network.right_lip.e_contra),
'right_ei_vis':
PopulationRateMonitor(brain_network.right_lip.e_ipsi_vis),
'right_ei_mem':
PopulationRateMonitor(brain_network.right_lip.e_ipsi_mem),
'right_ei':
PopulationRateMonitor(brain_network.right_lip.e_ipsi),
'right_ic':
PopulationRateMonitor(brain_network.right_lip.i_contra),
'right_ii':
PopulationRateMonitor(brain_network.right_lip.i_ipsi)
}
for mon_name, mon in self.population_rate_monitors.iteritems():
self.monitors.append(mon)
else:
self.population_rate_monitors = None
if record_neuron_firing_rates:
self.neuron_rate_monitors = {
'left_ec_vis': [],
'left_ec_mem': [],
'left_ei_vis': [],
'left_ei_mem': [],
'left_ic': [],
'left_ii': [],
'right_ec_vis': [],
'right_ec_mem': [],
'right_ei_vis': [],
'right_ei_mem': [],
'right_ic': [],
'right_ii': []
}
# Input rate monitors
if record_inputs:
self.left_background_rate_monitor = PopulationRateMonitor(
background_inputs[0])
self.monitors.append(self.left_background_rate_monitor)
self.right_background_rate_monitor = PopulationRateMonitor(
background_inputs[1])
self.monitors.append(self.right_background_rate_monitor)
self.left_visual_cortex_monitor = PopulationRateMonitor(
visual_cortex_inputs[0])
self.monitors.append(self.left_visual_cortex_monitor)
self.right_visual_cortex_monitor = PopulationRateMonitor(
visual_cortex_inputs[1])
self.monitors.append(self.right_visual_cortex_monitor)
self.go_input_monitor = PopulationRateMonitor(go_input)
self.monitors.append(self.go_input_monitor)
else:
self.left_background_rate_monitor = None
self.right_background_rate_monitor = None
self.left_visual_cortex_monitor = None
self.right_visual_cortex_monitor = None
self.go_input_monitor = None
# Spike monitors
if record_spikes:
self.spike_monitors = {
'left_ec': SpikeMonitor(brain_network.left_lip.e_contra),
'left_ei': SpikeMonitor(brain_network.left_lip.e_ipsi),
'left_ic': SpikeMonitor(brain_network.left_lip.i_contra),
'left_ii': SpikeMonitor(brain_network.left_lip.i_ipsi),
'right_ec': SpikeMonitor(brain_network.right_lip.e_contra),
'right_ei': SpikeMonitor(brain_network.right_lip.e_ipsi),
'right_ic': SpikeMonitor(brain_network.right_lip.i_contra),
'right_ii': SpikeMonitor(brain_network.right_lip.i_ipsi)
}
for mon_name, mon in self.spike_monitors.iteritems():
self.monitors.append(mon)
else:
self.spike_monitors = None
