def costheta_CS(pt1, eta1, phi1, pt2, eta2, phi2, l1id): mu1 = TLorentzVector() mu2 = TLorentzVector() Q = TLorentzVector() if (l1id < 0): mu1.SetPtEtaPhiM(pt1, eta1, phi1, 0) mu2.SetPtEtaPhiM(pt2, eta2, phi2, 0) else: mu1.SetPtEtaPhiM(pt2, eta2, phi2, 0) mu2.SetPtEtaPhiM(pt1, eta1, phi1, 0) Q = mu1 + mu2 mu1plus = ((2.0)**(-0.5)) * (mu1.E() + mu1.Pz()) mu1minus = ((2.0)**(-0.5)) * (mu1.E() - mu1.Pz()) mu2plus = ((2.0)**(-0.5)) * (mu2.E() + mu2.Pz()) mu2minus = ((2.0)**(-0.5)) * (mu2.E() - mu2.Pz()) costheta = ((2.0 / Q.Mag()) / ((Q.Mag()**2.0 + Q.Pt()**2.0)**(0.5))) * (mu1plus * mu2minus - mu1minus * mu2plus) return costheta
def process(self, event): '''Smear the beam energy. The two incoming particle energies are smeared under a Gaussian pdf of width sigma relative to the beam energy All outgoing particles are then boosted to the new com system ''' genptcs = getattr(event, self.cfg_ana.gen_particles) sigma = self.cfg_ana.sigma f1 = random.gauss(1, sigma) f2 = random.gauss(1, sigma) beamptcs = [p for p in genptcs if p.status() == 4] pprint.pprint(beamptcs) assert(len(beamptcs) == 2) def smear(ptc, factor): e = ptc.p4().E() * factor pz = math.sqrt(e ** 2 - ptc.m() ** 2) if ptc.p4().Pz() < 0: pz = -pz ptc._tlv.SetPxPyPzE( ptc.p4().Px(), ptc.p4().Py(), pz, e) newcom = TLorentzVector() for ptc, factor in zip(beamptcs, [f1, f2]): smear(ptc, factor) ptc.p4().Print() print ptc.m() newcom += ptc.p4() print 'new com:' newcom.Print() boost = newcom.BoostVector() stablep4_before = TLorentzVector() stablep4 = TLorentzVector() for p in genptcs: if p in beamptcs: continue if p.status() == 1: stablep4_before += p._tlv # p._tlv.Boost(boost) p._tlv.Boost(boost) if p.status() == 1: stablep4 += p._tlv pprint.pprint(beamptcs) print newcom.E(), newcom.Pz() print stablep4.E(), stablep4.Pz() print stablep4_before.E(), stablep4_before.Pz() boost.Print()
def make_LHEparticle(p, id=None): if id != None: fv = TLorentzVector() try: m = p.Mass except AttributeError: m = 0 try: pT = p.PT except AttributeError: pT = p.MET fv.SetPtEtaPhiM(pT, p.Eta, p.Phi, m) try: status = p.Status except AttributeError: status = 1 _dict={'id':id,'status':status,\ 'mother1':0,'mother2':0,'color1':0,'color2':0,\ 'px':fv.Px(),'py':fv.Py(),'pz':fv.Pz(),'e':fv.Energy(),'m':fv.M(),'lifetime':0,'spin':0} lhepart = lhef.LHEParticle(**_dict) return lhepart else: print("id must be specified") pass
def jet_Lorentz_4v(jet): for n in np.arange(len(jet)): if np.sum(jet[n,:]) != 0: v = TLorentzVector(0, 0, 0, 0) v.SetPtEtaPhiM(jet[n,0], jet[n,1], jet[n,2], jet[n,3]) jet[n,:] = v.E(), v.Px(), v.Py(), v.Pz() return jet
def computeProcessedFeatures(muon1_p4, muon2_p4, unpairedMuon_p4, jpsi_p4, bc_p4): if ( bc_p4.M() != 0): bcPtCorrected = (bcPdgMass * bc_p4.Pt())/ bc_p4.M() else: bcPtCorrected = bc_p4.Pt() muonsSystem_p4 = muon1_p4 + muon2_p4 + unpairedMuon_p4 bcCorrected_p4 = TLorentzVector() bcCorrected_p4.SetPtEtaPhiM(bcPtCorrected, muonsSystem_p4.Eta(), muonsSystem_p4.Phi(), #bc_p4.M()) bcPdgMass) boostToBcCorrectedRestFrame = -bcCorrected_p4.BoostVector() #boostToJpsiRestFrame = -(muon1_p4+muon2_p4).BoostVector() boostToJpsiRestFrame = -jpsi_p4.BoostVector() unpairedMuonBoostedToBcCorrectedRestFrame_p4 = TLorentzVector() unpairedMuonBoostedToBcCorrectedRestFrame_p4.SetPtEtaPhiM(unpairedMuon_p4.Pt(), unpairedMuon_p4.Eta(), unpairedMuon_p4.Phi(), unpairedMuon_p4.M()) unpairedMuonBoostedToBcCorrectedRestFrame_p4.Boost(boostToBcCorrectedRestFrame) unpairedMuonBoostedToJpsiRestFrame_p4 = TLorentzVector() unpairedMuonBoostedToJpsiRestFrame_p4.SetPtEtaPhiM(unpairedMuon_p4.Pt(), unpairedMuon_p4.Eta(), unpairedMuon_p4.Phi(), unpairedMuon_p4.M()) unpairedMuonBoostedToJpsiRestFrame_p4.Boost(boostToJpsiRestFrame) nn_energyBcRestFrame = unpairedMuonBoostedToBcCorrectedRestFrame_p4.E() #nn_missMass2 = (bcCorrected_p4 - muon1_p4 - muon2_p4 - unpairedMuon_p4).M2() nn_missMass2 = (bcCorrected_p4 - jpsi_p4 - unpairedMuon_p4).M2() #nn_q2 = (bc_p4 - muon1_p4 - muon2_p4).M2() nn_q2 = (bcCorrected_p4 - jpsi_p4).M2() #nn_missPt = bcCorrected_p4.Pt() - muon1_p4.Pt() - muon2_p4.Pt() - unpairedMuon_p4.Pt() nn_missPt = bcCorrected_p4.Pt() - jpsi_p4.Pt() - unpairedMuon_p4.Pt() nn_energyJpsiRestFrame = unpairedMuonBoostedToJpsiRestFrame_p4.E() #nn_varPt = (muon1_p4 + muon2_p4).Pt() - unpairedMuon_p4.Pt() nn_varPt = jpsi_p4.Pt() - unpairedMuon_p4.Pt() nn_deltaRMu1Mu2 = muon1_p4.DeltaR(muon2_p4) nn_unpairedMuPhi = unpairedMuon_p4.Phi() nn_unpairedMuPt = unpairedMuon_p4.Pt() nn_unpairedMuEta = unpairedMuon_p4.Eta() featuresEntry = np.array([ [bcCorrected_p4.Pt()], [bcCorrected_p4.Px()], [bcCorrected_p4.Py()], [bcCorrected_p4.Pz()], [bcCorrected_p4.E()], [nn_energyBcRestFrame], [nn_missMass2], [nn_q2], [nn_missPt], [nn_energyJpsiRestFrame], [nn_varPt], [nn_deltaRMu1Mu2], [nn_unpairedMuPhi], [nn_unpairedMuPt], [nn_unpairedMuEta]], dtype=np.double) return featuresEntry
def momentum_aftr_boost(df, args): #args must have 4 elements xyzt or pxpypzE px, py, pz = getXYZ(df, args) E = DfToNp(df[[args[3]]].dropna(axis=0)) l = TLorentzVector() with np.nditer([px, py, pz, E, None, None, None, None]) as it: for pi, pj, pk, el, pm, pn, po, eq in it: l.SetPxPyPzE(pi, pj, pk, el) bi = pi / el l.Boost(-bi, 0, 0) pm[...] = l.Px() pn[...] = l.Py() po[...] = l.Pz() eq[...] = l.E() return (it.operands[4], it.operands[5], it.operands[6], it.operands[7])
def GeneratePrimaries(self, anEvent): global debug, nevTot t_0 = time.time() npart = 0 while npart == 0: myPythia.GenerateEvent() nevTot += 1 myTimer['pythia'] += time.time() - t_0 # pythia interaction happens at 0,0,0 #x = rnr.Uniform(-3.,3.) #y = rnr.Uniform(-3.,3.) # leave this smearing for later # create new primaries and set them to the vertex particles = myPythia.GetListOfParticles() z = rnr.Exp(10 * cm) - 50. * m # tungsten interaction length ztarget = G4ThreeVector(0 * cm, 0 * cm, z) vertex = G4PrimaryVertex(ztarget, 0.) v = TLorentzVector() for p in particles: if p.GetStatusCode() != 1: continue pid = p.GetPdgCode() if tauOnly and abs(pid) != 16: continue mkey = p.GetMother(0) + 1 mother = myPythia.GetParticle(mkey) if JpsiMainly and abs( pid) != 13 and mother.GetPdgCode() != 443: continue qed = pid in qedlist # use cut only for photons, leptons/neutrinos, protons and neutrons p.Momentum(v) Ekin = (v.E() - v.M()) if Ekin * GeV < ecut and (qed or allPart): continue G4particle = G4PrimaryParticle(pid) G4particle.Set4Momentum(v.Px() * GeV, v.Py() * GeV, v.Pz() * GeV, v.E() * GeV) # store mother ID curPid = p.GetPdgCode() + 10000 # make it positive moPid = mother.GetPdgCode() + 10000 w = curPid + moPid * 100000 G4particle.SetWeight(w) vertex.SetPrimary(G4particle) npart += 1 # if debug: myPythia.EventListing() anEvent.AddPrimaryVertex(vertex) if debug: print 'new event at ', ztarget.z / m myTimer['geant4_conv'] += time.time() - t_0
def Boosted_Angle(pt1, eta1, phi1, pt2, eta2, phi2, ptz, etaz, phiz, mass): mu1 = TLorentzVector() mu2 = TLorentzVector() zb = TLorentzVector() mu1.SetPtEtaPhiM(pt1, eta1, phi1, 0) mu2.SetPtEtaPhiM(pt2, eta2, phi2, 0) angle = mu1.Angle(mu2.Vect()) zb.SetPtEtaPhiM(ptz, etaz, phiz, mass) angle_Z1 = zb.Angle(mu1.Vect()) angle_Z2 = zb.Angle(mu2.Vect()) mu1.Boost(-zb.Px() / zb.E(), -zb.Py() / zb.E(), -zb.Pz() / zb.E()) mu2.Boost(-zb.Px() / zb.E(), -zb.Py() / zb.E(), -zb.Pz() / zb.E()) angleBoost = mu1.Angle(mu2.Vect()) angleBoost_Z1 = zb.Angle(mu1.Vect()) angleBoost_Z2 = zb.Angle(mu2.Vect()) #print "******&&&&******", angle, angleBoost return [angleBoost, angle, angleBoost_Z1, angle_Z1, angle_Z2]
def GeneratePrimaries(self, anEvent): global debug, nevTot t_0 = time.time() npart = 0 while npart == 0: myPythia.GenerateEvent() nevTot += 1 myTimer['pythia'] += time.time() - t_0 # pythia interaction happens at 0,0,0 #x = rnr.Uniform(-3.,3.) #y = rnr.Uniform(-3.,3.) # leave this smearing for later pos = G4ThreeVector(0 * cm, 0 * cm, -50 * m) vertex = G4PrimaryVertex(pos, 0.) # create new primaries and set them to the vertex particles = myPythia.GetListOfParticles() for p in particles: if p.GetStatusCode() != 1: continue pid = p.GetPdgCode() if tauOnly and abs(pid) != 16: continue if pid in notWanted: continue G4particle = G4PrimaryParticle(pid) v = TLorentzVector() p.Momentum(v) if v.E() * GeV < ecut: continue G4particle.Set4Momentum(v.Px() * GeV, v.Py() * GeV, v.Pz() * GeV, v.E() * GeV) vertex.SetPrimary(G4particle) # store mother ID mkey = p.GetMother(0) + 1 mother = myPythia.GetParticle(mkey) curPid = p.GetPdgCode() + 10000 # make it positive moPid = mother.GetPdgCode() + 10000 w = curPid + moPid * 100000 G4particle.SetWeight(w) npart += 1 if tauOnly and debug: myPythia.EventListing() anEvent.AddPrimaryVertex(vertex) myTimer['geant4_conv'] += time.time() - t_0
def print_vec(self, vec): print "theta vec:", TMath.Pi() - vec.Theta() print return print "pxyz:", vec.Px(), vec.Py(), vec.Pz() print "en, phi:", vec.E(), vec.Phi() print v3 = vec.Vect() print "vxyz:", v3.x(), v3.y(), v3.z() print "theta v3: ", TMath.Pi() - v3.Theta() print theta_add = 1e-5 v3.SetTheta(v3.Theta() - theta_add) print "vxyz:", v3.x(), v3.y(), v3.z() print "theta v3: ", TMath.Pi() - v3.Theta() print vec2 = TLorentzVector(vec) vec3 = TLorentzVector(vec) vec.SetVect(v3) print "theta vec:", TMath.Pi() - vec.Theta() print "pxyz:", vec.Px(), vec.Py(), vec.Pz() print "en, phi:", vec.E(), vec.Phi() print vec2.SetTheta(vec2.Theta() - theta_add) print "theta vec:", TMath.Pi() - vec2.Theta() print "pxyz:", vec2.Px(), vec2.Py(), vec2.Pz() print "en, phi:", vec2.E(), vec2.Phi() print print "Delta theta, en, phi", vec3.Theta() - vec.Theta(), vec3.E( ) - vec.E(), vec3.Phi() - vec.Phi() print "Delta theta, en, phi", vec3.Theta() - vec2.Theta(), vec3.E( ) - vec2.E(), vec3.Phi() - vec2.Phi()
tmp_unrotated_Px = tmp_unrotated_PxPyPz_vec[0] tmp_unrotated_Py = tmp_unrotated_PxPyPz_vec[1] tmp_unrotated_Pz = tmp_unrotated_PxPyPz_vec[2] Global_4vec = ROOT.TLorentzVector() Global_4vec.SetPxPyPzE(tmp_unrotated_Px, tmp_unrotated_Py, tmp_unrotated_Pz, tmp_E) return Global_4vec ##### test ##### v = TLorentzVector() v.SetPxPyPzE(-3.6740152498, -2.79192430698, 21.6557548444, 22.1777103583) print "Px,Py,Pz,E,M:", v.Px(), v.Py(), v.Pz(), v.E(), v.M() print "tau_orig_theta, tau_orig_phi:", v.Theta(), v.Phi() tau_orig_theta_test = v.Theta() tau_orig_phi_test = v.Phi() toPrint = rotateToVisTauMomPointsInEtaEqualsZero(tau_orig_theta_test, tau_orig_phi_test, v) # print toPrint newPx = toPrint.Px() newPy = toPrint.Py() newPz = toPrint.Pz() newE = toPrint.E() newM = toPrint.M() newTheta = toPrint.Theta()
def PruneGenr8File(fname_in, fname_out, E_GAMMA_VARY, MIN_VAL, MAX_VAL, NACCEPTED, MAX_EVENTS, verbose=False): # print "input genr8 file: " + fname_in # print "output file: " + fname_out counter = 1 line1_out = "" #Run and event info line2_out = "1 1 0.000000\n" #Gamma ID info line3_out = "" #Gamma P4 info for line in open(fname_in, 'r'): if (NACCEPTED >= MAX_EVENTS): # print "Done generating this point!" break if (counter % 11 == 1): #Event info value_in_line = 1 run = "" event = "" for value in line.split(): if (value_in_line == 1): run = value if (value_in_line == 2): event = value if (verbose and value_in_line == 1): print "Run " + value if (verbose and value_in_line == 2): print "Event " + value if (verbose and value_in_line == 3): print "NParticles " + value value_in_line += 1 # line1_out = run + " " + event + " " + "1\n" line1_out = run + " " + str(NACCEPTED + 1) + " " + "1\n" if (counter % 11 == 2): #Gamma1 info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 if (counter % 11 == 3): #Gamma1 p4 value_in_line = 1 p4_string = line.split() p4_gam1 = TLorentzVector(float(p4_string[1]), float(p4_string[2]), float(p4_string[3]), float(p4_string[4])) for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 if (counter % 11 == 4): #Gamma2 info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 if (counter % 11 == 5): #Gamma2 p4 value_in_line = 1 p4_string = line.split() p4_gam2 = TLorentzVector(float(p4_string[1]), float(p4_string[2]), float(p4_string[3]), float(p4_string[4])) for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 if (counter % 11 == 6): #Pi+ info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 if (counter % 11 == 7): #Pi+ p4 value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 if (counter % 11 == 8): #Pi- info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 if (counter % 11 == 9): #Pi- p4 value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 if (counter % 11 == 10): #proton info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 if (counter % 11 == 0): #proton p4 value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 #Finished with this event. Check if one of the two photons passes cuts. #If so, save event and increment NACCEPTED if (verbose): print "Cut on energy? " + str(E_GAMMA_VARY) print "Cut on theta? " + str(not E_GAMMA_VARY) print "Min value: " + str(MIN_VAL) print "Max value: " + str(MAX_VAL) print "Gamma1 energy: " + str(p4_gam1.E()) print "Gamma2 energy: " + str(p4_gam2.E()) GAMMA1_PASSES = False if (E_GAMMA_VARY and MIN_VAL < p4_gam1.E() and p4_gam1.E() < MAX_VAL and p4_gam2.E() > E_SPECTATOR_MIN): GAMMA1_PASSES = True if (not E_GAMMA_VARY and MIN_VAL < p4_gam1.Theta() * 180 / 3.14159 and p4_gam1.Theta() * 180 / 3.14159 < MAX_VAL): GAMMA1_PASSES = True if (verbose and GAMMA1_PASSES): print "Gamma1 passes: " print "Min value: " + str(MIN_VAL) print "Max value: " + str(MAX_VAL) print "Gamma1 energy: " + str(p4_gam1.E()) if (GAMMA1_PASSES): with open(fname_out, "a") as myfile: line3_out = " 0 " + str(p4_gam1.Px()) + " " + str( p4_gam1.Py()) + " " + str(p4_gam1.Pz()) + " " + str( p4_gam1.E()) + "\n" myfile.write(line1_out) myfile.write(line2_out) myfile.write(line3_out) NACCEPTED += 1 GAMMA2_PASSES = False if (E_GAMMA_VARY and MIN_VAL < p4_gam2.E() and p4_gam2.E() < MAX_VAL and p4_gam1.E() > E_SPECTATOR_MIN): GAMMA2_PASSES = True if (not E_GAMMA_VARY and MIN_VAL < p4_gam2.Theta() * 180 / 3.14159 and p4_gam2.Theta() * 180 / 3.14159 < MAX_VAL): GAMMA2_PASSES = True if (verbose and GAMMA2_PASSES): print "Gamma2 passes: " print "Min value: " + str(MIN_VAL) print "Max value: " + str(MAX_VAL) print "Gamma2 energy: " + str(p4_gam2.E()) if (GAMMA2_PASSES): with open(fname_out, "a") as myfile: line3_out = " 0 " + str(p4_gam2.Px()) + " " + str( p4_gam2.Py()) + " " + str(p4_gam2.Pz()) + " " + str( p4_gam2.E()) + "\n" myfile.write(line1_out) myfile.write(line2_out) myfile.write(line3_out) NACCEPTED += 1 if (verbose): print "\n" # with open(fname_out, "a") as myfile: # myfile.write(line1_out) # myfile.write(line2_out) counter += 1 # if(counter>200): break return NACCEPTED
class particle: #_____________________________________________________________________________ def __init__(self, pdg): #particle Lorentz vector self.vec = TLorentzVector() #index in particle list self.idx = 0 #status code self.stat = 0 #pdg code self.pdg = pdg #particle database for pass and codes self.pdgdat = TDatabasePDG.Instance() #mass, GeV self.mass = self.pdgdat.GetParticle(self.pdg).Mass() #parent particle id self.parent_id = 0 #vertex coordinates, mm self.vx = 0. self.vy = 0. self.vz = 0. #precision for momentum and energy self.pxyze_prec = 6 #_____________________________________________________________________________ def write(self, out): #put event output line #index, status and pdg out.write("{0:10d}{1:11d}{2:11d}".format(self.idx, self.stat, self.pdg)) #parent particle id out.write("{0:11d}".format(self.parent_id)) #placeholder for daughter indices out.write(" 0 0") #px, py, pz, energy pxyze_form = "{0:16."+str(self.pxyze_prec)+"f}" out.write( pxyze_form.format( self.vec.Px() ) ) out.write( pxyze_form.format( self.vec.Py() ) ) out.write( pxyze_form.format( self.vec.Pz() ) ) out.write( pxyze_form.format( self.vec.E() ) ) #mass out.write( "{0:16.6f}".format(self.mass) ) #out.write(" 0.000000") #vertex out.write( "{0:16.6f}".format(self.vx) ) out.write( "{0:16.6f}".format(self.vy) ) out.write( "{0:16.6f}".format(self.vz) ) #end of line out.write("\n") #_____________________________________________________________________________ def write_tx(self, track_list): #output line in TX format #Geant code and momentum lin = "TRACK: "+str(self.pdgdat.ConvertPdgToGeant3(self.pdg)) pxyz_form = " {0:."+str(self.pxyze_prec)+"f}" lin += pxyz_form.format( self.vec.Px() ) lin += pxyz_form.format( self.vec.Py() ) lin += pxyz_form.format( self.vec.Pz() ) #track id lin += " " + str(len(track_list)) #start and stop vertex and pdg lin += " 1 0 " + str(self.pdg) track_list.append(lin) #_____________________________________________________________________________ def write_tparticle(self, particles, ipos): #write to TParticle clones array p = particles.ConstructedAt(ipos) p.SetMomentum(self.vec) p.SetPdgCode(self.pdg) p.SetProductionVertex(self.vx, self.vy, self.vz, 0)
b_had.SetPtEtaPhiM( tree.GetLeaf("Particle.PT").GetValue(indices['b_had']), tree.GetLeaf("Particle.Eta").GetValue(indices['b_had']), tree.GetLeaf("Particle.Phi").GetValue(indices['b_had']), tree.GetLeaf("Particle.Mass").GetValue(indices['b_had'])) b_lep.SetPtEtaPhiM( tree.GetLeaf("Particle.PT").GetValue(indices['b_lep']), tree.GetLeaf("Particle.Eta").GetValue(indices['b_lep']), tree.GetLeaf("Particle.Phi").GetValue(indices['b_lep']), tree.GetLeaf("Particle.Mass").GetValue(indices['b_lep'])) ############################################################## # CUTS USING PARTICLE LEVEL OBJECTS if (t_had.Pz() == 0.) or (t_had.M() != t_had.M()): print("Invalid t_had values, P_z = {0}, M = {1}".format( t_had.Pz(), t_had.M())) continue if (t_lep.Pz() == 0.) or (t_lep.M() != t_lep.M()): print("Invalid t_lep values, P_z = {0}, M = {1}".format( t_lep.Pz(), t_lep.M())) continue # if W_had.Pt() < 20: # print("Invalid W_had.pt: {}".format(W_had.Pt())) # continue # if W_lep.Pt() < 20: # print("Invalid W_lep.pt: {}".format(W_lep.Pt())) # continue # if b_had.Pt() < 20: # print("Invalid b_had.pt: {}".format(b_had.Pt()))
def PruneGenr8File(fname_in, fname_out, e_gamma_curr, theta_curr, verbose=False): # print "directory: " + os.getcwd() # print "input genr8 file: " + fname_in # print "output file: " + fname_out counter = 1 line1_out = "" #Run and event info line2_out = "" #Gamma ID info line3_out = "" #Gamma P4 info line4_out = "" #Proton ID info line5_out = "" #Proton P4 info line6_out = "" #Pi+ ID info line7_out = "" #Pi+ P4 info line8_out = "" #Pi- ID info line9_out = "" #Pi- P4 info rand = TRandom3(int(e_gamma_curr * 1000.)) p4_proton = TLorentzVector() for line in open(fname_in, 'r'): if (counter % 9 == 1): #Event info value_in_line = 1 run = "" event = "" for value in line.split(): if (value_in_line == 1): run = value if (value_in_line == 2): event = value if (verbose and value_in_line == 1): print "Run " + value if (verbose and value_in_line == 2): print "Event " + value if (verbose and value_in_line == 3): print "NParticles " + value value_in_line += 1 line1_out = run + " " + event + " " + "4\n" if (counter % 9 == 2): #Pi0 info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 if (counter % 9 == 3): #Pi0 p4 value_in_line = 1 p4_string = line.split() p4_gam1 = TLorentzVector(float(p4_string[1]), float(p4_string[2]), float(p4_string[3]), float(p4_string[4])) for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 if (counter % 9 == 4): #Pi+ info value_in_line = 1 line2_str = line for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 line6_out = "3 8 0.13957\n" if (counter % 9 == 5): #Pi+ p4 value_in_line = 1 p4_string = line.split() p4_pipl = TLorentzVector(float(p4_string[1]), float(p4_string[2]), float(p4_string[3]), float(p4_string[4])) for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 line7_out = " 1 " + str(p4_pipl.Px()) + " " + str( p4_pipl.Py()) + " " + str(p4_pipl.Pz()) + " " + str( p4_pipl.E()) + "\n" if (counter % 9 == 6): #Pi- info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 line8_out = "4 9 0.13957\n" if (counter % 9 == 7): #Pi- p4 value_in_line = 1 p4_string = line.split() p4_pim = TLorentzVector(float(p4_string[1]), float(p4_string[2]), float(p4_string[3]), float(p4_string[4])) for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 line9_out = " -1 " + str(p4_pim.Px()) + " " + str( p4_pim.Py()) + " " + str(p4_pim.Pz()) + " " + str( p4_pim.E()) + "\n" if (counter % 9 == 8): #proton info value_in_line = 1 for value in line.split(): if (verbose and value_in_line == 1): print "Particle number in event: " + value if (verbose and value_in_line == 2): print "Particle enum value " + value if (verbose and value_in_line == 3): print "Particle mass " + value value_in_line += 1 line4_out = "2 14 0.938272\n" if (counter % 9 == 0): #proton p4 value_in_line = 1 p4_string = line.split() p4_proton = TLorentzVector(float(p4_string[1]), float(p4_string[2]), float(p4_string[3]), float(p4_string[4])) p4_proton_boost_px = p4_proton.Px() p4_proton_boost_py = p4_proton.Py() p4_proton_boost_pz = p4_proton.Pz() p4_proton_boost_E = sqrt( abs(p4_proton_boost_px**2 + p4_proton_boost_py**2 + p4_proton_boost_pz**2 - 0.938272**2)) p4_proton_boost = TLorentzVector(p4_proton_boost_px, p4_proton_boost_py, p4_proton_boost_pz, p4_proton_boost_E) for value in line.split(): if (verbose and value_in_line == 1): print "Charge: " + value if (verbose and value_in_line == 2): print "Px " + value if (verbose and value_in_line == 3): print "Py " + value if (verbose and value_in_line == 4): print "Pz " + value if (verbose and value_in_line == 5): print "E " + value value_in_line += 1 line5_out = " 1 " + str(p4_proton.Px()) + " " + str( p4_proton.Py()) + " " + str(p4_proton.Pz()) + " " + str( p4_proton.E()) + "\n" my_phi = p4_proton_boost.Phi() + 3.14159 #Opposite proton my_theta = theta_curr * (3.14159 / 180.) gamma_px = str(e_gamma_curr * TMath.Sin(my_theta) * TMath.Cos(my_phi)) gamma_py = str(e_gamma_curr * TMath.Sin(my_theta) * TMath.Sin(my_phi)) gamma_pz = str(e_gamma_curr * TMath.Cos(my_theta)) line2_out = "1 1 0\n" line3_out = " 0 " + gamma_px + " " + gamma_py + " " + gamma_pz + " " + str( e_gamma_curr) + "\n" p4_gam_fcal = TLorentzVector(float(gamma_px), float(gamma_py), float(gamma_pz), e_gamma_curr) # print "Beam photon: " + str( (p4_gam_fcal+p4_proton_boost).E()) with open(fname_out, "a") as myfile: myfile.write(line1_out) myfile.write(line2_out) myfile.write(line3_out) myfile.write(line4_out) myfile.write(line5_out) myfile.write(line6_out) myfile.write(line7_out) myfile.write(line8_out) myfile.write(line9_out) counter += 1 # if(counter>200): break return
for event in range(pred.shape[0]): tau_lorentz_no_neutrino = TLorentzVector() # firedCount = 0 for index in range(0, tau_features_test.shape[1], 3): lorentz = TLorentzVector() lorentz.SetPtEtaPhiM((tau_features_test[event][index]), (tau_features_test[event][index + 1]), (tau_features_test[event][index + 2]), (0.139)) tau_lorentz_no_neutrino += lorentz print("I fired") #firedCount += 1 tofill['tau_pt_no_neutrino'] = tau_lorentz_no_neutrino.Pt() print("tau_lorentz_neutrino.Px()", tau_lorentz_no_neutrino.Px()) print("tau_lorentz_no_neutrino.Py()", tau_lorentz_no_neutrino.Py()) print("tau_lorentz_no_neutrino.Pz()", tau_lorentz_no_neutrino.Pz()) print("tau_lorentz_no_neutrino.E()", tau_lorentz_no_neutrino.E()) tofill['tau_eta_no_neutrino'] = tau_lorentz_no_neutrino.Eta() tofill['tau_phi_no_neutrino'] = tau_lorentz_no_neutrino.Phi() tofill['tau_mass_no_neutrino'] = tau_lorentz_no_neutrino.M() print("tau_mass_no_neutrino", tau_lorentz_no_neutrino.M()) print("tau_eta_no_neutrino", tau_lorentz_no_neutrino.Eta()) tau_lorentz = TLorentzVector() tau_lorentz.SetPxPyPzE( tau_lorentz_no_neutrino.Px(), tau_lorentz_no_neutrino.Py(), tau_lorentz_no_neutrino.Pz(), tau_lorentz_no_neutrino.E(), ) print("tau_lorentz.Px()", tau_lorentz.Px())
def main(): ########################################################################################## ########################################################################################## ########################################################################################## ### read fits to root file # fitsEx = GetFits() svd0Seed = ROOT.std.vector( float )() svd1Seed = ROOT.std.vector( float )() svd2Seed = ROOT.std.vector( float )() chi2xzSeed = ROOT.std.vector( float )() chi2yzSeed = ROOT.std.vector( float )() residxzSeed = ROOT.std.vector( float )() residyzSeed = ROOT.std.vector( float )() issigSeed = ROOT.std.vector( int )() iGenMatch = ROOT.std.vector( int )() x1Seed = ROOT.std.vector( float )() y1Seed = ROOT.std.vector( float )() z1Seed = ROOT.std.vector( float )() x2Seed = ROOT.std.vector( float )() y2Seed = ROOT.std.vector( float )() z2Seed = ROOT.std.vector( float )() x3Seed = ROOT.std.vector( float )() y3Seed = ROOT.std.vector( float )() z3Seed = ROOT.std.vector( float )() x4Seed = ROOT.std.vector( float )() y4Seed = ROOT.std.vector( float )() z4Seed = ROOT.std.vector( float )() pxSeed = ROOT.std.vector( float )() pySeed = ROOT.std.vector( float )() pzSeed = ROOT.std.vector( float )() eSeed = ROOT.std.vector( float )() pxGen = ROOT.std.vector( float )() pyGen = ROOT.std.vector( float )() pzGen = ROOT.std.vector( float )() eGen = ROOT.std.vector( float )() qGen = ROOT.std.vector( float )() iGen = ROOT.std.vector( int )() tF = TFile("../data/root/seeds_"+proc+".root","RECREATE") tF.cd() tT = TTree("seeds","seeds") tT.Branch('svd0Seed',svd0Seed) tT.Branch('svd1Seed',svd1Seed) tT.Branch('svd2Seed',svd2Seed) tT.Branch('chi2xzSeed',chi2xzSeed) tT.Branch('chi2yzSeed',chi2yzSeed) tT.Branch('residxzSeed',residxzSeed) tT.Branch('residyzSeed',residyzSeed) tT.Branch('issigSeed',issigSeed) tT.Branch('iGenMatch',iGenMatch) tT.Branch('x1Seed',x1Seed) tT.Branch('y1Seed',y1Seed) tT.Branch('z1Seed',z1Seed) tT.Branch('x2Seed',x2Seed) tT.Branch('y2Seed',y2Seed) tT.Branch('z2Seed',z2Seed) tT.Branch('x3Seed',x3Seed) tT.Branch('y3Seed',y3Seed) tT.Branch('z3Seed',z3Seed) tT.Branch('x4Seed',x4Seed) tT.Branch('y4Seed',y4Seed) tT.Branch('z4Seed',z4Seed) tT.Branch('pxSeed',pxSeed) tT.Branch('pySeed',pySeed) tT.Branch('pzSeed',pzSeed) tT.Branch('eSeed',eSeed) tT.Branch('pxGen',pxGen) tT.Branch('pyGen',pyGen) tT.Branch('pzGen',pzGen) tT.Branch('eGen',eGen) tT.Branch('qGen',qGen) tT.Branch('iGen',iGen) histos = { "h_residuals_xz_sig": TH1D("residuals_xz_sig",";residuals_{xz};Tracks", 500,0,0.5), "h_residuals_yz_sig": TH1D("residuals_yz_sig",";residuals_{yz};Tracks", 500,0,500), "h_residuals_xz_bkg": TH1D("residuals_xz_bkg",";residuals_{xz};Tracks", 500,0,0.5), "h_residuals_yz_bkg": TH1D("residuals_yz_bkg",";residuals_{yz};Tracks", 500,0,500), "h_svd_dd0_sig": TH1D("svd_dd0_sig",";svd_{dd0};Tracks", 500,21,24), "h_svd_dd0_bkg": TH1D("svd_dd0_bkg",";svd_{dd0};Tracks", 500,21,24), "h_svd_dd1_sig": TH1D("svd_dd1_sig",";svd_{dd1};Tracks", 500,0,0.1), "h_svd_dd1_bkg": TH1D("svd_dd1_bkg",";svd_{dd1};Tracks", 500,0,0.1), "h_svd_dd2_sig": TH1D("svd_dd2_sig",";svd_{dd2};Tracks", 500,0,0.05), "h_svd_dd2_bkg": TH1D("svd_dd2_bkg",";svd_{dd2};Tracks", 500,0,0.05), "h_prob_xz_sig": TH1D("prob_xz_sig",";prob_{xz};Tracks", 500,0,1.0), "h_prob_yz_sig": TH1D("prob_yz_sig",";prob_{yz};Tracks", 500,0,1.0), "h_prob_xz_bkg": TH1D("prob_xz_bkg",";prob_{xz};Tracks", 500,0,1.0), "h_prob_yz_bkg": TH1D("prob_yz_bkg",";prob_{yz};Tracks", 500,0,1.0), "h_chi2ndf_xz_sig": TH1D("chi2ndf_xz_sig",";chi2ndf_{xz};Tracks", 500,0,0.001), "h_chi2ndf_yz_sig": TH1D("chi2ndf_yz_sig",";chi2ndf_{yz};Tracks", 500,0,0.001), "h_chi2ndf_xz_bkg": TH1D("chi2ndf_xz_bkg",";chi2ndf_{xz};Tracks", 500,0,0.001), "h_chi2ndf_yz_bkg": TH1D("chi2ndf_yz_bkg",";chi2ndf_{yz};Tracks", 500,0,0.001), "h_seed_resE" : TH1D("seed_resE", ";(E_{seed}-E_{gen})/E_{gen};Tracks", 100,-3,+3), "h_seed_resPz": TH1D("seed_resPz",";(Pz_{seed}-Pz_{gen})/Pz_{gen};Tracks", 100,-3,+3), "h_seed_resPy": TH1D("seed_resPy",";(Py_{seed}-Py_{gen})/Py_{gen};Tracks", 100,-10,+10), "h_seed_resE_vs_x" : TH2D("seed_resE_vs_x", ";x;(E_{seed}-E_{gen})/E_{gen};Tracks", 100,detXmin,detXmax, 100,-5,+5), "h_seed_resPy_vs_x" : TH2D("seed_resPy_vs_x", ";x;(Py_{seed}-Py_{gen})/Py_{gen};Tracks", 100,detXmin,detXmax, 100,-10,+10), "h_N_sigacc": TH1D("N_sigacc", ";Track multiplicity;Events", 40,30,190), "h_N_all_seeds": TH1D("N_all_seeds", ";Track multiplicity;Events", 40,30,190), "h_N_matched_seeds": TH1D("N_matched_seeds", ";Track multiplicity;Events", 40,30,190), "h_N_good_seeds": TH1D("N_good_seeds", ";Track multiplicity;Events", 40,30,190), "h_seeding_score": TH1D("h_seeding_score", ";N_{seeds}^{matched}/N_{signa}^{in.acc} [%];Events", 20,91,101), "h_seeding_pool": TH1D("h_seeding_pool", ";N_{seeds}^{all}/N_{signa}^{in.acc} [%];Events", 50,90,590), } sidesarr = getLogicSidesArr() pdfname = "../output/pdf/seedingdemo_"+proc+".pdf" intfile = TFile("../data/root/rec_"+proc+".root","READ") intree = intfile.Get("res") nevents = intree.GetEntries() print("with %d events" % nevents) nmax = 100000 n=0 ### init n for event in intree: Nsigall = 0 Nsigacc = 0 Nseeds = 0 Nmatched = 0 Ngood = 0 ## clear the output vectors svd0Seed.clear() svd1Seed.clear() svd2Seed.clear() chi2xzSeed.clear() chi2yzSeed.clear() residxzSeed.clear() residyzSeed.clear() issigSeed.clear() iGenMatch.clear() x1Seed.clear() y1Seed.clear() z1Seed.clear() x2Seed.clear() y2Seed.clear() z2Seed.clear() x3Seed.clear() y3Seed.clear() z3Seed.clear() x4Seed.clear() y4Seed.clear() z4Seed.clear() pxSeed.clear() pySeed.clear() pzSeed.clear() eSeed.clear() pxGen.clear() pyGen.clear() pzGen.clear() eGen.clear() qGen.clear() iGen.clear() ### start the loop if(n>nmax): break ### draw? dodraw = (n<=NeventsToDraw) ### container for all clusters allpointsEside = initpoints() allpointsPside = initpoints() ## clusters' vectors are always written out (even if empty) for all gen tracks! ## each generated track in the vector always has 4 clusters accessed via TPolyMarker3D::GetPoint() for i in range(event.polm_clusters.size()): ############################################################### if(proc=="bppp"): if(sides=="e+" and event.qgen[i]<0): continue ## only positrons if(sides=="e-" and event.qgen[i]>0): continue ## only electrons if(proc=="trident" and event.qgen[i]<0): continue ## only positrons ############################################################### Nsigall += 1 wgt = event.wgtgen[i] pgen = event.pgen[i] ### cut on acceptance if(event.acctrkgen[i]!=1): continue Nsigacc += 1 ### write the truth track momentum and its index pxGen.push_back(pgen.Px()) pyGen.push_back(pgen.Py()) pzGen.push_back(pgen.Pz()) eGen.push_back(pgen.E()) qGen.push_back(event.qgen[i]) iGen.push_back(i) ### loop over all clusters of the track and put in the allpoints classified by the layer for jxy in range(event.polm_clusters[i].GetN()): rcls = [ ROOT.Double(), ROOT.Double(), ROOT.Double() ] event.polm_clusters[i].GetPoint(jxy,rcls[0],rcls[1],rcls[2]) ### the clusters if(rcls[0]>0): AddPoint(allpointsEside,rcls,True,i) if(rcls[0]<0): AddPoint(allpointsPside,rcls,True,i) Nsig4 = getNnon0(allpointsEside["Cls"][4])+getNnon0(allpointsPside["Cls"][4]) ### embed some noise clusters rnd = TRandom() rnd.SetSeed() for kN in range(NnoiseClusters): for layer in layers: for side in sidesarr: x = 0 if(side=="Pside"): x = rnd.Uniform(xPsideL,xPsideR) if(side=="Eside"): x = rnd.Uniform(xEsideL,xEsideR) y = rnd.Uniform(-0.75,+0.75) if(layer==1): z = 300 if(layer==2): z = 310 if(layer==3): z = 320 if(layer==4): z = 330 rnoise = [x,y,z] if(side=="Pside"): AddPoint(allpointsPside,rnoise) if(side=="Eside"): AddPoint(allpointsEside,rnoise) Nbkgsig4 = getNnon0(allpointsEside["Cls"][4])+getNnon0(allpointsPside["Cls"][4]) ### just draw the full event drawall(pdfname+"(",allpointsEside,allpointsPside,dodraw) ### loop on the 2 sides for side in sidesarr: allpoints = allpointsEside if(side=="Eside") else allpointsPside ### the initial pool for pivot clusters Nall4 = getNnon0(allpoints["Cls"][4]) ### loop over the clusters and start the seeding for j4 in range(Nall4): r4 = getpoint(allpoints["Cls"][4],j4) xpivot = r4[0] ### electron / positron? particlename = getparticlename(allpoints["Cls"][4],j4) ### get the yz window winpts_yz,winlin_yz = getyzwindow(allpoints["Cls"][4],j4) ### set the wide window starting from cluster_seed1 (window corners must be added clockwise!) winpts_xz_wide,winlin_xz_wide = getwidewindow(allpoints["Cls"][4],j4) ### discard all clusters which are not in the wide window widepoints = initpoints() trimwide(allpoints,widepoints,winpts_xz_wide,winpts_yz,xpivot) Nwide1 = getNnon0(widepoints["Cls"][1]) # if(Nwide1<1): print("Failed Nwide1") ### draw the wide window draw(pdfname,widepoints,dodraw,particlename,winlin_yz,winlin_xz_wide) ### choose one cluster in layer 1 as the second seed for j1 in range(Nwide1): ### get the narrow window (window corners must be added clockwise!) winpts_xz_narr,winlin_xz_narr = getnarrwindow(allpoints["Cls"][4],widepoints["Cls"][1],j4,j1) ### discard all clusters which are not in the narrow window narrpoints = initpoints() trimnarr(widepoints,narrpoints,winpts_xz_narr) Nnarr2 = getNnon0(narrpoints["Cls"][2]) Nnarr3 = getNnon0(narrpoints["Cls"][3]) ### check if there are at least 1 cluster in both layer 2 and layer 3 within the narrow window if(Nnarr2<1 or Nnarr3<1): continue ### draw the narrow window draw(pdfname,narrpoints,dodraw,particlename,None,winlin_xz_narr) ### get the seed - note: could be that there are several combinations but the seed momentum would be identical pseed = makeseed(allpoints["Cls"][4],widepoints["Cls"][1],j4,j1,particlename) # if(pseed.E()>Emax or pseed.E()<Emin): print("pseed.E()>Emax or pseed.E()<Emin") if(pseed.E()>Emax or pseed.E()<Emin): continue ### set the cluster in layer 1 r1 = getpoint(widepoints["Cls"][1],j1) ### loop on the clusters in layer 2 and 3: for j2 in range(Nnarr2): # for j2 in range(narrpoints["Cls"][2].GetN()): r2 = getpoint(narrpoints["Cls"][2],j2) for j3 in range(Nnarr3): # for j3 in range(narrpoints["Cls"][3].GetN()): r3 = getpoint(narrpoints["Cls"][3],j3) Nseeds += 1 issig1 = widepoints["IsSig"][1][j1] issig2 = narrpoints["IsSig"][2][j2] issig3 = narrpoints["IsSig"][3][j3] issig4 = allpoints["IsSig"][4][j4] trkid4 = allpoints["TrkId"][4][j4] trkid3 = narrpoints["TrkId"][3][j3] trkid2 = narrpoints["TrkId"][2][j2] trkid1 = widepoints["TrkId"][1][j1] issig = (issig4 and issig1 and issig2 and issig3) trkid = str(trkid4) if(trkid4==trkid1 and trkid1==trkid2 and trkid2==trkid3) else "mult" issiguniq = (issig and trkid!="mult") if(issiguniq): Nmatched += 1 ### two independent 2d fits chi2_xz,prob_xz,chi2_yz,prob_yz = seed2dfit(pdfname,r1,r2,r3,r4,dodraw) if(issiguniq): histos["h_chi2ndf_xz_sig"].Fill(chi2_xz) histos["h_chi2ndf_yz_sig"].Fill(chi2_yz) histos["h_prob_xz_sig"].Fill(prob_xz) histos["h_prob_yz_sig"].Fill(prob_yz) else: histos["h_chi2ndf_xz_bkg"].Fill(chi2_xz) histos["h_chi2ndf_yz_bkg"].Fill(chi2_yz) histos["h_prob_xz_bkg"].Fill(prob_xz) histos["h_prob_yz_bkg"].Fill(prob_yz) ### a single 3d fit res_xz, res_yz = seed3dfit(pdfname,r1,r2,r3,r4,dodraw) if(issiguniq): histos["h_residuals_xz_sig"].Fill(res_xz) histos["h_residuals_yz_sig"].Fill(res_yz) else: histos["h_residuals_xz_bkg"].Fill(res_xz) histos["h_residuals_yz_bkg"].Fill(res_yz) ### a single 3d fit SVD lfitpts, dd = seed3dfitSVD(pdfname,r1,r2,r3,r4,dodraw) ### set again the pseed according to lfit cluster1 = TPolyMarker3D() cluster2 = TPolyMarker3D() cluster1.SetNextPoint(lfitpts[0][0],lfitpts[0][1],lfitpts[0][2]) cluster2.SetNextPoint(lfitpts[1][0],lfitpts[1][1],lfitpts[1][2]) if(isel(lfitpts[0][0])): pseed = makeseed(cluster2,cluster1,0,0,particlename) else: pseed = makeseed(cluster1,cluster2,0,0,particlename) if(pseed.E()>Emax or pseed.E()<Emin): continue ### the SVD alg if(issiguniq): histos["h_svd_dd0_sig"].Fill(dd[0]) histos["h_svd_dd1_sig"].Fill(dd[1]) histos["h_svd_dd2_sig"].Fill(dd[2]) else: histos["h_svd_dd0_bkg"].Fill(dd[0]) histos["h_svd_dd1_bkg"].Fill(dd[1]) histos["h_svd_dd2_bkg"].Fill(dd[2]) ### get the generated matched track momentum pgen = TLorentzVector() igen = -1 for k in range(iGen.size()): if(iGen[k]==j4): igen = k break ### write out the good seeds svd0Seed.push_back(dd[0]) svd1Seed.push_back(dd[1]) svd2Seed.push_back(dd[2]) chi2xzSeed.push_back(chi2_xz) chi2yzSeed.push_back(chi2_yz) residxzSeed.push_back(res_xz) residyzSeed.push_back(res_yz) issigSeed.push_back(issiguniq) iGenMatch.push_back(igen) x1Seed.push_back(r1[0]) y1Seed.push_back(r1[1]) z1Seed.push_back(r1[2]) x2Seed.push_back(r2[0]) y2Seed.push_back(r2[1]) z2Seed.push_back(r2[2]) x3Seed.push_back(r3[0]) y3Seed.push_back(r3[1]) z3Seed.push_back(r3[2]) x4Seed.push_back(r4[0]) y4Seed.push_back(r4[1]) z4Seed.push_back(r4[2]) pxSeed.push_back(pseed.Px()) pySeed.push_back(pseed.Py()) pzSeed.push_back(pseed.Pz()) eSeed.push_back(pseed.E()) ### cut on some quality isgood = (dd[1]<0.005 and dd[2]<0.0025) if(not isgood): continue Ngood += 1 ### check perforrmance of seeding pgen.SetPxPyPzE(pxGen[igen],pyGen[igen],pzGen[igen],eGen[igen]) resE = (pseed.E()-pgen.E())/pgen.E() resPz = (pseed.Pz()-pgen.Pz())/pgen.Pz() resPy = (pseed.Py()-pgen.Py())/pgen.Py() histos["h_seed_resE"].Fill(resE) histos["h_seed_resPz"].Fill(resPz) histos["h_seed_resPy"].Fill(resPy) histos["h_seed_resE_vs_x"].Fill(r4[0],resE) histos["h_seed_resPy_vs_x"].Fill(r4[0],resPy) histos["h_N_sigacc"].Fill(Nsigacc) histos["h_N_all_seeds"].Fill(Nseeds) histos["h_N_matched_seeds"].Fill(Nmatched) histos["h_N_good_seeds"].Fill(Ngood) histos["h_seeding_score"].Fill(Nmatched/Nsigacc*100) histos["h_seeding_pool"].Fill(Nseeds/Nsigacc*100) if(dodraw): cnv = TCanvas("","",2000,2000) cnv.SaveAs(pdfname+")") print("Event: %g --> Nsigall=%g, Nsigacc=%g, Nseeds=%g, Nmatched=%g, Ngood=%g --> Seeds matching performance: Nmatched/Nsigacc=%5.1f%%" % (n,Nsigall,Nsigacc,Nseeds,Nmatched,Ngood,Nmatched/Nsigacc*100)) tT.Fill() if(n%10==0 and n>0): print(" processed %d events" % n) n+=1 print("Total events processed: ",n) cnv = TCanvas("","",1000,1000) cnv.Divide(2,2) cnv.cd(1) histos["h_chi2ndf_xz_sig"].SetLineColor(ROOT.kRed); histos["h_chi2ndf_xz_sig"].Draw() histos["h_chi2ndf_xz_bkg"].SetLineColor(ROOT.kBlack); histos["h_chi2ndf_xz_bkg"].Draw("same") cnv.cd(2) histos["h_chi2ndf_yz_sig"].SetLineColor(ROOT.kRed); histos["h_chi2ndf_yz_sig"].Draw() histos["h_chi2ndf_yz_bkg"].SetLineColor(ROOT.kBlack); histos["h_chi2ndf_yz_bkg"].Draw("same") cnv.cd(3) histos["h_prob_xz_sig"].SetLineColor(ROOT.kRed); histos["h_prob_xz_sig"].Draw() histos["h_prob_xz_bkg"].SetLineColor(ROOT.kBlack); histos["h_prob_xz_bkg"].Draw("same") cnv.cd(4) histos["h_prob_yz_sig"].SetLineColor(ROOT.kRed); histos["h_prob_yz_sig"].Draw() histos["h_prob_yz_bkg"].SetLineColor(ROOT.kBlack); histos["h_prob_yz_bkg"].Draw("same") cnv.SaveAs("../output/pdf/chi2ndf_"+proc+".pdf") cnv = TCanvas("","",1000,500) cnv.Divide(2,1) cnv.cd(1) histos["h_residuals_xz_sig"].SetLineColor(ROOT.kRed); histos["h_residuals_xz_sig"].Draw() histos["h_residuals_xz_bkg"].SetLineColor(ROOT.kBlack); histos["h_residuals_xz_bkg"].Draw("same") cnv.cd(2) histos["h_residuals_yz_sig"].SetLineColor(ROOT.kRed); histos["h_residuals_yz_sig"].Draw() histos["h_residuals_yz_bkg"].SetLineColor(ROOT.kBlack); histos["h_residuals_yz_bkg"].Draw("same") cnv.SaveAs("../output/pdf/resid3dfit_"+proc+".pdf") cnv = TCanvas("","",1500,500) cnv.Divide(3,1) cnv.cd(1) histos["h_svd_dd0_sig"].SetLineColor(ROOT.kRed); histos["h_svd_dd0_sig"].Draw() histos["h_svd_dd0_bkg"].SetLineColor(ROOT.kBlack); histos["h_svd_dd0_bkg"].Draw("same") cnv.cd(2) histos["h_svd_dd1_sig"].SetLineColor(ROOT.kRed); histos["h_svd_dd1_sig"].Draw() histos["h_svd_dd1_bkg"].SetLineColor(ROOT.kBlack); histos["h_svd_dd1_bkg"].Draw("same") cnv.cd(3) histos["h_svd_dd2_sig"].SetLineColor(ROOT.kRed); histos["h_svd_dd2_sig"].Draw() histos["h_svd_dd2_bkg"].SetLineColor(ROOT.kBlack); histos["h_svd_dd2_bkg"].Draw("same") cnv.SaveAs("../output/pdf/svd3dfit_"+proc+".pdf") cnv = TCanvas("","",1000,1000) cnv.Divide(2,2) cnv.cd(1); histos["h_seed_resE"].Draw("hist") cnv.cd(2); histos["h_seed_resPy"].Draw("hist") cnv.cd(3); histos["h_seed_resE_vs_x"].Draw("col") cnv.cd(4); histos["h_seed_resPy_vs_x"].Draw("col") cnv.SaveAs("../output/pdf/seedsres_"+proc+".pdf") cnv = TCanvas("","",1500,500) cnv.Divide(3,1) cnv.cd(1) histos["h_N_sigacc"].SetLineColor(ROOT.kBlack); histos["h_N_sigacc"].Draw() histos["h_N_all_seeds"].SetLineColor(ROOT.kBlue); histos["h_N_all_seeds"].Draw("same") histos["h_N_matched_seeds"].SetLineColor(ROOT.kGreen); histos["h_N_matched_seeds"].Draw("same") histos["h_N_good_seeds"].SetLineColor(ROOT.kRed); histos["h_N_good_seeds"].Draw("same") cnv.cd(2) histos["h_seeding_pool"].Draw("hist") cnv.cd(3) histos["h_seeding_score"].Draw("hist") cnv.SaveAs("../output/pdf/seedsmult_"+proc+".pdf") tF.cd() tT.Write() tF.Write() tF.Close() if __name__=="__main__": main()
def process(self, event): #survival variable is for an artififcal cut flow because the real selection is done in the ROOT macro survival = 'dead' self.counters['cut_flow'].inc('All events') det = getattr(event, self.cfg_ana.det) if det == 1: print 'no Solution for scaling factor!' return False jets = getattr(event, self.cfg_ana.input_jets) if len(jets) == 2: self.counters['cut_flow'].inc('2 jets') #bjets are actually all jets bjets = [jet for jet in jets] realbjets = [jet for jet in jets if jet.tags['bmatch']] #assuming 100% b-tag efficiency if len(realbjets) == 2: self.counters['cut_flow'].inc('2 b jets') survival = 'alive' elif len(realbjets) == 1: self.counters['cut_flow'].inc('1 b jet') #emratio returns the energy ration (electromagnetic E/total E) of the jet in which it is the greatest emratio = [] for i in range(2): emratio.append(bjets[i].constituents[22].e() / bjets[i].e()) setattr(event, self.cfg_ana.emratio, max(emratio)) #Total visible mass###################################### pvis = bjets[0].p4() + bjets[1].p4() mvis = pvis.M() setattr(event, self.cfg_ana.mvis, mvis) if mvis < 10 or mvis > 180: survival = 'dead' elif survival == 'alive': self.counters['cut_flow'].inc('mvis between 10 and 180') #missing mass############################################ misenergy = getattr(event, self.cfg_ana.misenergy) if misenergy.m() > 125 or misenergy.m() < 65: survival = 'dead' elif survival == 'alive': self.counters['cut_flow'].inc('m_miss between 65 and 125') #transversal momentum########################################### #cross check: succeeded # print 'compare ', bjets[0].pt(),' to ',math.sqrt(bjets[0].p3().Px()**2+bjets[0].p3().Py()**2) pTges = 0 lix = [] liy = [] for jet in bjets: lix.append(jet.p3().Px()) liy.append(jet.p3().Py()) xve = lix[0] + lix[1] yve = liy[0] + liy[1] pTges = math.sqrt(xve**2 + yve**2) setattr(event, self.cfg_ana.pTges, pTges) if pTges <= 15.: survival = 'dead' elif survival == 'alive': self.counters['cut_flow'].inc('Trans momentum > 15 GeV') #cross check: succeeded # pTtest=math.sqrt((bjets[0].p3().Px()+bjets[1].p3().Px())**2+(bjets[0].p3().Py()+bjets[1].p3().Py())**2) # print 'compare ',pTtest,' to ', pTges #longitudinal moementum############################################ pLges = 0 liz = [] for jet in bjets: liz.append(jet.p3().Pz()) pLges = abs(liz[0] + liz[1]) setattr(event, self.cfg_ana.pLges, abs(pLges)) if abs(pLges) >= 50.: survival = 'dead' elif survival == 'alive': self.counters['cut_flow'].inc('Long momentum < 50 GeV') #cross check: succeeded # pLtest=math.sqrt((bjets[0].p3().Pz()+bjets[1].p3().Pz())**2) # print 'compare ',pLtest,' to ',pLges #alpha: angle between the 2 jets############################################ # skalarp is the scalar product of bjet_1 and bjet_2; skalarpa(b) is the product of bjet_1(bjet_2) # with itself skalarp = bjets[1].p3().Px() * bjets[0].p3().Px() + bjets[0].p3().Py( ) * bjets[1].p3().Py() + bjets[0].p3().Pz() * bjets[1].p3().Pz() skalarpa = bjets[0].p3().Px() * bjets[0].p3().Px() + bjets[0].p3().Py( ) * bjets[0].p3().Py() + bjets[0].p3().Pz() * bjets[0].p3().Pz() skalarpb = bjets[1].p3().Px() * bjets[1].p3().Px() + bjets[1].p3().Py( ) * bjets[1].p3().Py() + bjets[1].p3().Pz() * bjets[1].p3().Pz() # print bjets[0].scalarp(bjets[0]) cosa = skalarp / (math.sqrt(skalarpa) * math.sqrt(skalarpb)) # alpha is the angle between the two jets in degrees try: alpha = 360 * math.acos(cosa) / (2 * math.pi) except ValueError: #Very Rare...something like 1 of 100000 events in qqbar #This ValueError is very weird and must come from some roudning problems in python. It happens very rarely. The particles are exactly back to back so cosa is -1 but the way cosa is calc it becomes just slightly smaller than -1 and math.acos(cosa) returns ValueError. Instead of returning False its prob better to set alpha to 180. But gonna check this in more detail print "#################ValueError#################" print "cosa= ", cosa #this prints 1 or -1 print "skalarp= ", skalarp print "skalarpa=", skalarpa print "skalarpb=", skalarpb return False setattr(event, self.cfg_ana.alpha, alpha) if alpha < 100: survival = 'dead' elif survival == 'alive': self.counters['cut_flow'].inc('Angle between jets > 100 degrees') #cross variable ################################################################ # normal vector of the plane between the two vectors i.e. cross product normvec = TLorentzVector(0, 0, 0, 0) normvec.SetPx(bjets[0].p3().Py() * bjets[1].p3().Pz() - bjets[0].p3().Pz() * bjets[1].p3().Py()) normvec.SetPy(bjets[0].p3().Pz() * bjets[1].p3().Px() - bjets[0].p3().Px() * bjets[1].p3().Pz()) normvec.SetPz(bjets[0].p3().Px() * bjets[1].p3().Py() - bjets[0].p3().Py() * bjets[1].p3().Px()) cross = abs(normvec.Pz() / (math.sqrt(skalarpa * skalarpb))) cross = math.asin(cross) * 180. / math.pi setattr(event, self.cfg_ana.cross, cross) #cross check for cross variable (Patricks code): succeeded # p1=TVector3(bjets[0].p3().Px(),bjets[0].p3().Py(),bjets[0].p3().Pz()) # p2=TVector3(bjets[1].p3().Px(),bjets[1].p3().Py(),bjets[1].p3().Pz()) # cross2=p1.Unit().Cross(p2.Unit()) # cross2=abs(cross2.Unit().z()) # cross2=math.asin(cross2)*180./math.pi #cross check: succeeded # print 'compare: ',bjets[0].norm(), 'to : ',math.sqrt(bjets[0].scalarp(bjets[0])) # cross check: succeeded # print abs(normvec.Pz()),'-----',abs((bjets[0].cross(bjets[1])).Pz()) # beta is the angle between the plane of the two jets and the beamaxis #ZeroDivisonError if math.sqrt(normvec.Px()**2 + normvec.Py()**2 + normvec.Pz()**2) == 0: print "##########normvec has norm of 0!!!#########" #A very rare case...about 1 in 1000000 qqbar events #reason is the angle between the 2 jets is 0 print "Px= ", normvec.Px() print "Py= ", normvec.Py() print "Pz= ", normvec.Pz() print "jet energies= ", bjets[0].e(), "_,", bjets[1].e() print "angle betwee nthe jets= ", alpha #this returns 0 return False cosb = normvec.Pz() / (math.sqrt(normvec.Px()**2 + normvec.Py()**2 + normvec.Pz()**2)) beta = 360 * math.acos(cosb) / (2 * math.pi) beta1 = 180 - beta #cross check Colins acoplanarity code: succeeded # j1=bjets[0].p3() # j2=bjets[1].p3() # axis=TVector3(0,0,1) # normal = j1.Cross(j2).Unit() # angle=normal.Angle(axis)-math.pi/2. # print angle,angle*180./math.pi,90-min(beta,beta1),cross2 # cross check: succeeded # sintest=abs(normvec.Pz())/(math.sqrt(normvec.Px()**2+normvec.Py()**2+normvec.Pz()**2)) # betatest=360*math.asin(sintest)/(2*math.pi) # print 'compare ',betatest, ' to ',90-min(beta,beta1) setattr(event, self.cfg_ana.beta, 90 - min(beta, beta1)) if cross < 10: survival = 'dead' elif survival == 'alive': self.counters['cut_flow'].inc('cross > 10') if survival == 'alive': self.counters['cut_flow'].inc('Total # of events after cuts') setattr(event, self.cfg_ana.cutlife, survival) #cross check:succeeded # ptcs = getattr(event, self.cfg_ana.particles) # pvis = TLorentzVector(0,0,0,0) # for ptc in ptcs: # pvis+=ptc.p4() # print pvis.M() # print mvis #Total number of charged tracks nchargedtracks = bjets[0].constituents[211].num( ) + bjets[1].constituents[211].num() setattr(event, self.cfg_ana.ctracks, nchargedtracks)
def jetdisplay(): inputfile1 = "wwlj_truth.root" inputfile2 = "wwlj.root" inputfile1 = TFile(inputfile1) inputfile2 = TFile(inputfile2) print "Analyzing: " + str(inputfile1) + " \n" tree1 = TTree() tree2 = TTree() inputfile1.GetObject("truth", tree1) inputfile2.GetObject("B4", tree2) tree1.AddFriend(tree2) outputfile = "wwlj_output" displayfile = TFile(outputfile + ".root", "RECREATE") graphmass = TH1F("mass_jet", "mass_jet", 100, 0., 200.) graphmass_truth = TH1F("mass_jet_truth", "mass_jet_truth", 100, 0., 200.) #loop over events for Event in range(int(10)): tree1.GetEntry(Event) #Set values of the tree numtru = tree1.mcs_n print numtru muvec = [] inputparticles_tru = [] nmuon = 0 #loop over true particles for itru in range(0, numtru): partid = tree1.mcs_pdgId[itru] #for particle depositing in calo, store them as input for jet building if abs(partid) != 13 and abs(partid) != 12 and abs( partid) != 14 and abs(partid) != 16: trup = TLorentzVector() trup.SetPtEtaPhiM(tree1.mcs_pt[itru], tree1.mcs_eta[itru], tree1.mcs_phi[itru], tree1.mcs_m[itru]) inputparticles_tru.append( fastjet.PseudoJet(trup.Px(), trup.Py(), trup.Pz(), trup.E())) #store muons in event if abs(partid) == 13: muon = TLorentzVector() muon.SetPtEtaPhiM(tree1.mcs_pt[itru], tree1.mcs_eta[itru], tree1.mcs_phi[itru], tree1.mcs_m[itru]) muvec.append(muon) nmuon = nmuon + 1 print " nmuon ", nmuon #now build truth jets jet_def = fastjet.JetDefinition(fastjet.ee_genkt_algorithm, 2 * math.pi, 1.) clust_seq = fastjet.ClusterSequence(inputparticles_tru, jet_def) jetexc = fastjet.sorted_by_E(clust_seq.exclusive_jets(int(2))) print "*********** jets ************" for jet in jetexc: print jet.e(), jet.eta(), jet.phi() print "*********** muons ************" for muon in muvec: print muon.E(), muon.Eta(), muon.Phi() jet1_truth = jetexc[0] jet2_truth = jetexc[1] j = jet1_truth + jet2_truth graphmass_truth.Fill(j.m()) # now handle calo sim BarrelR_VectorSignals = tree2.VectorSignalsR BarrelL_VectorSignals = tree2.VectorSignalsL BarrelR_VectorSignalsCher = tree2.VectorSignalsCherR BarrelL_VectorSignalsCher = tree2.VectorSignalsCherL VectorR = tree2.VectorR VectorL = tree2.VectorL Calib_BarrelL_VectorSignals = calibration.calibscin( BarrelL_VectorSignals) Calib_BarrelR_VectorSignals = calibration.calibscin( BarrelR_VectorSignals) Calib_BarrelL_VectorSignalsCher = calibration.calibcher( BarrelL_VectorSignalsCher) Calib_BarrelR_VectorSignalsCher = calibration.calibcher( BarrelR_VectorSignalsCher) energy = float( sum(Calib_BarrelR_VectorSignals) + sum(Calib_BarrelL_VectorSignals)) print " simulated energy ", energy if (energy > 0): threshold = 0.1 inputparticles_scin = [] inputparticles_cher = [] #right part for towerindex in range(75 * 36): theta, phi, eta = newmap_truth.maptower(towerindex, "right") energy_scin = Calib_BarrelR_VectorSignals[towerindex] pt_scin = energy_scin * np.sin(theta * math.pi / 180.) energy_cher = Calib_BarrelR_VectorSignalsCher[towerindex] pt_cher = energy_cher * np.sin(theta * math.pi / 180.) towerscin = TLorentzVector() towerscin.SetPtEtaPhiM(pt_scin, eta, phi * math.pi / 180., 0.) towercher = TLorentzVector() towercher.SetPtEtaPhiM(pt_cher, eta, phi * math.pi / 180., 0.) deltamumin = 999999. for muon in muvec: deltaR = abs(towerscin.DeltaR(muon)) if deltaR < deltamumin: deltamumin = deltaR if energy_scin > threshold: if deltamumin < 0.1: print " deltamumin ", deltamumin if deltamumin > 0.1: inputparticles_scin.append( fastjet.PseudoJet(towerscin.Px(), towerscin.Py(), towerscin.Pz(), towerscin.E())) inputparticles_cher.append( fastjet.PseudoJet(towercher.Px(), towercher.Py(), towercher.Pz(), towercher.E())) #left part for towerindex in range(75 * 36): theta, phi, eta = newmap_truth.maptower(towerindex, "left") energy_scin = Calib_BarrelL_VectorSignals[towerindex] pt_scin = energy_scin * np.sin(theta * math.pi / 180.) energy_cher = Calib_BarrelL_VectorSignalsCher[towerindex] pt_cher = energy_cher * np.sin(theta * math.pi / 180.) towerscin = TLorentzVector() towerscin.SetPtEtaPhiM(pt_scin, eta, phi * math.pi / 180., 0.) towercher = TLorentzVector() towercher.SetPtEtaPhiM(pt_cher, eta, phi * math.pi / 180., 0.) deltamumin = 999999. for muon in muvec: deltaR = abs(towerscin.DeltaR(muon)) if deltaR < deltamumin: deltamumin = deltaR if energy_scin > threshold: if deltamumin < 0.1: print " deltamumin ", deltamumin if deltamumin > 0.1: inputparticles_scin.append( fastjet.PseudoJet(towerscin.Px(), towerscin.Py(), towerscin.Pz(), towerscin.E())) inputparticles_cher.append( fastjet.PseudoJet(towercher.Px(), towercher.Py(), towercher.Pz(), towercher.E())) print "len: ", len(inputparticles_scin) print "lencher: ", len(inputparticles_cher) jet_def = fastjet.JetDefinition(fastjet.ee_genkt_algorithm, 2 * math.pi, 1.) clust_seq = fastjet.ClusterSequence(inputparticles_scin, jet_def) clust_seq_cher = fastjet.ClusterSequence(inputparticles_cher, jet_def) print "n jet: ", len(clust_seq.exclusive_jets(int(2))), len( clust_seq_cher.exclusive_jets(int(2))) jet1_scin = clust_seq.exclusive_jets(int(2))[0] jet2_scin = clust_seq.exclusive_jets(int(2))[1] jet1_cher = clust_seq_cher.exclusive_jets(int(2))[0] jet2_cher = clust_seq_cher.exclusive_jets(int(2))[1] #merge jet jet1, jet2 = mergejet(jet1_scin, jet2_scin, jet1_cher, jet2_cher) jet = jet1 + jet2 graphmass.Fill(jet.m()) graphmass.Write() graphmass_truth.Write()
v_jet = TLorentzVector() pv2sv = TVector3() njet = 0 for ievt in range(jet_njets.shape[0]): for ijet in range(jet_njets[ievt]): v_jet.SetPtEtaPhiM(jet_pt[ijet], jet_eta[ijet], jet_phi[ijet], jet_m[ijet]) if jet_sv1_vtx_x_raw[ievt][ijet].shape[0] == 1: dx = jet_sv1_vtx_x_raw[ievt][ijet][0] - PVx[ievt] dy = jet_sv1_vtx_y_raw[ievt][ijet][0] - PVy[ievt] dz = jet_sv1_vtx_z_raw[ievt][ijet][0] - PVz[ievt] pv2sv.SetXYZ(dx, dy, dz) jetAxis = TVector3(v_jet.Px(), v_jet.Py(), v_jet.Pz()) jet_sv1_L3d[ijet + njet] = sqrt(dx**2 + dy**2 + dz**2) jet_sv1_Lxy[ijet + njet] = sqrt(dx**2 + dy**2) jet_sv1_dR[ijet + njet] = pv2sv.DeltaR(jetAxis) else: jet_sv1_L3d[ijet + njet] = -100 jet_sv1_Lxy[ijet + njet] = -100 jet_sv1_dR[ijet + njet] = -1 njet += jet_njets[ievt] print "jet_sv1_l3d", jet_sv1_L3d print "jet_sv1_lxy", jet_sv1_Lxy print "jet_sv1_dR", jet_sv1_dR
MinPtRatio[0] = min( (l1+l2).Pt(), (q1+q2).Pt() ) / (l1+l2+q1+q2).M() SqrtSSPt[0] = -99. nbtag[0] = nb nbtagInFatjet[0] = nb #Es *= Heaviside(np.sqrt((l1+l2).Pt()**2+(q1+q2).Pt()**2)/(l1+l2+q1+q2).M()-0.4) #Es *= Heaviside(105e+3-(q1+q2).M()) #Es *= Heaviside((q1+q2).M()-70e+3) # Invariant mass of Z1 and Z2 Mll[0] = (l1 + l2).M() Mjj[0] = (q1 + q2).M() Mlljj[0] = (l1 + l2 + q1 + q2).M() # Boost to X's static system l_X = TLorentzRotation().Boost(-1.*X.Px()/X.E(), -1.*X.Py()/X.E(), -1.*X.Pz()/X.E()) X = l_X * X; Z1 = l_X * Zll; Z2 = l_X * Zjj; l1 = l_X * l1; l2 = l_X * l2; q1 = l_X * q1; q2 = l_X * q2; # Boost to Z1's static system l_Z1 = TLorentzRotation().Boost(-1.*Z1.Px()/Z1.E(), -1.*Z1.Py()/Z1.E(), -1.*Z1.Pz()/Z1.E()) Z1_Z1SS = l_Z1 * Z1 Z2_Z1SS = l_Z1 * Z2 l1_Z1SS = l_Z1 * l1 l2_Z1SS = l_Z1 * l2
G *= Heaviside(q2.Pt() - 30.0e+3) if G > 0: # Invariant mass of Z1 and Z2 mll[0] = (l1 + l2).M() mqq[0] = (q1 + q2).M() mZZ[0] = (l1 + l2 + q1 + q2).M() PtZZ[0] = (l1 + l2 + q1 + q2).Pt() Ptll[0] = (l1 + l2).Pt() Ptqq[0] = (q1 + q2).Pt() # Boost to X's static system l_X = TLorentzRotation().Boost(-1. * X.Px() / X.E(), -1. * X.Py() / X.E(), -1. * X.Pz() / X.E()) X = l_X * X Z1 = l_X * Z1 Z2 = l_X * Z2 l1 = l_X * l1 l2 = l_X * l2 q1 = l_X * q1 q2 = l_X * q2 # Boost to Z1's static system l_Z1 = TLorentzRotation().Boost(-1. * Z1.Px() / Z1.E(), -1. * Z1.Py() / Z1.E(), -1. * Z1.Pz() / Z1.E()) Z1_Z1SS = l_Z1 * Z1 Z2_Z1SS = l_Z1 * Z2 l1_Z1SS = l_Z1 * l1
## Fill these chosen muons into the TLorentzVectors posMuon1.SetPtEtaPhiM(t.Muon_pt[posMu1], t.Muon_eta[posMu1], t.Muon_phi[posMu1], t.Muon_mass[posMu1]) negMuon1.SetPtEtaPhiM(t.Muon_pt[negMu1], t.Muon_eta[negMu1], t.Muon_phi[negMu1], t.Muon_mass[negMu1]) ## Create a list of physics quantities allmuons = [ posMuon1.E(), negMuon1.E(), posMuon1.Px(), negMuon1.Px(), posMuon1.Py(), negMuon1.Py(), posMuon1.Pz(), negMuon1.Pz() ] ## Test it! This is just for you Z = posMuon1 + negMuon1 hist.Fill(Z.M()) ## Store this event's information into the text file textfile.write(str(allmuons)[1:-2] + '\n') ## Store this event's information into the data object data.append(allmuons) isaved += 1 ## Write the data object into a text file and a pickle file for students to use
class particle: #_____________________________________________________________________________ def __init__(self, pdg): #particle Lorentz vector self.vec = TLorentzVector() #index in particle list self.idx = 0 #status code self.stat = 0 #pdg code self.pdg = pdg #particle database for pass and codes self.pdgdat = TDatabasePDG.Instance() #mass, GeV self.mass = self.pdgdat.GetParticle(self.pdg).Mass() #parent particle id self.parent_id = 0 #vertex coordinates, mm self.vx = 0. self.vy = 0. self.vz = 0. #precision for momentum and energy self.pxyze_prec = 6 #_____________________________________________________________________________ def write_tx(self, track_list): #output line in TX format #Geant code and momentum lin = "TRACK: " + str(self.pdgdat.ConvertPdgToGeant3(self.pdg)) pxyz_form = " {0:." + str(self.pxyze_prec) + "f}" lin += pxyz_form.format(self.vec.Px()) lin += pxyz_form.format(self.vec.Py()) lin += pxyz_form.format(self.vec.Pz()) #track id lin += " " + str(len(track_list)) #start and stop vertex and pdg lin += " 1 0 " + str(self.pdg) track_list.append(lin) #_____________________________________________________________________________ def write_tparticle(self, particles, ipos): #write to TParticle clones array p = particles.ConstructedAt(ipos) p.SetMomentum(self.vec) p.SetPdgCode(self.pdg) p.SetProductionVertex(self.vx, self.vy, self.vz, 0) #_____________________________________________________________________________ def make_hepmc_particle(self, hepmc): #create HepMC3 particle p = hepmc.GenParticle( hepmc.FourVector(self.vec.Px(), self.vec.Py(), self.vec.Pz(), self.vec.E()), self.pdg, 1) return p
Py = rp.Unit().Y()*P0 Pz = rp.Unit().Z()*P0 E0 = ROOT.TMath.Sqrt(P0*P0+me2) p4 = TLorentzVector() p4.SetXYZM(Px,Py,Pz,me) wgt0 = 1 pdgId0 = 11 if(rnd.Uniform()>0.5) else -11 ### fill output vectors wgt.push_back(wgt0) pdgId.push_back(pdgId0) vx.push_back(vx0) vy.push_back(vy0) vz.push_back(vz0) px.push_back(p4.Px()) py.push_back(p4.Py()) pz.push_back(p4.Pz()) E.push_back(p4.E()) if(n%100==0): print("done %g out of %g" % (n,Nevt)) tt.Fill() tf.Write() tf.Write() tf.Close()
print "Higgs" # No higgs event else: #print "No Higgs!" for pin in range(0, branchParticle.GetEntriesFast()): #for pin in range(0, 20): part = branchParticle.At(pin) if (abs(part.PID) == 24 and part.Status == 22): wpart.SetPtEtaPhiE(part.PT, part.Eta, part.Phi, part.E) for etrenrty in range(0, branchTrack.GetEntriesFast()): eterm = branchTrack.At(etrenrty) temp.SetPtEtaPhiE(eterm.PT, eterm.Eta, eterm.Phi, eterm.PT * np.cosh(eterm.Eta)) vectors.append((temp.E(), temp.Px(), temp.Py(), temp.Pz())) for pentry in range(0, branchPhoton.GetEntriesFast()): pterm = branchPhoton.At(pentry) temp.SetPtEtaPhiE(pterm.ET, pterm.Eta, pterm.Phi, pterm.E) vectors.append((temp.E(), temp.Px(), temp.Py(), temp.Pz())) for nentry in range(0, branchNeutral.GetEntriesFast()): nterm = branchNeutral.At(nentry) temp.SetPtEtaPhiE(nterm.ET, nterm.Eta, nterm.Phi, nterm.E) vectors.append((temp.E(), temp.Px(), temp.Py(), temp.Pz())) vects = np.asarray(vectors, dtype=np.dtype([('E', 'f8'), ('px', 'f8'), ('py', 'f8'), ('pz', 'f8')]))
taup_tofill['ignore_branch'] = taup_lv.M() taup_ntuple.Fill(array('f',taup_tofill.values())) """ if tag_upsilon: print 'Found Upsilon -> tau+ tau- -> pi+*3 pi-*3' tofill = OrderedDict(zip(branches, [-99.] * len(branches))) upsilon_lv = neu_lv + antineu_lv + pi_m_lv1 + pi_m_lv2 + pi_m_lv3 + pi_p_lv1 + pi_p_lv2 + pi_p_lv3 tofill['taup_neu_px'] = antineu_lv.Px() tofill['taup_neu_py'] = antineu_lv.Py() tofill['taup_neu_pz'] = antineu_lv.Pz() tofill['pi_plus1_px'] = pi_p_lv1.Px() tofill['pi_plus1_py'] = pi_p_lv1.Py() tofill['pi_plus1_pz'] = pi_p_lv1.Pz() tofill['pi_plus2_px'] = pi_p_lv2.Px() tofill['pi_plus2_py'] = pi_p_lv2.Py() tofill['pi_plus2_pz'] = pi_p_lv2.Pz() tofill['pi_plus3_px'] = pi_p_lv3.Px() tofill['pi_plus3_py'] = pi_p_lv3.Py() tofill['pi_plus3_pz'] = pi_p_lv3.Pz() tofill['taup_m'] = taup_lv.M() tofill['pi_minus1_px'] = pi_m_lv1.Px() tofill['pi_minus1_py'] = pi_m_lv1.Py() tofill['pi_minus1_pz'] = pi_m_lv1.Pz()
def jetdisplay(): outputfile = "Jetdisplay" displayfile = TFile(outputfile+".root","RECREATE") inputfile = "wwlj1k.root" inputfile = TFile(inputfile) print "Analyzing: "+str(inputfile)+" \n" tree = TTree() inputfile.GetObject("B4", tree) graph = TH1F("energyjet", "energyjet", 100, 0., 200.) graph2 = TH1F("energycherjet", "energycherjet", 100, 0., 200.) graph3 = TH1F("energyscinjet", "energyscinjet", 100, 0., 200.) graphmass = TH1F("mass_jet", "mass_jet", 100, 0., 200.) graph4 = TH1F("energy", "energy", 100, 0., 200.) graph5 = TH1F("energycher", "energycher", 100, 0., 200.) graph6 = TH1F("energyscin", "energyscin", 100, 0., 200.) #loop over events for Event in range(tree.GetEntries()): tree.GetEntry(Event) #Set values of the tree PrimaryParticleName = tree.PrimaryParticleName # MC truth: primary particle Geant4 name PrimaryParticleEnergy = tree.PrimaryParticleEnergy EnergyTot = tree.EnergyTot # Total energy deposited in calorimeter Energyem = tree.Energyem # Energy deposited by the em component EnergyScin = tree.EnergyScin # Energy deposited in Scin fibers (not Birk corrected) EnergyCher = tree.EnergyCher # Energy deposited in Cher fibers (not Birk corrected) NofCherenkovDetected = tree.NofCherenkovDetected # Total Cher p.e. detected BarrelR_VectorSignals = tree.VectorSignalsR # Vector of energy deposited in Scin fibers (Birk corrected) BarrelL_VectorSignals = tree.VectorSignalsL # Vector of energy deposited in Scin fibers (Birk corrected) BarrelR_VectorSignalsCher = tree.VectorSignalsCherR # Vector of Cher p.e. detected in Cher fibers BarrelL_VectorSignalsCher = tree.VectorSignalsCherL VectorR = tree.VectorR VectorL = tree.VectorL Calib_BarrelL_VectorSignals = calibration.calibscin(BarrelL_VectorSignals) Calib_BarrelR_VectorSignals = calibration.calibscin(BarrelR_VectorSignals) Calib_BarrelL_VectorSignalsCher = calibration.calibcher(BarrelL_VectorSignalsCher) Calib_BarrelR_VectorSignalsCher = calibration.calibcher(BarrelR_VectorSignalsCher) energy = float(sum(Calib_BarrelR_VectorSignals)+sum(Calib_BarrelL_VectorSignals)) energycher = float(sum(Calib_BarrelR_VectorSignalsCher)+sum(Calib_BarrelL_VectorSignalsCher)) threshold = 0.0 #(GeV) if energy>70.: #event displays with signals (p.e.) #if Event < 1: #displayfile.cd() #ROOTHistograms.create_eventdisplay_scin("Jet", BarrelR_VectorSignals, BarrelL_VectorSignals, "signal"+str(Event)) #ROOTHistograms.create_eventdisplay_cher("Jet", BarrelR_VectorSignalsCher, BarrelL_VectorSignalsCher, "signal"+str(Event)) #event displays with energy (GeV) if Event<10: displayfile.cd() ROOTHistograms.create_eventdisplay_scin("Jet_energy", Calib_BarrelR_VectorSignals, Calib_BarrelL_VectorSignals, "energy"+str(Event), threshold) ROOTHistograms.create_eventdisplay_cher("Jet_energy", Calib_BarrelR_VectorSignalsCher, Calib_BarrelL_VectorSignalsCher, "energy"+str(Event), threshold) inputparticles_scin = [] inputparticles_cher = [] #right part for towerindex in range(75*36): theta, phi, eta = newmap.maptower(towerindex, "right") energy_scin = Calib_BarrelR_VectorSignals[towerindex] pt_scin = energy_scin*np.sin(theta*math.pi/180.) energy_cher = Calib_BarrelR_VectorSignalsCher[towerindex] pt_cher = energy_cher*np.sin(theta*math.pi/180.) towerscin = TLorentzVector() towerscin.SetPtEtaPhiM(pt_scin, eta, phi*math.pi/180., 0.) towercher = TLorentzVector() towercher.SetPtEtaPhiM(pt_cher, eta, phi*math.pi/180., 0.) if energy_scin > threshold: #print "truth towers: "+str(energy_scin)+" "+str(eta)+" "+str(phi) inputparticles_scin.append(fastjet.PseudoJet(towerscin.Px(), towerscin.Py(), towerscin.Pz(), towerscin.E())) inputparticles_cher.append(fastjet.PseudoJet(towercher.Px(), towercher.Py(), towercher.Pz(), towercher.E())) #left part for towerindex in range(75*36): theta, phi, eta = newmap.maptower(towerindex, "left") energy_scin = Calib_BarrelL_VectorSignals[towerindex] pt_scin = energy_scin*np.sin(theta*math.pi/180.) energy_cher = Calib_BarrelL_VectorSignalsCher[towerindex] pt_cher = energy_cher*np.sin(theta*math.pi/180.) towerscin = TLorentzVector() towerscin.SetPtEtaPhiM(pt_scin, eta, phi*math.pi/180., 0.) towercher = TLorentzVector() towercher.SetPtEtaPhiM(pt_cher, eta, phi*math.pi/180., 0.) if energy_scin > threshold: #print "truth towers: "+str(energy_scin)+" "+str(eta)+" "+str(phi) inputparticles_scin.append(fastjet.PseudoJet(towerscin.Px(), towerscin.Py(), towerscin.Pz(), towerscin.E())) inputparticles_cher.append(fastjet.PseudoJet(towercher.Px(), towercher.Py(), towercher.Pz(), towercher.E())) jet_def = fastjet.JetDefinition(fastjet.ee_genkt_algorithm, 2*math.pi, 1.) clust_seq = fastjet.ClusterSequence(inputparticles_scin, jet_def) print "Event: "+str(Event)+" energy (GeV): "+str(energy)+" n-jets: "+str(len(clust_seq.exclusive_jets(int(2))))+" truth: "+str(len(inputparticles_scin)) clust_seq_cher = fastjet.ClusterSequence(inputparticles_cher, jet_def) jet1_scin = fastjet.sorted_by_E(clust_seq.exclusive_jets(int(2)))[0] jet2_scin = fastjet.sorted_by_E(clust_seq.exclusive_jets(int(2)))[1] jet1_cher = fastjet.sorted_by_E(clust_seq_cher.exclusive_jets(int(2)))[0] jet2_cher = fastjet.sorted_by_E(clust_seq_cher.exclusive_jets(int(2)))[1] print "DeltaR jet1_scin: "+str(jet1_scin.delta_R(jet1_cher))+" "+str(jet1_scin.delta_R(jet2_cher)) c = 0.34 #chi factor jet1, jet2 = mergejet(jet1_scin, jet2_scin, jet1_cher, jet2_cher) graph.Fill(jet1.e()+jet2.e()) graph3.Fill(jet1_scin.e()+jet2_scin.e()) graph2.Fill(jet1_cher.e()+jet2_cher.e()) j = jet1+jet2 graphmass.Fill(j.m()) graph4.Fill((energy-c*energycher)/(1.-c)) graph5.Fill(energycher) graph6.Fill(energy) graph.Write() graph2.Write() graph3.Write() graph4.Write() graph5.Write() graph6.Write() graphmass.Write()
def selectEvents(fileName,saveProbes=False,saveSummary=False,outputDir='./',xsec=-1,correctionsMap={}): gSystem.ExpandPathName(fileName) file=TFile.Open(fileName) #exclusivity of triggers per PD eTriggersOnly = ('SingleEle' in fileName) muTriggersOnly = ('SingleMu' in fileName) #normalizations and corrections origEvents=1.0 puWeightsGr=None if xsec>0 : origEvents=file.Get('smDataAnalyzer/cutflow').GetBinContent(1) if origEvents==0 : print '[Warning] 0 initial events ?' #derive pileup weights origPileup=file.Get('smDataAnalyzer/pileup') try: dataPileupFile=TFile.Open(correctionsMap['pu']) dataPileup=dataPileupFile.Get('pileup') normF=origPileup.Integral()/dataPileup.Integral() if normF>0 : puWeightsGr=TGraph() for xbin in xrange(1,origPileup.GetXaxis().GetNbins()+1) : iweight=1.0 if origPileup.GetBinContent(xbin)>0 : iweight=normF*dataPileup.GetBinContent(xbin)/origPileup.GetBinContent(xbin) puWeightsGr.SetPoint( puWeightsGr.GetN(), origPileup.GetXaxis().GetBinCenter(xbin), iweight ) dataPileupFile.Close() except : print 'No data pileup file provided or other error occurred. If you wish add -w pu,pu_file.root' jecCorrector=None jecUncertainty=None try: prefix='Data' if xsec>0 : prefix='MC' jecDir=correctionsMap['jec'] gSystem.ExpandPathName(jecDir) jetCorLevels='L1FastJet' jetCorFiles=jecDir+'/'+prefix+'_L1FastJet_AK5PFchs.txt' jetCorLevels=jetCorLevels+':L2Relative' jetCorFiles=jetCorFiles+':'+jecDir+'/'+prefix+'_L2Relative_AK5PFchs.txt' jetCorLevels=jetCorLevels+':L3Absolute' jetCorFiles=jetCorFiles+':'+jecDir+'/'+prefix+'_L3Absolute_AK5PFchs.txt' #if prefix=='Data': # jetCorLevels=jetCorLevels+':L2L3Residual' # jetCorFiles=jetCorFiles+':'+jecDir+'/'+prefix+'_L2L3Residual_AK5PFchs.txt' jecCorrector=FactorizedJetCorrector(jetCorLevels,jetCorFiles) print 'Jet energy corrector initialized with levels ',jetCorLevels,' for ',prefix if prefix=='MC': jecUncertainty=JetCorrectionUncertainty(jecDir+"/"+prefix+"_Uncertainty_AK5PFchs.txt") print 'Jet uncertainty is ',jecUncertainty except Exception as e: print '[Error]',e tree=file.Get("smDataAnalyzer/data") nev = tree.GetEntries() outUrl=outputDir+'/'+os.path.basename(fileName) monitor=Monitor(outUrl) #same the initial normalization and cross section monitor.addValue(origEvents,'iniEvents') monitor.addValue(xsec,'crossSection') #some basic histograms monitor.addHisto('nvtx', ';Vertices;Events', 50,0,50) monitor.addHisto('nvtxraw', ';Vertices;Events', 50,0,50) monitor.addHisto('vmass', ';Mass [GeV];Events', 50,0,250) monitor.addHisto('vmt', ';Transverse mass [GeV];Events', 50,0,250) monitor.addHisto('vpt', ';Boson transverse momentum [GeV];Events',50,0,250) monitor.addHisto('leg1pt', ';Transverse momentum [GeV];Events', 50,0,250) monitor.addHisto('leg2pt', ';Transverse momentum [GeV];Events', 50,0,250) monitor.addHisto('leg1iso', ';Relative isolation;Events', 50,0,0.5) monitor.addHisto('leg2iso', ';Relative isolation;Events', 50,0,0.5) #save a summary ntuple for analysis summaryTuple=None if saveSummary : varList='cat:weight:nvtx:njets' varList=varList+':v_mass:v_mt:v_pt:genv_mass:genv_pt' varList=varList+':leg1_pt:leg1_eta:leg1_phi:genleg1_pt:leg1_relIso' varList=varList+':leg2_pt:leg2_eta:leg2_phi:genleg2_pt:leg2_relIso' varList=varList+':sumEt:ht' varList=varList+':met_lesup:met_lesdown:met_jesup:met_jesdown:met_jerup:met_jerdown:met_umetup:met_umetdown' summaryTuple=TNtuple('data','summary',varList) summaryTuple.SetDirectory(0) monitor.addObject(summaryTuple) #save a dedicated ntuple for Tag and Probe probesTuple=None probesId = array.array( 'f', [ 0 ] ) probesPt = array.array( 'f', [ 0 ] ) probesEta = array.array( 'f', [ 0 ] ) probesPhi = array.array( 'f', [ 0 ] ) probesNvtx = array.array( 'f', [ 0 ] ) probesMass = array.array( 'f', [ 0 ] ) probesIsMatched = array.array( 'i', [0] ) probesPassLoose = array.array( 'i', [ 0 ] ) probesPassTight = array.array( 'i', [ 0 ] ) probesFireTrigger = array.array( 'i', [ 0 ] ) if saveProbes : probesTuple=TTree('tandp','summary for tandp') probesTuple.Branch( 'id', probesId, 'id/F' ) probesTuple.Branch( 'pt', probesPt, 'pt/F' ) probesTuple.Branch( 'eta', probesEta, 'eta/F' ) probesTuple.Branch( 'phi', probesPhi, 'phi/F' ) probesTuple.Branch( 'nvtx', probesNvtx, 'nvtx/F' ) probesTuple.Branch( 'mass', probesMass, 'mass/F' ) probesTuple.Branch( 'isMatched', probesIsMatched, 'isMatched/I' ) probesTuple.Branch( 'passLoose', probesPassLoose, 'passLoose/I' ) probesTuple.Branch( 'passTight', probesPassTight, 'passTight/I' ) probesTuple.Branch( 'fireTrigger', probesFireTrigger, 'fireTrigger/I' ) probesTuple.SetDirectory(0) monitor.addObject(probesTuple) # # LOOP OVER THE EVENTS # for iev in xrange(0,nev): tree.GetEntry(iev) if iev%10000 == 0 : sys.stdout.write("\r[ %d/100 ] completed" %(100.*iev/nev)) sys.stdout.flush() #check mc truth (select V bosons from the hard process genBosonP4=TLorentzVector(0,0,0,0) genNeutP4=TLorentzVector(0,0,0,0) for g in xrange(0,tree.mcn): if tree.mc_status[g]!=3 : continue genP4=TLorentzVector(tree.mc_px[g],tree.mc_py[g],tree.mc_pz[g],tree.mc_en[g]) if abs(tree.mc_id[g])==12 or abs(tree.mc_id[g])==14 or abs(tree.mc_id[g])==14 : genNeutP4=genNeutP4+genP4 if abs(tree.mc_id[g])!=23 and abs(tree.mc_id[g])!=24 : continue genBosonP4=genP4 #get triggers that fired eFire,mFire,emFire=decodeTriggerWord(tree.tbits) if eTriggersOnly : mFire=False if muTriggersOnly : eFire=False #select the leptons leptonCands=[] validTags=[] lepSums=[TLorentzVector(0,0,0,0)]*3 lepFlux=TLorentzVector(0,0,0,0) for l in xrange(0,tree.ln) : lep=LeptonCand(tree.ln_id[l],tree.ln_px[l],tree.ln_py[l],tree.ln_pz[l],tree.ln_en[l]) if lep.p4.Pt()<20 : continue if abs(tree.ln_id[l])==11 : if math.fabs(lep.p4.Eta())>2.5 : continue if math.fabs(lep.p4.Eta())>1.4442 and math.fabs(lep.p4.Eta())<1.566 : continue if abs(tree.ln_id[l])==13 : if math.fabs(lep.p4.Eta())>2.1 : continue relIso, isLoose, isLooseIso, isTight, isTightIso = selectLepton(tree.ln_id[l],tree.ln_idbits[l],tree.ln_gIso[l],tree.ln_chIso[l],tree.ln_nhIso[l],tree.ln_puchIso[l],lep.p4.Pt()) lep.selectionInfo(relIso,isLoose, isLooseIso, isTight, isTightIso) lep.triggerInfo(tree.ln_Tbits[l]) #check the generator level information genMatchIdx=tree.ln_genid[l] if genMatchIdx < tree.mcn : lep.genMatch(tree.mc_id[genMatchIdx],tree.mc_px[genMatchIdx],tree.mc_py[genMatchIdx],tree.mc_pz[genMatchIdx],tree.mc_en[genMatchIdx]) else : lep.genMatch(0,0,0,0,0) leptonCands.append(lep) if not saveProbes: continue if not isTight or not isTightIso or lep.Tbits==0 : continue if abs(lep.id)==11 and not eFire: continue if abs(lep.id)==13 and not mFire: continue validTags.append( len(leptonCands)-1 ) lepSums[1]=lepSums[1]+lep.getP4('lesup')-lep.p4 lepSums[2]=lepSums[2]+lep.getP4('lesdown')-lep.p4 lepFlux=lepFlux+lep.p4 #check if probes tree should be saved if saveProbes and len(validTags)>0: # choose a random tag tagIdx=random.choice(validTags) tag=leptonCands[tagIdx] #find probe probe=None for l in xrange(0,len(leptonCands)) : if l==tagIdx: continue if abs(tag.id)!=abs(leptonCands[l].id) : continue probe=leptonCands[l] break #for electrons save superclusters if probe is not found matchToEle=1 #if abs(tag.id)==11 and probe is None : # matchToEle=0 # for sc in xrange(0,tree.scn) : # sc_en=tree.scn_e[sc] # sc_eta=tree.scn_eta[sc] # sc_phi=tree.scn_phi[sc] # sc_pt=sc_en/math.cosh(sc_eta) # sc_p4=TLorentzVector(0,0,0,0) # sc_p4.SetPtEtaPhiE(sc_pt,sc_eta,sc_phi,sc_en) # lscp4=tag.p4+sc_p4 # if math.fabs(lscp4.M()-91)>30 : continue # scCand=LeptonCand(tag.id,sc_p4.Px(),sc_p4.Py(),sc_p4.Pz(),sc_p4.E()) # scCand.selectionInfo(0,0,0,0,0) # scCand.triggerInfo(0) # probe=scCand # break if abs(tag.id)==13 : matchToEle=0 #save info if probe is not None: tpp4=tag.p4+probe.p4 if math.fabs(tpp4.M()-91)<30 : probesId[0]=probe.id probesPt[0]=probe.p4.Pt() probesEta[0]=probe.p4.Eta() probesPhi[0]=probe.p4.Phi() probesNvtx[0]=tree.nvtx probesMass[0]=tpp4.M() probesIsMatched[0]=(probe.genId!=0) probesPassLoose[0]=(probe.passLoose and probe.passLooseIso) probesPassTight[0]=(probe.passTight and probe.passTightIso) probesFireTrigger[0]=(probe.Tbits>0) probesTuple.Fill() #jets selJets=[] jetSums=[TLorentzVector(0,0,0,0)]*5 jetFlux=TLorentzVector(0,0,0,0) ht=0 for j in xrange(0,tree.jn) : jet=JetCand(tree.jn_px[j],tree.jn_py[j],tree.jn_pz[j],tree.jn_en[j],tree.jn_area[j],tree.jn_torawsf[j]) #cross clean with loose isolated leptons overlapFound=False for l in leptonCands: if not l.passLoose or not l.passLooseIso : continue dR=jet.p4.DeltaR(l.p4) if dR>0.4 : continue overlapFound=True break if overlapFound: continue #very loose kinematics cuts if math.fabs(jet.p4.Eta())>4.7 or jet.p4.Pt()<10 : continue #save it jet.genMatch(tree.jn_genpx[j],tree.jn_py[j],tree.jn_pz[j],tree.jn_en[j],tree.jn_genid[j],tree.jn_genflav[j]) jet.updateJEC(jecCorrector,jecUncertainty,tree.rho,tree.nvtx) selJets.append(jet) #account for all the corrections you have applied jetSums[0]=jetSums[0] + jet.getCorrectedJet() - jet.getCorrectedJet('raw') jetSums[1]=jetSums[1] + jet.getCorrectedJet('jesup') - jet.getCorrectedJet() jetSums[2]=jetSums[2] + jet.getCorrectedJet('jesdown') - jet.getCorrectedJet() jetSums[3]=jetSums[3] + jet.getCorrectedJet('jerup') - jet.getCorrectedJet() jetSums[4]=jetSums[4] + jet.getCorrectedJet('jerdown') - jet.getCorrectedJet() jetFlux=jetFlux+jet.p4 ht=ht+jet.p4.Pt() # met metCand=METCand(tree.met_pt[0]*math.cos(tree.met_phi[0]),tree.met_pt[0]*math.sin(tree.met_phi[0]),0,tree.met_pt[0]) metCand.genMatch(genNeutP4.Px(),genNeutP4.Py(),genNeutP4.Pz(),genNeutP4.E()) metCand.addSumEts(tree.met_sumet[0], tree.met_chsumet[0]) metCand.addJetCorrections(jetSums) metCand.addLeptonCorrections(lepSums) unclFlux=-(metCand.p4+lepFlux+jetFlux) unclSums=[TLorentzVector(0,0,0,0),unclFlux*0.10,unclFlux*(-0.10)] metCand.addUnclusteredCorrections(unclSums) #build the candidate vCand=buildVcand(eFire,mFire,emFire,leptonCands,metCand) if vCand is None : continue #prepare to save weight=1.0 if puWeightsGr is not None: weight=puWeightsGr.Eval(tree.ngenITpu) #show isolations for ileg in [0,1]: hname='leg'+str(ileg+1)+'iso' lid='' if abs(vCand.m_legs[ileg].id)==11 : lid='e' elif abs(vCand.m_legs[ileg].id)==13 : lid='mu' else : continue monitor.fill(hname,[lid],vCand.m_legs[ileg].relIso,weight) tags=[vCand.tag] monitor.fill('nvtxraw',tags, tree.nvtx, 1.0) monitor.fill('nvtx', tags, tree.nvtx, weight) monitor.fill('vmass', tags, vCand.p4.M(), weight) monitor.fill('vpt', tags, vCand.p4.Pt(), weight) monitor.fill('leg1pt', tags, vCand.m_legs[0].p4.Pt(), weight) monitor.fill('leg2pt', tags, vCand.m_legs[1].p4.Pt(), weight) for var in ['','lesup','lesdown','jesup','jesdown','jerup','jerdown','umetup','umetdown']: mtVar=vCand.computeMt(var) monitor.fill('vmt', [vCand.tag+var], mtVar, weight) if saveSummary : values=[ vCand.id, weight, tree.nvtx, len(selJets), vCand.p4.M(), vCand.mt, vCand.p4.Pt(), genBosonP4.M(), genBosonP4.Pt(), vCand.m_legs[0].p4.Pt(),vCand.m_legs[0].p4.Eta(),vCand.m_legs[0].p4.Phi(), vCand.m_legs[0].genP4.Pt(), vCand.m_legs[0].relIso, vCand.m_legs[1].p4.Pt(),vCand.m_legs[1].p4.Eta(),vCand.m_legs[1].p4.Phi(), vCand.m_legs[1].genP4.Pt(), vCand.m_legs[1].relIso, metCand.sumet, ht, metCand.p4Vars['lesup'].Pt(),metCand.p4Vars['lesdown'].Pt(),metCand.p4Vars['jesup'].Pt(),metCand.p4Vars['jesdown'].Pt(),metCand.p4Vars['jerup'].Pt(),metCand.p4Vars['jerdown'].Pt(),metCand.p4Vars['umetup'].Pt(),metCand.p4Vars['umetdown'].Pt() ] summaryTuple.Fill(array.array("f",values)) file.Close() monitor.close()