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)
