def producemeanwaveform(self, wf): size = len(wf.amp) mean = np.mean(wf.amp[size/2:]) std = np.std(wf.amp[size/2:]) mean = (wf.amp)/mean newwf = waveform.Waveform(wf.time,mean,'an_mean') return newwf
def producesigmawaveform(self, wf): size = len(wf.amp) mean = np.mean(wf.amp[size/2:size*0.8]) std = np.std(wf.amp[size/2:size*0.8]) sigma = (wf.amp - mean)/std newwf = waveform.Waveform(wf.time,sigma,'an_sigma') return newwf
def switchsignaldirection(self,wf): mean = self.getmean(wf) # print mean #newamp = (wf.amp-mean) newamp = mean - (wf.amp-mean) newwf = waveform.Waveform(wf.time,newamp) return newwf
def main (): from sys import platform if 'linux' not in platform: demo_file = '/Volumes/External/Documents/Research/data/cases/Case003.hd5' else: demo_file = '/mnt/data01/CONDUIT/Cases/Case003.hd5' wf=waveform.Waveform(demo_file,start='20171213 1500',duration=600,process=True) #plot a good segment templates, ts = abp_templates(wf, 2) df = pd.DataFrame(templates).transpose() # store the templates in a single dataframe df.columns = df.columns.astype(str) # Bokeh wants columns to be names as str df['ts']=ts # add the time series to the df t_source = ColumnDataSource(df) p_abp_t = figure(x_axis_label='Time (s)', y_axis_label='ABP (mmHg)', tools=['box_zoom', 'xwheel_zoom', 'pan', 'reset',], plot_width=400, plot_height=400, ) p_abp_t.title.text = 'Bad Segment' for i in range(df.shape[1]-1): p_abp_t.line(x='ts', y=str(i), source=t_source) output_file('template.html', title='ABP Template') layout=column(p_abp_t) show(layout)
def adaptationboard2(self, wf): # first we compute the fft of the waveform: fft = np.fft.rfft(wf.amp) spec = np.absolute(fft) fftfreq = np.fft.rfftfreq(len(wf.amp),wf.time[1] - wf.time[0]) # then we produce the gain of the amplifier for the given frequencies (exept DC) # according the study that extracted the parameters empirically prefact = constant.boardspecprefact mu = constant.boardspecmu sigma = constant.boardspecsigma k = constant.boardspeck gainspec = utils.boardspecfunc(fftfreq,prefact,mu,sigma,k) a = constant.boardphasea b = constant.boardphasea c = constant.boardphasea gainphase = utils.boardphasefunc(fftfreq,a,b,c) if self.type=='norsat' or self.type=='helix': gainfft = gainspec[1:]*np.exp(1j*gainphase[1:]) # dcgain = -self.board_slope - self.board_k/np.mean(wf.amp) #!!! hardcoded value for the board in the case of GD. dcgain = -self.board_slope - 8/np.mean(wf.amp) else: gainfft = -gainspec[1:]*np.exp(1j*gainphase[1:]) dcgain = self.board_slope + self.board_k/np.mean(wf.amp) gainfft = np.insert(gainfft,0,dcgain) newamp = np.fft.irfft(gainfft*fft) newwf = waveform.Waveform(wf.time[:-1],newamp,'board') return newwf
def get_waveform(self, index, data='waveform'): """Load a single Waveform object from the HDF5 file (or its waveform parameters). Parameters ---------- index : int Index of the waveform you want. data : str, {'waveform', 'parameters'} The data to extract for the waveform. Returns ------- Waveform for 'waveform' array for 'parameters' """ # Get the waveform group groupname = 'wave_' + str(index) wave = self.ws_file[groupname] if data == 'waveform': # Create blank dictionary for waveform # Then fill it with the arrays in the wave group data = {} for key in wave.keys(): if key != 'parameters': data[key] = wave[key][:] return wo.Waveform(data) elif data == 'parameters': return wave['parameters'][:] else: raise Exception, "Valid data options for 'data' are {'waveform', 'parameters'}."
def FEfilter(self, wf): Nyfreq = wf.sampling/2 ratiofreq = float(fcut)/Nyfreq b, a = signal.butter(4, ratiofreq) y = utils.lowpass(wf.amp,wf.sampling,4,1*fcut) newwf = waveform.Waveform(wf.time,y,'fefilter') return newwf
def producepowerwaveform(self, wf): vfeamp = utils.adctov_board(wf.amp) fewf = waveform.Waveform(wf.time,vfeamp,'an_fe') if self.det.type == 'norsat' or self.det.type=='helix': # fewf = self.switchsignaldirection(fewf) powerdet = (vfeamp-constant.boardoffsetGD)/constant.boardslopeGD else: powerdet = (vfeamp-self.det.board_k)/self.det.board_slope # vfeamp = fewf.amp # powerdet = (vfeamp+8)/4 # pdbm = (powerdet - self.det.m2_offset)/self.det.m2_slope pdbm = (powerdet - self.det.m3_offset)/self.det.m3_slope watt = utils.dbmtowatt(pdbm) newwf = waveform.Waveform(wf.time,watt,'an_watt') # newwf = waveform.Waveform(wf.time,vfeamp,'an_watt') # newwf = waveform.Waveform(wf.time,powerdet,'an_watt') return newwf
def saveSampleImage(self, data): fName = data['sample']['wav'] fLoc = pjoin(curdir, "audio", fName) imgLoc = pjoin(curdir, "img/waveform", fName.replace('.wav','.png')) waveImg = waveform.Waveform(fLoc) imgInitLoc = waveImg.save() rename(imgInitLoc,imgLoc) return imgLoc
def producepowerwaveform(self, wf): vfeamp = utils.adctov_board(wf.amp) powerdet = (vfeamp- (-8))/4 # powerdet = (vfeamp-self.det.board_k)/self.det.board_slope pdbm = (powerdet - self.det.m3_offset)/self.det.m3_slope watt = utils.dbmtowatt(pdbm) newwf = waveform.Waveform(wf.time,watt,'an_watt') # newwf = waveform.Waveform(wf.time,powerdet,'an_watt') return newwf
def m3_powerdetsim(self, wf, tau=None): if tau == None: newwf = utils.m3_powerdetectorsim(wf.time, wf.amp, self.gain, self.m3_tau, self.m3_slope, self.m3_offset) else: newwf = utils.m3_powerdetectorsim(wf.time, wf.amp, self.gain, tau, self.m3_slope, self.m3_offset) newwf = waveform.Waveform(newwf[0], newwf[1], 'powerdetector') return newwf
def getWaveforms(self, run, event): nproot = nuphaseroot.NUPHASEROOT(run) self.wfm_length = nproot.waveform_length wfms = nproot.getEvents([event])[0] self.channels = len(wfms) for i in range(self.channels): self.wave.append( waveform.Waveform(wfms[i] - numpy.median(wfms[i]), sampling_rate=self.sampling_rate))
def FEtimesampling(self, wf): #first time sampling: step = float(1./fesampling) tracelength = wf.length nrofpoints = int(tracelength/step) newtime = np.linspace(wf.tstart,wf.tend,nrofpoints) [a,b] = utils.resize(wf.time,wf.amp) newy = np.interp(newtime,a,b) newwf = waveform.Waveform(newtime,newy,'timesampled') return newwf
def produceresponse(self,wf): tend = 500e-9 period = 1./wf.sampling x = np.arange(0,tend,period) convfunc = period*np.exp(-x/self.m1_tau)/( -(math.exp(-tend/self.m1_tau) - 1)*self.m1_tau) # response in dBm power = self.gain*(wf.amp*wf.amp)/constant.impedance signal = 10*np.log10(power) + 30 resp = np.convolve(signal,convfunc,'valid') newtime = np.linspace(wf.time[0], float(len(resp))/wf.sampling+wf.time[0], len(resp)) newamp = resp newwf = waveform.Waveform(newtime,newamp,'logresponse') return newwf
def __init__(self, wfms=None, sampling_rate=detector.nuphase_sampling_rate): ''' data can either be loaded here by assigning a list of numpy array wfms, or directly from the ROOT file usind getWaveforms ''' self.wave = [] self.wfm_length = 0 self.sampling_rate = 1. / sampling_rate self.channels = 0 if wfms is not None: self.wfm_length = len(wfms[0]) self.channels = len(wfms) for i in range(self.channels): self.wave.append( waveform.Waveform(wfms[i] - numpy.median(wfms[i]), sampling_rate=self.sampling_rate))
def crosscorrel(self, wf, envelopewf): newenv = np.interp(wf.time, envelopewf.time, envelopewf.amp/np.max(envelopewf.amp)) crosscorrel = signal.correlate(wf.amp, newenv, mode='full') #here we cut the correlated waveform. # it is not really clean now, but we select the window of the input size with the largest integral size = len(wf.time) halfccsize = int(len(crosscorrel)/2) goodindexstart = 0 goodindexstop = 0 maxint = -1. for i in range(halfccsize): indexstart = i indexstop = i+size newc = crosscorrel[indexstart:indexstop] if np.sum(newc) > maxint: maxint = np.sum(newc) goodindexstart = indexstart goodindexstop = indexstop newc = crosscorrel[goodindexstart:goodindexstop] newwf = waveform.Waveform(wf.time,newc,'an_correl') return newwf
def __init__(self): """Initializes all elements in the system""" super(Plotter, self).__init__() print("Starting init") self.total_length = 1000 # total sample size self.time = 1000 # time of sample in ms self.t = 0 self.time_scale = 10000.0 # samples per second, total time = total_length/time_scale self.chunk_size = 400 self.time_unit = 1.0 self.power = 0.0 self.timer_thing = time.time() # Booleans for still, pause and noise self.still = True self.pause = False self.noise = False self.unoise = False self.show_noise = False self.noise_magnitude = .01 self.waveform1 = waveform.Waveform("Current", amplitude=1.0, frequency=60,color='g') self.waveform2 = waveform.Waveform("Voltage", amplitude=1.50, frequency=60, color='w') self.noiseform = waveform.Waveform("Uniform Noise", amplitude = 0.001, frequency=1000.0, color='b') # Power Waveform information self.show_power = True self.colorp = 'r' self.show_filtered_power = True self.colorfp = 'y' self.cutoff = 1000.0 self.order = 2 # All the needed arrays for graphing self.xs = np.zeros(self.total_length) self.ys1 = np.zeros(self.total_length) self.ys2 = np.zeros(self.total_length) self.ysp = np.zeros(self.total_length) self.ysf = np.zeros(self.total_length) self.init_ui() # Initializes the UI self.qt_connections() # Connects the buttons to their functions # Creates curve items and adds them to the plot self.plotcurve1 = pg.PlotCurveItem() self.plotcurve2 = pg.PlotCurveItem() self.powercurve1 = pg.PlotCurveItem() self.noisecurve = pg.PlotCurveItem() self.filtercurve = pg.PlotCurveItem() self.plotwidget.addItem(self.plotcurve1) self.plotwidget.addItem(self.plotcurve2) self.plotwidget.addItem(self.powercurve1) self.plotwidget.addItem(self.noisecurve) self.plotwidget.addItem(self.filtercurve) # Sets self.update() to repeat self.timer = QtCore.QTimer() self.timer.timeout.connect(self.update) self.timer.start(1) print("init complete!")
def adaptationboard(self, wf): newwf = waveform.Waveform(wf.time,self.board_k + self.board_slope*wf.amp,'board') return newwf
def m2_powerdetsim(self, wf): newamp = utils.m2_powerdetectorsim(wf.time,wf.amp,self.gain,self.capaornot) newwf = waveform.Waveform(wf.time,newamp,'powerdetector') return newwf
def powerdetlinear(self, wf): newwf = waveform.Waveform(wf.time,self.m1_offset + self.m1_slope*wf.amp,'powerdetector') return newwf
names = glob.glob(folder+ filenames+'*.pkl') ana = analyse.Analyse(det=det) evcount = 0 a_max = np.array([]) # print names for n in names[::1]: file = open(n, 'rb') revent = pickle.load(file) if revent.shower.energy < 5: continue for ant in revent.antennas: size = len(ant.trace) if size==0: continue time = np.arange(0,size*binsize,binsize) wf = waveform.Waveform(time,ant.trace) # time = ant.maketimearray() # lpwf = ana.lowpass(wf,1e6,2) powerwf = ana.producepowerwaveform(wf) sigmawf = ana.producesigmawaveform(powerwf) a_max = np.append(a_max, np.max(sigmawf.amp[150:250])) if np.max(sigmawf.amp[150:250]) > 5 : evcount +=1 file.close() print ' evcount = ' , evcount a_ev = np.append(a_ev,evcount) a_mean = np.append(a_mean,np.mean(a_ev)/normalization) a_rms = np.append(a_rms,np.std(a_ev)/normalization) out = 'results' print a_mean
def do_POST(self): conn = sqlite3.connect(sqlite_file) c = conn.cursor() if (self.path == '/login'): postvars = self.parse_POST() uName = postvars['username'][0] uPass = postvars['password'][0] c.execute("SELECT id, pyKey FROM `user` WHERE `username` = '{username}' AND `password` = '{password}'".\ format(username=uName, password=uPass)) user_match = c.fetchone() if not user_match: self.respond(401) c.execute("SELECT id FROM `user` WHERE `username` = '{username}'".format(username=uName)) username_found = c.fetchone() if username_found: postRes = { "error": 'wrong-password' } else: postRes = { "error": 'no-user' } else: self.respond(200) postRes = {} postRes['user_id'] = user_match[0] postRes['pyKey'] = user_match[1] postRes['username'] = uName self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/register'): postvars = self.parse_POST() uName = postvars['username'][0] uPass = postvars['password'][0] uEmail = postvars['email'][0] c.execute("SELECT id, pyKey FROM `user` WHERE `username` = '{username}'".format(username=uName)) user_match = c.fetchone() if user_match: self.respond(401) postRes = { "error": 'username-taken' } else: c.execute("SELECT id, pyKey FROM `user` WHERE `email` = '{email}'".format(email=uEmail)) email_match = c.fetchone() if email_match: self.respond(401) postRes = { "error": 'email-taken' } else: uKey = self.randomString(32) insertSql = "INSERT INTO `user` (username,email,password,pyKey) VALUES ('{un}','{em}','{pw}','{pk}')"\ .format(un=uName, em=uEmail, pw=uPass, pk=uKey) c.execute(insertSql) conn.commit() self.respond(200) postRes = { "username" : uName, "email" : uEmail, "pyKey" : uKey } self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/upload'): postvars = self.parse_POST() fName = postvars['filename'][0] fData = postvars['file'][0] fLoc = pjoin(curdir, "audio/uploaded", fName) with open(fLoc, 'wb') as fh: fh.write(fData) imgLoc = pjoin(curdir, "img/waveform/uploaded", fName.replace('.wav','.png')) waveImg = waveform.Waveform(fLoc) imgInitLoc = waveImg.save() rename(imgInitLoc,imgLoc) self.respond(200) postRes = { "wav": fName, "img": imgLoc } self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/song'): postvars = self.parse_POST() pyKey = postvars['pyKey'][0] uid = postvars['user_id'][0] sid = postvars['song_id'][0] authorized = self.checkCreds(uid,pyKey) if not authorized: self.respond(401) return self.respond(200) postRes = self.getSongData(sid) postRes['id'] = sid postRes['channels'] = self.getSongChannels(sid) postRes['patterns'] = self.getSongPatterns(sid) self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/songs'): postvars = self.parse_POST() pyKey = postvars['pyKey'][0] uid = postvars['user_id'][0] authorized = self.checkCreds(uid,pyKey) if not authorized: self.respond(401) return self.respond(200) postRes = self.getSongList(uid) # postRes['id'] = sid # postRes['channels'] = self.getSongChannels(sid) # postRes['patterns'] = self.getSongPatterns(sid) self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/channels'): postvars = self.parse_POST() pyKey = postvars['pyKey'][0] uid = postvars['user_id'][0] sid = postvars['song_id'][0] authorized = self.checkCreds(uid,pyKey) if not authorized: self.respond(401) return self.respond(200) postRes = self.getSongChannels(sid) self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/patterns'): postvars = self.parse_POST() pyKey = postvars['pyKey'][0] uid = postvars['user_id'][0] sid = postvars['song_id'][0] authorized = self.checkCreds(uid,pyKey) if not authorized: self.respond(401) return self.respond(200) postRes = self.getSongPatterns(sid) self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/upload-splitter'): postvars = self.parse_POST() fName = postvars['filename'][0] fData = postvars['file'][0] fLoc = pjoin(curdir, "audio/uploaded", fName) with open(fLoc, 'wb') as fh: fh.write(fData) imgLoc = pjoin(curdir, "img/waveform/uploaded", fName.replace('.wav','.png')) waveImg = waveform.Waveform(fLoc) imgInitLoc = waveImg.save() rename(imgInitLoc,imgLoc) self.respond(200) postRes = { "wav": fName, "img": imgLoc, "slices": groove.split(fName,16) } self.wfile.write(json.dumps(postRes).encode("utf-8")) conn.close() return elif (self.path == '/render'): self.data_string = self.rfile.read(int(self.headers['Content-Length'])) fName = groove.renderJSON(self.data_string); self.wfile.write(bytes(fName, "utf8")) else: self.data_string = self.rfile.read(int(self.headers['Content-Length'])) data = simplejson.loads(self.data_string) postRes = {} pyKey = data['currentUser']['pyKey'] # TODO HERE: checkUserKey(pyKey,data['currentUser']['user_id']) ... if fail, return if ('id' in data and data['id']): songId = data['id'] self.saveSongData({ "user_id": data['currentUser']['user_id'], "title": data['title'], "bpm": int(data['bpm']), "swing": data['swing'], "id": songId }) else: songId = self.saveSongData({ "user_id": data['currentUser']['user_id'], "title": data['title'], "bpm": int(data['bpm']), "swing": data['swing'] }) postRes['id'] = songId trackPos=0 for key, track in data['tracks'].items(): if not ('image' in track): track['image'] = self.saveSampleImage(track) sampleId = self.saveSample({ "filename": track['sample']['wav'], "reverse": track['reverse'], "normalize": track['normalize'], "trim": track['trim'], "image": track['image'] }) trackPos = trackPos + 1 track['sample_id'] = sampleId track['song_id'] = songId track['name'] = key track['position'] = trackPos channelId = self.saveSongChannel(track) track['channel_id'] = channelId filterSectionId = self.saveFilterSection(1,channelId,track['filter']) filterSection2Id = self.saveFilterSection(2,channelId,track['filter2']) track['filter_id'] = filterSectionId track['filter2_id'] = filterSection2Id # NOTE: We don't have multiple patterns yet so this will get a little more complex for key, pattern in data['patterns'].items(): patternId = pattern['id'] if (patternId): self.savePattern({ "id": pattern['id'], "bars": pattern['bars'], "song_id": songId, "position": pattern['position'], "name": pattern['name'] }) else: position = key patternId = self.savePattern({ "bars": data['bars'], "song_id": songId, "position": position, "name": data['title'] + " Pattern " + str(position) }) for key, track in data['tracks'].items(): self.saveStepSequence({ "pattern_id": patternId, "channel_id": track['channel_id'], "steps": track['notes'] }) self.respond(200) self.wfile.write(json.dumps(postRes).encode("utf-8")) return
def producemeanwaveform(self, wf): mean = self.getmean(wf) mean = (wf.amp)/mean newwf = waveform.Waveform(wf.time,mean,'an_mean') return newwf
detname = 'EASIER' if dettype == 'norsat': detname = 'GDC' if dettype == 'helix': detname = 'GDL' method = 3 tsys = constant.meantempdict[detname] det = detector.Detector(temp = tsys, type=dettype) det.loadspectrum() print 'tsys = ' , tsys print 'delta B = ', det.deltaB #sig = waveform.Waveform(ant.time*1e-9,ant.vtrace,'vtrace') sig = waveform.Waveform(ant.time*1e-9,ant.othervtrace,'vtrace') print 'sig smampling = ' , sig.sampling print 'sig lenght = ' , sig.length #time = ant.maketimearray() sim = simulation.Simulation(det=det, sampling = sig.sampling) sim.producetime() sim.producenoise(True) #sim.time = time sim.setsignalwitharrays(sig.time,sig.amp) # sim.setpowerenvelopewitharray([time,ant.power]) # sim.producesignal() print 'len(noise) = ' , len(sim.noise),'len(nsig) = ' , len(sim.signal),'len(time) = ' , len(sim.time) simwf = waveform.Waveform(sim.time,sim.noise+sim.signal, type='hf') wf = det.producesimwaveform(simwf,'adc',method)
def __init__(self): """Initializes all elements in the system""" super(Plotter, self).__init__() print("Starting init") self.total_time = 5000 self.ms_scale = 20 self.sample_size = self.total_time * self.ms_scale self.st = 0 self.et = 100 self.speed = 1 self.timer_thing = time.time() # Booleans for still, pause and noise self.still = True self.pause = False self.noise = True self.unoise = False self.show_noise = False self.noise_magnitude = 0 self.waveform1 = waveform.Waveform("Current", amplitude=1.0, frequency=60, color='g', time=self.total_time, samp_per_msec=self.ms_scale) self.waveform2 = waveform.Waveform("Voltage", amplitude=1.0, frequency=60, color='w', phase=90, time=self.total_time, samp_per_msec=self.ms_scale) self.noiseform = Noiseform.Noiseform("Uniform Noise", amplitude=50, frequency=1.0, color='b', freq_scale=1000, amp_scale=.001, time=self.total_time, samp_per_msec=self.ms_scale) # Power Waveform information self.show_power = True self.colorp = 'r' self.show_filtered_power = True self.colorfp = 'y' self.show_pure_power = True self.colorpp = 'm' self.cutoff = 200.0 self.order = 15 # All the needed arrays for graphing self.x = np.linspace(0.0, self.total_time, self.sample_size) self.y1 = np.zeros(self.sample_size) self.y2 = np.zeros(self.sample_size) self.yp = np.zeros(self.sample_size) self.ypp = np.zeros(self.sample_size) self.yf = np.zeros(self.sample_size) self.init_ui() # Initializes the UI self.qt_connections() # Connects the buttons to their functions # Creates curve items and adds them to the plot self.plotcurve1 = pg.PlotCurveItem() self.plotcurve2 = pg.PlotCurveItem() self.powercurve1 = pg.PlotCurveItem() self.powercurve2 = pg.PlotCurveItem() self.noisecurve = pg.PlotCurveItem() self.filtercurve = pg.PlotCurveItem() self.plotwidget.addItem(self.plotcurve1) self.plotwidget.addItem(self.plotcurve2) self.plotwidget.addItem(self.powercurve1) self.plotwidget.addItem(self.powercurve2) self.plotwidget.addItem(self.noisecurve) self.plotwidget.addItem(self.filtercurve) # Sets self.update() to repeat self.timer = QtCore.QTimer() self.timer.timeout.connect(self.update) self.timer.start(1) print("init complete!")
det = detector.Detector(temp = tsys, type=dettype) det.loadspectrum() #print names for n in names: ev = event.Event(fname=n, type='test') ev.loadevent() figtrace = plt.figure(figsize=(10,8)) figtrace.suptitle('file: '+n,fontweight='bold',fontsize=15) axtrace = plt.subplot(111) for ant in ev.antennas: if np.isnan(np.max(ant.power)): print 'nan !!!!!!!' continue time = ant.maketimearray() sim = simulation.Simulation(det=det) sim.producetime() sim.producenoise(True) # sim.time = time sim.setpowerenvelopewitharray([time,ant.power]) sim.producesignal() simwf = waveform.Waveform(sim.time,sim.noise+sim.signal, type='hf') wf = det.producesimwaveform(simwf,'adc',method) fig = plt.figure() plt.plot(wf.time, wf.amp) plt.show()
def load_cb(): global wf, wvt # Disable buttons while segmenting seg_button.disabled = True seg_button.label = 'Segmenting File' seg_button.button_type = 'warning' disable_wf_panel() # Get the dates selected on the slider and convert them to timestamps dates = date_range_slider.value vs_start = pd.Timestamp(dates[0] / 1000, unit='s') vs_end = pd.Timestamp(dates[1] / 1000, unit='s') print('Current x range is from {} to {})'.format(vs_start.round('s'), vs_end.round('s'))) start_str = vs_start.strftime('%Y%m%d-%H%M%S') end_str = vs_end.strftime('%Y%m%d-%H%M%S') # Perform the segmentation and wavelet operations on the selected data if 'AR' in vs_types[wf_radio_button.active]: wf = waveform.Waveform(active_file, start=start_str, end=end_str, process=True, seg_channel=vs_types[wf_radio_button.active]) wvt = waveform.ABPWavelet(wf, process=True) elif 'CVP' in vs_types[wf_radio_button.active]: wf = waveform.CVPWaveform(active_file, start=start_str, end=end_str, process=True, seg_channel=vs_types[wf_radio_button.active]) wvt = waveform.CVPWavelet(wf, process=True) # Update the segment slider seg_slider.value = 1 seg_slider.end = len(wf.segments) # Update the waveform panel plots wf_source.data = ColumnDataSource(wf.segments[1]).data wf_start = pd.to_datetime(min(wf_source.data['index'])).timestamp() * 1000 wf_end = pd.to_datetime(max(wf_source.data['index'])).timestamp() * 1000 p_seg.yaxis.axis_label = wf_types[wf_radio_button.active] p_seg.x_range.start = wf_start p_seg.x_range.end = wf_end # Update pressor information if it exists if p: p_subset = p.DFpressors.loc[(p.DFpressors.index >= vs_start) & (p.DFpressors.index <= vs_end)] for elem in p_subset.index: print( int((elem - vs_start) / ((vs_end - vs_start) / len(wf.segments)) + 1)) pressor_seg.data = ColumnDataSource( p.DFpressors.loc[(p.DFpressors.index >= pd.to_datetime( p_seg.x_range.start / 1000, unit='s')) & (p.DFpressors.index <= pd.to_datetime( p_seg.x_range.end / 1000, unit='s'))]).data wf_line.glyph.y = wf_types[wf_radio_button.active] p_wf_II.x_range.start = wf_start p_wf_II.x_range.end = wf_end # Show R peaks if selected if show_peaks.active == 'no': #deactivated df = pd.DataFrame(wf_source.data) df['DateTime'] = wf_source.data['index'] try: ind = [x.item() for x in pd.to_numeric(df['index'])] except AttributeError: ind = list(pd.to_numeric(df['index'])) try: ecg = [x.item() * 1000 for x in df['II']] except AttributeError: ecg = list(df['II'] * 1000) ann, anntype = eng.wrapper(ind, ecg, 'wf_files/' + active_file.split('\\')[-1].split('.')[0], 240, nargout=2) R_peaks = [int(ann[i][0]) for i, e in enumerate(anntype) if e == 'N'] ann_source.data = ColumnDataSource(df.iloc[R_peaks, :]).data # Enable elements on vitals panel seg_button.disabled = False disable_wf_panel(False) seg_button.label = 'Segment File' seg_button.button_type = 'success' print('Read complete')
def lowpasshard(self, wf, fcut): filtamp = utils.lowpasshard(wf.amp,wf.sampling,fcut) newwf = waveform.Waveform(wf.time,filtamp,'an_filt') return newwf
def FEampsampling(self, wf): #first time sampling: newy = -0.5*wf.amp*1023 newy = newy.astype(int) newwf = waveform.Waveform(wf.time,newy,'adc') return newwf
ana = analyse.Analyse(det=det) evcount = 0 a_max = np.array([]) noisedist = np.array([]) for n in names[::1]: print n file = open(n, 'rb') revent = pickle.load(file) if revent.shower.energy < 5: continue for ant in revent.antennas: size = len(ant.trace) if size == 0: continue time = np.arange(0, size * binsize, binsize) wf = waveform.Waveform(time, ant.trace) timepower = ant.maketimearray() wfori = waveform.Waveform(timepower, ant.power) # time = ant.maketimearray() # lpwf = ana.lowpass(wf,1e6,2) powerwf = ana.producepowerwaveform(wf) sigmawf = ana.producesigmawaveform(powerwf) # a_max = np.append(a_max, np.max(sigmawf.amp[100:-100])) if np.max(sigmawf.amp[180:220]) > 5: fig, (ax0, ax1) = plt.subplots(2, 1) ax0.plot(wfori.time, wfori.amp) # ax1.plot(sigmawf.time,sigmawf.amp) ax1.plot(sigmawf.amp) # ax1.plot(powerwf.time,powerwf.amp) # plt.plot(ant.trace)