def perform_analysis(self): dsv1 = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating') for sheet in dsv1.sheets(): dsv = queries.param_filter_query(dsv1, sheet_name=sheet) segs1, stids = colapse(dsv.get_segments(),dsv.get_stimuli(),parameter_list=['trial'],allow_non_identical_objects=True) for segs,st in zip(segs1, stids): first_analog_signal = segs[0].get_esyn(segs[0].get_stored_esyn_ids()[0]) duration = first_analog_signal.t_stop - first_analog_signal.t_start frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).params()['temporal_frequency'].units period = 1/frequency period = period.rescale(first_analog_signal.t_start.units) cycles = duration / period first_har = round(cycles) e_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_esyn_ids()] i_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_isyn_ids()] v_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_vm_ids()] e_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten()/len(segs[0].get_esyn(idd)))[first_har]) for idd in segs[0].get_stored_esyn_ids()] i_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten()/len(segs[0].get_esyn(idd)))[first_har]) for idd in segs[0].get_stored_isyn_ids()] v_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten()/len(segs[0].get_esyn(idd)))[first_har]) for idd in segs[0].get_stored_vm_ids()] self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f0,segs[0].get_stored_esyn_ids(),first_analog_signal.units,value_name = 'F0_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f0,segs[0].get_stored_isyn_ids(),first_analog_signal.units,value_name = 'F0_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f0,segs[0].get_stored_vm_ids(),first_analog_signal.units,value_name = 'F0_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f1,segs[0].get_stored_esyn_ids(),first_analog_signal.units,value_name = 'F1_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f1,segs[0].get_stored_isyn_ids(),first_analog_signal.units,value_name = 'F1_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f1,segs[0].get_stored_vm_ids(),first_analog_signal.units,value_name = 'F1_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st)))
def perform_analysis(self): for sheet in self.parameters.sheet_list: #Obtain the average firing rate for each neuron and each samples of the stimuli, separately for the spectrally matched noise and synthetic texture stimuli dsv_noise = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=sheet, st_texture = self.parameters.texture_list, value_name = "Firing rate", st_stats_type = 2) dsv_texture = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=sheet, st_texture = self.parameters.texture_list, value_name = "Firing rate", st_stats_type = 1) pnvs_noise = dsv_noise.get_analysis_result() pnvs_texture = dsv_texture.get_analysis_result() firing_rates_noise = numpy.array([pnv.get_value_by_id(pnvs_noise[0].ids) for pnv in pnvs_noise]) firing_rates_texture = numpy.array([pnv.get_value_by_id(pnvs_texture[0].ids) for pnv in pnvs_texture]) assert firing_rates_noise.shape == firing_rates_texture.shape count_positively_modulated = 0 count_negatively_modulated = 0 #For every neuron, check if it is significantly modulated through a randomization test for i in range (firing_rates_noise.shape[1]): mean_response_texture = numpy.mean(firing_rates_texture[:,i]) mean_response_noise = numpy.mean(firing_rates_noise[:,i]) modulation = (mean_response_texture - mean_response_noise)/(mean_response_texture + mean_response_noise) neuron_modulated = self.randomization_test(firing_rates_noise[:,i],firing_rates_texture[:,i], modulation) if modulation > 0: count_positively_modulated += neuron_modulated elif modulation < 0: count_negatively_modulated += neuron_modulated st = MozaikParametrized.idd(pnvs_texture[0].stimulus_id) setattr(st,'stats_type',None) setattr(st,'sample',None) setattr(st,'texture',None) self.datastore.full_datastore.add_analysis_result(SingleValue(float(count_positively_modulated)/firing_rates_noise.shape[1] * 100, qt.percent, value_name = "Percentage of neurons significantly positively modulated", sheet_name=sheet, tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(SingleValue(float(count_negatively_modulated)/firing_rates_noise.shape[1] * 100, qt.percent, value_name = "Percentage of neurons significantly negatively modulated", sheet_name=sheet, tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(SingleValue(float(firing_rates_noise.shape[1] - count_positively_modulated - count_negatively_modulated)/firing_rates_noise.shape[1] * 100,qt.percent, value_name = "Percentage of neurons not significantly modulated", sheet_name=sheet, tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st)))
def perform_analysis(self): dsv1 = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating') for sheet in dsv1.sheets(): dsv = queries.param_filter_query(dsv1, sheet_name=sheet) segs1, stids = colapse(dsv.get_segments(),dsv.get_stimuli(),parameter_list=['trial'],allow_non_identical_objects=True) for segs,st in zip(segs1, stids): first_analog_signal = segs[0].get_esyn(segs[0].get_stored_esyn_ids()[0]) duration = first_analog_signal.t_stop - first_analog_signal.t_start frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).params()['temporal_frequency'].units period = 1/frequency period = period.rescale(first_analog_signal.t_start.units) cycles = duration / period first_har = round(cycles) e_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_esyn_ids()] i_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_isyn_ids()] v_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_vm_ids()] e_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten()/len(segs[0].get_esyn(idd)))[first_har]) for idd in segs[0].get_stored_esyn_ids()] i_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten()/len(segs[0].get_esyn(idd)))[first_har]) for idd in segs[0].get_stored_isyn_ids()] v_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten()/len(segs[0].get_esyn(idd)))[first_har]) for idd in segs[0].get_stored_vm_ids()] self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f0,segs[0].get_stored_esyn_ids(),first_analog_signal.units,value_name = 'F0_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f0,segs[0].get_stored_isyn_ids(),first_analog_signal.units,value_name = 'F0_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f0,segs[0].get_stored_vm_ids(),first_analog_signal.units,value_name = 'F0_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f1,segs[0].get_stored_esyn_ids(),first_analog_signal.units,value_name = 'F1_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f1,segs[0].get_stored_isyn_ids(),first_analog_signal.units,value_name = 'F1_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f1,segs[0].get_stored_vm_ids(),first_analog_signal.units,value_name = 'F1_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st)))
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(20, 1, subplot_spec=subplotspec,hspace=1.0, wspace=1.0) dsv = queries.param_filter_query(self.datastore,y_axis_name=['Vm (no AP) trial-to-trial mean','Vm (no AP) trial-to-trial variance'],st_name="NaturalImageWithEyeMovement") plots['plot1'] = (PerNeuronAnalogSignalScatterPlot(dsv,ParameterSet({'neurons' : self.parameters.neurons})),gs[2:10,0],{}) dsv = queries.param_filter_query(self.datastore,y_axis_name=['Vm (no AP) trial-to-trial mean','Vm (no AP) trial-to-trial variance'],st_name="FullfieldDriftingSinusoidalGrating",st_orientation=0,st_contrast=100) plots['plot2'] = (PerNeuronAnalogSignalScatterPlot(dsv,ParameterSet({'neurons' : self.parameters.neurons})),gs[12:,0],{}) return plots
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(20, 1, subplot_spec=subplotspec,hspace=1.0, wspace=1.0) dsv = queries.param_filter_query(self.datastore,y_axis_name=['Vm (no AP) trial-to-trial mean','Vm (no AP) trial-to-trial variance'],st_name="NaturalImageWithEyeMovement") plots['plot1'] = (PerNeuronAnalogSignalScatterPlot(dsv,ParameterSet({'neurons' : self.parameters.neurons})),gs[2:10,0],{}) dsv = queries.param_filter_query(self.datastore,y_axis_name=['Vm (no AP) trial-to-trial mean','Vm (no AP) trial-to-trial variance'],st_name="FullfieldDriftingSinusoidalGrating",st_orientation=0,st_contrast=100) plots['plot2'] = (PerNeuronAnalogSignalScatterPlot(dsv,ParameterSet({'neurons' : self.parameters.neurons})),gs[12:,0],{}) return plots
def perform_analysis(self): for sheet in self.datastore.sheets(): dsv = queries.param_filter_query(self.datastore, sheet_name=sheet) if len(dsv.get_segments()) != 0: assert queries.equal_stimulus_type(self.datastore) , "Data store has to contain only recordings to the same stimulus type" st = self.datastore.get_stimuli()[0] assert MozaikParametrized.idd(st).getParams().has_key('temporal_frequency'), "The stimulus has to have parameter temporal_frequency which is used as first harmonic" segs1, stids = colapse(dsv.get_segments(),dsv.get_stimuli(),parameter_list=['trial'],allow_non_identical_objects=True) for segs,st in zip(segs1, stids): first_analog_signal = segs[0].get_esyn(segs[0].get_stored_esyn_ids()[0]) duration = first_analog_signal.t_stop - first_analog_signal.t_start frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).getParams()['temporal_frequency'].units period = 1/frequency period = period.rescale(first_analog_signal.t_start.units) cycles = duration / period first_har = int(round(cycles)) e_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_esyn_ids()] i_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_isyn(idd))) for idd in segs[0].get_stored_isyn_ids()] v_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_vm(idd))) for idd in segs[0].get_stored_vm_ids()] e_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten())[first_har]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_esyn_ids()] i_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten())[first_har]/len(segs[0].get_isyn(idd))) for idd in segs[0].get_stored_isyn_ids()] v_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten())[first_har]/len(segs[0].get_vm(idd))) for idd in segs[0].get_stored_vm_ids()] cond_units = segs[0].get_esyn(segs[0].get_stored_esyn_ids()[0]).units vm_units = segs[0].get_vm(segs[0].get_stored_esyn_ids()[0]).units self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f0,segs[0].get_stored_esyn_ids(),cond_units,value_name = 'F0_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f0,segs[0].get_stored_isyn_ids(),cond_units,value_name = 'F0_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f0,segs[0].get_stored_vm_ids(),vm_units,value_name = 'F0_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f1,segs[0].get_stored_esyn_ids(),cond_units,value_name = 'F1_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f1,segs[0].get_stored_isyn_ids(),cond_units,value_name = 'F1_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f1,segs[0].get_stored_vm_ids(),vm_units,value_name = 'F1_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) # AnalogSignalList part dsv = queries.param_filter_query(dsv, sheet_name=sheet,name='AnalogSignalList') for asl in dsv.get_analysis_result(): assert MozaikParametrized.idd(asl.stimulus_id).getParams().has_key('temporal_frequency'), "The stimulus has to have parameter temporal_frequency which is used as first harmonic" signals = asl.asl first_analog_signal = signals[0] duration = first_analog_signal.t_stop - first_analog_signal.t_start frequency = MozaikParametrized.idd(asl.stimulus_id).temporal_frequency * MozaikParametrized.idd(asl.stimulus_id).getParams()['temporal_frequency'].units period = 1/frequency period = period.rescale(first_analog_signal.t_start.units) cycles = duration / period first_har = int(round(cycles)) f0 = [abs(numpy.fft.fft(signal)[0]) for signal in signals] f1 = [2*abs(numpy.fft.fft(signal)[first_har]) for signal in signals] self.datastore.full_datastore.add_analysis_result(PerNeuronValue(f0,asl.ids,asl.y_axis_units,value_name = 'F0('+ asl.y_axis_name + ')',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=asl.stimulus_id)) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(f1,asl.ids,asl.y_axis_units,value_name = 'F1('+ asl.y_axis_name + ')',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=asl.stimulus_id))
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore, identifier='PerNeuronValue') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id', 'sheet_name']) textures = list(set([MozaikParametrized.idd(ads.stimulus_id).texture for ads in dsv.get_analysis_result()])) samples = list(set([MozaikParametrized.idd(ads.stimulus_id).sample for ads in dsv.get_analysis_result()])) trials = list(set([MozaikParametrized.idd(ads.stimulus_id).trial for ads in dsv.get_analysis_result()])) for sheet in self.parameters.sheet_list: mean_rates = [] #This is a 4D array where we will store the firing rates of each neurons for each trial of each sample of each texture family for texture in textures: mean_rates_texture = [] dsv_tmp = queries.param_filter_query(dsv,identifier='PerNeuronValue',sheet_name=sheet,st_texture=texture,st_stats_type=1) for sample in samples: mean_rates_sample = [] for trial in trials: pnv = queries.param_filter_query(dsv_tmp,identifier='PerNeuronValue',st_sample=sample,st_trial=trial).get_analysis_result()[0] mean_rates_sample.append(pnv.values) mean_rates_texture.append(mean_rates_sample) mean_rates.append(mean_rates_texture) global_averaged_rates = numpy.mean(mean_rates, axis = (0,1,2)) #Calculating the global averaged firing rates for each neurons accross each texture family, samples and trials textures_averaged_rates = numpy.mean(mean_rates, axis = (1,2)) #Calculating the firing rates of each neurons for each texture family by averaging accross samples and trials samples_averaged_rates = numpy.mean(mean_rates, axis = 2) #Calculating the firing rates of each neurons for each sample by averaging accross trials SStextures = len(trials) * len(samples) * numpy.sum((textures_averaged_rates - global_averaged_rates)**2, axis=0) #Compute the Anova sum of squares accross texture families SSsamples = len(trials) * numpy.sum((numpy.transpose(samples_averaged_rates,(1,0,2)) - textures_averaged_rates)**2, axis=(0,1)) #Compute the Anova sum of squares accross samples SStrials = numpy.sum((numpy.transpose(mean_rates,(2,0,1,3)) - samples_averaged_rates)**2, axis=(0,1,2)) #Compute the Anova sum of squares accross trials (residuals) SStotal = numpy.sum((mean_rates - global_averaged_rates)**2, axis=(0,1,2)) #Compute tha Anova total sum of squares #We compute the mean squares of the nested Anova MStextures = SStextures/(len(textures)-1) MSsamples = SSsamples/(len(textures) * (len(samples) - 1)) MStrials = SStrials/(len(textures) * len(samples) * (len(trials) - 1)) #We compute the R-squared for each factor and for the residuals RsquaredTextures = SStextures/SStotal RsquaredSamples = SSsamples/SStotal RsquaredTrials = SStrials/SStotal #The variance ratio is the F statistic of the nested Anova varianceRatio = MStextures/MSsamples st = MozaikParametrized.idd(pnv.stimulus_id) setattr(st,'stats_type',None) setattr(st,'trial',None) setattr(st,'sample',None) setattr(st,'texture',None) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(varianceRatio,pnv.ids,None,value_name = "Texture variance ratio",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(RsquaredTextures * 100,pnv.ids,value_units=qt.percent,value_name = "Texture r-squared",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(RsquaredSamples * 100,pnv.ids,value_units=qt.percent,value_name = "Sample r-squared",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(RsquaredTrials * 100,pnv.ids,value_units=qt.percent,value_name = "Trial r-squared",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st)))
def perform_analysis(self): for sheet in self.datastore.sheets(): dsv = queries.param_filter_query(self.datastore, sheet_name=sheet) if len(dsv.get_segments()) != 0: assert queries.equal_stimulus_type(self.datastore) , "Data store has to contain only recordings to the same stimulus type" st = self.datastore.get_stimuli()[0] assert MozaikParametrized.idd(st).getParams().has_key('temporal_frequency'), "The stimulus has to have parameter temporal_frequency which is used as first harmonic" segs1, stids = colapse(dsv.get_segments(),dsv.get_stimuli(),parameter_list=['trial'],allow_non_identical_objects=True) for segs,st in zip(segs1, stids): first_analog_signal = segs[0].get_esyn(segs[0].get_stored_esyn_ids()[0]) duration = first_analog_signal.t_stop - first_analog_signal.t_start frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).getParams()['temporal_frequency'].units period = 1/frequency period = period.rescale(first_analog_signal.t_start.units) cycles = duration / period first_har = int(round(cycles)) e_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_esyn_ids()] i_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_isyn(idd))) for idd in segs[0].get_stored_isyn_ids()] v_f0 = [abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten())[0]/len(segs[0].get_vm(idd))) for idd in segs[0].get_stored_vm_ids()] e_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_esyn(idd) for seg in segs],axis=0).flatten())[first_har]/len(segs[0].get_esyn(idd))) for idd in segs[0].get_stored_esyn_ids()] i_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_isyn(idd) for seg in segs],axis=0).flatten())[first_har]/len(segs[0].get_isyn(idd))) for idd in segs[0].get_stored_isyn_ids()] v_f1 = [2*abs(numpy.fft.fft(numpy.mean([seg.get_vm(idd) for seg in segs],axis=0).flatten())[first_har]/len(segs[0].get_vm(idd))) for idd in segs[0].get_stored_vm_ids()] cond_units = segs[0].get_esyn(segs[0].get_stored_esyn_ids()[0]).units vm_units = segs[0].get_vm(segs[0].get_stored_esyn_ids()[0]).units self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f0,segs[0].get_stored_esyn_ids(),cond_units,value_name = 'F0_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f0,segs[0].get_stored_isyn_ids(),cond_units,value_name = 'F0_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f0,segs[0].get_stored_vm_ids(),vm_units,value_name = 'F0_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(e_f1,segs[0].get_stored_esyn_ids(),cond_units,value_name = 'F1_Exc_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(i_f1,segs[0].get_stored_isyn_ids(),cond_units,value_name = 'F1_Inh_Cond',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(v_f1,segs[0].get_stored_vm_ids(),vm_units,value_name = 'F1_Vm',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) # AnalogSignalList part dsv = queries.param_filter_query(dsv, sheet_name=sheet,name='AnalogSignalList') for asl in dsv.get_analysis_result(): assert MozaikParametrized.idd(asl.stimulus_id).getParams().has_key('temporal_frequency'), "The stimulus has to have parameter temporal_frequency which is used as first harmonic" signals = asl.asl first_analog_signal = signals[0] duration = first_analog_signal.t_stop - first_analog_signal.t_start frequency = MozaikParametrized.idd(asl.stimulus_id).temporal_frequency * MozaikParametrized.idd(asl.stimulus_id).getParams()['temporal_frequency'].units period = 1/frequency period = period.rescale(first_analog_signal.t_start.units) cycles = duration / period first_har = int(round(cycles)) f0 = [abs(numpy.fft.fft(signal)[0])/len(signal) for signal in signals] f1 = [2*abs(numpy.fft.fft(signal)[first_har])/len(signal) for signal in signals] self.datastore.full_datastore.add_analysis_result(PerNeuronValue(f0,asl.ids,asl.y_axis_units,value_name = 'F0('+ asl.y_axis_name + ')',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=asl.stimulus_id)) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(f1,asl.ids,asl.y_axis_units,value_name = 'F1('+ asl.y_axis_name + ')',sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=asl.stimulus_id))
def perform_analysis(self): for sheet in self.datastore.sheets(): dsv_psth = queries.param_filter_query( self.datastore, analysis_algorithm="PopulationMean", y_axis_name='Mean(psth (bin=5.0))', sheet_name=sheet) dsv_cv = queries.param_filter_query( self.datastore, analysis_algorithm="PopulationMean", value_name='Mean(CV of ISI squared)', sheet_name=sheet, identifier="SingleValue") dsv_corr = queries.param_filter_query( self.datastore, analysis_algorithm="PopulationMean", value_name='Mean(Correlation coefficient(psth (bin=5.0)))', sheet_name=sheet, identifier="SingleValue") assert len( dsv_cv.get_analysis_result() ) == 1, "Error: SpontaneousActivityLength accepts only datastore that holds one SingleValue analysis data structure with value_name: Mean(CV of ISI squared). It contains: %d" % len( dsv_cv.get_analysis_result()) assert len( dsv_corr.get_analysis_result() ) == 1, "Error: SpontaneousActivityLength accepts only datastore that holds one SingleValue analysis data structure with value_name: 'Mean(Correlation coefficient(psth (bin=5.0))).It contains: %d" % len( dsv_cv.get_analysis_result()) assert len( dsv_psth.get_analysis_result() ) == 1, "Error: SpontaneousActivityLength accepts only datastore that holds one AnalogSignal analysis data structure with value_name: 'Mean(psth (bin=5.0)).It contains: %d" % len( dsv_cv.get_analysis_result()) if dsv_cv.get_analysis_result( )[0].value >= 0.95 and dsv_corr.get_analysis_result( )[0].value <= 0.05: i = numpy.nonzero( dsv_psth.get_analysis_result()[0].analog_signal)[0][-1] logger.warning(i) l = dsv_psth.get_analysis_result()[0].analog_signal.times[i] else: l = 0 logger.warning(dsv_psth.get_analysis_result()[0].analog_signal) logger.warning(dsv_cv.get_analysis_result()[0].value) logger.warning(dsv_corr.get_analysis_result()[0].value) logger.warning(l) self.datastore.full_datastore.add_analysis_result( SingleValue(l, qt.ms, value_name='Spontaneous activity length', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__))
def __init__(self, datastore, **params): Parameterized.__init__(self, **params) self.datastore = datastore ### lets first find the values of the two parameters in the datastore self.x_axis_values = list(parameter_value_list(datastore.get_analysis_result(),self.x_axis_parameter)) self.y_axis_values = list(parameter_value_list(param_filter_query(datastore,**{self.x_axis_parameter:self.x_axis_values[0]}).get_analysis_result(),self.y_axis_parameter)) ### and verify it forms a grid for v in self.x_axis_values: assert set(self.y_axis_values) == parameter_value_list(param_filter_query(datastore,**{self.x_axis_parameter:v}).get_analysis_result(),self.y_axis_parameter)
def __init__(self, datastore, **params): Parameterized.__init__(self, **params) self.datastore = datastore ### lets first find the values of the two parameters in the datastore self.x_axis_values = list(parameter_value_list(datastore.get_analysis_result(),self.x_axis_parameter)) self.y_axis_values = list(parameter_value_list(param_filter_query(datastore,**{self.x_axis_parameter:self.x_axis_values[0]}).get_analysis_result(),self.y_axis_parameter)) ### and verify it forms a grid for v in self.x_axis_values: assert set(self.y_axis_values) == parameter_value_list(param_filter_query(datastore,**{self.x_axis_parameter:v}).get_analysis_result(),self.y_axis_parameter)
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingCenterSurroundStimulus') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'surround_orientation' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"surround_orientation") for k in self.tc_dict.keys(): sis = [] surround_tuning=[] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): ors = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) d={} for o,v in zip(ors,values): d[o] = v sis.append(d[0] / d[numpy.pi/2]) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def __init__(self, datastore, parameters, plot_file_name=None,fig_param=None): Plotting.__init__(self, datastore, parameters, plot_file_name, fig_param) self.st = [] self.tc_dict = [] self.pnvs = [] self.max_mean_response_indexes = [] assert queries.ads_with_equal_stimulus_type(datastore) assert len(self.parameters.neurons) > 0 , "ERROR, empty list of neurons specified" dsvs = queries.partition_analysis_results_by_parameters_query(self.datastore,parameter_list=['value_name'],excpt=True) for dsv in dsvs: dsv = queries.param_filter_query(dsv,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name) assert matching_parametrized_object_params(dsv.get_analysis_result(), params=['value_name']) self.pnvs.append(dsv.get_analysis_result()) # get stimuli st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs[-1]] self.st.append(st) # transform the pnvs into a dictionary of tuning curves along the parameter_name # also make sure the values are ordered according to ids in the first pnv dic = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs[-1]],st,self.parameters.parameter_name) #sort the entries in dict according to the parameter parameter_name values for k in dic: (b, a) = dic[k] par, val = zip( *sorted( zip(b, numpy.array(a)))) dic[k] = (par,numpy.array(val)) self.tc_dict.append(dic) if self.parameters.centered: self.max_mean_response_indexes.append(numpy.argmax(sum([a[1] for a in dic.values()]),axis=0))
def perform_analysis(self): sigma = self.parameters.sigma for sheet in self.datastore.sheets(): positions = self.datastore.get_neuron_postions()[sheet] for pnv in queries.param_filter_query(self.datastore,sheet_name=sheet,identifier='PerNeuronValue').get_analysis_result(): lhis = [] for x in pnv.ids: idx = self.datastore.get_sheet_indexes(sheet,x) sx = positions[0][idx] sy = positions[1][idx] lhi_current=[0,0] for y in pnv.ids: idx = self.datastore.get_sheet_indexes(sheet,y) tx = positions[0][idx] ty = positions[1][idx] lhi_current[0]+=numpy.exp(-((sx-tx)*(sx-tx)+(sy-ty)*(sy-ty))/(2*sigma*sigma))*numpy.cos(2*pnv.get_value_by_id(y)) lhi_current[1]+=numpy.exp(-((sx-tx)*(sx-tx)+(sy-ty)*(sy-ty))/(2*sigma*sigma))*numpy.sin(2*pnv.get_value_by_id(y)) lhis.append(numpy.sqrt(lhi_current[0]*lhi_current[0] + lhi_current[1]*lhi_current[1])/(2*numpy.pi*sigma*sigma)) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(lhis, pnv.ids, qt.dimensionless, value_name='LocalHomogeneityIndex' + '(' + str(self.parameters.sigma) + ':' + pnv.value_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(pnv.stimulus_id)))
def perform_analysis(self): sigma = self.parameters.sigma for sheet in self.datastore.sheets(): positions = self.datastore.get_neuron_postions()[sheet] for pnv in queries.param_filter_query(self.datastore,sheet_name=sheet,identifier='PerNeuronValue').get_analysis_result(): lhis = [] for x in pnv.ids: idx = self.datastore.get_sheet_indexes(sheet,x) sx = positions[0][idx] sy = positions[1][idx] lhi_current=[0,0] for y in pnv.ids: idx = self.datastore.get_sheet_indexes(sheet,y) tx = positions[0][idx] ty = positions[1][idx] lhi_current[0]+=numpy.exp(-((sx-tx)*(sx-tx)+(sy-ty)*(sy-ty))/(2*sigma*sigma))*numpy.cos(2*pnv.get_value_by_id(y)) lhi_current[1]+=numpy.exp(-((sx-tx)*(sx-tx)+(sy-ty)*(sy-ty))/(2*sigma*sigma))*numpy.sin(2*pnv.get_value_by_id(y)) lhis.append(numpy.sqrt(lhi_current[0]*lhi_current[0] + lhi_current[1]*lhi_current[1])/(2*numpy.pi*sigma*sigma)) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(lhis, pnv.ids, qt.dimensionless, value_name='LocalHomogeneityIndex' + '(' + str(self.parameters.sigma) + ':' + pnv.value_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__))
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingCenterSurroundStimulus') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'surround_orientation' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"surround_orientation") for k in self.tc_dict.keys(): sis = [] surround_tuning=[] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): ors = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) d=OrderedDict() for o,v in zip(ors,values): d[o] = v sis.append(d[0] / d[numpy.pi/2]) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(20, 29, subplot_spec=subplotspec, hspace=1.0, wspace=1.0) #analog_ids = sorted(numpy.random.permutation(queries.param_filter_query(self.datastore,sheet_name=self.parameters.exc_sheet_name).get_segments()[0].get_stored_esyn_ids())) #analog_ids_inh = sorted(numpy.random.permutation(queries.param_filter_query(self.datastore,sheet_name=self.parameters.inh_sheet_name).get_segments()[0].get_stored_isyn_ids())) analog_ids = sorted(numpy.random.permutation(queries.param_filter_query(self.datastore,sheet_name=self.parameters.exc_sheet_name).get_segments()[0].get_stored_spike_train_ids())) analog_ids_inh = sorted(numpy.random.permutation(queries.param_filter_query(self.datastore,sheet_name=self.parameters.inh_sheet_name).get_segments()[0].get_stored_spike_train_ids())) #pnv = queries.param_filter_query(self.datastore,value_name=['orientation max of Firing rate'],sheet_name=self.parameters.exc_sheet_name,st_contrast=100).get_analysis_result()[0] #analog_ids = numpy.array(pnv.ids)[pnv.values>5.0] #pnv = queries.param_filter_query(self.datastore,value_name=['orientation max of Firing rate'],sheet_name=self.parameters.inh_sheet_name,st_contrast=100).get_analysis_result()[0] #analog_ids_inh = numpy.array(pnv.ids)[pnv.values>5.0] dsv1 = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['LGNAfferentOrientation'],sheet_name=self.parameters.exc_sheet_name) dsv2 = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['orientation preference of Firing rate'],sheet_name=self.parameters.exc_sheet_name,st_contrast=100,analysis_algorithm='GaussianTuningCurveFit') plots['Or_corr_exc'] = (PerNeuronValueScatterPlot(dsv1+dsv2, ParameterSet({'only_matching_units' : True , 'ignore_nan' : True})),gs[0:4,3:5],{'x_label' : 'OR measured','y_label' : 'OR set','x_lim': (0.0,numpy.pi),'y_lim' : (0.0,numpy.pi), 'cmp' : None}) dsv1 = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['LGNAfferentOrientation'],sheet_name=self.parameters.inh_sheet_name) dsv2 = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['orientation preference of Firing rate'],sheet_name=self.parameters.inh_sheet_name,st_contrast=100,analysis_algorithm='GaussianTuningCurveFit') plots['Or_corr_ing'] = (PerNeuronValueScatterPlot(dsv1+dsv2, ParameterSet({'only_matching_units' : True , 'ignore_nan' : True})),gs[0:4,5:7],{'x_label' : 'OR measured','y_label' : None,'x_lim': (0.0,numpy.pi),'y_lim' : (0.0,numpy.pi), 'cmp' : None}) dsv = queries.param_filter_query(self.datastore,value_name=['orientation HWHH of Firing rate'],sheet_name=[self.parameters.exc_sheet_name,self.parameters.inh_sheet_name]) plots['HWHH'] = (PerNeuronValueScatterPlot(dsv, ParameterSet({'only_matching_units' : True, 'ignore_nan' : True})),gs[0:4,8:12],{'x_lim': (0,50),'y_lim' : (0,50),'identity_line' : True, 'x_label' : 'HWHH Cont. 100%','y_label' : 'HWHH Cont. 50%', 'cmp' : None}) dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',analysis_algorithm=['TrialAveragedFiringRate']) plots['ExcORTCMean'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.exc_sheet_name,'centered' : True,'mean' : True,'pool' : False,'polar' : False})),gs[6:10,:3],{'title' : None,'x_label' : None , 'y_label' : 'EXC\nfiring rate (sp/s)','colors' : ['#FFAB00','#000000']}) plots['ExcORTC1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:7]), 'sheet_name' : self.parameters.exc_sheet_name,'centered' : True,'mean' : False,'pool' : False,'polar' : False})),gs[6:8,3:],{'title' : None,'x_label' : None,'x_axis' : False, 'x_ticks' : False,'colors' : ['#FFAB00','#000000']}) plots['ExcORTC2'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[7:14]), 'sheet_name' : self.parameters.exc_sheet_name,'centered' : True,'mean' : False,'pool' : False,'polar': False})),gs[8:10,3:],{'title' : None,'x_label' : None,'x_axis' : False,'colors' : ['#FFAB00','#000000']}) plots['InhORTCMean'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids_inh), 'sheet_name' : self.parameters.inh_sheet_name,'centered' : True,'mean' : True,'pool' : False,'polar' : False})),gs[11:15,:3],{'title' : None, 'y_label' : 'INH\nfiring rate (sp/s)','colors' : ['#FFAB00','#000000']}) plots['InhORTC1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids_inh[0:3]), 'sheet_name' : self.parameters.inh_sheet_name,'centered' : True,'mean' : False,'pool' : False,'polar' : False})),gs[11:13,3:],{'title' : None,'x_label' : None,'y_axis' : False,'x_axis' : False,'colors' : ['#FFAB00','#000000']}) plots['InhORTC2'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids_inh[3:6]), 'sheet_name' : self.parameters.inh_sheet_name,'centered' : True,'mean' : False,'pool' : False,'polar' : False})),gs[13:15,3:],{'title' : None,'y_axis' : None,'colors' : ['#FFAB00','#000000']}) dsv = queries.param_filter_query(self.datastore,value_name=['orientation HWHH of Firing rate'],sheet_name=[self.parameters.exc_sheet_name]) plots['HWHHHistogramExc'] = (PerNeuronValuePlot(dsv, ParameterSet({'cortical_view' : False})),gs[17:,1:7],{'title' : 'Excitatory' , 'x_lim' : (0.0,50.0), 'x_label' : 'HWHH'}) dsv = queries.param_filter_query(self.datastore,value_name=['orientation HWHH of Firing rate'],sheet_name=[self.parameters.inh_sheet_name]) plots['HWHHHistogramInh'] = (PerNeuronValuePlot(dsv, ParameterSet({'cortical_view' : False})),gs[17:,8:14],{'title' : 'Inhibitory' , 'x_lim' : (0.0,50.0), 'x_label' : 'HWHH'}) return plots
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(1, 1, subplot_spec=subplotspec,hspace=1.0, wspace=1.0) dsv = queries.param_filter_query(self.datastore,value_name='Fano Factor (spike count (bin=13.0))') assert len(queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="NaturalImageWithEyeMovement").get_analysis_result()) == 1 assert len(queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="FullfieldDriftingSinusoidalGrating",st_orientation=0).get_analysis_result()) == 1 a= queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="NaturalImageWithEyeMovement").get_analysis_result()[0].values b= queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="FullfieldDriftingSinusoidalGrating",st_orientation=0).get_analysis_result()[0].values a = a[~numpy.isnan(a)] b = b[~numpy.isnan(b)] plots['Bar'] = (BarComparisonPlot({"NI" : numpy.mean(a), "GR" : numpy.mean(b)}),gs[:,:],{}) return plots
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(1, 1, subplot_spec=subplotspec,hspace=1.0, wspace=1.0) dsv = queries.param_filter_query(self.datastore,value_name='Fano Factor (spike count (bin=13.0))') assert len(queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="NaturalImageWithEyeMovement").get_analysis_result()) == 1 assert len(queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="FullfieldDriftingSinusoidalGrating",st_orientation=0).get_analysis_result()) == 1 a= queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="NaturalImageWithEyeMovement").get_analysis_result()[0].values b= queries.param_filter_query(dsv,analysis_algorithm='TrialToTrialFanoFactorOfAnalogSignal',st_name="FullfieldDriftingSinusoidalGrating",st_orientation=0).get_analysis_result()[0].values a = a[~numpy.isnan(a)] b = b[~numpy.isnan(b)] plots['Bar'] = (BarComparisonPlot({"NI" : numpy.mean(a), "GR" : numpy.mean(b)}),gs[:,:],{}) return plots
def check_segments_gratings_merge(self, ref_dss, merged_ds): """ Check if all the segments from the Drifting Sinusoidal Gratings experiment of the reference datastores are present in the merged datastore Parameters ---------- ref_dss : An iterable object containing the reference datastores that have be used for the merge merged_ds : The DataStore object that resulted from the merge """ merged_seg_count = len(merged_ds.get_segments()) merged_null_seg_count = len(merged_ds.get_segments(null=True)) ref_seg_count = 0 ref_null_seg_count = 0 for ds in ref_dss: ref_seg_count += len(ds.get_segments()) ref_null_seg_count += len(ds.get_segments(null=True)) segs = queries.param_filter_query( ds, st_name="DriftingSinusoidalGrating").get_segments() for seg in segs: stimulus = eval(seg.annotations["stimulus"]) s = queries.param_filter_query( merged_ds, st_name="DriftingSinusoidalGrating", sheet_name=seg.annotations["sheet_name"], st_orientation=stimulus["orientation"], st_contrast=stimulus["contrast"], st_trial=stimulus["trial"], ).get_segments()[0] np.testing.assert_equal( self.get_spikes(seg), self.get_spikes(s), ) seg.release() s.release() assert ( merged_seg_count == ref_seg_count ), "The number of segments in the merged datastore must be equal to the sum of the number of segments in each reference datastores" assert ( merged_null_seg_count == ref_null_seg_count ), "The number of null segments in the merged datastore must be equal to the sum of the number of null segments in each reference datastores"
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='SingleValue') f = open(Global.root_directory+self.parameters.file_name,'w') for a in dsv.get_analysis_result(): f.write("%s %s %s %s %s\n" % (a.sheet_name, a.value_name, str(a.value), a.analysis_algorithm, a.stimulus_id)) f.close()
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingDisk') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'radius' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"radius") for k in self.tc_dict.keys(): crf_sizes = [] supp_sizes= [] sis = [] max_responses=[] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): rads = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) # sort them based on radiuses rads , values = zip(*sorted(zip(rads,values))) max_response = numpy.max(values) crf_index = numpy.argmax(values) crf_size = rads[crf_index] if crf_index < len(values)-1: supp_index = crf_index+numpy.argmax(values[crf_index+1:])+1 else: supp_index = len(values)-1 supp_size = rads[supp_index] if values[crf_index] != 0: si = (values[crf_index]-values[supp_index])/values[crf_index] else: si = 0 crf_sizes.append(crf_size) supp_sizes.append(supp_size) sis.append(si) max_responses.append(max_response) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(max_responses,self.parameters.neurons,self.st[0].params()["radius"].units,value_name = 'Max. response of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(crf_sizes,self.parameters.neurons,self.st[0].params()["radius"].units,value_name = 'Max. facilitation radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(supp_sizes,self.parameters.neurons,self.st[0].params()["radius"].units,value_name = 'Max. suppressive radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(4, 18, subplot_spec=subplotspec, hspace=1.0, wspace=1.0) orr = list(set([MozaikParametrized.idd(s).orientation for s in queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100).get_stimuli()])) #ors = self.datastore.get_analysis_result(identifier='PerNeuronValue',value_name = 'LGNAfferentOrientation', sheet_name = self.parameters.sheet_name) #dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_orientation=orr[numpy.argmin([circular_dist(o,ors[0].get_value_by_id(self.parameters.neuron),numpy.pi) for o in orr])],st_contrast=100) dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_orientation=0,st_contrast=100) plots['Gratings'] = (OverviewPlot(dsv, ParameterSet({'sheet_name': self.parameters.sheet_name,'neuron': self.parameters.neuron,'spontaneous' : True, 'sheet_activity' : {}})),gs[0:2,:],{'x_label': None}) #dsv = queries.param_filter_query(self.datastore,st_name='DriftingGratingWithEyeMovement') #plots['GratingsWithEM'] = (OverviewPlot(dsv, ParameterSet({'sheet_name': self.parameters.sheet_name,'neuron': self.parameters.neuron, 'spontaneous' : True,'sheet_activity' : {}})),gs[2:4,:],{'x_label': None}) dsv = queries.param_filter_query(self.datastore,st_name='NaturalImageWithEyeMovement') plots['NIwEM'] = (OverviewPlot(dsv, ParameterSet({'sheet_name': self.parameters.sheet_name,'neuron': self.parameters.neuron,'spontaneous' : True, 'sheet_activity' : {}})),gs[2:4,:],{}) return plots
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(12, 18, subplot_spec=subplotspec, hspace=1.0, wspace=1.0) assert queries.equal_stimulus(self.datastore,['trial']) lgn_on_dsv = queries.param_filter_query(self.datastore, sheet_name='X_ON') lgn_off_dsv = queries.param_filter_query(self.datastore, sheet_name='X_OFF') lgn_spikes_a = [[s.spiketrains[0:2] for s in lgn_on_dsv.get_segments()], [s.spiketrains[0:2] for s in lgn_off_dsv.get_segments()]] lgn_spikes_b = [[s.spiketrains[2:4] for s in lgn_on_dsv.get_segments()], [s.spiketrains[2:4] for s in lgn_off_dsv.get_segments()]] plots['LGN_SRP1'] = (SpikeRasterPlot(lgn_spikes_a),gs[1:4, 0:5],{'x_axis' : False, 'x_label': None,'colors':['#FACC2E', '#0080FF']}) plots['LGN_SHP1'] = (SpikeHistogramPlot(lgn_spikes_a),gs[4:5, 0:5],{'x_axis' : False, 'x_label': None,'colors':['#FACC2E', '#0080FF']}) plots['LGN_SRP2'] = (SpikeRasterPlot(lgn_spikes_b),gs[7:10, 0:5],{'x_axis' : False, 'x_label': None,'colors':['#FACC2E', '#0080FF']}) plots['LGN_SHP2'] = (SpikeHistogramPlot(lgn_spikes_b),gs[10:11, 0:5],{'colors':['#FACC2E', '#0080FF']}) dsv1 = queries.param_filter_query(self.datastore,sheet_name=self.parameters.sheet_name) #print self.parameters.neuron #sp = [[[s.get_spiketrain(self.parameters.neuron)] for s in dsv1.get_segments()]] plots['V1_SRP1'] = (RasterPlot(dsv1,ParameterSet({'sheet_name' : self.parameters.sheet_name, 'spontaneous' : True,'neurons' : [self.parameters.neuron],'trial_averaged_histogram': False})),gs[:3, 6:14],{'x_axis' : False, 'x_label': None}) plots['V1_SHP1'] = (RasterPlot(dsv1,ParameterSet({'sheet_name' :self.parameters.sheet_name, 'spontaneous' : True,'neurons' : [self.parameters.neuron],'trial_averaged_histogram': False})),gs[:3, 6:14],{'x_axis' : False, 'x_label': None}) p = {} p['title']=None p['x_axis']=None p['x_label']=None plots['Vm_Plot'] = (VmPlot(dsv1, ParameterSet({'sheet_name': self.parameters.sheet_name,'neuron': self.parameters.neuron, 'spontaneous' : True})),gs[4:8, 6:14],p) p = {} p['title']=None plots['Gsyn_Plot'] = (GSynPlot(dsv1, ParameterSet({'sheet_name': self.parameters.sheet_name,'neuron': self.parameters.neuron,'spontaneous' : True})),gs[8:12, 6:14],p) plots['GSTA_Plot'] = (ConductanceSignalListPlot(queries.TagBasedQuery(ParameterSet({'tags': ['GSTA']})).query(dsv1),ParameterSet({'normalize_individually': True, 'neurons' : [self.parameters.neuron]})),gs[7:10, 15:],{}) #p = {} #p['mean'] = False #AnalogSignalListPlot(dsv, ParameterSet({'sheet_name': self.parameters.sheet_name, # 'ylabel': 'AC (norm)'})).subplot(gs[2:5, 15:], p) return plots
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(12, 18, subplot_spec=subplotspec, hspace=1.0, wspace=1.0) assert queries.equal_stimulus(self.datastore,['trial']) lgn_on_dsv = queries.param_filter_query(self.datastore, sheet_name='X_ON') lgn_off_dsv = queries.param_filter_query(self.datastore, sheet_name='X_OFF') lgn_spikes_a = [[s.spiketrains[0:2] for s in lgn_on_dsv.get_segments()], [s.spiketrains[0:2] for s in lgn_off_dsv.get_segments()]] lgn_spikes_b = [[s.spiketrains[2:4] for s in lgn_on_dsv.get_segments()], [s.spiketrains[2:4] for s in lgn_off_dsv.get_segments()]] plots['LGN_SRP1'] = (SpikeRasterPlot(lgn_spikes_a),gs[1:4, 0:5],{'x_axis' : False, 'x_label': None,'colors':['#FACC2E', '#0080FF']}) plots['LGN_SHP1'] = (SpikeHistogramPlot(lgn_spikes_a),gs[4:5, 0:5],{'x_axis' : False, 'x_label': None,'colors':['#FACC2E', '#0080FF']}) plots['LGN_SRP2'] = (SpikeRasterPlot(lgn_spikes_b),gs[7:10, 0:5],{'x_axis' : False, 'x_label': None,'colors':['#FACC2E', '#0080FF']}) plots['LGN_SHP2'] = (SpikeHistogramPlot(lgn_spikes_b),gs[10:11, 0:5],{'colors':['#FACC2E', '#0080FF']}) dsv1 = queries.param_filter_query(self.datastore,sheet_name=self.parameters.sheet_name) #print self.parameters.neuron #sp = [[[s.get_spiketrain(self.parameters.neuron)] for s in dsv1.get_segments()]] plots['V1_SRP1'] = (RasterPlot(dsv1,ParameterSet({'sheet_name' : self.parameters.sheet_name, 'spontaneous' : True,'neurons' : [self.parameters.neuron],'trial_averaged_histogram': False})),gs[:3, 6:14],{'x_axis' : False, 'x_label': None}) plots['V1_SHP1'] = (RasterPlot(dsv1,ParameterSet({'sheet_name' :self.parameters.sheet_name, 'spontaneous' : True,'neurons' : [self.parameters.neuron],'trial_averaged_histogram': False})),gs[:3, 6:14],{'x_axis' : False, 'x_label': None}) p = {} p['title']=None p['x_axis']=None p['x_label']=None plots['Vm_Plot'] = (VmPlot(dsv1, ParameterSet({'sheet_name': self.parameters.sheet_name,'neuron': self.parameters.neuron, 'spontaneous' : True})),gs[4:8, 6:14],p) p = {} p['title']=None plots['Gsyn_Plot'] = (GSynPlot(dsv1, ParameterSet({'sheet_name': self.parameters.sheet_name,'neuron': self.parameters.neuron,'spontaneous' : True})),gs[8:12, 6:14],p) plots['GSTA_Plot'] = (ConductanceSignalListPlot(queries.TagBasedQuery(ParameterSet({'tags': ['GSTA']})).query(dsv1),ParameterSet({'normalize_individually': True, 'neurons' : [self.parameters.neuron]})),gs[7:10, 15:],{}) #p = {} #p['mean'] = False #AnalogSignalListPlot(dsv, ParameterSet({'sheet_name': self.parameters.sheet_name, # 'ylabel': 'AC (norm)'})).subplot(gs[2:5, 15:], p) return plots
def perform_analysis(self): for sheet in self.datastore.sheets(): dsv_psth = queries.param_filter_query(self.datastore,analysis_algorithm="PopulationMean",y_axis_name='Mean(psth (bin=5.0))',sheet_name=sheet) dsv_cv = queries.param_filter_query(self.datastore,analysis_algorithm="PopulationMean",value_name='Mean(CV of ISI squared)',sheet_name=sheet,identifier="SingleValue") dsv_corr = queries.param_filter_query(self.datastore,analysis_algorithm="PopulationMean",value_name='Mean(Correlation coefficient(psth (bin=5.0)))',sheet_name=sheet,identifier="SingleValue") assert len(dsv_cv.get_analysis_result()) == 1, "Error: SpontaneousActivityLength accepts only datastore that holds one SingleValue analysis data structure with value_name: Mean(CV of ISI squared). It contains: %d" % len(dsv_cv.get_analysis_result()) assert len(dsv_corr.get_analysis_result()) ==1, "Error: SpontaneousActivityLength accepts only datastore that holds one SingleValue analysis data structure with value_name: 'Mean(Correlation coefficient(psth (bin=5.0))).It contains: %d" % len(dsv_cv.get_analysis_result()) assert len(dsv_psth.get_analysis_result()) ==1, "Error: SpontaneousActivityLength accepts only datastore that holds one AnalogSignal analysis data structure with value_name: 'Mean(psth (bin=5.0)).It contains: %d" % len(dsv_cv.get_analysis_result()) if dsv_cv.get_analysis_result()[0].value >= 0.95 and dsv_corr.get_analysis_result()[0].value <= 0.05: i = numpy.nonzero(dsv_psth.get_analysis_result()[0].analog_signal)[0][-1] logger.warning(i) l = dsv_psth.get_analysis_result()[0].analog_signal.times[i] else: l = 0 logger.warning(dsv_psth.get_analysis_result()[0].analog_signal) logger.warning(dsv_cv.get_analysis_result()[0].value) logger.warning(dsv_corr.get_analysis_result()[0].value) logger.warning(l) self.datastore.full_datastore.add_analysis_result(SingleValue(value=l,value_name = 'Spontaneous activity length',sheet_name=sheet,tags=self.tags,analysis_algorithm=self.__class__.__name__))
def make_grid_plot(self, subplotspec): """ Call to execute the grid plot. Parameters ---------- subplotspec : subplotspec Is the subplotspec into which the whole lineplot is to be plotted. """ subplotspec = gridspec.GridSpecFromSubplotSpec( 100, 100, subplot_spec=subplotspec)[int(100 * self.extra_space_top):100, 0:int(100 * (1 - self.extra_space_right))] gs = gridspec.GridSpecFromSubplotSpec(len(self.y_axis_values), len(self.x_axis_values), subplot_spec=subplotspec) params = OrderedDict() d = OrderedDict() for i in range(0, len(self.x_axis_values)): for j in range(0, len(self.y_axis_values)): if i > 0 and self.shared_axis: params["y_label"] = None if self.shared_lim: params["y_axis"] = False else: params["y_label"] = self.y_axis_values[j] if j < len(self.y_axis_values) - 1 and self.shared_axis: params["x_label"] = None if self.shared_lim: params["x_axis"] = False else: params["x_label"] = self.x_axis_values[i] dsv = param_filter_query( self.datastore, **{ self.x_axis_parameter: self.x_axis_values[i], self.y_axis_parameter: self.y_axis_values[j] }) li = self._single_plot(dsv, gs[j, i]) for (name, plot, gss, par) in li: par.update(params) d[name + '.' + 'plot[' + str(i) + ',' + str(j) + ']'] = (plot, gss, par) return d
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(1,2, subplot_spec=subplotspec,hspace=1.0, wspace=1.0) var_gr = 0 var_ni = 0 std_gr = 0 std_ni = 0 orr = list(set([MozaikParametrized.idd(s).orientation for s in queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100).get_stimuli()])) l4_exc_or = self.datastore.get_analysis_result(identifier='PerNeuronValue',value_name = 'LGNAfferentOrientation', sheet_name = self.parameters.sheet_name) # lets calculate spont. activity trial to trial variability # we assume that the spontaneous activity had already the spikes removed dsv = queries.param_filter_query(self.datastore,st_name='InternalStimulus',st_direct_stimulation_name='None',sheet_name=self.parameters.sheet_name,analysis_algorithm='ActionPotentialRemoval',ads_unique=True) ids = dsv.get_analysis_result()[0].ids sp = {} for idd in ids: assert len(dsv.get_analysis_result()) == 1 s = dsv.get_analysis_result()[0].get_asl_by_id(idd).magnitude sp[idd] = 1/numpy.mean(numpy.std([s[i*int(len(s)/10):(i+1)*int(len(s)/10)] for i in xrange(0,10)],axis=0,ddof=1)) #sp[idd] = 1/numpy.std(s,ddof=1) print sp[ids[1]] #lets calculate the mean of trial-to-trial variances across the neurons in the datastore for gratings dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',sheet_name=self.parameters.sheet_name,st_contrast=100,analysis_algorithm='TrialVariability',y_axis_name='Vm (no AP) trial-to-trial variance') assert queries.equal_ads(dsv, except_params=['stimulus_id']) ids = dsv.get_analysis_result()[0].ids var_gr_ind = [] logger.info("AA") logger.info(str([sp[i] for i in ids])) for i in ids: # find the or pereference of the neuron o = orr[numpy.argmin([circular_dist(o,l4_exc_or[0].get_value_by_id(i),numpy.pi) for o in orr])] assert len(queries.param_filter_query(dsv,st_orientation=o,ads_unique=True).get_analysis_result())==1 a = 1/numpy.mean(numpy.sqrt(queries.param_filter_query(dsv,st_orientation=o,ads_unique=True).get_analysis_result()[0].get_asl_by_id(i).magnitude)) var_gr = var_gr + a / sp[i] var_gr_ind.append(a / sp[i]) std_gr = std_gr + a var_gr = var_gr / len(ids) std_gr = std_gr / len(ids) logger.info(str(var_gr_ind)) #lets calculate the mean of trial-to-trial variances across the neurons in the datastore for natural images dsv = queries.param_filter_query(self.datastore,st_name='NaturalImageWithEyeMovement',sheet_name=self.parameters.sheet_name,y_axis_name='Vm (no AP) trial-to-trial variance',ads_unique=True) var_ni_ind = [1/numpy.mean(numpy.sqrt(dsv.get_analysis_result()[0].get_asl_by_id(i).magnitude)) / sp[i] for i in ids] var_ni = numpy.mean(var_ni_ind) plots['Bar'] = (BarComparisonPlot({"NI" : var_ni*100.0, "GR" : var_gr*100.0}),gs[0,0],{}) plots['Scatter'] = (ScatterPlot(var_gr_ind*100, var_ni_ind*100),gs[0,1],{'x_label' : 'GR', 'y_label' : 'NI','identity_line' : True}) return plots
def __init__(self, datastore, parameters, plot_file_name=None, fig_param=None): Plotting.__init__(self, datastore, parameters, plot_file_name, fig_param) self.poss = [] self.pnvs = [] self.sheets = [] for sheet in datastore.sheets(): dsv = queries.param_filter_query(self.datastore,sheet_name=sheet) z = dsv.get_analysis_result(identifier='PerNeuronValue') if len(z) != 0: if len(z) > 1: logger.error('Warning currently only one PerNeuronValue per sheet will be plotted!!!') self.poss.append(datastore.get_neuron_postions()[sheet]) self.pnvs.append(z) self.sheets.append(sheet) self.length=len(self.poss)
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore, identifier='PerNeuronValue') textures = list(set([MozaikParametrized.idd(ads.stimulus_id).texture for ads in dsv.get_analysis_result()])) samples = list(set([MozaikParametrized.idd(ads.stimulus_id).sample for ads in dsv.get_analysis_result()])) for sheet in self.parameters.sheet_list: for texture in textures: #First we calculate the modulation for each sample of each original image for sample in samples: pnv_noise = queries.param_filter_query(dsv,sheet_name=sheet,st_sample=sample,st_texture=texture,st_stats_type=2).get_analysis_result()[0] pnv_texture = queries.param_filter_query(dsv,sheet_name=sheet,st_sample=sample,st_texture=texture,st_stats_type=1).get_analysis_result()[0] modulation=[] for texture_firing_rate,noise_firing_rate in zip(pnv_texture.get_value_by_id(pnv_texture.ids),pnv_noise.get_value_by_id(pnv_noise.ids)): modulation.append(numpy.nan_to_num((texture_firing_rate - noise_firing_rate)/(texture_firing_rate + noise_firing_rate))) st = MozaikParametrized.idd(pnv_texture.stimulus_id) setattr(st,'stats_type',None) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(modulation,pnv_texture.ids,None,value_name = "Sample Modulation of " + pnv_texture.value_name, sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) #Then we calculate the modulation for each texture family by averaging the firing rates accross samples pnvs_noise = queries.param_filter_query(dsv,sheet_name=sheet,st_texture=texture,st_stats_type=2).get_analysis_result() pnvs_texture = queries.param_filter_query(dsv,sheet_name=sheet,st_texture=texture,st_stats_type=1).get_analysis_result() mean_rates_noise = [pnv.get_value_by_id(pnvs_noise[0].ids) for pnv in pnvs_noise] mean_rates_texture = [pnv.get_value_by_id(pnvs_noise[0].ids) for pnv in pnvs_texture] _mean_rates_noise = numpy.mean(mean_rates_noise,axis=0) _mean_rates_texture = numpy.mean(mean_rates_texture,axis=0) modulation = numpy.nan_to_num((_mean_rates_texture - _mean_rates_noise)/(_mean_rates_texture + _mean_rates_noise)) st = MozaikParametrized.idd(pnvs_texture[0].stimulus_id) setattr(st,'stats_type',None) setattr(st,'sample',None) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(modulation,pnv_texture.ids,None,value_name = "Texture Modulation of " + pnv_texture.value_name ,sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) #Finally we calculate the global modulation by averaging the firing rates accross texture families pnvs_noise = queries.param_filter_query(dsv,identifier='PerNeuronValue',sheet_name=sheet,st_stats_type=2).get_analysis_result() pnvs_texture = queries.param_filter_query(dsv,identifier='PerNeuronValue',sheet_name=sheet,st_stats_type=1).get_analysis_result() mean_rates_noise = [pnv.get_value_by_id(pnvs_noise[0].ids) for pnv in pnvs_noise] mean_rates_texture = [pnv.get_value_by_id(pnvs_noise[0].ids) for pnv in pnvs_texture] _mean_rates_noise = numpy.mean(mean_rates_noise,axis=0) _mean_rates_texture = numpy.mean(mean_rates_texture,axis=0) modulation = numpy.nan_to_num((_mean_rates_texture - _mean_rates_noise)/(_mean_rates_texture + _mean_rates_noise)) st = MozaikParametrized.idd(pnvs_texture[0].stimulus_id) setattr(st,'stats_type',None) setattr(st,'sample',None) setattr(st,'texture',None) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(modulation,pnv_texture.ids,None,value_name = "Global Modulation of " + pnv_texture.value_name ,sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st)))
def perform_analysis(self): logger.info('Starting NeuronAnnotationsToPerNeuronValues Analysis') anns = self.datastore.get_neuron_annotations() for sheet in self.datastore.sheets(): dsv = queries.param_filter_query(self.datastore, sheet_name=sheet) keys = set([]) for n in range(0, len(anns[sheet])): keys = keys.union(anns[sheet][n].keys()) for k in keys: # first check if the key is defined for all neurons key_ok = True for n in range(0, len(anns[sheet])): if not k in anns[sheet][n]: key_ok = False break if key_ok: values = [] for n in range(0, len(anns[sheet])): values.append(anns[sheet][n][k]) period = None if k == 'LGNAfferentOrientation': period = numpy.pi if k == 'LGNAfferentPhase': period = 2 * numpy.pi self.datastore.full_datastore.add_analysis_result( PerNeuronValue( values, dsv.get_sheet_ids(sheet), qt.dimensionless, period=period, value_name=k, sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__))
def perform_analysis(self): logger.info('Starting NeuronAnnotationsToPerNeuronValues Analysis') anns = self.datastore.get_neuron_annotations() for sheet in self.datastore.sheets(): dsv = queries.param_filter_query(self.datastore,sheet_name=sheet) keys = Set([]) for n in xrange(0, len(anns[sheet])): keys = keys.union(anns[sheet][n].keys()) for k in keys: # first check if the key is defined for all neurons key_ok = True for n in xrange(0, len(anns[sheet])): if not k in anns[sheet][n]: key_ok = False break if key_ok: values = [] for n in xrange(0, len(anns[sheet])): values.append(anns[sheet][n][k]) period = None if k == 'LGNAfferentOrientation': period = numpy.pi if k == 'LGNAfferentPhase': period = 2*numpy.pi self.datastore.full_datastore.add_analysis_result( PerNeuronValue(values, dsv.get_sheet_ids(sheet), qt.dimensionless, period=period, value_name=k, sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__))
def make_grid_plot(self, subplotspec): """ Call to execute the grid plot. Parameters ---------- subplotspec : subplotspec Is the subplotspec into which the whole lineplot is to be plotted. """ subplotspec = gridspec.GridSpecFromSubplotSpec( 100, 100, subplot_spec=subplotspec )[int(100*self.extra_space_top):100, 0:int(100*(1-self.extra_space_right))] gs = gridspec.GridSpecFromSubplotSpec(len(self.y_axis_values),len(self.x_axis_values),subplot_spec=subplotspec) params = {} d = {} for i in xrange(0,len(self.x_axis_values)): for j in xrange(0,len(self.y_axis_values)): if i > 0 and self.shared_axis: params["y_label"]=None if self.shared_lim: params["y_axis"] = False else: params["y_label"]=self.y_axis_values[j] if j < len(self.y_axis_values)-1 and self.shared_axis: params["x_label"]=None if self.shared_lim: params["x_axis"] = False else: params["x_label"]=self.x_axis_values[i] dsv = param_filter_query(self.datastore,**{self.x_axis_parameter:self.x_axis_values[i],self.y_axis_parameter:self.y_axis_values[j]}) li = self._single_plot(dsv,gs[j,i]) for (name,plot,gss,par) in li: par.update(params) d[name + '.' + 'plot[' +str(i) + ',' +str(j) + ']'] = (plot,gss,par) return d
def subplot(self, subplotspec): dsv = queries.param_filter_query(self.datastore,sheet_name=self.parameters.sheet_name) return PerStimulusPlot(dsv, function=self._ploter, title_style="Standard" ).make_line_plot(subplotspec)
def perform_analysis(self): for sheet in self.datastore.sheets(): # Load up spike trains for the right sheet and the corresponding # stimuli, and transform spike trains into psth dsv = queries.param_filter_query(self.datastore,identifier='AnalogSignalList',sheet_name=sheet,analysis_algorithm='PSTH',st_name='FullfieldDriftingSinusoidalGrating') assert queries.equal_ads(dsv,except_params=['stimulus_id']) , "It seems PSTH computed in different ways are present in datastore, ModulationRatio can accept only one" psths = dsv.get_analysis_result() st = [MozaikParametrized.idd(p.stimulus_id) for p in psths] # average across trials psths, stids = colapse(psths,st,parameter_list=['trial'],func=neo_sum,allow_non_identical_objects=True) # retrieve the computed orientation preferences pnvs = self.datastore.get_analysis_result(identifier='PerNeuronValue', sheet_name=sheet, value_name='orientation preference') if len(pnvs) != 1: logger.error("ERROR: Expected only one PerNeuronValue per sheet " "with value_name 'orientation preference' in datastore, got: " + str(len(pnvs))) return None or_pref = pnvs[0] # find closest orientation of grating to a given orientation preference of a neuron # first find all the different presented stimuli: ps = OrderedDict() for s in st: ps[MozaikParametrized.idd(s).orientation] = True ps = ps.keys() # now find the closest presented orientations closest_presented_orientation = [] for i in xrange(0, len(or_pref.values)): circ_d = 100000 idx = 0 for j in xrange(0, len(ps)): if circ_d > circular_dist(or_pref.values[i], ps[j], numpy.pi): circ_d = circular_dist(or_pref.values[i], ps[j], numpy.pi) idx = j closest_presented_orientation.append(ps[idx]) closest_presented_orientation = numpy.array(closest_presented_orientation) # collapse along orientation - we will calculate MR for each # parameter combination other than orientation d = colapse_to_dictionary(psths, stids, "orientation") for (st, vl) in d.items(): # here we will store the modulation ratios, one per each neuron modulation_ratio = [] f0 = [] f1 = [] ids = [] frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).getParams()['temporal_frequency'].units for (orr, ppsth) in zip(vl[0], vl[1]): for j in numpy.nonzero(orr == closest_presented_orientation)[0]: if or_pref.ids[j] in ppsth.ids: a = or_pref.ids[j] mr,F0,F1 = self._calculate_MR(ppsth.get_asl_by_id(or_pref.ids[j]).flatten(),frequency) modulation_ratio.append(mr) f0.append(F0) f1.append(F1) ids.append(or_pref.ids[j]) logger.debug('Adding PerNeuronValue:' + str(sheet)) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(modulation_ratio, ids, qt.dimensionless, value_name='Modulation ratio' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(f0, ids, qt.dimensionless, value_name='F0' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(f1, ids, qt.dimensionless, value_name='F1' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) import pylab pylab.figure() pylab.hist(modulation_ratio)
Global.root_directory = sys.argv[1] + '/' setup_logging() data_store = PickledDataStore(load=True, parameters=ParameterSet({ 'root_directory': sys.argv[1], 'store_stimuli': False }), replace=True) NeuronAnnotationsToPerNeuronValues(data_store, ParameterSet({})).analyse() analog_ids = queries.param_filter_query( data_store, sheet_name="V1_Exc_L4").get_segments()[0].get_stored_esyn_ids() dsv = queries.param_filter_query(data_store, st_name='FlashedBar') for ads in dsv.get_analysis_result(): sid = MozaikParametrized.idd(ads.stimulus_id) sid.x = 0 ads.stimulus_id = str(sid) for seg in dsv.get_segments(): sid = MozaikParametrized.idd(seg.annotations['stimulus']) sid.x = 0 seg.annotations['stimulus'] = str(sid) for seg in dsv.get_segments(null=True): sid = MozaikParametrized.idd(seg.annotations['stimulus']) sid.x = 0 seg.annotations['stimulus'] = str(sid)
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingDisk') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'radius' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"radius") for k in self.tc_dict.keys(): crf_sizes = [] supp_sizes= [] sis = [] max_responses=[] csis = [] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): rads = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) # sort them based on radiuses rads , values = zip(*sorted(zip(rads,values))) max_response = numpy.max(values) crf_index = numpy.argmax(values) crf_size = rads[crf_index] if crf_index < len(values)-1: supp_index = crf_index+numpy.argmin(values[crf_index+1:])+1 else: supp_index = len(values)-1 supp_size = rads[supp_index] if supp_index < len(values)-1: cs_index = supp_index+numpy.argmax(values[supp_index+1:])+1 else: cs_index = len(values)-1 if values[crf_index] != 0: si = (values[crf_index]-values[supp_index])/values[crf_index] else: si = 0 if values[cs_index] != 0: csi = (values[cs_index]-values[supp_index])/values[crf_index] else: csi = 0 crf_sizes.append(crf_size) supp_sizes.append(supp_size) sis.append(si) max_responses.append(max_response) csis.append(csi) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(max_responses,self.parameters.neurons,self.st[0].getParams()["radius"].units,value_name = 'Max. response of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(crf_sizes,self.parameters.neurons,self.st[0].getParams()["radius"].units,value_name = 'Max. facilitation radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(supp_sizes,self.parameters.neurons,self.st[0].getParams()["radius"].units,value_name = 'Max. suppressive radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(csis,self.parameters.neurons,None,value_name = 'Counter-suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def subplot(self, subplotspec): dsv = queries.param_filter_query(self.datastore,sheet_name=self.parameters.sheet_name,identifier='AnalogSignal') return PerStimulusADSPlot(dsv, function=self._ploter, title_style="Clever").make_line_plot(subplotspec)
def plot(self): self.fig = pylab.figure(facecolor='w', **self.fig_param) gs = gridspec.GridSpec(1, 1) gs.update(left=0.07, right=0.97, top=0.9, bottom=0.1) gs = gs[0,0] gs = gridspec.GridSpecFromSubplotSpec(4, 5,subplot_spec=gs) orr = list(set([MozaikParametrized.idd(s).orientation for s in queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100).get_stimuli()])) l4_exc_or = self.datastore.get_analysis_result(identifier='PerNeuronValue',value_name = 'LGNAfferentOrientation', sheet_name = 'V1_Exc_L4') col = orr[numpy.argmin([circular_dist(o,l4_exc_or[0].get_value_by_id(self.parameters.neuron),numpy.pi) for o in orr])] #segs = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100,st_orientation=col,sheet_name='V1_Exc_L4').get_segments() #signals = [seg.get_vm(self.parameters.neuron) for seg in segs] dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',sheet_name='V1_Exc_L4',st_contrast=100,analysis_algorithm='ActionPotentialRemoval',st_orientation=col) assert queries.ads_with_equal_stimuli(dsv,except_params=["trial"]) adss = dsv.get_analysis_result() signals = [ads.get_asl_by_id(self.parameters.neuron) for ads in adss] (signal,noise,snr) = self.wavelet_decomposition(signals) ax = pylab.subplot(gs[0,0:2]) for s in signals: ax.plot(s,c='k') pylab.ylabel('Vm') pylab.title("Gratings",fontsize=20) pylab.xlim(0,len(signals[0])) pylab.ylim(-80,-50) ax = pylab.subplot(gs[1,0:2]) ax.imshow(signal,aspect='auto',origin='lower') pylab.ylabel('Signal') ax = pylab.subplot(gs[2,0:2]) ax.imshow(noise,aspect='auto',origin='lower') pylab.ylabel('Noise') ax = pylab.subplot(gs[3,0:2]) ax.imshow(snr,aspect='auto',origin='lower') pylab.ylabel('SNR') pylab.xlabel('time') #segs = queries.param_filter_query(self.datastore,st_name='NaturalImageWithEyeMovement',sheet_name='V1_Exc_L4').get_segments() #signals = [seg.get_vm(self.parameters.neuron) for seg in segs] dsv = queries.param_filter_query(self.datastore,st_name='NaturalImageWithEyeMovement',sheet_name='V1_Exc_L4',analysis_algorithm='ActionPotentialRemoval') assert queries.ads_with_equal_stimuli(dsv,except_params=["trial"]) adss = dsv.get_analysis_result() signals = [ads.get_asl_by_id(self.parameters.neuron) for ads in adss] (signal_ni,noise_ni,snr_ni) = self.wavelet_decomposition(signals) ax = pylab.subplot(gs[0,2:4]) for s in signals: ax.plot(s,c='k') pylab.xlim(0,len(signals[0])) pylab.ylim(-80,-50) pylab.title("NI",fontsize=20) ax = pylab.subplot(gs[1,2:4]) ax.imshow(signal_ni,aspect='auto',origin='lower') ax = pylab.subplot(gs[2,2:4]) ax.imshow(noise_ni,aspect='auto',origin='lower') ax = pylab.subplot(gs[3,2:4]) ax.imshow(snr_ni,aspect='auto',origin='lower') pylab.xlabel('time') ax = pylab.subplot(gs[1,4]) ax.plot(numpy.mean(signal,axis=1),label="GR") ax.plot(numpy.mean(signal_ni,axis=1),label="NI") ax.set_xscale('log') ax.set_yscale('log') pylab.legend() ax = pylab.subplot(gs[2,4]) ax.plot(numpy.mean(noise,axis=1)) ax.plot(numpy.mean(noise_ni,axis=1)) ax.set_xscale('log') ax.set_yscale('log') ax = pylab.subplot(gs[3,4]) ax.plot(numpy.mean(snr,axis=1)) ax.plot(numpy.mean(snr_ni,axis=1)) ax.set_xscale('log') ax.set_yscale('log') pylab.xlabel("frequency") if self.plot_file_name: pylab.savefig(Global.root_directory+self.plot_file_name)
def plot(self): self.fig = pylab.figure(facecolor='w', **self.fig_param) gs = gridspec.GridSpec(1, 1) gs.update(left=0.07, right=0.97, top=0.9, bottom=0.1) gs = gs[0,0] gs = gridspec.GridSpecFromSubplotSpec(4, 5,subplot_spec=gs) orr = list(set([MozaikParametrized.idd(s).orientation for s in queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100).get_stimuli()])) l4_exc_or = self.datastore.get_analysis_result(identifier='PerNeuronValue',value_name = 'LGNAfferentOrientation', sheet_name = 'V1_Exc_L4') col = orr[numpy.argmin([circular_dist(o,l4_exc_or[0].get_value_by_id(self.parameters.neuron),numpy.pi) for o in orr])] #segs = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100,st_orientation=col,sheet_name='V1_Exc_L4').get_segments() #signals = [seg.get_vm(self.parameters.neuron) for seg in segs] dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',sheet_name='V1_Exc_L4',st_contrast=100,analysis_algorithm='ActionPotentialRemoval',st_orientation=col) assert queries.ads_with_equal_stimuli(dsv,except_params=["trial"]) adss = dsv.get_analysis_result() signals = [ads.get_asl_by_id(self.parameters.neuron) for ads in adss] (signal,noise,snr) = self.wavelet_decomposition(signals) ax = pylab.subplot(gs[0,0:2]) for s in signals: ax.plot(s,c='k') pylab.ylabel('Vm') pylab.title("Gratings",fontsize=20) pylab.xlim(0,len(signals[0])) pylab.ylim(-80,-50) ax = pylab.subplot(gs[1,0:2]) ax.imshow(signal,aspect='auto',origin='lower') pylab.ylabel('Signal') ax = pylab.subplot(gs[2,0:2]) ax.imshow(noise,aspect='auto',origin='lower') pylab.ylabel('Noise') ax = pylab.subplot(gs[3,0:2]) ax.imshow(snr,aspect='auto',origin='lower') pylab.ylabel('SNR') pylab.xlabel('time') #segs = queries.param_filter_query(self.datastore,st_name='NaturalImageWithEyeMovement',sheet_name='V1_Exc_L4').get_segments() #signals = [seg.get_vm(self.parameters.neuron) for seg in segs] dsv = queries.param_filter_query(self.datastore,st_name='NaturalImageWithEyeMovement',sheet_name='V1_Exc_L4',analysis_algorithm='ActionPotentialRemoval') assert queries.ads_with_equal_stimuli(dsv,except_params=["trial"]) adss = dsv.get_analysis_result() signals = [ads.get_asl_by_id(self.parameters.neuron) for ads in adss] (signal_ni,noise_ni,snr_ni) = self.wavelet_decomposition(signals) ax = pylab.subplot(gs[0,2:4]) for s in signals: ax.plot(s,c='k') pylab.xlim(0,len(signals[0])) pylab.ylim(-80,-50) pylab.title("NI",fontsize=20) ax = pylab.subplot(gs[1,2:4]) ax.imshow(signal_ni,aspect='auto',origin='lower') ax = pylab.subplot(gs[2,2:4]) ax.imshow(noise_ni,aspect='auto',origin='lower') ax = pylab.subplot(gs[3,2:4]) ax.imshow(snr_ni,aspect='auto',origin='lower') pylab.xlabel('time') ax = pylab.subplot(gs[1,4]) ax.plot(numpy.mean(signal,axis=1),label="GR") ax.plot(numpy.mean(signal_ni,axis=1),label="NI") ax.set_xscale('log') ax.set_yscale('log') pylab.legend() ax = pylab.subplot(gs[2,4]) ax.plot(numpy.mean(noise,axis=1)) ax.plot(numpy.mean(noise_ni,axis=1)) ax.set_xscale('log') ax.set_yscale('log') ax = pylab.subplot(gs[3,4]) ax.plot(numpy.mean(snr,axis=1)) ax.plot(numpy.mean(snr_ni,axis=1)) ax.set_xscale('log') ax.set_yscale('log') pylab.xlabel("frequency") if self.plot_file_name: pylab.savefig(Global.root_directory+self.plot_file_name)
def perform_analysis(self): samples = list(set([MozaikParametrized.idd(ads.stimulus_id).sample for ads in self.datastore.get_analysis_result()])) for sheet in self.parameters.sheet_list: averaged_noise_psths = [] averaged_texture_psths = [] modulation_list = [] #First, we compute the time-course of the modulation for every individual texture for texture in self.parameters.texture_list: #Get the PSTHs for both the spectrallu-matched noise and the synthetic texture stimuli psths_noise = queries.param_filter_query(self.datastore,identifier='AnalogSignalList',sheet_name=sheet, analysis_algorithm = "PSTH", st_stats_type = 2, st_texture = texture).get_analysis_result() psths_texture = queries.param_filter_query(self.datastore,identifier='AnalogSignalList',sheet_name=sheet, analysis_algorithm = "PSTH", st_stats_type = 1, st_texture = texture).get_analysis_result() ids = psths_noise[0].ids t_start = psths_noise[0].asl[0].t_start sampling_period = psths_noise[0].asl[0].sampling_period units = psths_noise[0].asl[0].units assert len(psths_noise) == len(psths_texture) asls_noise = [psth.get_asl_by_id(ids) for psth in psths_noise] asls_texture = [psth.get_asl_by_id(ids) for psth in psths_texture] #For every neuron, compute the average of the PSTHs for both type of stimuli noise_psth = numpy.mean(asls_noise, axis = 0) texture_psth = numpy.mean(asls_texture, axis = 0) #Then calculate the modulation for every time step modulation = numpy.nan_to_num((texture_psth - noise_psth)/(texture_psth + noise_psth)) #Store the values obtained for this texture in some lists averaged_noise_psths.append(noise_psth) averaged_texture_psths.append(texture_psth) modulation_list.append(modulation) averaged_noise_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = units) for asl in noise_psth] averaged_texture_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = units) for asl in texture_psth] modulation_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = qt.dimensionless) for asl in modulation] st_noise = MozaikParametrized.idd(psths_noise[0].stimulus_id) setattr(st_noise,'sample',None) st_texture = MozaikParametrized.idd(psths_texture[0].stimulus_id) setattr(st_texture,'sample',None) st_modulation = MozaikParametrized.idd(psths_noise[0].stimulus_id) setattr(st_modulation,'sample',None) setattr(st_modulation,'stats_type',None) #Store both the averaged PSTHs, and the time-course of the modulation for every neuron in the population self.datastore.full_datastore.add_analysis_result( AnalogSignalList(averaged_noise_asls, ids, psths_noise[0].y_axis_units, x_axis_name='time', y_axis_name='Noise ' + psths_noise[0].y_axis_name + ' samples averaged', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_noise))) self.datastore.full_datastore.add_analysis_result( AnalogSignalList(averaged_texture_asls, ids, psths_noise[0].y_axis_units, x_axis_name='time', y_axis_name='Texture ' + psths_noise[0].y_axis_name + ' samples averaged', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_texture))) self.datastore.full_datastore.add_analysis_result( AnalogSignalList(modulation_asls, ids, qt.dimensionless, x_axis_name='time', y_axis_name='Modulation ' + psths_noise[0].y_axis_name + ' samples averaged', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_modulation))) #Normalize the PSTHs max_firing_rates = numpy.max(numpy.concatenate((averaged_noise_psths, averaged_texture_psths)), axis = (0,2,3)) averaged_noise_psths = numpy.transpose(numpy.transpose(averaged_noise_psths,(0,2,3,1))/max_firing_rates, (0,3,1,2)) averaged_texture_psths = numpy.transpose(numpy.transpose(averaged_texture_psths,(0,2,3,1))/max_firing_rates, (0,3,1,2)) #Compute the average accross textures families of the time course of the modulation and of the PSTHs for both type of stimuli noise_psth = numpy.mean(averaged_noise_psths, axis = 0) texture_psth = numpy.mean(averaged_texture_psths, axis = 0) modulation = numpy.mean(modulation_list, axis = 0) var_noise_psth = numpy.var(averaged_noise_psths, axis = 0) var_texture_psth = numpy.var(averaged_texture_psths, axis = 0) averaged_noise_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = units) for asl in noise_psth] averaged_texture_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = units) for asl in texture_psth] modulation_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = qt.dimensionless) for asl in modulation] var_noise_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = units) for asl in var_noise_psth] var_texture_asls = [NeoAnalogSignal(asl, t_start=t_start, sampling_period=sampling_period,units = units) for asl in var_texture_psth] setattr(st_noise,'texture',None) setattr(st_texture,'texture',None) setattr(st_modulation,'texture',None) self.datastore.full_datastore.add_analysis_result( AnalogSignalList(averaged_noise_asls, ids, psths_noise[0].y_axis_units, x_axis_name='time', y_axis_name='Noise ' + psths_noise[0].y_axis_name + ' textures averaged', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_noise))) self.datastore.full_datastore.add_analysis_result( AnalogSignalList(averaged_texture_asls, ids, psths_noise[0].y_axis_units, x_axis_name='time', y_axis_name='Texture ' + psths_noise[0].y_axis_name + ' textures averaged', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_texture))) self.datastore.full_datastore.add_analysis_result( AnalogSignalList(var_noise_asls, ids, psths_noise[0].y_axis_units, x_axis_name='time', y_axis_name='Noise ' + psths_noise[0].y_axis_name + ' textures var', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_noise))) self.datastore.full_datastore.add_analysis_result( AnalogSignalList(var_texture_asls, ids, psths_noise[0].y_axis_units, x_axis_name='time', y_axis_name='Texture ' + psths_noise[0].y_axis_name + ' textures var', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_texture))) self.datastore.full_datastore.add_analysis_result( AnalogSignalList(modulation_asls, ids, qt.dimensionless, x_axis_name='time', y_axis_name='Modulation ' + psths_noise[0].y_axis_name + ' textures averaged', sheet_name=sheet, tags=self.tags, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st_modulation)))
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(16, 14, subplot_spec=subplotspec, hspace=1.0, wspace=1.0) low_contrast = str(5) analog_ids = sorted(queries.param_filter_query(self.datastore,sheet_name=self.parameters.sheet_name,value_name=['F0_Exc_Cond-Mean(ECond)']).get_analysis_result()[0].ids) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond-Mean(ECond)','F0_Inh_Cond-Mean(ICond)'],sheet_name=self.parameters.sheet_name) plots['MeanF0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[:4,:3],{'legend' : False, 'y_label': 'F0(Cond)' ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond-Mean(ECond) contrast : 100' : '#FF0000' , 'F0_Exc_Cond-Mean(ECond) contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond-Mean(ICond) contrast : 100' : '#0000FF' , 'F0_Inh_Cond-Mean(ICond) contrast : ' +low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['MeanF1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[4:8,:3],{'y_label': 'F1(Cond)','title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['MeanVMF0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[8:12,:3],{'y_label': 'F0(Vm)' ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['MeanVMF1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[12:16,:3],{'y_label': 'F1(Vm)','title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) if True: if self.parameters.many: dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond','F0_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F0a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[:2,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond contrast : 100' : '#FF0000' , 'F0_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond contrast : 100' : '#0000FF' , 'F0_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond','F0_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F0b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[2:4,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond contrast : 100' : '#FF0000' , 'F0_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond contrast : 100' : '#0000FF' , 'F0_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F1a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[4:6,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F1b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[6:8,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['VMF0a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[8:10,3:],{'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['VMF0b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[10:12,3:],{'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['VMF1a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[12:14,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['VMF1b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[14:16,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) else: #neurons = [0,6,2,4,9,15] #neurons = [i fori in xrange(0:10)] neurons = [5,15,3,38,18,24] #neurons = [30,31,32,33,34,35,36,37,38,39,40] dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond-Mean(ECond)','F0_Inh_Cond-Mean(ICond)'],sheet_name=self.parameters.sheet_name) plots['F0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[:4,3:],{'legend' : False, 'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond-Mean(ECond) contrast : 100' : '#FF0000' , 'F0_Exc_Cond-Mean(ECond) contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond-Mean(ICond) contrast : 100' : '#0000FF' , 'F0_Inh_Cond-Mean(ICond) contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[4:8,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['VMF0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[8:12,3:],{'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['VMF1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[12:16,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) return plots
def perform_analysis(self): for sheet in self.datastore.sheets(): # Load up spike trains for the right sheet and the corresponding # stimuli, and transform spike trains into psth print sheet self.datastore.print_content() dsv = queries.param_filter_query(self.datastore,identifier='AnalogSignalList',sheet_name=sheet,analysis_algorithm='PSTH',st_name='FullfieldDriftingSinusoidalGrating') dsv.print_content() assert queries.equal_ads(dsv,except_params=['stimulus_id']) , "It seems PSTH computed in different ways are present in datastore, ModulationRatio can accept only one" psths = dsv.get_analysis_result() st = [MozaikParametrized.idd(p.stimulus_id) for p in psths] # average across trials psths, stids = colapse(psths,st,parameter_list=['trial'],func=neo_sum,allow_non_identical_objects=True) # retrieve the computed orientation preferences pnvs = self.datastore.get_analysis_result(identifier='PerNeuronValue', sheet_name=sheet, value_name='orientation preference') if len(pnvs) != 1: logger.error("ERROR: Expected only one PerNeuronValue per sheet " "with value_name 'orientation preference' in datastore, got: " + str(len(pnvs))) return None or_pref = pnvs[0] # find closest orientation of grating to a given orientation preference of a neuron # first find all the different presented stimuli: ps = {} for s in st: ps[MozaikParametrized.idd(s).orientation] = True ps = ps.keys() print ps # now find the closest presented orientations closest_presented_orientation = [] for i in xrange(0, len(or_pref.values)): circ_d = 100000 idx = 0 for j in xrange(0, len(ps)): if circ_d > circular_dist(or_pref.values[i], ps[j], numpy.pi): circ_d = circular_dist(or_pref.values[i], ps[j], numpy.pi) idx = j closest_presented_orientation.append(ps[idx]) closest_presented_orientation = numpy.array(closest_presented_orientation) # collapse along orientation - we will calculate MR for each # parameter combination other than orientation d = colapse_to_dictionary(psths, stids, "orientation") for (st, vl) in d.items(): # here we will store the modulation ratios, one per each neuron modulation_ratio = [] ids = [] frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).params()['temporal_frequency'].units for (orr, ppsth) in zip(vl[0], vl[1]): for j in numpy.nonzero(orr == closest_presented_orientation)[0]: if or_pref.ids[j] in ppsth.ids: modulation_ratio.append(self._calculate_MR(ppsth.get_asl_by_id(or_pref.ids[j]),frequency)) ids.append(or_pref.ids[j]) logger.debug('Adding PerNeuronValue:' + str(sheet)) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(modulation_ratio, ids, qt.dimensionless, value_name='Modulation ratio' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) import pylab pylab.figure() pylab.hist(modulation_ratio)
def subplot(self, subplotspec): dsv = queries.param_filter_query(self.datastore,identifier='ConductanceSignalList') return PerStimulusADSPlot(dsv, function=self._ploter, title_style="Clever").make_line_plot(subplotspec)
def plot(self): self.fig = pylab.figure(facecolor='w', **self.fig_param) gs = gridspec.GridSpec(1, 1) gs.update(left=0.1, right=0.9, top=0.9, bottom=0.1) gs = gs[0,0] gs = gridspec.GridSpecFromSubplotSpec(2, 1,subplot_spec=gs) orr = list(set([MozaikParametrized.idd(s).orientation for s in queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100).get_stimuli()])) oor = self.datastore.get_analysis_result(identifier='PerNeuronValue',value_name = 'LGNAfferentOrientation', sheet_name = self.parameters.sheet_name) if True: for neuron_idd in self.parameters.neurons: col = orr[numpy.argmin([circular_dist(o,oor[0].get_value_by_id(neuron_idd),numpy.pi) for o in orr])] dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100,st_orientation=col,sheet_name=self.parameters.sheet_name,analysis_algorithm='ActionPotentialRemoval') TrialToTrialCrossCorrelationOfAnalogSignalList(dsv,ParameterSet({'neurons' : [neuron_idd]}),tags=['helper']).analyse() dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100,st_orientation=col,sheet_name=self.parameters.sheet_name,analysis_algorithm='PSTH') TrialToTrialCrossCorrelationOfAnalogSignalList(dsv,ParameterSet({'neurons' : [neuron_idd]}),tags=['helper']).analyse() dsv = queries.tag_based_query(self.datastore,['helper']) dsv1 = queries.param_filter_query(dsv,y_axis_name='trial-trial cross-correlation of Vm (no AP)',st_name='FullfieldDriftingSinusoidalGrating',sheet_name=self.parameters.sheet_name) vm_cc_gr = numpy.mean(numpy.array([asl.asl[0] for asl in dsv1.get_analysis_result()]),axis=0) dsv1 = queries.param_filter_query(dsv,y_axis_name='trial-trial cross-correlation of psth (bin=2.0)',st_name='FullfieldDriftingSinusoidalGrating',sheet_name=self.parameters.sheet_name) psth_cc_gr = numpy.mean(numpy.array([asl.asl[0] for asl in dsv1.get_analysis_result()]),axis=0) #queries.param_filter_query(self.datastore,analysis_algorithm='TrialToTrialCrossCorrelationOfAnalogSignalList').print_content(full_ADS=True) dsv = queries.param_filter_query(self.datastore,y_axis_name='trial-trial cross-correlation of Vm (no AP)',st_name="NaturalImageWithEyeMovement",sheet_name=self.parameters.sheet_name,ads_unique=True) vm_cc_ni = numpy.mean(numpy.array(dsv.get_analysis_result()[0].asl),axis=0) dsv = queries.param_filter_query(self.datastore,y_axis_name='trial-trial cross-correlation of psth (bin=2.0)',st_name="NaturalImageWithEyeMovement",sheet_name=self.parameters.sheet_name,ads_unique=True) psth_cc_ni = numpy.mean(numpy.array(dsv.get_analysis_result()[0].asl),axis=0) logger.info(str(vm_cc_gr)) logger.info(str(vm_cc_ni)) z = int(min(self.parameters.window_length,len(vm_cc_gr-1)/2,len(vm_cc_ni-1)/2)/2)*2 logger.info(str(psth_cc_ni)) logger.info(str(psth_cc_gr)) fontsize = 30 pylab.rcParams['xtick.major.pad'] = fontsize-5 pylab.rcParams['ytick.major.pad'] = 10 pylab.rc('axes', linewidth=5) logger.info(len(vm_cc_gr[int(len(vm_cc_gr)/2)-z:int(len(vm_cc_gr)/2)+z+1])) logger.info(len(numpy.linspace(-z,z,2*z+1))) ax = pylab.subplot(gs[0,0]) ax.plot(numpy.linspace(-z,z,2*z+1),vm_cc_gr[int(len(vm_cc_gr)/2)-z:int(len(vm_cc_gr)/2)+z+1],label="Gratings") ax.plot(numpy.linspace(-z,z,2*z+1),vm_cc_ni[int(len(vm_cc_ni)/2)-z:int(len(vm_cc_ni)/2)+z+1],label="Natural images") pylab.legend() pylab.title("VM") pylab.xlabel("time (ms)") #pylab.ylabel("corr coef") ax = pylab.subplot(gs[1,0]) ax.plot(numpy.linspace(-z,z,z+1),psth_cc_gr[int(len(psth_cc_gr)/2)-z/2:int(len(psth_cc_gr)/2)+z/2+1],label="Gratings") ax.plot(numpy.linspace(-z,z,z+1),psth_cc_ni[int(len(psth_cc_ni)/2)-z/2:int(len(psth_cc_ni)/2)+z/2+1],label="Natural images") pylab.xlim(-z,z) pylab.xticks([-z,0,z],[-250,0,250])#[-2*z,0,2*z]) pylab.yticks([-1.0,0.0,1.0]) #pylab.legend() #pylab.title("Spikes") #pylab.xlabel("time (ms)",fontsize=fontsize) #pylab.ylabel("corr. coef.",fontsize=fontsize) #three_tick_axis(pylab.gca().xaxis) for label in ax.get_xticklabels() + ax.get_yticklabels(): label.set_fontsize(fontsize) if self.plot_file_name: pylab.savefig(Global.root_directory+self.plot_file_name)
def perform_analysis(self): layers = [["V1_Exc_L2/3", "V1_Inh_L2/3"], ["V1_Exc_L4", "V1_Inh_L4"]] for layer in layers: if not set(layer).issubset(set(self.datastore.sheets())): warnings.warn("Layer %s not part of data store sheets: %s!" % (layer, self.datastore.sheets())) continue # pool all spikes from the layer allspikes = [] dsv = queries.param_filter_query(self.datastore, sheet_name=layer) segs = dsv.get_segments() # add spikes from the layer to the pool tstart = tstop = 0 for seg in segs: for st in seg.spiketrains: tstart = min(st.t_start.magnitude, tstart) tstop = max(st.t_stop.magnitude, tstop) allspikes.extend(st.magnitude) assert (len({ load_parameters(str(s))["name"] for s in dsv.get_stimuli() }) == 1), "All stimuli have to have the same name!" # calculate specific time bin in each segment as in Fontenele2019 dt = np.mean(np.diff(np.sort(allspikes))) # case with no spikes is not taken care off! bins = np.arange(tstart, tstop, dt) hist, bins = np.histogram(allspikes, bins) # find zeros in the histogram zeros = np.where(hist == 0)[0] # calculate durations of avalanches durs = np.diff(zeros) * dt durs = durs[durs > dt] # calculate sizes of avalanches szs = [] for i in range(len(zeros) - 1): szs.append(np.sum(hist[zeros[i]:zeros[i + 1]])) # .magnitude)) szs = np.array(szs) szs = szs[szs > 0] # calculate tau=exponent of size distr s_distr, s_bins = self.create_hist(szs, self.parameters.num_bins) s_amp, s_slope, s_error_sq, s_error_diff = self.fit_powerlaw_distribution( s_bins, s_distr, "size") # calculate tau_t=exponent of distr of durations d_distr, d_bins = self.create_hist(durs, self.parameters.num_bins) d_amp, d_slope, d_error_sq, d_error_diff = self.fit_powerlaw_distribution( d_bins, d_distr, "duration") # calculate the <S>(D) curve, S=size, D=duration [sd_amp, sd_slope], _ = curve_fit(f=self.powerlaw, xdata=durs, ydata=szs, p0=[0, 0]) beta = sd_slope # for dcc calculation error_diff = sum(szs - self.powerlaw(durs, sd_amp, sd_slope)) error_sq = np.linalg.norm(szs - self.powerlaw(durs, sd_amp, sd_slope)) crit_dist = np.abs(beta - (-d_slope - 1) / (-s_slope - 1)) stims = dsv.get_stimuli() common_stim_params = load_parameters(str(stims[0])) for st in stims: p = load_parameters(str(st)) common_stim_params = { # Inner join of 2 dicts k: v for (k, v) in p.items() if k in common_stim_params and p[k] == common_stim_params[k] } for sheet in layer: common_params = { "sheet_name": sheet, "tags": self.tags, "analysis_algorithm": self.__class__.__name__, "stimulus_id": str(common_stim_params), } self.datastore.full_datastore.add_analysis_result( SingleValue( value=crit_dist * pq.dimensionless, value_units=pq.dimensionless, value_name="DistanceToCriticality", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=dt * pq.s, value_units=pq.s, value_name="AvalancheBinSize", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValueList( values=durs * pq.s, values_unit=pq.s, value_name="AvalancheDurations", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValueList( values=szs * pq.dimensionless, values_unit=pq.dimensionless, value_name="AvalancheSizes", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=sd_amp * pq.dimensionless, value_units=pq.dimensionless, value_name="SDAmplitude", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=sd_slope * pq.dimensionless, value_units=pq.dimensionless, value_name="SDSlope", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=error_sq * pq.dimensionless, value_units=pq.dimensionless, value_name="SDErrorSq", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=error_diff * pq.dimensionless, value_units=pq.dimensionless, value_name="SDErrorDiff", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=s_slope * pq.dimensionless, value_units=pq.dimensionless, value_name="SSlope", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=s_amp * pq.dimensionless, value_units=pq.dimensionless, value_name="SAmplitude", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValueList( values=s_distr * pq.dimensionless, values_unit=pq.dimensionless, value_name="SDistr", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValueList( values=s_bins * pq.dimensionless, values_unit=pq.dimensionless, value_name="SBins", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=s_error_sq * pq.dimensionless, value_units=pq.dimensionless, value_name="SErrorSq", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=s_error_diff * pq.dimensionless, value_units=pq.dimensionless, value_name="SErrorDiff", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=d_slope * pq.dimensionless, value_units=pq.dimensionless, value_name="DSlope", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=d_amp * pq.dimensionless, value_units=pq.dimensionless, value_name="DAmplitude", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValueList( values=d_distr * pq.s, values_unit=pq.dimensionless, value_name="DDistr", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValueList( values=d_bins * pq.s, values_unit=pq.dimensionless, value_name="DBins", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=d_error_sq * pq.dimensionless, value_units=pq.dimensionless, value_name="DErrorSq", **common_params, )) self.datastore.full_datastore.add_analysis_result( SingleValue( value=d_error_diff * pq.dimensionless, value_units=pq.dimensionless, value_name="DErrorDiff", **common_params, ))
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(16, 14, subplot_spec=subplotspec, hspace=1.0, wspace=1.0) low_contrast = str(5) analog_ids = sorted(queries.param_filter_query(self.datastore,sheet_name=self.parameters.sheet_name,value_name=['F0_Exc_Cond-Mean(ECond)']).get_analysis_result()[0].ids) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond-Mean(ECond)','F0_Inh_Cond-Mean(ICond)'],sheet_name=self.parameters.sheet_name) plots['MeanF0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[:4,:3],{'legend' : False, 'y_label': 'F0(Cond)' ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond-Mean(ECond) contrast : 100' : '#FF0000' , 'F0_Exc_Cond-Mean(ECond) contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond-Mean(ICond) contrast : 100' : '#0000FF' , 'F0_Inh_Cond-Mean(ICond) contrast : ' +low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['MeanF1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[4:8,:3],{'y_label': 'F1(Cond)','title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['MeanVMF0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[8:12,:3],{'y_label': 'F0(Vm)' ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['MeanVMF1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids), 'sheet_name' : self.parameters.sheet_name,'centered' : True,'mean' : True,'pool' : True,'polar' : True})),gs[12:16,:3],{'y_label': 'F1(Vm)','title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) if True: if self.parameters.many: dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond','F0_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F0a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[:2,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond contrast : 100' : '#FF0000' , 'F0_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond contrast : 100' : '#0000FF' , 'F0_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond','F0_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F0b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[2:4,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond contrast : 100' : '#FF0000' , 'F0_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond contrast : 100' : '#0000FF' , 'F0_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F1a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[4:6,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F1b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[6:8,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['VMF0a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[8:10,3:],{'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['VMF0b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[10:12,3:],{'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['VMF1a'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[0:10]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[12:14,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['VMF1b'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(analog_ids[10:20]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[14:16,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) else: #neurons = [0,6,2,4,9,15] #neurons = [i fori in xrange(0:10)] neurons = [5,15,3,38,18,24] #neurons = [30,31,32,33,34,35,36,37,38,39,40] dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Exc_Cond-Mean(ECond)','F0_Inh_Cond-Mean(ICond)'],sheet_name=self.parameters.sheet_name) plots['F0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[:4,3:],{'legend' : False, 'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Exc_Cond-Mean(ECond) contrast : 100' : '#FF0000' , 'F0_Exc_Cond-Mean(ECond) contrast : ' + low_contrast : '#FFACAC','F0_Inh_Cond-Mean(ICond) contrast : 100' : '#0000FF' , 'F0_Inh_Cond-Mean(ICond) contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Exc_Cond','F1_Inh_Cond'],sheet_name=self.parameters.sheet_name) plots['F1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[4:8,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Exc_Cond contrast : 100' : '#FF0000' , 'F1_Exc_Cond contrast : ' + low_contrast : '#FFACAC','F1_Inh_Cond contrast : 100' : '#0000FF' , 'F1_Inh_Cond contrast : ' + low_contrast : '#ACACFF'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F0_Vm-Mean(VM)'],sheet_name=self.parameters.sheet_name) plots['VMF0'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[8:12,3:],{'y_label': None ,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F0_Vm-Mean(VM) contrast : 100' : '#000000' , 'F0_Vm-Mean(VM) contrast : ' + low_contrast : '#ACACAC'}}) dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',value_name=['F1_Vm'],sheet_name=self.parameters.sheet_name) plots['VMF1'] = (PlotTuningCurve(dsv, ParameterSet({'parameter_name' : 'orientation', 'neurons': list(numpy.array(analog_ids)[neurons]), 'sheet_name' : self.parameters.sheet_name,'centered' : False,'mean' : False,'pool' : True,'polar' : True})),gs[12:16,3:],{'y_label': None,'title' : None, 'x_ticks' : None, 'x_label' : None,'colors': {'F1_Vm contrast : 100' : '#000000' , 'F1_Vm contrast : ' + low_contrast : '#ACACAC'}}) return plots
import mozaik from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore from mozaik.tools.mozaik_parametrized import colapse, colapse_to_dictionary, MozaikParametrized from mozaik.analysis.technical import NeuronAnnotationsToPerNeuronValues from parameters import ParameterSet import numpy from mozaik.storage import queries from mozaik.controller import Global Global.root_directory = sys.argv[1]+'/' setup_logging() data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':sys.argv[1],'store_stimuli' : False}),replace=True) NeuronAnnotationsToPerNeuronValues(data_store,ParameterSet({})).analyse() analog_ids = queries.param_filter_query(data_store,sheet_name="V1_Exc_L4").get_segments()[0].get_stored_esyn_ids() dsv = queries.param_filter_query(data_store,st_name='FlashedBar') for ads in dsv.get_analysis_result(): sid = MozaikParametrized.idd(ads.stimulus_id) sid.x=0 ads.stimulus_id = str(sid) for seg in dsv.get_segments(): sid = MozaikParametrized.idd(seg.annotations['stimulus']) sid.x=0 seg.annotations['stimulus'] = str(sid) for seg in dsv.get_segments(null=True): sid = MozaikParametrized.idd(seg.annotations['stimulus']) sid.x=0 seg.annotations['stimulus'] = str(sid)
def plot(self): self.fig = pylab.figure(facecolor='w', **self.fig_param) gs = gridspec.GridSpec(1, 1) gs.update(left=0.07, right=0.97, top=0.9, bottom=0.1) gs = gs[0,0] dsv_simple = self.datastore.get_analysis_result(identifier='PerNeuronValue',sheet_name=self.parameters.SimpleSheetName,analysis_algorithm='ModulationRatio') dsv_complex = self.datastore.get_analysis_result(identifier='PerNeuronValue',sheet_name=self.parameters.ComplexSheetName,analysis_algorithm='ModulationRatio') dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_orientation=0) dsv_simple_v_F0 = dsv.get_analysis_result(identifier='PerNeuronValue',sheet_name=self.parameters.SimpleSheetName,value_name='F0_Vm-Mean(VM)') dsv_complex_v_F0 = dsv.get_analysis_result(identifier='PerNeuronValue',sheet_name=self.parameters.ComplexSheetName,value_name='F0_Vm-Mean(VM)') dsv_simple_v_F1 = dsv.get_analysis_result(identifier='PerNeuronValue',sheet_name=self.parameters.SimpleSheetName,value_name='F1_Vm') dsv_complex_v_F1 = dsv.get_analysis_result(identifier='PerNeuronValue',sheet_name=self.parameters.ComplexSheetName,value_name='F1_Vm') print len(dsv_simple) assert len(dsv_simple) == 1 assert len(dsv_complex) == 1 assert len(dsv_simple_v_F0) == 1 assert len(dsv_complex_v_F0) == 1 assert len(dsv_simple_v_F1) == 1 assert len(dsv_complex_v_F1) == 1 print dsv_simple_v_F0[0].values print dsv_simple_v_F1[0].values simple_v_mr = 2*dsv_simple_v_F1[0].values/abs(dsv_simple_v_F0[0].values) print simple_v_mr complex_v_mr = 2*dsv_complex_v_F1[0].values/abs(dsv_complex_v_F0[0].values) dsv_simple = dsv_simple[0] dsv_complex = dsv_complex[0] gs = gridspec.GridSpecFromSubplotSpec(3, 2,subplot_spec=gs) ax = pylab.subplot(gs[0,0]) ax.hist(dsv_simple.values,bins=numpy.arange(0,2.2,0.2),color='k') pylab.ylim(0,450) disable_xticks(ax) remove_x_tick_labels() remove_y_tick_labels() #pylab.ylabel('Layer 4',fontsize=15) ax = pylab.subplot(gs[1,0]) ax.hist(dsv_complex.values,bins=numpy.arange(0,2.2,0.2),color='w') pylab.ylim(0,450) disable_xticks(ax) remove_x_tick_labels() remove_y_tick_labels() #pylab.ylabel('Layer 2/3',fontsize=15) ax = pylab.subplot(gs[2,0]) ax.hist([dsv_simple.values,dsv_complex.values],bins=numpy.arange(0,2.2,0.2),histtype='barstacked',color=['k','w']) pylab.ylim(0,450) #pylab.ylabel('Pooled',fontsize=15) three_tick_axis(ax.xaxis) remove_y_tick_labels() #pylab.xlabel('Modulation ratio',fontsize=15) for label in ax.get_xticklabels() + ax.get_yticklabels(): label.set_fontsize(30) if True: ax = pylab.subplot(gs[0,1]) ax.hist(simple_v_mr,bins=numpy.arange(0,2.2,0.2),color='k') disable_xticks(ax) remove_x_tick_labels() remove_y_tick_labels() ax = pylab.subplot(gs[1,1]) ax.hist(complex_v_mr,bins=numpy.arange(0,2.2,0.2),color='k') disable_xticks(ax) remove_x_tick_labels() remove_y_tick_labels() ax = pylab.subplot(gs[2,1]) ax.hist([simple_v_mr,complex_v_mr],bins=numpy.arange(0,2.2,0.2),histtype='barstacked',color=['k','w']) three_tick_axis(ax.xaxis) remove_y_tick_labels() for label in ax.get_xticklabels() + ax.get_yticklabels(): label.set_fontsize(30) if self.plot_file_name: pylab.savefig(Global.root_directory+self.plot_file_name)