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)
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) 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) for ppsth,stid in zip(psths,stids): t_start = ppsth[0].t_start duration = ppsth[0].t_stop-ppsth[0].t_start al = [] for n in self.parameters.neurons: ac = numpy.correlate(numpy.array(ppsth[:,n]), numpy.array(ppsth[:,n]), mode='full') div = numpy.sum(numpy.power(numpy.array(ppsth[:,n]),2)) if div != 0: ac = ac / div al.append(AnalogSignal(ac, t_start=-duration,t_stop=duration-self.parameters.bin_length*t_start.units,sampling_period=self.parameters.bin_length*qt.ms,units=qt.dimensionless)) logger.debug('Adding AnalogSignalList:' + str(sheet)) self.datastore.full_datastore.add_analysis_result(AnalogSignalList(al,self.parameters.neurons,qt.ms,qt.dimensionless,x_axis_name='time',y_axis_name='autocorrelation',sheet_name=sheet,tags=self.tags,analysis_algorithm=self.__class__.__name__,stimulus_id=str(stid)))