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