def mass(tau1, tau2, METpx, METpy):
"""
Calculate and return the collinear mass and momentum fractions
of tau1 and tau2
TODO: set visible mass of taus. 1.2 GeV for 3p and 0.8 GeV for 1p
"""
recTau1 = TLorentzVector()
recTau2 = TLorentzVector()
# tau 4-vector; synchronize for MMC calculation
if tau1.numTrack < 3:
recTau1.SetPtEtaPhiM(tau1.pt, tau1.eta, tau1.phi, 800.) # MeV
else:
recTau1.SetPtEtaPhiM(tau1.pt, tau1.eta, tau1.phi, 1200.) # MeV
if tau2.numTrack < 3:
recTau2.SetPtEtaPhiM(tau2.pt, tau2.eta, tau2.phi, 800.) # MeV
else:
recTau2.SetPtEtaPhiM(tau2.pt, tau2.eta, tau2.phi, 1200.) # MeV
K = ROOT.TMatrixD(2, 2)
K[0][0] = recTau1.Px()
K[0][1] = recTau2.Px()
K[1][0] = recTau1.Py()
K[1][1] = recTau2.Py()
if K.Determinant() == 0:
return -1., -1111., -1111.
M = ROOT.TMatrixD(2, 1)
M[0][0] = METpx
M[1][0] = METpy
Kinv = K.Invert()
X = Kinv * M
X1 = X(0, 0)
X2 = X(1, 0)
x1 = 1. / (1. + X1)
x2 = 1. / (1. + X2)
p1 = recTau1 * (1. / x1)
p2 = recTau2 * (1. / x2)
m_col = (p1 + p2).M()
m_vis = (recTau1 + recTau2).M()
return m_vis, m_col, x1, x2
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 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 TransBoosted_Angle(pt1,eta1,phi1,pt2,eta2,phi2,ptz,etaz,phiz,mass,Met,Metphi): mu1 = TLorentzVector() mu2 = TLorentzVector() zb = TLorentzVector() met = TLorentzVector() mu1.SetPtEtaPhiM(pt1,0,phi1,0) mu2.SetPtEtaPhiM(pt2,0,phi2,0) zb.SetPtEtaPhiM(ptz,0,phiz,mass) MET.SetPtEtaPhiM(Met,0,Metphi,0) MET.Boost(-zb.Px()/zb.Et(),-zb.Py()/zb.Et(),0) mu1.Boost(-zb.Px()/zb.Et(),-zb.Py()/zb.Et(),0) mu2.Boost(-zb.Px()/zb.Et(),-zb.Py()/zb.Et(),0) angleBoost_1 = MET.DeltaPhi(mu1) angleBoost_2 = MET.DeltaPhi(mu2) angleBoost_Z = MET.DeltaPhi(zb) return [angleBoost_Z,angleBoost_1,angleBoost_2]
def PTmiss_vect(Energy,parts): # here parts is visible parts #p=parts[0].p4-parts[0].p4 p=TLorentzVector(0,0,0,Energy) for part in parts: p=p-part.P4() return p.Px(),p.Py()
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()
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)
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(),
)
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 analyze(self, event):
eventWeightLumi, lheWeight, stitchWeight, puWeight, qcdnloWeight, qcdnnloWeight, ewknloWeight, topWeight = 1., 1., 1., 1., 1., 1., 1., 1.
triggerWeight, leptonWeight = 1., 1.
isSingleMuonTrigger, isSingleMuonPhotonTrigger, isSingleMuonNoFiltersPhotonTrigger, isDoubleMuonTrigger, isDoubleMuonPhotonTrigger, isJPsiTrigger, isDisplacedTrigger = False, False, False, False, False, False, False
nCleanElectron, nCleanMuon, nCleanTau, nCleanPhoton, nCleanJet, nCleanBTagJet, HT30 = 0, 0, 0, 0, 0, 0, 0
cosThetaStar, cosTheta1, phi1 = -2., -2., -4.
genCosThetaStar, genCosTheta1, genPhi1 = -2., -2., -4.
for t in self.SingleMuonTriggers:
if hasattr(event, t) and getattr(event, t): isSingleMuonTrigger = True
for t in self.SingleMuonPhotonTriggers:
if hasattr(event, t) and getattr(event, t): isSingleMuonPhotonTrigger = True
for t in self.SingleMuonNoFiltersPhotonTriggers:
if hasattr(event, t) and getattr(event, t): isSingleMuonNoFiltersPhotonTrigger = True
for t in self.DoubleMuonTriggers:
if hasattr(event, t) and getattr(event, t): isDoubleMuonTrigger = True
for t in self.DoubleMuonPhotonTriggers:
if hasattr(event, t) and getattr(event, t): isDoubleMuonPhotonTrigger = True
for t in self.JPsiTriggers:
if hasattr(event, t) and getattr(event, t): isJPsiTrigger = True
for t in self.DisplacedTriggers:
if hasattr(event, t) and getattr(event, t): isDisplacedTrigger = True
lheWeight = 1.
if self.isMC:
# Event weight
if not self.isLO and hasattr(event, "LHEWeight_originalXWGTUP"): lheWeight = event.LHEWeight_originalXWGTUP
# PU weight
puWeight = self.puTool.getWeight(event.Pileup_nTrueInt)
self.hists["Nevents"].Fill(0, lheWeight)
self.hists["Acceptance"].Fill(0, lheWeight)
self.hists["Cutflow"].Fill(0, lheWeight)
# Gen studies
if self.isMC and self.isSignal:
genHIdx, genJPsiIdx, genMuon1Idx, genMuon2Idx, genPhotonIdx = -1, -1, -1, -1, -1
# print "-"*40
for i in range(event.nGenPart):
# print i, "\t", event.GenPart_pdgId[i], "\t", event.GenPart_status[i], "\t", event.GenPart_statusFlags[i], "\t", event.GenPart_pt[i]
if event.GenPart_pdgId[i] == 25 or event.GenPart_pdgId[i] == 23: genHIdx = i
if event.GenPart_pdgId[i] == 443 and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] == 25: genJPsiIdx = i
if event.GenPart_pdgId[i] == 22 and event.GenPart_status[i] in [1, 23] and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] == 25: genPhotonIdx = i #and (genPhotonIdx < 0 or event.GenPart_pt[i] > event.GenPart_pt[genPhotonIdx])
if event.GenPart_pdgId[i] == -13 and event.GenPart_status[i] == 1 and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] != 22 and (genMuon1Idx < 0 or event.GenPart_pt[i] > event.GenPart_pt[genMuon1Idx]): genMuon1Idx = i
if event.GenPart_pdgId[i] == +13 and event.GenPart_status[i] == 1 and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] != 22 and (genMuon2Idx < 0 or event.GenPart_pt[i] > event.GenPart_pt[genMuon2Idx]): genMuon2Idx = i
if genHIdx >= 0 and genJPsiIdx >= 0 and genPhotonIdx >= 0 and genMuon1Idx >= 0 and genMuon2Idx >= 0:
genH, genJPsi, genMuon1, genMuon2, genPhoton = TLorentzVector(), TLorentzVector(), TLorentzVector(), TLorentzVector(), TLorentzVector()
if genHIdx >= 0: genH.SetPtEtaPhiM(event.GenPart_pt[genHIdx], event.GenPart_eta[genHIdx], event.GenPart_phi[genHIdx], event.GenPart_mass[genHIdx])
if genJPsiIdx >= 0: genJPsi.SetPtEtaPhiM(event.GenPart_pt[genJPsiIdx], event.GenPart_eta[genJPsiIdx], event.GenPart_phi[genJPsiIdx], event.GenPart_mass[genJPsiIdx])
if genPhotonIdx >= 0: genPhoton.SetPtEtaPhiM(event.GenPart_pt[genPhotonIdx], event.GenPart_eta[genPhotonIdx], event.GenPart_phi[genPhotonIdx], event.GenPart_mass[genPhotonIdx])
if genMuon1Idx >= 0: genMuon1.SetPtEtaPhiM(event.GenPart_pt[genMuon1Idx], event.GenPart_eta[genMuon1Idx], event.GenPart_phi[genMuon1Idx], event.GenPart_mass[genMuon1Idx])
if genMuon2Idx >= 0: genMuon2.SetPtEtaPhiM(event.GenPart_pt[genMuon2Idx], event.GenPart_eta[genMuon2Idx], event.GenPart_phi[genMuon2Idx], event.GenPart_mass[genMuon2Idx])
# Recalculate candidate 4-vectors for consistent calculation of angular variables
genJPsi = genMuon1 + genMuon2
genH = genJPsi + genPhoton
genCosThetaStar, genCosTheta1, genPhi1 = self.returnCosThetaStar(genH, genJPsi), self.returnCosTheta1(genJPsi, genMuon1, genMuon2, genPhoton), self.returnPhi1(genH, genMuon1, genMuon2)
self.hists["genH_pt"].Fill(genH.Pt(), lheWeight)
self.hists["genH_eta"].Fill(genH.Eta(), lheWeight)
self.hists["genH_phi"].Fill(genH.Phi(), lheWeight)
self.hists["genH_mass"].Fill(genH.M(), lheWeight)
self.hists["genJPsi_pt"].Fill(genJPsi.Pt(), lheWeight)
self.hists["genJPsi_eta"].Fill(genJPsi.Eta(), lheWeight)
self.hists["genJPsi_phi"].Fill(genJPsi.Phi(), lheWeight)
self.hists["genJPsi_mass"].Fill(genJPsi.M(), lheWeight)
self.hists["genPhoton_pt"].Fill(genPhoton.Pt(), lheWeight)
self.hists["genPhoton_eta"].Fill(genPhoton.Eta(), lheWeight)
self.hists["genMuon1_pt"].Fill(max(genMuon1.Pt(), genMuon2.Pt()), lheWeight)
self.hists["genMuon1_eta"].Fill(genMuon1.Eta(), lheWeight)
self.hists["genMuon2_pt"].Fill(min(genMuon1.Pt(), genMuon2.Pt()), lheWeight)
self.hists["genMuon2_eta"].Fill(genMuon2.Eta(), lheWeight)
self.hists["genCosThetaStar"].Fill(genCosThetaStar, lheWeight)
self.hists["genCosTheta1"].Fill(genCosTheta1, lheWeight)
self.hists["genPhi1"].Fill(genPhi1, lheWeight)
self.hists["genCosThetaStarZtoMM"].Fill(self.returnCosThetaStar(genH, genMuon1), lheWeight)
# Reweight
topWeight = 3./4. * (1. + genCosTheta1**2) # Transverse polarization (H, Z)
if 'ZToJPsiG' in self.sampleName:
stitchWeight = 3./2. * (1. - genCosTheta1**2) # Longitudinal polarization (Z)
# Acceptance
if abs(genPhoton.Eta()) < 2.5:
self.hists["Acceptance"].Fill(1, lheWeight)
if abs(genMuon1.Eta()) < 2.4:
self.hists["Acceptance"].Fill(2, lheWeight)
if abs(genMuon2.Eta()) < 2.4:
self.hists["Acceptance"].Fill(3, lheWeight)
self.hists["Cutflow"].Fill(1, lheWeight)
if genPhoton.Pt() > 15. and genMuon1.Pt() > 5. and genMuon2.Pt() > 5.:
self.hists["Acceptance"].Fill(4, lheWeight)
# Muons
m1, m2 = -1, -1
for i in range(event.nMuon):
if event.Muon_pt[i] > self.thMuons[0 if m1 < 0 else 1] and abs(event.Muon_eta[i]) < 2.4 and event.Muon_looseId[i]:
if m1 < 0: m1 = i
if m2 < 0 and m1 >= 0 and event.Muon_charge[m1] != event.Muon_charge[i]: m2 = i
if m1 < 0 or m2 < 0:
if self.verbose >= 2: print "- No OS loose muons in acceptance"
return False
self.hists["Cutflow"].Fill(2, lheWeight)
muon1, muon2 = TLorentzVector(), TLorentzVector()
muon1.SetPtEtaPhiM(event.Muon_pt[m1], event.Muon_eta[m1], event.Muon_phi[m1], event.Muon_mass[m1])
muon2.SetPtEtaPhiM(event.Muon_pt[m2], event.Muon_eta[m2], event.Muon_phi[m2], event.Muon_mass[m2])
muonP = muon1 if event.Muon_charge[m1] > event.Muon_charge[m2] else muon2
muonM = muon1 if event.Muon_charge[m1] < event.Muon_charge[m2] else muon2
muon1v2, muon2v2 = TVector2(muon1.Px(), muon1.Py()), TVector2(muon2.Px(), muon2.Py())
jpsi = muon1 + muon2
if jpsi.M() < 2. or jpsi.M() > 12.:
if self.verbose >= 2: print "- Dimuon invariant mass < 2 or > 12 GeV"
return False
self.hists["Cutflow"].Fill(3, lheWeight)
# Photons
p0 = -1
for i in range(event.nPhoton):
if event.Photon_pt[i] > self.thPhoton[0] and abs(event.Photon_eta[i]) < 2.5 and event.Photon_pfRelIso03_all[i] < 0.25: # and event.Photon_mvaID_WP80[i]:
if p0 < 0: p0 = i
if p0 < 0:
if self.verbose >= 2: print "- No isolated photons in acceptance"
return False
self.hists["Cutflow"].Fill(4, lheWeight)
photon = TLorentzVector()
photon.SetPtEtaPhiM(event.Photon_pt[p0], event.Photon_eta[p0], event.Photon_phi[p0], event.Photon_mass[p0])
photonv2 = TVector2(photon.Px(), photon.Py())
met, metPlusPhoton = TVector2(), TVector2()
met.SetMagPhi(event.MET_pt, event.MET_phi)
metPlusPhoton.Set(met.Px() + photon.Px(), met.Py() + photon.Py())
h = jpsi + photon
jpsi_pt = jpsi.Pt()
jpsi_eta = jpsi.Eta()
jpsi_phi = jpsi.Phi()
jpsi_mass = jpsi.M()
jpsi_dEta = abs(muon1.Eta() - muon2.Eta())
jpsi_dPhi = abs(muon1.DeltaPhi(muon2))
jpsi_dR = muon1.DeltaR(muon2)
h_pt = h.Pt()
h_eta = h.Eta()
h_phi = h.Phi()
h_mass = h.M()
h_dEta = abs(jpsi.Eta() - photon.Eta())
h_dPhi = abs(jpsi.DeltaPhi(photon))
h_dR = jpsi.DeltaR(photon)
Muon1TrkIso, Muon2TrkIso = event.Muon_tkRelIso[m1], event.Muon_tkRelIso[m2]
if jpsi_dR < 0.3:
Muon1TrkIso = max(0., (Muon1TrkIso * event.Muon_pt[m1] * event.Muon_tunepRelPt[m1] - event.Muon_pt[m2] * event.Muon_tunepRelPt[m2])) / (event.Muon_pt[m1] * event.Muon_tunepRelPt[m1])
Muon2TrkIso = max(0., (Muon2TrkIso * event.Muon_pt[m2] * event.Muon_tunepRelPt[m2] - event.Muon_pt[m1] * event.Muon_tunepRelPt[m1])) / (event.Muon_pt[m2] * event.Muon_tunepRelPt[m2])
minMuonTrkIso = min(Muon1TrkIso, Muon2TrkIso)
maxMuonTrkIso = max(Muon1TrkIso, Muon2TrkIso)
minMuonIso = min(event.Muon_pfRelIso03_all[m1], event.Muon_pfRelIso03_all[m2])
maxMuonIso = max(event.Muon_pfRelIso03_all[m1], event.Muon_pfRelIso03_all[m2])
minMuonMetDPhi = min(abs(muon1v2.DeltaPhi(met)), abs(muon2v2.DeltaPhi(met)))
maxMuonMetDPhi = max(abs(muon1v2.DeltaPhi(met)), abs(muon2v2.DeltaPhi(met)))
photonMetDPhi = abs(photonv2.DeltaPhi(met))
metPlusPhotonDPhi = abs(met.DeltaPhi(metPlusPhoton))
cosThetaStar = self.returnCosThetaStar(h, jpsi)
cosTheta1 = self.returnCosTheta1(jpsi, muonP, muonM, photon)
phi1 = self.returnPhi1(h, muonP, muonM)
# Weights
# if self.isMC:
# triggerWeight = self.muSFs.getTriggerSF(event.Muon_pt[m1], event.Muon_eta[m1])
# IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0], event.Muon_eta[0], 2)
# IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0], event.Muon_eta[0])
# IdSF2 = self.muSFs.getIdSF(event.Muon_pt[1], event.Muon_eta[1], 2)
# IsoSF2 = self.muSFs.getIsoSF(event.Muon_pt[1], event.Muon_eta[1])
# IdIsoSF3 = self.elSFs.getIdIsoSF(event.Electron_pt[0], event.Electron_eta[0])
# leptonWeight = IdSF1 * IsoSF1 * IdSF2 * IsoSF2 * IdIsoSF3
passedMETFilters = True
filters = ["Flag_goodVertices", "Flag_globalSuperTightHalo2016Filter", "Flag_BadPFMuonFilter", "Flag_EcalDeadCellTriggerPrimitiveFilter", "Flag_HBHENoiseFilter", "Flag_HBHENoiseIsoFilter", "Flag_ecalBadCalibFilter", "Flag_ecalBadCalibFilterV2"]
if not self.isMC: filters += ["Flag_eeBadScFilter"]
for f in filters:
if hasattr(event, f) and getattr(event, f) == False: passedMETFilters = False
# try:
## if event.Flag_goodVertices: print "Flag_goodVertices"
## if event.Flag_globalSuperTightHalo2016Filter: print "Flag_globalSuperTightHalo2016Filter"
## if event.Flag_BadPFMuonFilter: print "Flag_BadPFMuonFilter"
## if event.Flag_EcalDeadCellTriggerPrimitiveFilter: print "Flag_EcalDeadCellTriggerPrimitiveFilter"
## if event.Flag_HBHENoiseFilter: print "Flag_HBHENoiseFilter"
## if event.Flag_HBHENoiseIsoFilter: print "Flag_HBHENoiseIsoFilter"
### if (self.isMC or event.Flag_eeBadScFilter): print "Flag_eeBadScFilter"
## if event.Flag_ecalBadCalibFilter: print "Flag_ecalBadCalibFilterV2"
# if event.Flag_goodVertices and event.Flag_globalSuperTightHalo2016Filter and event.Flag_BadPFMuonFilter and event.Flag_EcalDeadCellTriggerPrimitiveFilter and event.Flag_HBHENoiseFilter and event.Flag_HBHENoiseIsoFilter: # and event.Flag_ecalBadCalibFilter: #and (self.isMC or event.Flag_eeBadScFilter): FIXME
# passedMETFilters = True
## if not self.isMC:
## if not event.Flag_eeBadScFilter:
## passedMETFilters = False
# except:
# passedMETFilters = False
### Event variables ###
# Muons
for i in range(event.nMuon):
if i != m1 and i != m2 and event.Muon_pt[i] > 10. and abs(event.Muon_eta[i]) < 2.4 and event.Muon_looseId[i] and event.Muon_pfRelIso03_all[i] < 0.15:
nCleanMuon += 1
# Electrons
for i in range(event.nElectron):
if event.Electron_pt[i] > 10. and abs(event.Electron_eta[i]) < 2.5 and event.Electron_cutBased[i] >= 2:
nCleanElectron += 1
# Taus
for i in range(event.nTau):
if event.Tau_pt[i] > 20. and abs(event.Tau_eta[i]) < 2.5 and event.Tau_idDeepTau2017v2p1VSe[i] >= 16 and event.Tau_idDeepTau2017v2p1VSmu[i] >= 8 and event.Tau_idDeepTau2017v2p1VSjet[i] >= 16 and event.Tau_rawIsodR03[i] < 0.15:
nCleanTau += 1
# Photons
for i in range(event.nPhoton):
if i != p0 and event.Photon_pt[i] > 15. and abs(event.Photon_eta[i]) < 2.5 and event.Photon_pfRelIso03_all[i] < 0.15 and event.Photon_mvaID_WP90[i]:
nCleanPhoton += 1
# Jets and Event variables
for i in range(event.nJet):
if event.Jet_jetId[i] >= 6 and abs(event.Jet_eta[i]) < 2.5:
HT30 += event.Jet_pt[i]
nCleanJet += 1
if event.Jet_btagDeepB[i] >= self.btagMedium: nCleanBTagJet += 1
if self.isMC: eventWeightLumi = self.lumiWeight * lheWeight * puWeight * topWeight * qcdnloWeight * qcdnnloWeight * ewknloWeight * triggerWeight * leptonWeight
self.out.fillBranch("isMC", self.isMC)
self.out.fillBranch("is2016", (self.year == 2016))
self.out.fillBranch("is2017", (self.year == 2017))
self.out.fillBranch("is2018", (self.year == 2018))
self.out.fillBranch("isSingleMuonTrigger", isSingleMuonTrigger)
self.out.fillBranch("isSingleMuonPhotonTrigger", isSingleMuonPhotonTrigger)
self.out.fillBranch("isSingleMuonNoFiltersPhotonTrigger", isSingleMuonNoFiltersPhotonTrigger)
self.out.fillBranch("isDoubleMuonTrigger", isDoubleMuonTrigger)
self.out.fillBranch("isDoubleMuonPhotonTrigger", isDoubleMuonPhotonTrigger)
self.out.fillBranch("isJPsiTrigger", isJPsiTrigger)
self.out.fillBranch("passedMETFilters", passedMETFilters)
self.out.fillBranch("nCleanElectron", nCleanElectron)
self.out.fillBranch("nCleanMuon", nCleanMuon)
self.out.fillBranch("nCleanTau", nCleanTau)
self.out.fillBranch("nCleanPhoton", nCleanPhoton)
self.out.fillBranch("nCleanJet", nCleanJet)
self.out.fillBranch("nCleanBTagJet", nCleanBTagJet)
self.out.fillBranch("HT30", HT30)
self.out.fillBranch("iPhoton", p0)
self.out.fillBranch("iMuon1", m1)
self.out.fillBranch("iMuon2", m2)
#
self.out.fillBranch("Muon1_pt", event.Muon_pt[m1])
self.out.fillBranch("Muon1_eta", event.Muon_eta[m1])
self.out.fillBranch("Muon2_pt", event.Muon_pt[m2])
self.out.fillBranch("Muon2_eta", event.Muon_eta[m2])
self.out.fillBranch("Muon1_pfRelIso03_all", event.Muon_pfRelIso03_all[m1])
self.out.fillBranch("Muon2_pfRelIso03_all", event.Muon_pfRelIso03_all[m2])
self.out.fillBranch("Muon1_mediumId", event.Muon_mediumId[m1])
self.out.fillBranch("Muon2_mediumId", event.Muon_mediumId[m2])
self.out.fillBranch("Muon1_ip3d", event.Muon_ip3d[m1])
self.out.fillBranch("Muon2_ip3d", event.Muon_ip3d[m2])
self.out.fillBranch("minMuonIso", minMuonIso)
self.out.fillBranch("maxMuonIso", maxMuonIso)
self.out.fillBranch("minMuonTrkIso", minMuonTrkIso)
self.out.fillBranch("maxMuonTrkIso", maxMuonTrkIso)
self.out.fillBranch("Muon12_diffdxy", abs(event.Muon_dxy[m1]-event.Muon_dxy[m2]))
self.out.fillBranch("Muon12_diffdz", abs(event.Muon_dz[m1]-event.Muon_dz[m2]))
self.out.fillBranch("Muon12_signdxy", abs(event.Muon_dxy[m1]-event.Muon_dxy[m2]) / math.sqrt(event.Muon_dxyErr[m1]**2 + event.Muon_dxyErr[m2]**2))
self.out.fillBranch("Muon12_signdz", abs(event.Muon_dz[m1]-event.Muon_dz[m2]) / math.sqrt(event.Muon_dzErr[m1]**2 + event.Muon_dzErr[m2]**2))
self.out.fillBranch("Photon1_pt", event.Photon_pt[p0])
self.out.fillBranch("Photon1_eta", event.Photon_eta[p0])
self.out.fillBranch("Photon1_mvaID_WP80", event.Photon_mvaID_WP80[p0])
self.out.fillBranch("Photon1_pfRelIso03_all", event.Photon_pfRelIso03_all[p0])
#
self.out.fillBranch("JPsi_pt", jpsi_pt)
self.out.fillBranch("JPsi_eta", jpsi_eta)
self.out.fillBranch("JPsi_phi", jpsi_phi)
self.out.fillBranch("JPsi_mass", jpsi_mass)
self.out.fillBranch("JPsi_dEta", jpsi_dEta)
self.out.fillBranch("JPsi_dPhi", jpsi_dPhi)
self.out.fillBranch("JPsi_dR", jpsi_dR)
self.out.fillBranch("H_pt", h_pt)
self.out.fillBranch("H_eta", h_eta)
self.out.fillBranch("H_phi", h_phi)
self.out.fillBranch("H_mass", h_mass)
self.out.fillBranch("H_dEta", h_dEta)
self.out.fillBranch("H_dPhi", h_dPhi)
self.out.fillBranch("H_dR", h_dR)
self.out.fillBranch("minMuonMetDPhi", minMuonMetDPhi)
self.out.fillBranch("maxMuonMetDPhi", maxMuonMetDPhi)
self.out.fillBranch("photonMetDPhi", photonMetDPhi)
self.out.fillBranch("metPlusPhotonDPhi", metPlusPhotonDPhi)
self.out.fillBranch("cosThetaStar", cosThetaStar)
self.out.fillBranch("cosTheta1", cosTheta1)
self.out.fillBranch("phi1", phi1)
self.out.fillBranch("genCosThetaStar", genCosThetaStar)
self.out.fillBranch("genCosTheta1", genCosTheta1)
self.out.fillBranch("genPhi1", genPhi1)
self.out.fillBranch("lumiWeight", self.lumiWeight)
self.out.fillBranch("lheWeight", lheWeight)
self.out.fillBranch("stitchWeight", stitchWeight)
self.out.fillBranch("puWeight", puWeight)
self.out.fillBranch("topWeight", topWeight)
self.out.fillBranch("qcdnloWeight", qcdnloWeight)
self.out.fillBranch("qcdnnloWeight", qcdnnloWeight)
self.out.fillBranch("ewknloWeight", ewknloWeight)
self.out.fillBranch("triggerWeight", triggerWeight)
self.out.fillBranch("leptonWeight", leptonWeight)
self.out.fillBranch("eventWeightLumi", eventWeightLumi)
if self.verbose >= 2: print "+ Tree filled"
return True
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()
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()
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
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
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')]))
G *= Heaviside(q1.Pt() - 30.0e+3)
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
## Skip events without a +/- charge pair
if posMu1 < 0 or negMu1 < 0: continue
## 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
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
if ((len(_lPt) != 0) & (len(_jetPt) != 0)):
total_entries1 = total_entries1 + 1
qt_l = TLorentzVector(0, 0, 0, 0)
for i in range(0, len(_lPt)):
qt_l1 = TLorentzVector(0, 0, 0, 0)
qt_l1.SetPtEtaPhiE(_lPt[i], _lEta[i], _lPhi[i], _lenergy[i])
qt_l += qt_l1
qt_jet = TLorentzVector(0, 0, 0, 0)
for i in range(0, len(_jetPt)):
qt_jet1 = TLorentzVector(0, 0, 0, 0)
qt_jet1.SetPtEtaPhiE(_jetPt[i], _jetEta[i], _jetPhi[i],
_jetenergy[i])
qt_jet += qt_jet1
qt_l_x = qt_l.Px()
qt_l_y = qt_l.Py()
qt_jet_x = qt_jet.Px()
qt_jet_y = qt_jet.Py()
qt_dot = qt_l_x * qt_jet_x + qt_l_y * qt_jet_y
up = qt_dot / (qt_l.Pt())
h_qt_qt.Fill(abs(qt_l.Pt()), abs(qt_l.Pt()))
h_qt_up.Fill(abs(qt_l.Pt()), abs(up))
test = abs(qt_l.Pt())
print "#########"
print test
print "-----"
print up
print "#########"
# ---------- save histogram --------------
taup_tofill['pi_plus3_normpt'] = pi_p_lv3.Pt() / ptTot
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()
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():
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()
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()
