def TF(RATES, Model, NRN_KEY): neuron_params = built_up_neuron_params(Model, NRN_KEY) SYN_POPS = build_up_afferent_synaptic_input(Model, Model['POP_STIM'], NRN_KEY) ### OUTPUT OF ANALYTICAL CALCULUS IN SI UNITS !! -> from here SI, be careful... muV, sV, gV, Tv = getting_statistical_properties(neuron_params, SYN_POPS, RATES, already_SI=False) Proba = Proba_g_P(muV, sV, gV, 1e-3*neuron_params['Vthre']) Fout_th = firing_rate(muV, sV, gV, Tv, Proba, Model['COEFFS']) return Fout_th
def get_full_statistical_quantities( Model, DYN_SYSTEM={ 'RecExc': { 'aff_pops': ['AffExc'], 'aff_pops_input_values': [1.], 'x0': 1. }, 'RecInh': { 'aff_pops': ['AffExc'], 'aff_pops_input_values': [1.], 'x0': 1. } }): """ we use the x0 point to calculate the satistical values, so consider the replace_x0 options in find_FP or run_dyn_system """ DYN_KEYS = [key for key in DYN_SYSTEM.keys() ] # for a quick access to the dynamical system variables # initialize neuronal and synaptic params (very likely already done) for key in DYN_KEYS: DYN_SYSTEM[key]['nrn_params'] = built_up_neuron_params(Model, key) DYN_SYSTEM[key]['syn_input'] = build_up_afferent_synaptic_input( Model, DYN_KEYS + DYN_SYSTEM[key]['aff_pops'], key) output, RATES = {}, {} for key in DYN_KEYS: RATES['F_' + key] = DYN_SYSTEM[key][ 'x0'] # we use x0 as the activity point to compute for key in DYN_KEYS: for aff_key, x in zip(DYN_SYSTEM[key]['aff_pops'], DYN_SYSTEM[key]['aff_pops_input_values']): RATES['F_' + aff_key] = x output['muV_'+key], output['sV_'+key],\ output['gV_'+key], output['Tv_'+key],\ output['Isyn_'+key] = getting_statistical_properties( DYN_SYSTEM[key]['nrn_params'], DYN_SYSTEM[key]['syn_input'], RATES, already_SI=False, with_Isyn=True) return output
def get_full_statistical_quantities(Model, DYN_SYSTEM, RATES, CURRENT_INPUTS={}): """ DYN_SYSTEM = {'RecExc': {'aff_pops':['AffExc'], 'x0':1.}, 'RecInh': {'aff_pops':['AffExc'], 'x0':1.}} RATES = {'F_AffExc':1., 'F_RecExc':1., 'F_RecInh':1.} """ DYN_KEYS = [key for key in DYN_SYSTEM.keys() ] # for a quick access to the dynamical system variables # initialize neuronal and synaptic params (very likely already done) for key in DYN_KEYS: DYN_SYSTEM[key]['nrn_params'] = built_up_neuron_params(Model, key) DYN_SYSTEM[key]['syn_input'] = build_up_afferent_synaptic_input( Model, DYN_KEYS + DYN_SYSTEM[key]['aff_pops'], key) # output, RATES = {}, {} # for key in DYN_KEYS: # RATES['F_'+key] = DYN_SYSTEM[key]['x0'] # we use x0 as the activity point to compute output = {} for key in DYN_KEYS: current_input = 0. if key in CURRENT_INPUTS: current_input = CURRENT_INPUTS[key] output['muV_'+key], output['sV_'+key],\ output['gV_'+key], output['Tv_'+key],\ output['Isyn_'+key] = getting_statistical_properties( DYN_SYSTEM[key]['nrn_params'], DYN_SYSTEM[key]['syn_input'], RATES, current_input=current_input, already_SI=False, with_Isyn=True) return output
def solve_mean_field_first_order( Model, DYN_SYSTEM={ 'RecExc': { 'aff_pops': ['AffExc'], 'x0': 1. }, 'RecInh': { 'aff_pops': ['AffExc'], 'x0': 1. } }, INPUTS={ 'AffExc_RecExc': np.ones(1000), 'AffExc_RecInh': np.ones(1000) }, CURRENT_INPUTS={}, dt=1e-4, tstop=.1, T=5e-3, replace_x0=False, verbose=True): """ if replace_x0 -> then you can directly use get_stat_props """ DYN_KEYS = [key for key in DYN_SYSTEM.keys() ] # for a quick access to the dynamical system variables # initialize neuronal and synaptic params for key in DYN_KEYS: DYN_SYSTEM[key]['nrn_params'] = built_up_neuron_params(Model, key) DYN_SYSTEM[key]['syn_input'] = build_up_afferent_synaptic_input(Model,\ DYN_KEYS+DYN_SYSTEM[key]['aff_pops'], key, verbose=verbose) # --- CONSTRUCT THE DIFFERENTIAL OPERATOR --- # def dX_dt(X, t, dt, DYN_KEYS, DYN_SYSTEM, INPUTS, CURRENT_INPUTS): dX_dt, RATES = [], {} # we fill the X-defined recurent act: for x, key in zip(X, DYN_KEYS): RATES['F_' + key] = x # then we compute it, key by key for i, key in enumerate(DYN_KEYS): for aff_key in DYN_SYSTEM[key]['aff_pops']: RATES['F_'+aff_key] = INPUTS[aff_key+'_'+key][\ min([int(t/dt), len(INPUTS[aff_key+'_'+key])-1]) ] if key in CURRENT_INPUTS: current_input = CURRENT_INPUTS[key][min( [int(t / dt), len(CURRENT_INPUTS[key]) - 1])] else: current_input = 0 Fout = input_output(DYN_SYSTEM[key]['nrn_params'], DYN_SYSTEM[key]['syn_input'], RATES, Model['COEFFS_' + key], current_input=current_input) dX_dt.append((Fout - X[i]) / T) # Simple one-dimensional framework return dX_dt # ------------------------------------------- # # starting point X0 = [] for key in DYN_KEYS: X0.append(DYN_SYSTEM[key]['x0']) if verbose: print('running ODE integration [...]') start_time = time.time() X = odeint(dX_dt, X0, np.arange(int(tstop / dt)) * dt, args=(dt, DYN_KEYS, DYN_SYSTEM, INPUTS, CURRENT_INPUTS)) if verbose: print("--- ODE integration took %.1f seconds ---" % (time.time() - start_time)) output = {} for key, x in zip(DYN_KEYS, X.T): output[key] = x if replace_x0: DYN_SYSTEM[key]['x0'] = x[-1] return output
def build_TF_func(self, Ngrid=20, coeffs_location='data/COEFFS_pyrExc.npy', with_Vm_functions=False, pop=None, Exc_lim=[0.01,1000], Inh_lim=[0.01, 1000], sampling='log', EXC_VALUE_THRESHOLD=10.): """ """ print('Initializing simulation [...]') if pop is None: pop = self.REC_POPS[0] # taking just one Exc and One Inh pop for the scan !! Exc_pop = [rec for rec in self.REC_POPS if len(rec.split('Exc'))>1][0] Inh_pop = [rec for rec in self.REC_POPS if len(rec.split('Inh'))>1][0] # building artificial simulation situation (with just one exc and one inh) AFF_POPS = [Exc_pop, Inh_pop] Model2 = self.Model.copy() Model2['N_%s'%Exc_pop], Model2['N_%s'%Inh_pop] = 10, 10 Model2['p_%s_%s'%(Exc_pop, pop)], Model2['p_%s_%s'%(Inh_pop, pop)] = 0.1, 0.1 nrn_params = built_up_neuron_params(Model2, pop) syn_input = build_up_afferent_synaptic_input(Model2, AFF_POPS, pop) Model2['COEFFS'] = np.load(coeffs_location) if sampling=='log': Freq_Exc = np.logspace(*np.log10(Exc_lim), Ngrid+1) Freq_Inh = np.logspace(*np.log10(Inh_lim), Ngrid) else: Freq_Exc = np.linspace(*Exc_lim, Ngrid+1) Freq_Inh = np.linspace(*Inh_lim, Ngrid) Ioscill = np.linspace(0, 20*10, int(Ngrid/2)) output_freq = np.zeros((len(Freq_Exc), len(Freq_Inh), len(Ioscill))) if with_Vm_functions: mean_Vm = np.zeros((len(Freq_Exc), len(Freq_Inh), len(Ioscill))) std_Vm = np.zeros((len(Freq_Exc), len(Freq_Inh), len(Ioscill))) gamma_Vm = np.zeros((len(Freq_Exc), len(Freq_Inh), len(Ioscill))) print('Performing grid simulation [...]') for i, j, k in itertools.product(range(len(Freq_Exc)), range(len(Freq_Inh)), range(len(Ioscill))): if Freq_Exc[i]<EXC_VALUE_THRESHOLD: output_freq[i,j,k] = 0 else: output_freq[i,j,k] = input_output(nrn_params, syn_input, {'F_%s'%Exc_pop:Freq_Exc[i], 'F_%s'%Inh_pop:Freq_Inh[j]}, Model2['COEFFS'], current_input=Ioscill[k]) if with_Vm_functions: mean_Vm[i,j,k], std_Vm[i,j,k], _, _ = getting_statistical_properties(nrn_params, syn_input, {'F_%s'%Exc_pop:Freq_Exc[i], 'F_%s'%Inh_pop:Freq_Inh[j]}, current_input=Ioscill[k]) print('Building interpolation [...]') self.TF_func = RegularGridInterpolator([Freq_Exc*\ Model2['p_%s_%s'%(Exc_pop, pop)]*Model2['N_%s'%Exc_pop], Freq_Inh*\ Model2['p_%s_%s'%(Inh_pop, pop)]*Model2['N_%s'%Inh_pop], Ioscill], output_freq, method='linear', fill_value=None, bounds_error=False) if with_Vm_functions: self.mean_Vm_func = RegularGridInterpolator([Freq_Exc*\ Model2['p_%s_%s'%(Exc_pop,pop)]*Model2['N_%s'%Exc_pop], Freq_Inh*\ Model2['p_%s_%s'%(Inh_pop,pop)]*Model2['N_%s'%Inh_pop], Ioscill], mean_Vm, method='linear', fill_value=None, bounds_error=False) # self.std_Vm_func = RegularGridInterpolator([Freq_Exc*\ # Model2['p_%s_%s'%(Exc_pop, pop)]*Model2['N_%s'%Exc_pop], # Freq_Inh*\ # Model2['p_%s_%s'%(Inh_pop, pop)]*Model2['N_%s'%Inh_pop], # Ioscill], # std_Vm, # method='linear', # fill_value=None, bounds_error=False) print('--> Done !')
def simulate_TF_func(self, Ngrid=20, coeffs_location='data/COEFFS_pyrExc.npy', tf_sim_file='tf_sim_points.npz', with_Vm_functions=False, pop=None, Exc_lim=[0.01,1000], Inh_lim=[0.01, 1000], Iinj_lim=None, sampling='log', EXC_VALUE_THRESHOLD=10.): """ """ print('Initializing simulation [...]') if pop is None: pop = self.REC_POPS[0] # taking just one Exc and One Inh pop for the scan !! Exc_pop = [rec for rec in self.REC_POPS if len(rec.split('Exc'))>1][0] Inh_pop = [rec for rec in self.REC_POPS if len(rec.split('Inh'))>1][0] # building artificial simulation situation (with just one exc and one inh) AFF_POPS = [Exc_pop, Inh_pop] Model2 = copy.deepcopy(self.Model) Model2['N_%s'%Exc_pop], Model2['N_%s'%Inh_pop] = 10, 10 Model2['p_%s_%s'%(Exc_pop, pop)], Model2['p_%s_%s'%(Inh_pop, pop)] = 0.1, 0.1 nrn_params = built_up_neuron_params(Model2, pop) syn_input = build_up_afferent_synaptic_input(Model2, AFF_POPS, pop) Model2['COEFFS'] = np.load(coeffs_location) Freq_Exc, Freq_Inh, Iinj = self.build_TF_inputs(Exc_lim, Inh_lim, Iinj_lim, sampling, Ngrid) output_freq = np.zeros((len(Freq_Exc), len(Freq_Inh), len(Iinj))) if with_Vm_functions: mean_Vm, std_Vm, gamma_Vm = 0*output_freq, 0*output_freq, 0*output_freq print('Performing grid simulation [...]') for i, j, k in itertools.product(range(len(Freq_Exc)), range(len(Freq_Inh)), range(len(Iinj))): # if Freq_Exc[i]<EXC_VALUE_THRESHOLD: # output_freq[i,j,k] = 0 # else: output_freq[i,j,k] = input_output(nrn_params, syn_input, {'F_%s'%Exc_pop:Freq_Exc[i], 'F_%s'%Inh_pop:Freq_Inh[j]}, Model2['COEFFS'], current_input=Iinj[k]) if with_Vm_functions: mean_Vm[i,j,k], std_Vm[i,j,k], _, _ = getting_statistical_properties(nrn_params, syn_input, {'F_%s'%Exc_pop:Freq_Exc[i], 'F_%s'%Inh_pop:Freq_Inh[j]}, current_input=Iinj[k]) np.savez(tf_sim_file, **{'output_freq':output_freq, 'mean_Vm':mean_Vm, 'std_Vm':std_Vm, 'sampling':sampling, 'Ngrid':Ngrid, 'Exc_lim':Exc_lim, 'Inh_lim':Inh_lim, 'Iinj_lim':Iinj_lim})