def push_data_std(diode_t, diode, buffer): """ Calculate rolling standard deviation of diode readings. Generate lists containing values one standard deviation away from the median (lower and higher) and push resulting list into buffer to be graphed. """ timeStuff = list(diode_t) times = [ 1000 * time for time in timeStuff ] # Convert time to seconds so bokeh formatter can get correct datetime diodeData = pd.Series(diode, index=times) zipped = basic_event_builder(diode=diodeData) median = zipped.rolling(120, min_periods=1).median() std = zipped.rolling(120, min_periods=1).std() lowerbound = median - std higherbound = median + std df = pd.DataFrame({ 'lowerbound': lowerbound['diode'], 'higherbound': higherbound['diode'] }) buffer.send(df[119::2])
def push_data(): """ Push data into stream to be ploted on hextiles plot """ nonlocal ipm2_plot, ipm3_plot, ebeam_plot, ipm2TS_plot, ipm3TS_plot, ebeamTS_plot, paused_list ipm2_plot = list(ipm2List)[ipm2_index:] ipm3_plot = list(ipm3List)[ipm3_index:] ebeam_plot = list(ebeamList)[ebeam_index:] ipm2TS_plot = list(ipm2TS)[ipm2TS_index:] ipm3TS_plot = list(ipm3TS)[ipm3TS_index:] ebeamTS_plot = list(ebeamTS)[ebeamTS_index:] ipm2Data = pd.Series(ipm2_plot, index=ipm2TS_plot) ipm3Data = pd.Series(ipm3_plot, index=ipm3TS_plot) ebeamData = pd.Series(ebeam_plot, index=ebeamTS_plot) zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData) data = zipped[['ebeam', switch_key_hex]] paused_list = zipped #print(zipped) streamHex.event(df=data)
def scatter_tick(): """ Push new scatter points into stream to plot. """ nonlocal paused_list # Still has the freezing points error, though, it seems to come more frequently. # This may be a bigger problem now ebeamConverted = list(ebeamList) ipm2Converted = list(ipm2List) ipm3Converted = list(ipm3List) ebeamTimeConverted = list(ebeamTS) ipm2TimeConverted = list(ipm2TS) ipm3TimeConverted = list(ipm3TS) ipm2Data = pd.Series(ipm2Converted[-limit:], index=ipm2TimeConverted[-limit:]) ipm3Data = pd.Series(ipm3Converted[-limit:], index=ipm3TimeConverted[-limit:]) ebeamData = pd.Series(ebeamConverted[-limit:], index=ebeamTimeConverted[-limit:]) zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData) scatterList = zipped[-limit:] data = scatterList[['ebeam', switch_key_scatter]] paused_list = scatterList streamScatter.event(df=data)
def push_data(x_diode, y_diode, x_diode_t, y_diode_t, buffer): """ Push data from x and y diode into buffer to be graphed. """ x_diode_data = pd.Series(x_diode, index=x_diode_t) y_diode_data = pd.Series(y_diode, index=y_diode_t) zipped = basic_event_builder(x_diode=x_diode_data, y_diode=y_diode_data) buffer.send(zipped)
def saveFile(): """ Save current data plotted to csv file as a pandas.DataFrame """ ipm2Data = pd.Series(ipm2_plot, index=ipm2TS_plot) ipm3Data = pd.Series(ipm3_plot, index=ipm3TS_plot) ebeamData = pd.Series(ebeam_plot, index=ebeamTS_plot) zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData) zipped.to_csv('data2.csv')
def push_data_scatter(timetool_d, timetool_t, buffer): timeStuff = list(timetool_t) # Convert time to seconds so bokeh formatter can get correct datetime times = [1000 * time for time in timeStuff] edgePos = [] for array in timetool_d: edgePos.append(array[1]) edgePos_data = pd.Series(edgePos, index=times) zipped = basic_event_builder(timetool_data=edgePos_data) buffer.send(zipped)
def push_data_median(diode_t, diode, buffer): """ Push rolling median of diode readings and push resulting list into buffer to be graphed. """ timeStuff = list(diode_t) # Convert time to seconds so bokeh formatter can get correct datetime times = [1000 * time for time in timeStuff] diodeData = pd.Series(diode, index=times) zipped = basic_event_builder(diode=diodeData) median = zipped.rolling(120, min_periods=1).median() # Exclude first 119 points because of binning issues and sparsing the data (Doesn't seem to really work though) buffer.send(median[119::2]) zipped.to_csv('testData2.csv')
def push_data(stream): if switch_key == 'ipm2': ipm_plot = list(ipm2List) timestamp_plot = list(ipm2TS) elif switch_key == 'ipm3': ipm_plot = list(ipm3List) timestamp_plot = list(ipm3TS) times = [1000 * time for time in timestamp_plot] ipmData = pd.Series(ipm_plot, index=times) zipped = basic_event_builder(ipm=ipmData) median = zipped.rolling(120, min_periods=1).median() #This might be making it take a long time to switch if type(stream) == hv.streams.Buffer: if len(median) > 1000: counter = 0 pos = 0 send = pd.DataFrame({'ipm': []}) while counter < 1000: divide = len(median) / 1000. test = int(pos) send = send.append(median.iloc[[test]]) #print(send) #print(type(median.iloc[[test]])) pos += divide counter += 1 #print(len(send)) #print(len(stream.data)) stream.send(send) #print(stream.data[-10:]) print("Done") else: stream.send(median) #stream.send(median) elif len(median) > 100: stream.event(df=median)
def saveFile(): """ Save current data plotted to csv file as a pandas.DataFrame """ ipm2Data = pd.Series(self.ipm2_plot[self.ipm2_index:], index=self.ipm2TS_plot[self.ipm2TS_index:]) ipm3Data = pd.Series(self.ipm3_plot[self.ipm3_index:], index=self.ipm3TS_plot[self.ipm3TS_index:]) ebeamData = pd.Series(self.ebeam_plot[self.ebeam_index:], index=self.ebeamTS_plot[self.ebeamTS_index:]) zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData) zipped.to_csv('data_class.csv')
def push_data(ipm, timestamp, stream): """ Push data into stream to be ploted on hextiles plot """ ipm_plot = list(ipm) timestamp_plot = list(timestamp) times = [1000 * time for time in timestamp_plot] ipmData = pd.Series(ipm_plot, index=times) zipped = basic_event_builder(ipm=ipmData) median = zipped.rolling(120, min_periods=1).median() if type(stream) == hv.streams.Buffer: if len(median) > 1000: counter = 0 pos = 0 send = pd.DataFrame({'ipm': []}) while counter < 1000: divide = len(median) / 1000. test = int(pos) send = send.append(median.iloc[[test]]) #print(send) #print(type(median.iloc[[test]])) pos += divide counter += 1 #print(len(send)) #print(len(stream.data)) stream.send(send) #print(stream.data[-10:]) print("Done") else: stream.send(median) #stream.send(median) elif len(median) > 100: stream.event(df=median)
def push_std(stream): if switch_key == 'ipm2': ipm_plot = list(ipm2List) timestamp_plot = list(ipm2TS) elif switch_key == 'ipm3': ipm_plot = list(ipm3List) timestamp_plot = list(ipm3TS) times = [1000 * time for time in timestamp_plot] ipmData = pd.Series(ipm_plot, index=times) zipped = basic_event_builder(ipm=ipmData) median = zipped.rolling(120, min_periods=1).median() std = zipped.rolling(120, min_periods=1).std() lowerbound = median - std higherbound = median + std df = pd.DataFrame({ 'lowerbound': lowerbound['ipm'], 'higherbound': higherbound['ipm'] }) if len(df) > 1000: counter = 0 pos = 0 send = pd.DataFrame({ 'lowerbound': lowerbound['ipm'], 'higherbound': higherbound['ipm'] }) while counter < 1000: divide = len(df) / 1000. test = int(pos) send = send.append(df.iloc[[test]]) pos += divide counter += 1 #print(divide) stream.send(send) else: stream.send(df)
def push_data(stream): TS_key = switch_key + '_TS' data = list(peak[switch_key]) timestamp = list(peakTS[TS_key]) times = [1000 * time for time in timestamp] dataSeries = pd.Series(data, index=times) zipped = basic_event_builder(peak=dataSeries) median = zipped.rolling(120, min_periods=1).median() std = zipped.rolling(120, min_periods=1).std() lowerbound = median - std higherbound = median + std df = pd.DataFrame({ 'peak': median['peak'], 'lowerbound': lowerbound['peak'], 'higherbound': higherbound['peak'] }) stream.send(df)
def push_data(): """ Push data into stream to be ploted on hextiles plot """ # Doesn't seem to get the most recent data :( socket.send_string("Hello") print("Oof") #if socket.poll(timeout=0): data_dict = socket.recv_pyobj() peakDict = data_dict['peakDict'] peakTSDict = data_dict['peakTSDict'] self.ipm2_plot = list(peakDict['peak_8']) self.ipm3_plot = list(peakDict['peak_9']) self.ebeam_plot = list(peakDict['peak_10']) self.ipm2TS_plot = list(peakTSDict['peak_8_TS']) self.ipm3TS_plot = list(peakTSDict['peak_9_TS']) self.ebeamTS_plot = list(peakTSDict['peak_10_TS']) ipm2Data = pd.Series( self.ipm2_plot[self.ipm2_index:], index=self.ipm2TS_plot[self.ipm2TS_index:]) ipm3Data = pd.Series( self.ipm3_plot[self.ipm3_index:], index=self.ipm3TS_plot[self.ipm3TS_index:]) ebeamData = pd.Series( self.ebeam_plot[self.ebeam_index:], index=self.ebeamTS_plot[self.ebeamTS_index:]) zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData) data = zipped[['ebeam', self.switch_key]] self.paused_list = zipped self.streamHex.event(df=data)
def push_std(stream): if switch_key == 'ipm2': ipm_plot = list(ipm2List) timestamp_plot = list(ipm2TS) elif switch_key == 'ipm3': ipm_plot = list(ipm3List) timestamp_plot = list(ipm3TS) times = [1000 * time for time in timestamp_plot] ipmData = pd.Series(ipm_plot, index=times) zipped = basic_event_builder(ipm=ipmData) median = zipped.rolling(120, min_periods=1).median() std = zipped.rolling(120, min_periods=1).std() lowerbound = median - std higherbound = median + std df = pd.DataFrame({ 'lowerbound': lowerbound['ipm'], 'higherbound': higherbound['ipm'] }) stream.send(df)
def push_data(stream): """ Push data to timetool time history graph """ median = pd.DataFrame({'peak': []}) lowerbound = pd.DataFrame({'peak': []}) higherbound = pd.DataFrame({'peak': []}) # Request socket.send_string("Hello") print("Oof") data_dict = socket.recv_pyobj() peakDict = data_dict['peakDict'] peakTSDict = data_dict['peakTSDict'] TS_key = self.switch_key + '_TS' data = list(peakDict[self.switch_key]) timestamp = list(peakTSDict[TS_key]) times = [1000 * time for time in timestamp] dataSeries = pd.Series(data, index=times) zipped = basic_event_builder(peak=dataSeries) median = zipped.rolling(120, min_periods=1).median() std = zipped.rolling(120, min_periods=1).std() lowerbound = median - std higherbound = median + std df = pd.DataFrame({ 'peak': median['peak'], 'lowerbound': lowerbound['peak'], 'higherbound': higherbound['peak'] }) stream.send(df)
def scatter_tick(): """ Push new scatter points into stream to plot. """ # Still has the freezing points error, though, it seems to come more frequently. # This may be a bigger problem now if socket.poll(timeout=0): data_dict = socket.recv_pyobj() peakDict = data_dict['peakDict'] peakTSDict = data_dict['peakTSDict'] self.ipm2_plot = list(peakDict['peak_8']) self.ipm3_plot = list(peakDict['peak_9']) self.ebeam_plot = list(peakDict['peak_10']) self.ipm2TS_plot = list(peakTSDict['peak_8_TS']) self.ipm3TS_plot = list(peakTSDict['peak_9_TS']) self.ebeamTS_plot = list(peakTSDict['peak_10_TS']) ipm2Data = pd.Series(self.ipm2_plot[-self.limit:], index=self.ipm2TS_plot[-self.limit:]) ipm3Data = pd.Series(self.ipm3_plot[-self.limit:], index=self.ipm3TS_plot[-self.limit:]) ebeamData = pd.Series(self.ebeam_plot[-self.limit:], index=self.ebeamTS_plot[-self.limit:]) zipped = basic_event_builder(ipm2=ipm2Data, ipm3=ipm3Data, ebeam=ebeamData) scatterList = zipped data = scatterList[['ebeam', self.switch_key]] self.paused_list = scatterList self.streamScatter.event(df=data)
def push_data(stream): """ Push data to timetool time history graph """ median = pd.DataFrame({'peak': []}) lowerbound = pd.DataFrame({'peak': []}) higherbound = pd.DataFrame({'peak': []}) # Maybe fix this for stopping no data coming in? And switching issue? (Right now it's a feature) if socket.poll(timeout=0): data_dict = socket.recv_pyobj() peakDict = data_dict['peakDict'] peakTSDict = data_dict['peakTSDict'] TS_key = self.switch_key + '_TS' data = list(peakDict[self.switch_key]) timestamp = list(peakTSDict[TS_key]) times = [1000 * time for time in timestamp] dataSeries = pd.Series(data, index=times) zipped = basic_event_builder(peak=dataSeries) median = zipped.rolling(120, min_periods=1).median() std = zipped.rolling(120, min_periods=1).std() lowerbound = median - std higherbound = median + std df = pd.DataFrame({ 'peak': median['peak'], 'lowerbound': lowerbound['peak'], 'higherbound': higherbound['peak'] }) stream.send(df)