def updateData():
global img, doppler_shifts_plot
#img.setImage(doppler_shifts_plot,autoLevels=False, levels=[-0.2, 0.9], lut=viridis.viridis())
img.setImage(doppler_shifts_plot,
autoLevels=False,
levels=[-0.2, 0.9],
lut=jet.jet())
QtCore.QTimer.singleShot(1, updateData)
def bow_train(featfunc, opts, canon_opts, params):
descs = []
files = dataset.training_files(opts['num_train_images'])
for img_file, depth_file in print_progress(files):
img, segmask = canonize(img_file, depth_file, canon_opts, params)
if featfunc == 'daisy':
h = daisy(img_as_float(img), **opts['feature_opts'])
if featfunc == 'jet':
h = jet(img_as_float(img), **opts['feature_opts'])
segmask = sp.misc.imresize(segmask, h.shape[:2])
for i in range(h.shape[0]):
for j in range(h.shape[1]):
if segmask[i,j] != 0:
descs.append(h[i,j,:].flatten())
descs = [descs[i] for i in range(0, len(descs), opts['feature_step'])]
descs = np.vstack(tuple(descs))
print '# K-means clustering of %i features of dimensionality %i'%(descs.shape[0], descs.shape[1])
kmeans = KMeans(opts['num_clusters'], n_jobs=options.num_threads)
kmeans.fit(descs)
return kmeans
def __init__(self, f, x, k, f_args=None):
self.f = f
self.x = x
self.k = k
if np.array(x).shape == ():
n, x = 1, [x]
else:
n = len(x)
# call to f
if f_args is None:
f_eval = f(*x)
else:
f_eval = f(*(list(x) + list(f_args)))
if np.array(f_eval).shape == ():
m = 1
else:
# call to f
m = len(f_eval)
self.m = m
self.n = n
# list of symbolic variables
var = sympy.symarray('x', (n, ))
# polynomial basis
pb = bases.poly_basis(var)
# vector basis
vb = bases.vf_basis(pb, m)
# k-jet of f centered at x
# call to f
self.jet = jet.jet(f, x, k, f_args, var, pb)
# fundamental operator of normal form theory, Lie bracket with f'
self.L1 = lie_operator.lie_operator(self.jet.fun_deg[1], var, 1, pb,
vb)
# work space of coefficients
n_terms = combinatorics.simplicial_list(n, k)
wrk = [[np.zeros(m * n_terms[i + j + 1]) for j in range(k - i)]
for i in range(k)]
# initialize first row of workspace as k-jet
for j in range(k):
wrk[0][j] = np.concatenate(self.jet.coeff[j + 1])
# generators
g = []
# Lie brackets with generators
L = []
# equivariant vector fields
eqv = []
# list of factorials
fac = combinatorics.factorial_list(k)
# algorithm based on Murdock
for deg in range(2, k + 1):
# update workspace and solve for generator
for j, l in enumerate(L):
wrk[1][deg - 2] += l[deg - 1 - j].dot(wrk[0][deg - 2 - j])
f_coeff = np.zeros(m * n_terms[deg])
for i in range(deg):
f_coeff += wrk[i][deg - 1 - i] / fac[i]
g_coeff = np.linalg.lstsq(self.L1[deg], f_coeff)[0]
# normal form coefficients
h_coeff = f_coeff - self.L1[deg].dot(g_coeff)
# represent normal form term in L1.T nullspace basis
u, s, v = np.linalg.svd(self.L1[deg])
rank = min(self.L1[deg].shape) - np.isclose(s, 0).sum()
perp_basis = u[:, rank:]
e_coeff = perp_basis.T.conj().dot(h_coeff)
e = [
sympy.Matrix(perp_basis[:, i].reshape(
m, perp_basis[:, i].shape[0] / m)) * pb[deg]
for i in range(perp_basis.shape[1])
]
# truncate roundoff error
for coeff in [e_coeff, f_coeff, g_coeff, h_coeff]:
coeff[np.isclose(coeff, 0)] = 0
# store generator
g.append(
sympy.Matrix(np.reshape(g_coeff,
(m, len(g_coeff) / m))) * pb[deg])
# update series coeff
self.jet.coeff[deg] = np.reshape(h_coeff, (m, len(h_coeff) / m))
# store equivariant vector fields
eqv.append((e_coeff, e))
# store Lie operator
L.append(lie_operator.lie_operator(g[-1], var, deg, pb, vb))
# update workspace
wrk[1][deg - 2] += L[-1][1].dot(wrk[0][0])
for i in range(2, k - deg + 2):
for j, l in enumerate(L):
wrk[i][deg - 2] += l[deg - 2 + i - j].dot(
wrk[i - 1][deg - 2 - j])
self.L = L
self.g = g
self.eqv = eqv
# update series symbolic and lambdified representation
self.jet.update_fun()
# make jet.fun accessible from this class
self.fun = self.jet.fun
import numpy as np
from jet import jet
import matplotlib.pyplot as plt
plt.figure(figsize=(6.4, 4.8))
n_stream = 10
phi = np.linspace(-1, 5, 31)
j = jet([0.5j, np.inf, -0.5j], [2, -2])
print('q =', j.q)
print('theta =', np.degrees(j.theta))
j.plot(phi, n_stream, 'b')
j.plot_boundary('r')
plt.axis('equal')
plt.axis('off')
plt.axis([-2, 2, -1.5, 1.5])
plt.tight_layout()
plt.savefig('fig8a.eps')
plt.show()
plt.close()
#######################################################
plt.figure(figsize=(6.4, 4.8))
n_stream = 10
phi = np.linspace(-1, 5, 31)
j = jet([0.5j, np.inf, -0.5j], [3 / 2, -1])
print('q =', j.q)
def analyze(self,event) : self.ERR_CODE = ERR_NONE #keep track of whether event has been cut keepEvent = True #event type split if self.is_data == 0 : #GenParticles event.getByLabel(self.genLabel,self.genHandle) if not self.genHandle.isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE GenParticles = self.genHandle.product() #pythia8 nTuple genParticles genPartVars = [] for i in range(len(self.genPartHandles)) : event.getByLabel(self.genPartLabels[i],self.genPartHandles[i]) if not self.genPartHandles[i].isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE genPartVars.append(self.genPartHandles[i].product()) if self.event_type != 4 : keepEvent,add_twice = eventTypeCheck(self.MC_generator,GenParticles,genPartVars,self.event_type) #abovefunction in eventTypeHelper.py if add_twice : self.addTwice[0] = 1 if not keepEvent : return self.ERR_CODE #Trigger information event.getByLabel(self.trigLabel,self.trigHandle) if not self.trigHandle.isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE trigResults = self.trigHandle.product() trigNames = event.object().triggerNames(trigResults) for i in range(trigResults.size()) : s = str(trigNames.triggerName(i)) if s.startswith(MU_TRIG_PATH) : if trigResults.accept(i) : self.mu_trigger[0] = 1 else : self.mu_trigger[0] = 0 if self.el_trigger[0] != 2 : break elif s.startswith(EL_TRIG_PATH) : if trigResults.accept(i) : self.el_trigger[0] = 1 else : self.el_trigger[0] = 0 if self.mu_trigger[0] != 2 : break #PDF information if self.is_data == 0 : event.getByLabel(self.CT10Label,self.CT10Handle) event.getByLabel(self.cteqLabel,self.cteqHandle) event.getByLabel(self.GJRLabel,self.GJRHandle) CT10ws = self.CT10Handle.product() cteqws = self.cteqHandle.product() GJRws = self.GJRHandle.product() for i in range(len(CT10ws)) : self.CT10_weights[i] = CT10ws[i]/CT10ws[0] for i in range(len(cteqws)) : self.cteq_weights[i] = cteqws[i]/cteqws[0] for i in range(len(GJRws)) : self.GJR_weights[i] = GJRws[i]/CT10ws[0] else : for i in range(len(self.CT10_weights)) : self.CT10_weights[i] = 1.0 for i in range(len(self.cteq_weights)) : self.cteq_weights[i] = 1.0 for i in range(len(self.GJR_weights)) : self.GJR_weights[i] = 1.0 #Mother particle and MC truth top assignment if self.is_data == 0 : #MC truth values only relevant for semileptonic qqbar->ttbar q_vec = findInitialQuark(self.MC_generator,GenParticles,genPartVars) #function in eventTypeHelper.py qbar_vec = ROOT.TLorentzVector(q_vec.X(),q_vec.Y(),-1.0*q_vec.Z(),q_vec.E()) MCt_vec, MCtbar_vec = findMCTops(self.MC_generator,GenParticles) #function in eventTypeHelper.py else : #if we don't have the MC truth information, we have to assign which is which later when we do the boost q_vec = ROOT.TLorentzVector(1.0,0.0,sqrt(BEAM_ENERGY*BEAM_ENERGY -1*1),BEAM_ENERGY) qbar_vec = ROOT.TLorentzVector(1.0,0.0,-1.0*sqrt(BEAM_ENERGY*BEAM_ENERGY -1*1),BEAM_ENERGY) MCt_vec = ROOT.TLorentzVector(1.0,0.0,0.0,1.0) MCtbar_vec = ROOT.TLorentzVector(-1.0,0.0,0.0,1.0) self.__fillMC__(q_vec,qbar_vec,MCt_vec,MCtbar_vec) #get all the info from the event #MET metVars = [] for i in range(len(self.metHandles)) : event.getByLabel(self.metLabels[i],self.metHandles[i]) if not self.metHandles[i].isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE metVars.append(self.metHandles[i].product()) met = ROOT.TLorentzVector(); met.SetPtEtaPhiM(metVars[0][0], 0., metVars[0][1], 0.) self.__fillMET__(met) #jets alljets = []; jets = []; jetVars = [] for i in range(len(self.jetHandles)) : event.getByLabel(self.jetLabels[i],self.jetHandles[i]) if not self.jetHandles[i].isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE jetVars.append(self.jetHandles[i].product()) #adjust the jets as per the JEC if self.JES != 'nominal' or self.JER != 'nominal' : for i in range(len(jetVars[0])) : newJet = adjustJEC(jetVars[0][i],jetVars[1][i],jetVars[2][i],jetVars[3][i],jetVars[4][i],jetVars[5][i],jetVars[6][i],jetVars[7][i],self.JES,self.JER) jetVars[0][i].SetPt(newJet.Pt()) jetVars[0][i].SetEta(newJet.Eta()) jetVars[0][i].SetPhi(newJet.Phi()) jetVars[0][i].SetM(newJet.M()) for i in range(len(jetVars[8])) : newJet = adjustJEC(jetVars[8][i],jetVars[9][i],jetVars[10][i],jetVars[11][i],jetVars[12][i],jetVars[13][i],jetVars[14][i],jetVars[15][i],self.JES,self.JER) jetVars[8][i].SetPt(newJet.Pt()) jetVars[8][i].SetEta(newJet.Eta()) jetVars[8][i].SetPhi(newJet.Phi()) jetVars[8][i].SetM(newJet.M()) #build the list of analysis jets for i in range(len(jetVars[0])) : flavor = -1 if len(jetVars)>20 : flavor = jetVars[20][i] newJet = jet(jetVars[0][i],jetVars[8],jetVars[16],jetVars[17],jetVars[18],jetVars[19][i],flavor) jets.append(newJet); alljets.append(newJet) #separate the jets into the top and b candidates jets = selectJets(jets) self.__fillJets__(jets) if len(jets)<2 : return self.ERR_CODE self.sf_btag_eff[0] = jets[1].btagSF self.sf_btag_eff_low[0] = jets[1].btagSFlow self.sf_btag_eff_hi[0] = jets[1].btagSFhigh #muons muons = []; muVars = [] for i in range(len(self.muHandles)) : event.getByLabel(self.muLabels[i],self.muHandles[i]) if not self.muHandles[i].isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE muVars.append(self.muHandles[i].product()) for i in range(len(muVars[0])) : newMuon = muon(muVars[0][i],muVars[1][i],muVars[2][i],muVars[3][i],alljets) muons.append(newMuon) muons.sort(key = lambda x: x.vec.Pt(),reverse=True) #electrons electrons = []; elVars = [] for i in range(len(self.elHandles)) : event.getByLabel(self.elLabels[i],self.elHandles[i]) if not self.elHandles[i].isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE elVars.append(self.elHandles[i].product()) for i in range(len(elVars[0])) : newElectron = electron(elVars[0][i],elVars[1][i],elVars[2][i],elVars[3][i],met,alljets) electrons.append(newElectron) electrons.sort(key = lambda x: x.vec.Pt(),reverse=True) #assign the lepton type and fill the tree if len(muons)<1 and len(electrons)<1 : return self.ERR_CODE self.lep_type = 0 if len(muons)<1 or (len(electrons)>0 and len(muons)>0 and electrons[0].vec.Pt()>muons[0].vec.Pt()) : self.lep_type = 1 self.__fillMuons__(muons) self.__fillElectrons__(electrons) #pileup event.getByLabel(self.pileupLabel,self.pileupHandle) if not self.pileupHandle.isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE pileup = self.pileupHandle.product()[0] MCpileup = 0 if self.is_data == 0 : event.getByLabel(self.MCpileupLabel,self.MCpileupHandle) if not self.MCpileupHandle.isValid() : self.ERR_CODE = ERR_INVALID_HANDLE return self.ERR_CODE MCpileup = self.MCpileupHandle.product()[0] self.pileup[0] = int(pileup); self.MC_pileup[0] = int(MCpileup) # #lepton selection, put nice leptons ahead of high-pT leptons # muons = muonCuts(muons); electrons = electronCuts(electrons) # self.__fillMuons__(muons); self.__fillElectrons__(electrons) #neutrino handling and setup for fit if self.lep_type==0 : met1_vec, met2_vec = setupMET(muons[0].vec,metVars) #function in metHelper.py elif self.lep_type==1 : met1_vec, met2_vec = setupMET(electrons[0].vec,metVars) #function in metHelper.py self.met_pt[0], self.met_eta[0] = met1_vec.Pt(), met1_vec.Eta() self.met_phi[0], self.met_M[0] = met1_vec.Phi(), met1_vec.M() self.nFits[0] = 2 if met1_vec.Pz() == met2_vec.Pz() : self.nFits[0] = 1 #fill the rest of the leptonic fourvectors if self.lep_type==0 : self.__fillLepSide__(muons[0].vec,met1_vec,jets[1].vec) elif self.lep_type==1 : self.__fillLepSide__(electrons[0].vec,met1_vec,jets[1].vec) #event reconstruction with kinematic fit scaledlep = ROOT.TLorentzVector(); scaledmet = ROOT.TLorentzVector() scaledlepb = ROOT.TLorentzVector(); scaledhadt = ROOT.TLorentzVector() if self.lep_type == 0 : scaledlep, scaledmet, scaledlepb, scaledhadt, self.chi2[0] = reconstruct(muons[0].vec,met1_vec,met2_vec,jets) elif self.lep_type == 1 : scaledlep, scaledmet, scaledlepb, scaledhadt, self.chi2[0] = reconstruct(electrons[0].vec,met1_vec,met2_vec,jets) #above function in ttbarReconstructor.py #fill the TTree with the scaled fourvector variables self.__fillScaledFourVecs__(scaledlep,scaledmet,scaledlepb,scaledhadt) #reconstruct the observables using both the scaled and unscaled vectors if self.lep_type == 0 : self.cstar[0], self.x_F[0], self.M[0] = getObservables(muons[0].vec+met1_vec+jets[1].vec,jets[0].vec,self.Q_l[0]) elif self.lep_type == 1 : self.cstar[0], self.x_F[0], self.M[0] = getObservables(electrons[0].vec+met1_vec+jets[1].vec,jets[0].vec,self.Q_l[0]) ( self.cstar_scaled[0], self.x_F_scaled[0], self.M_scaled[0] ) = getObservables(scaledlep+scaledmet+scaledlepb,scaledhadt,self.Q_l[0]) #above function in angleReconstructor.py #MC Truth observable and reweighting calculation if self.is_data==0 : if self.event_type!=4 : ( self.cstar_MC[0],self.x_F_MC[0],self.M_MC[0], self.wg1[0],self.wg2[0],self.wg3[0],self.wg4[0], self.wqs1[0],self.wqs2[0],self.wqa0[0],self.wqa1[0],self.wqa2[0], self.wg1_opp[0],self.wg2_opp[0],self.wg3_opp[0],self.wg4_opp[0], self.wqs1_opp[0],self.wqs2_opp[0], self.wqa0_opp[0],self.wqa1_opp[0],self.wqa2_opp[0] ) = getMCObservables(q_vec,qbar_vec,MCt_vec,MCtbar_vec,self.event_type) #scale factor and reweighting calculations if self.lep_type==0 : meas_lep_pt=muons[0].vec.Pt(); meas_lep_eta=muons[0].vec.Eta() elif self.lep_type==1 : meas_lep_pt=electrons[0].vec.Pt(); meas_lep_eta=electrons[0].vec.Eta() #8TeV numbers self.sf_top_pT[0], self.sf_top_pT_low[0], self.sf_top_pT_hi[0] = self.corrector.getToppT_reweight(MCt_vec,MCtbar_vec,self.Q_l[0]) self.sf_pileup[0], self.sf_pileup_low[0], self.sf_pileup_hi[0] = self.corrector.getpileup_reweight(MCpileup) ( self.sf_lep_ID[0], self.sf_lep_ID_low[0], self.sf_lep_ID_hi[0] ) = self.corrector.getID_eff(pileup,meas_lep_pt,meas_lep_eta,self.lep_type) ( self.sf_trig_eff[0], self.sf_trig_eff_low[0], self.sf_trig_eff_hi[0] ) = self.corrector.gettrig_eff(pileup,meas_lep_pt,meas_lep_eta,self.lep_type) self.__closeout__() #yay! A successful event!
import pygame import sys import random import jet from colors import * pygame.init() screen_size = height, width = 600 , 480 screen = pygame.display.set_mode(screen_size) player = jet.jet() player.init(height,width) clock = pygame.time.Clock() astroids = [] while 1 : for event in pygame.event.get(): if event.type == pygame.QUIT : sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: player.x_change = - 10 if event.key == pygame.K_RIGHT: player.x_change = 10 if event.type == pygame.KEYUP: if event.key == pygame.K_LEFT: player.x_change = - 0 if event.key == pygame.K_RIGHT: player.x_change = 0 screen.fill(GREEN) player.move(screen) pygame.display.flip() clock.tick(50)
