def find_distn(lgbinwidth, numlgbins, transient, N, M_t, M_i): totspkhist = zeros((numlgbins, 1)) skiptime = transient * ms skipbin = int(ceil(skiptime / lgbinwidth)) for i in xrange(numlgbins): step_start = (i) * lgbinwidth #30*ms # step_end = (i + 1) * lgbinwidth #30*ms # for j in xrange(N): #spks=where(logical_and(M[j]>step_start, M[j]<step_end)) #totspkhist[i]+=len(M[j][spks]) totspkhist[i] += len(M_i[logical_and(M_t > step_start, M_t < step_end)]) #totspkhist_1D=reshape(totspkhist,len(totspkhist)) ###smooth plot first so thresholds work better #b,a=butter(3,0.4,'low') #totspkhist_smooth=filtfilt(b,a,totspkhist_1D) totspkhist_smooth = reshape( totspkhist, len(totspkhist) ) #here we took out the actual smoothing and left it as raw distn. #create distn based on hist, but skip first skiptime to cut out transient excessive spiking if max(totspkhist_smooth[skipbin:]) > 0: totspkdist_smooth = totspkhist_smooth / max( totspkhist_smooth[skipbin:]) else: totspkdist_smooth = totspkhist_smooth totspkhist_list = [val for subl in totspkhist for val in subl] return [totspkhist, totspkdist_smooth, totspkhist_list]
def filter_func(x): ok = logical_and(x.Rload == R, x.phase == phase) # print 334,x,R, phase # print ok return ok
def checkClassification(self,binary): fp = count_nonzero(logical_and(self.notMask, binary)) tp = count_nonzero(logical_and(self.mask,binary)) return fp,tp
def find_bursts(duration, dt, transient, N, M_t, M_i, max_freq): base = 2 #round lgbinwidth to nearest 2 so will always divide into durations expnum = 2.0264 * exp(-0.2656 * max_freq + 2.9288) + 5.7907 lgbinwidth = (int(base * round( (-max_freq + 33) / base))) * ms #23-good for higher freq stuff #lgbinwidth=(int(base*round((expnum)/base)))/1000 #use exptl based on some fit of choice binwidths #lgbinwidth=10*ms numlgbins = int(ceil(duration / lgbinwidth)) #totspkhist=zeros((numlgbins,1)) totspkhist = zeros(numlgbins) #totspkdist_smooth=zeros((numlgbins,1)) skiptime = transient * ms skipbin = int(ceil(skiptime / lgbinwidth)) inc_past_thresh = [] dec_past_thresh = [] #Create histogram given the bins calculated for i in xrange(numlgbins): step_start = (i) * lgbinwidth step_end = (i + 1) * lgbinwidth totspkhist[i] = len(M_i[logical_and(M_t > step_start, M_t < step_end)]) ###smooth plot first so thresholds work better #totspkhist_1D=reshape(totspkhist,len(totspkhist)) #first just reshape so single row not single colm #b,a=butter(3,0.4,'low') #totspkhist_smooth=filtfilt(b,a,totspkhist_1D) #totspkhist_smooth=reshape(totspkhist,len(totspkhist)) #here we took out the actual smoothing and left it as raw distn. here just reshape so single row not single colm totspkdist_smooth = totspkhist / max( totspkhist[skipbin:] ) #create distn based on hist, but skip first skiptime to cut out transient excessive spiking # ####### FOR MOVING THRESHOLD ################# ## find points where increases and decreases over some threshold dist_thresh = [] thresh_plot = [] mul_fac = 0.35 switch = 0 #keeps track of whether inc or dec last elim_noise = 1 / (max_freq * 2.5 * Hz) #For line 95, somehow not required in previous version? #elim_noise_units = 1/(max_freq*Hz*2.5) thresh_time = 5 / (max_freq) #capture 5 cycles thresh_ind = int(floor( (thresh_time / lgbinwidth) / 2)) #the number of indices on each side of the window #dist_thresh moves with window capturing approx 5 cycles (need special cases for borders) Find where increases and decreases past threshold (as long as a certain distance apart, based on "elim_noise" which is based on avg freq of bursts dist_thresh.append( totspkdist_smooth[skipbin:skipbin + thresh_ind].mean(0) + mul_fac * totspkdist_smooth[skipbin:skipbin + thresh_ind].std(0)) for i in xrange(1, numlgbins): step_start = (i) * lgbinwidth step_end = (i + 1) * lgbinwidth #moving threshold if i > (skipbin + thresh_ind) and (i + thresh_ind) < len(totspkdist_smooth): #print(totspkdist_smooth[i-thresh_ind:i+thresh_ind]) dist_thresh.append( totspkdist_smooth[i - thresh_ind:i + thresh_ind].mean(0) + mul_fac * totspkdist_smooth[i - thresh_ind:i + thresh_ind].std(0)) elif (i + thresh_ind) >= len(totspkdist_smooth): dist_thresh.append(totspkdist_smooth[-thresh_ind:].mean(0) + mul_fac * totspkdist_smooth[-thresh_ind:].std(0)) else: dist_thresh.append( totspkdist_smooth[skipbin:skipbin + thresh_ind].mean(0) + mul_fac * totspkdist_smooth[skipbin:skipbin + thresh_ind].std(0)) if (totspkdist_smooth[i - 1] < dist_thresh[i]) and (totspkdist_smooth[i] >= dist_thresh[i]): #inc_past_thresh.append(step_start-0.5*lgbinwidth) if (inc_past_thresh): #there has already been at least one inc, if ( abs(inc_past_thresh[-1] - (step_start - 0.5 * lgbinwidth)) > elim_noise ) and switch == 0: #must be at least x ms apart (yHz), and it was dec last.. inc_past_thresh.append( step_start - 0.5 * lgbinwidth ) #take lower point (therefore first) when increasing. Need to -0.5binwidth to adjust for shift between index of bin width and index of bin distn #print (['incr=%f'%inc_past_thresh[-1]]) thresh_plot.append(dist_thresh[i]) switch = 1 else: inc_past_thresh.append( step_start - 0.5 * lgbinwidth ) #take lower point (therefore first) when increasing. Need to -0.5binwidth to adjust for shift between index of bin width and index of bin distn thresh_plot.append(dist_thresh[i]) switch = 1 #keeps track of that it was inc. last elif (totspkdist_smooth[i - 1] >= dist_thresh[i]) and (totspkdist_smooth[i] < dist_thresh[i]): # dec_past_thresh.append(step_end-0.5*lgbinwidth) #take lower point (therefore second) when decreasing if (dec_past_thresh): #there has already been at least one dec if ( abs(dec_past_thresh[-1] - (step_end - 0.5 * lgbinwidth)) > elim_noise ) and switch == 1: #must be at least x ms apart (y Hz), and it was inc last dec_past_thresh.append( step_end - 0.5 * lgbinwidth ) #take lower point (therefore second) when decreasing #print (['decr=%f'%dec_past_thresh[-1]]) switch = 0 else: dec_past_thresh.append( step_end - 0.5 * lgbinwidth ) #take lower point (therefore second) when decreasing switch = 0 #keeps track of that it was dec last if totspkdist_smooth[0] < dist_thresh[ 0]: #if you are starting below thresh, then pop first inc. otherwise, don't (since will decrease first) if inc_past_thresh: #if list is not empty inc_past_thresh.pop(0) # ##################################################################### # ######### TO DEFINE A STATIC THRESHOLD AND FIND CROSSING POINTS # dist_thresh=0.15 #static threshold # switch=0 #keeps track of whether inc or dec last # overall_freq=3.6 #0.9 # elim_noise=1/(overall_freq*5)#2.5) # # # for i in xrange(1,numlgbins): # step_start=(i)*lgbinwidth # step_end=(i+1)*lgbinwidth # # if (totspkdist_smooth[i-1]<dist_thresh) and (totspkdist_smooth[i]>=dist_thresh): #if cross threshold (increasing) # if (inc_past_thresh): #there has already been at least one inc, # if (abs(dec_past_thresh[-1]-(step_start-0.5*lgbinwidth))>elim_noise) and switch==0: #must be at least x ms apart (yHz) from the previous dec, and it was dec last.. # inc_past_thresh.append(step_start-0.5*lgbinwidth) #take lower point (therefore first) when increasing. Need to -0.5binwidth to adjust for shift between index of bin width and index of bin distn # #print (['incr=%f'%inc_past_thresh[-1]]) #-0.5*lgbinwidth # switch=1 # else: # inc_past_thresh.append(step_start-0.5*lgbinwidth) #take lower point (therefore first) when increasing. Need to -0.5binwidth to adjust for shift between index of bin width and index of bin distn # switch=1 #keeps track of that it was inc. last # elif (totspkdist_smooth[i-1]>=dist_thresh) and (totspkdist_smooth[i]<dist_thresh): # if (dec_past_thresh): #there has already been at least one dec # if (abs(inc_past_thresh[-1]-(step_end-0.5*lgbinwidth))>elim_noise) and switch==1: #must be at least x ms apart (y Hz) from the previous incr, and it was inc last # dec_past_thresh.append(step_end-0.5*lgbinwidth) #take lower point (therefore second) when decreasing # #print (['decr=%f'%dec_past_thresh[-1]]) # switch=0 # else: # dec_past_thresh.append(step_end-0.5*lgbinwidth) #take lower point (therefore second) when decreasing # switch=0 #keeps track of that it was dec last # # # if totspkdist_smooth[0]<dist_thresh: #if you are starting below thresh, then pop first inc. otherwise, don't (since will decrease first) # if inc_past_thresh: #if list is not empty # inc_past_thresh.pop(0) ################################################################ ############################################################### ######## DEFINE INTER AND INTRA BURSTS ######## #since always start with dec, intraburst=time points from 1st inc:2nd dec, from 2nd inc:3rd dec, etc. #interburst=time points from 1st dec:1st inc, from 2nd dec:2nd inc, etc. intraburst_time_ms_compound_list = [] interburst_time_ms_compound_list = [] intraburst_bins = [] #in seconds interburst_bins = [] #print(inc_past_thresh) if len(inc_past_thresh) < len(dec_past_thresh): #if you end on a decrease for i in xrange(len(inc_past_thresh)): intraburst_time_ms_compound_list.append( arange(inc_past_thresh[i] / ms, dec_past_thresh[i + 1] / ms, 1)) #10 is timestep interburst_time_ms_compound_list.append( arange((dec_past_thresh[i] + dt) / ms, (inc_past_thresh[i] - dt) / ms, 1)) #10 is timestep intraburst_bins.append(inc_past_thresh[i]) intraburst_bins.append(dec_past_thresh[i + 1]) interburst_bins.append(dec_past_thresh[i]) interburst_bins.append(inc_past_thresh[i]) else: #if you end on an increase for i in xrange(len(inc_past_thresh) - 1): intraburst_time_ms_compound_list.append( arange(inc_past_thresh[i] / ms, dec_past_thresh[i + 1] / ms, 1)) #10 is timestep interburst_time_ms_compound_list.append( arange((dec_past_thresh[i] + dt) / ms, (inc_past_thresh[i] - dt) / ms, 1)) #10 is timestep intraburst_bins.append(inc_past_thresh[i]) intraburst_bins.append(dec_past_thresh[i + 1]) interburst_bins.append(dec_past_thresh[i] + dt) interburst_bins.append(inc_past_thresh[i] - dt) if dec_past_thresh and inc_past_thresh: #if neither dec_past_thresh nor inc_past_thresh is empty interburst_bins.append(dec_past_thresh[-1] + dt) #will have one more inter than intra interburst_bins.append(inc_past_thresh[-1] + dt) interburst_bins = interburst_bins / second intraburst_bins = intraburst_bins / second intraburst_time_ms = [ num for elem in intraburst_time_ms_compound_list for num in elem ] #flatten list interburst_time_ms = [ num for elem in interburst_time_ms_compound_list for num in elem ] #flatten list num_intraburst_bins = len( intraburst_bins ) / 2 #/2 since have both start and end points for each bin num_interburst_bins = len(interburst_bins) / 2 intraburst_bins_ms = [x * 1000 for x in intraburst_bins] interburst_bins_ms = [x * 1000 for x in interburst_bins] ###################################### #bin_s=[((inc_past_thresh-dec_past_thresh)/2+dec_past_thresh) for inc_past_thresh, dec_past_thresh in zip(inc_past_thresh,dec_past_thresh)] bin_s = [((x - y) / 2 + y) for x, y in zip(inc_past_thresh, dec_past_thresh)] / second binpt_ind = [int(floor(x / lgbinwidth)) for x in bin_s] ########## FIND PEAK TO TROUGH AND SAVE VALUES ################### ########## CATEGORIZE BURSTING BASED ON PEAK TO TROUGH VALUES ################### ########## DISCARD BINPTS IF PEAK TO TROUGH IS TOO SMALL ################### peaks = [] trough = [] peak_to_trough_diff = [] min_burst_size = 0.2 #defines a burst as 0.2 or larger. for i in xrange(len(binpt_ind) - 1): peaks.append(max(totspkdist_smooth[binpt_ind[i]:binpt_ind[i + 1]])) trough.append(min(totspkdist_smooth[binpt_ind[i]:binpt_ind[i + 1]])) peak_to_trough_diff = [ max_dist - min_dist for max_dist, min_dist in zip(peaks, trough) ] #to delete all bins following any <min_burst_size first_ind_not_burst = next( (x[0] for x in enumerate(peak_to_trough_diff) if x[1] < 0.2), None) # if first_ind_not_burst: # del bin_s[first_ind_not_burst+1:] #needs +1 since bin_s has one additional value (since counts edges) #to keep track of any bins <0.2 so can ignore in stats later all_ind_not_burst = [ x[0] for x in enumerate(peak_to_trough_diff) if x[1] < 0.2 ] #defines a burst as 0.2 or larger. bin_ms = [x * 1000 for x in bin_s] binpt_ind = [int(floor(x / lgbinwidth)) for x in bin_s] #for moving threshold only thresh_plot = [] thresh_plot = [dist_thresh[x] for x in binpt_ind] #for static threshold #thresh_plot=[dist_thresh]*len(bin_ms) # # # bin_s=[((inc_past_thresh-dec_past_thresh)/2+dec_past_thresh) for inc_past_thresh, dec_past_thresh in zip(inc_past_thresh,dec_past_thresh)] # bin_ms=[x*1000 for x in bin_s] # thresh_plot=[] # binpt_ind=[int(floor(x/lgbinwidth)) for x in bin_s] # thresh_plot=[dist_thresh[x] for x in binpt_ind] # binpts = xrange(int(lgbinwidth * 1000 / 2), int(numlgbins * lgbinwidth * 1000), int(lgbinwidth * 1000)) totspkhist_list = totspkhist.tolist( ) #[val for subl in totspkhist for val in subl] #find first index after transient to see if have enough bins to do stats bin_ind_no_trans = bisect.bisect(bin_ms, transient) intrabin_ind_no_trans = bisect.bisect(intraburst_bins, transient / 1000) #transient to seconds if intrabin_ind_no_trans % 2 != 0: #index must be even since format is ind0=start_bin, ind1=end_bin, ind2=start_bin, .... . intrabin_ind_no_trans += 1 interbin_ind_no_trans = bisect.bisect(interburst_bins, transient / 1000) if interbin_ind_no_trans % 2 != 0: interbin_ind_no_trans += 1 return [ bin_s, bin_ms, binpts, totspkhist, totspkdist_smooth, dist_thresh, totspkhist_list, thresh_plot, binpt_ind, lgbinwidth, numlgbins, intraburst_bins, interburst_bins, intraburst_bins_ms, interburst_bins_ms, intraburst_time_ms, interburst_time_ms, num_intraburst_bins, num_interburst_bins, bin_ind_no_trans, intrabin_ind_no_trans, interbin_ind_no_trans ]