def perform_analysis(self): self.datastore.print_content() dsv = analysis_data_structure_parameter_filter_query(self.datastore,identifier='PerNeuronValue') for sheet in self.datastore.sheets(): # Get PerNeuronValue ASD and make sure they are all associated with the same stimulus are # do not differ in any ASD parameters except the stimulus dsv = select_result_sheet_query(dsv,sheet) if ads_is_empty(dsv): break assert equal_ads_except(dsv,['stimulus_id']) assert ads_with_equal_stimulus_type(dsv,not_None=True) self.pnvs = dsv.get_analysis_result(sheet_name=sheet) # get stimuli st = [StimulusID(s.stimulus_id) for s in self.pnvs] d = colapse_to_dictionary([z.values for z in self.pnvs],st,self.parameters.parameter_name) result_dict = {} for k in d.keys(): keys,values = d[k] y = [] x = [] for v,p in zip(values,keys): y.append(v) x.append(numpy.zeros(numpy.shape(v))+p) pref,sel = circ_mean(numpy.array(x),weights=numpy.array(y),axis=0,low=0,high=st[0].periods[self.parameters.parameter_name],normalize=True) logger.debug('Adding PerNeuronValue to datastore') self.datastore.full_datastore.add_analysis_result(PerNeuronValue(pref,st[0].units[self.parameters.parameter_name],value_name = self.parameters.parameter_name + ' preference',sheet_name=sheet,tags=self.tags,period=st[0].periods[self.parameters.parameter_name],analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sel,st[0].units[self.parameters.parameter_name],value_name = self.parameters.parameter_name + ' selectivity',sheet_name=sheet,tags=self.tags,period=1.0,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
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 = select_result_sheet_query(self.datastore,sheet) assert equal_ads_except(dsv,['stimulus_id']) assert ads_with_equal_stimulus_type(dsv) assert equal_stimulus_type(dsv) psths = [psth(seg.spiketrains,self.parameters.bin_length) for seg in dsv.get_segments()] st = [StimulusID(s) for s in dsv.get_stimuli()] # average across trials psths,stids = colapse(psths,st,parameter_list=['trial'],func=neo_mean,allow_non_identical_stimuli=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 else: 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[StimulusID(s).params['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) # colapse 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 = numpy.zeros((numpy.shape(psths[0])[1],)) frequency = StimulusID(st).params['temporal_frequency'] * StimulusID(st).units['temporal_frequency'] for (orr,ppsth) in zip(vl[0],vl[1]): for j in numpy.nonzero(orr == closest_presented_orientation)[0]: modulation_ratio[j] = self.calculate_MR(ppsth[:,j],frequency) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(modulation_ratio,qt.dimensionless,value_name = 'Modulation ratio',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)