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):
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):
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 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):
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):
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):
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):
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)
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)))