def __init__(self, *args, **kwargs):
'''Defines a gTower'''
"""
initialize it by passing in kwargs that contain all information
"""
if len(args) == 2 and isinstance(args[0], pow.__class__):
super(self.__class__, self).__init__(args[0](*args[1]))
else:
newVector = bool(len(kwargs) == 6)
# require that exactly one of the sets of arguments are valid length
if not newVector:
raise ValueError('invalid number of keyword arguments supplied')
TLorentzVector.__init__(self)
validKeys = ('et', 'etamin', 'etamax', 'phimin', 'phimax', 'num_cells')
kwargs = dict((k.lower(), v) for k, v in kwargs.iteritems())
if all(k in kwargs for k in validKeys):
# set the center of the tower to the geometric center
self.SetPtEtaPhiM(kwargs['et'],
(kwargs['etamax'] + kwargs['etamin'])/2.0,
(kwargs['phimax'] + kwargs['phimin'])/2.0,
0.0)
else:
raise ValueError('Missing specific keys to make new vector, {}'.format(validKeys))
self._etamax = kwargs['etamax']
self._etamin = kwargs['etamin']
self._phimax = kwargs['phimax']
self._phimin = kwargs['phimin']
self._num_cells = np.int(kwargs['num_cells'])
def mt_with(self, *cands):
myP4 = self.p4()
lepP4 = TLorentzVector()
for lep in cands: lepP4 += lep.p4()
# squared transverse mass of system =
# (met.Et + lep.Et)^2 - (met + lep).Pt)^2
mt = math.sqrt(abs((lepP4.et() + myP4.et())**2 - ((lepP4 + myP4).pt())**2))
return mt
def __init__(self,name="<Py4Vector Object>"):
"""
Initialize the TLorentzVector (to inherit its properties).
@param name Set the name of the object, if given (useful for printing).
"""
TLorentzVector.__init__(self) # Inheriting from TLorentzVector
if name == "<Py4Vector Object>":
self.name = name+" {0}".format( id(self) ) # unique name based on object's id
else:
self.name = name
return
def __init__(self, *arg, **kwargs):
'''Defines an offline jet'''
"""
energy : jet energy, E
momentum_transverse: magnitude of momentum transverse
to beam, mag(p)*sin(theta)
mass : invariant mass of jet
pseudo-rapidity coordinates
- eta : -ln( tan[theta/2] )
- phi : polar angle in the transverse plane
-- theta is angle between particle momentum and the beam axis
-- see more: http://en.wikipedia.org/wiki/Pseudorapidity
radius : radius of jet (eta-phi coordinates)
initialize it by Jet(TLorentzVector) or Jet({'Pt': #, 'm': #, 'eta': #, 'phi': #, ...})
"""
copyVector = bool(len(arg) == 1)
newVector = bool(len(kwargs) >= 4)
# require that exactly one of the sets of arguments are valid length
if not(copyVector ^ newVector):
raise ValueError('invalid number of arguments supplied')
if copyVector:
if isinstance(arg[0], TLorentzVector):
TLorentzVector.__init__(self, arg[0])
else:
raise TypeError('expected a TLorentzVector')
else:
TLorentzVector.__init__(self)
validKeys = ('pt','eta','phi','m')
kwargs = dict((k.lower(), v) for k,v in kwargs.iteritems())
if all(k in kwargs for k in validKeys):
self.SetPtEtaPhiM(*(kwargs[k] for k in validKeys))
else:
raise ValueError('Missing specific keys to make new vector, {}'.format(validKeys))
# remember that the names are lowercased to make it consistent
self._radius = np.float(kwargs.get('radius', 1.0))
self._nsj = np.int(kwargs.get('nsj', 0))
self._tau = np.array(kwargs.get('tau', [None,None,None]))
self._split = np.array(kwargs.get('split', [None,None,None]))
self._subjetsPt = np.array(kwargs.get('subjetspt', [None]))
def test03CopyContructor( self ):
"""Test copy constructor"""
t1 = TLorentzVector( 1., 2., 3., -4. )
t2 = TLorentzVector( 0., 0., 0., 0. )
t3 = TLorentzVector( t1 )
t4 = TLorentzVector(0, 0, 0, 0)
t4.__init__(TLorentzVector(0, 1, 2, 3))
# the following should work exactly as above, but no longer does on some version of ROOT 6
t5 = TLorentzVector(0, 0, 0, 0)
TLorentzVector.__init__(t5, TLorentzVector(0, 1, 2, 3))
self.assertEqual( t1, t3 )
self.assertNotEqual( t1, t2 )
#self.assertNotEqual( t4, t5 )
for i in range(4):
self.assertEqual( t1[i], t3[i] )
self.assertEqual( t4[i], t5[i] )
def __init__(self, *args, **kwargs):
'''Defines a trigger jet'''
"""
vector : a TLorentzVector() defined from ROOT that contains
information about the Jet's 4-vector
area : jet area based on sum of gTower areas that made jet
radius : radius of jet (eta-phi coordinates)
towers_around : contains the top 3 gTowers
seed : contains the seed used for this jet
initialize it by passing in a TLorentzVector() object plus kwargs that
contain area, radius, and towers_around
"""
if len(args) == 2 and isinstance(args[0], pow.__class__):
super(self.__class__, self).__init__(args[0](*args[1]))
else:
copyVector = bool(len(args) == 1)
newVector = bool(len(kwargs) == 4)
# require that exactly one of the sets of arguments are valid length
if not(copyVector and newVector):
raise ValueError('invalid number of arguments supplied')
if isinstance(args[0], TLorentzVector):
TLorentzVector.__init__(self, args[0])
else:
raise TypeError('expected a TLorentzVector')
# TLorentzVector.__init__(self)
validKeys = ('area', 'radius', 'towers', 'seed')
kwargs = dict((k.lower(), v) for k, v in kwargs.iteritems())
if all(k in kwargs for k in validKeys):
self._area = np.float(kwargs['area'])
self._radius = np.float(kwargs['radius'])
self._towers = np.array(kwargs['towers'])
self._seed = kwargs['seed']
else:
raise ValueError('Missing specific keys to make tJet object, {}'.format(validKeys))
tau1_1[0] = 0
tau2_1[0] = 0
tau3_1[0] = 0
csv_0[0] = 0
csv_1[0] = 0
mass_asym_f[0] = 0
mass_avg[0] = 0
if data_chain.fj_ak8_num < 2:
continue
if data_chain.jet_num < 1:
continue
jet_0 = TLorentzVector(0, 0, 0, 0)
jet_1 = TLorentzVector(0, 0, 0, 0)
jet_0.SetPtEtaPhiM(data_chain.fj_ak8_pt[0], data_chain.fj_ak8_eta[0],
data_chain.fj_ak8_phi[0],
data_chain.fj_ak8_trimmed_mass[0])
jet_1.SetPtEtaPhiM(data_chain.fj_ak8_pt[1], data_chain.fj_ak8_eta[1],
data_chain.fj_ak8_phi[1],
data_chain.fj_ak8_trimmed_mass[1])
m0 = data_chain.fj_ak8_trimmed_mass[0]
m1 = data_chain.fj_ak8_trimmed_mass[1]
mass_asym = abs(m0 - m1) / (m0 + m1)
delta_eta = abs(jet_0.Eta() - jet_1.Eta())
def setFSR(self,photon):
self.fsrPhoton=photon
gamma = TLorentzVector( photon.px(), photon.py(), photon.pz(), photon.energy() )
z = TLorentzVector(self.Px(),self.Py(),self.Pz(),self.Energy())
new=gamma+z
self.SetPxPyPzE(new.Px(),new.Py(),new.Pz(),new.Energy())
def makep4(px, py, pz, e):
p4 = TLorentzVector(0., 0., 0., 0.)
p4.SetPxPyPzE(px, py, pz, e)
return p4
#for x in range(50):
#a[0]=3.0
additionalvariables = ['XS','BR','LUM','NGE','B2','B3','RND','CUT','Thrust','DeltaPz','DeltaPhi_ZH','TransMass','TransMass_Eff','CScostheta']#,'CScostheta']#,'ST','CScos']
for v in additionalvariables:
exec(v+' = numpy.zeros(1,dtype=float)')
exec('tout.Branch(\''+v+'\','+v+',\''+v+'/D\')')
#SetPtEtaPhiM
#DeltaPhi_ll = fabs(L1_4.DeltaPhi(L2_4))
for v in variables: #trees added automatically, from Ntuple
exec(v+' = numpy.zeros(1,dtype=float)')
exec('tout.Branch(\''+v+'\','+v+',\''+v+'/D\')')
L1 = TLorentzVector() ####### causes function to be out of scope?!
L2 = TLorentzVector()
ZB = TLorentzVector()
MET = TLorentzVector()
#def costheta_CS(X):
#return "HELLO"
#for h in HiggsMass:
#exec('MET'+h+' = TLorentzVector()')
#exec('TransMass'+h+' = numpy.zeros(1,dtype=float)')
#exec('tout.Branch(\'TransMass'+h+'\',TransMass'+h+',\'TransMass'+h+'/D\')')
#exec('TransMass_Eff'+h+' = numpy.zeros(1,dtype=float)')
#exec('tout.Branch(\'TransMass_Eff'+h+'\',TransMass_Eff'+h+',\'TransMass_Eff'+h+'/D\')')
def p4(self):
return TLorentzVector(self.px, self.py, self.pz, self.energy)
def evaluate( self, lplus, lminus, jets, missingET, nu = TLorentzVector(), nubar = TLorentzVector(),
doIntegration = True, coords = None, **kwargs ):
return self.__call__( lplus, lminus, jets, missingET, nu, nubar, doIntegration, coords )
1000)
hmuchanFwrdJetEta = TH1D(
"hmuchanFwrdJetEta",
"Muon Channel #eta of Most Forward Jet; #eta; Events;", 40, -4.0, 4.0)
hmuchanNumBJets = TH1D(
"hmuchanNumBJets",
"Muon Channel Number of B Jets; Number of Jets; Events;", 10, 0.0, 10.0)
hmuST = TH1D("hmuST", "Muon Channel ST; ST {GeV}; Events;", 50, 0.0, 2500.0)
hmuchanCentJetPt = TH1D("hmuchanCentJetPt",
"Muon Channel Central Jets Pt; p_{t} {GeV}; Events;",
50, 0, 1000)
hmuchanCentJetEta = TH1D("hmuchanCentJetEta",
"Muon Channel Central Jets Eta; #eta; Events;", 40,
-4.0, 4.0)
lepP4 = TLorentzVector(0.0, 0.0, 0.0, 0.0)
jetP4 = TLorentzVector(0.0, 0.0, 0.0, 0.0)
nearestJetP4 = TLorentzVector(0.0, 0.0, 0.0, 0.0)
# Open the input ntuples
# Begin running over all trees
ievt = 0
#if ievt%100 == 0: print " Processing evt %i" % ievt
print 'Opening file %s' % fname
f = TFile.Open(fname)
print f.ls()
tree = f.Get("ana/anatree")
entries = tree.GetEntriesFast()
def p4(r1, r2, E):
p = p3(r1, r2, E)
tlv = TLorentzVector()
tlv.SetXYZM(p.Px(), p.Py(), p.Pz(), me)
return tlv ## TLorentzVector
def test_root_particle_copy(self):
'''Test that root-based particles can be created, deepcopied,
and compared.'''
ptc = TlvParticle(1, 1, TLorentzVector())
ptc2 = copy.deepcopy(ptc)
self.assertEqual(ptc, ptc2)
#include "TLorentzVector.h"
#include "TMath.h"
import ROOT
from ROOT import TLorentzVector, TMath
from math import sqrt
#enum {L1DoubleMuOpen, Mu0Track0Jpsi, Mu3Track0Jpsi, DoubleMu0, DoubleMu3};
# beam energy in GeV
pbeam = 3500.
# masses
Mprot = 0.9382720
Ebeam = sqrt(pbeam * pbeam + Mprot * Mprot)
beam1_LAB = TLorentzVector(0., 0., pbeam, Ebeam)
beam2_LAB = TLorentzVector(0., 0., -pbeam, Ebeam)
muMass = 0.105658
#rap bins
kNbRapForPTBins = 5
# Double_t rapForPTRange[kNbRapForPTBins+1] = {0., 0.9, 1.5, 1.9, 2.3}; */
rapForPTRange = [[0., 0.9], [0.9, 1.2], [1.2, 1.6], [1.6, 2.1], [2.1, 2.4]]
#pT bins (optimized to have at least 10.000 entries per bin)
kNbPTMaxBins = 12
kNbPTBins = [kNbPTMaxBins, 7, 8, 9, 12, 12] #all y, y1, y2, y3, y4, y5
pTRange = [
[[0., 1.], [1., 2.], [2., 3.], [3., 4.], [4., 5.], [5., 6.], [6., 7.],
[7., 8.], [8., 10.], [10., 15.], [15., 20.], [20., 30.]], #all rapidities
[[0., 6.], [6., 7.], [7., 8.], [8., 10.], [10., 15.], [15., 20.],
[20., 30.]], #mid-rap
[[0., 4.], [4., 6.], [6., 7.], [7., 8.], [8., 10.], [10., 15.], [15., 20.],
[20., 30.]]
] #
checker = None checker1 = None checker2 = None cheker3 = None checker4 = None checker5 = None checker6 = None mu_ID = 0 gen_ID = 0 gen_mother = 0 eTphMin = -1000 pTpiMin = -1000 ph_cont = 0 ph_cont1 = 0 ph_cont2 = 0 candidate_ph = TLorentzVector() candidate_pi = TLorentzVector() candidate_eta = 0 candidate_phi = 0 photon_eta = 0 photon_phi = 0 pxpi = 0 pypi = 0 pzpi = 0 pxph = 0 pyph = 0 pzph = 0 pTph = 0 pi_from_w = 0 photon_from_w = 0 pi_and_photon_from_w = 0
def save_raw(f_in, cms, t, D_sample):
m_runNo = array('i', [0])
m_evtNo = array('i', [0])
m_mode = array('i', [0])
m_charm = array('i', [0])
m_charge_pi = array('d', [999.])
m_rawm_D = array('d', [999.])
m_m_D = array('d', [999.])
m_p_D = array('d', [999.])
m_E_D = array('d', [999.])
m_rm_D = array('d', [999.])
m_rm2_D = array('d', [999.])
m_m_Dpi = array('d', [999.])
m_m2_Dpi = array('d', [999.])
m_rm_Dpi = array('d', [999.])
m_rm_pi = array('d', [999.])
m_chi2_vf = array('d', [999.])
m_chi2_kf = array('d', [999.])
m_n_othershws = array('i', [0])
m_n_othertrks = array('i', [0])
m_chi2_pi0 = array('d', [999.])
m_m_Dpi0 = array('d', [999.])
m_rm_Dpi0 = array('d', [999.])
m_n_pi0 = array('i', [0])
m_indexmc = array('i', [0])
m_motheridx = array('i', 100*[0])
m_pdgid = array('i', 100*[0])
t.Branch('runNo', m_runNo, 'm_runNo/I')
t.Branch('evtNo', m_evtNo, 'm_evtNo/I')
t.Branch('mode', m_mode, 'm_mode/I')
t.Branch('charm', m_charm, 'm_charm/I')
t.Branch('charge_pi', m_charge_pi, 'm_charge_pi/D')
t.Branch('rawm_D', m_rawm_D, 'm_rawm_D/D')
t.Branch('m_D', m_m_D, 'm_m_D/D')
t.Branch('p_D', m_p_D, 'm_p_D/D')
t.Branch('E_D', m_E_D, 'm_E_D/D')
t.Branch('rm_D', m_rm_D, 'm_rm_D/D')
t.Branch('rm2_D', m_rm2_D, 'm_rm2_D/D')
t.Branch('m_Dpi', m_m_Dpi, 'm_m_Dpi/D')
t.Branch('m2_Dpi', m_m2_Dpi, 'm_m2_Dpi/D')
t.Branch('rm_Dpi', m_rm_Dpi, 'm_rm_Dpi/D')
t.Branch('rm_pi', m_rm_pi, 'm_rm_pi/D')
t.Branch('chi2_vf', m_chi2_vf, 'm_chi2_vf/D')
t.Branch('chi2_kf', m_chi2_kf, 'm_chi2_kf/D')
t.Branch('n_othertrks', m_n_othertrks, 'm_n_othertrks/I')
t.Branch('n_othershws', m_n_othershws, 'm_n_othershws/I')
t.Branch('chi2_pi0', m_chi2_pi0, 'm_chi2_pi0/D')
t.Branch('m_Dpi0', m_m_Dpi0, 'm_m_Dpi0/D')
t.Branch('rm_Dpi0', m_rm_Dpi0, 'm_rm_Dpi0/D')
t.Branch('n_pi0', m_n_pi0, 'm_n_pi0/I')
t.Branch('indexmc', m_indexmc, 'indexmc/I')
t.Branch('motheridx', m_motheridx, 'motheridx[100]/I')
t.Branch('pdgid', m_pdgid, 'pdgid[100]/I')
t_std = f_in.Get('STD')
nentries = t_std.GetEntries()
for ientry in range(nentries):
t_std.GetEntry(ientry)
if t_std.mode != 200 and t_std.mode != 0 and t_std.mode != 1 and t_std.mode != 3:
continue
pD_raw = TLorentzVector(0, 0, 0, 0)
pD = TLorentzVector(0, 0, 0, 0)
for iTrk in range(t_std.n_trkD):
ptrack_raw = TLorentzVector(0, 0, 0, 0)
ptrack = TLorentzVector(0, 0, 0, 0)
ptrack_raw.SetPxPyPzE(t_std.rawp4_Dtrk[iTrk*6+0], t_std.rawp4_Dtrk[iTrk*6+1], t_std.rawp4_Dtrk[iTrk*6+2], t_std.rawp4_Dtrk[iTrk*6+3])
ptrack.SetPxPyPzE(t_std.p4_Dtrk[iTrk*4+0], t_std.p4_Dtrk[iTrk*4+1], t_std.p4_Dtrk[iTrk*4+2], t_std.p4_Dtrk[iTrk*4+3])
pD_raw += ptrack_raw
pD += ptrack
for iShw in range(t_std.n_shwD):
pshower_raw = TLorentzVector(0, 0, 0, 0)
pshower = TLorentzVector(0, 0, 0, 0)
pshower_raw.SetPxPyPzE(t_std.rawp4_Dshw[iShw*4+0], t_std.rawp4_Dshw[iShw*4+1], t_std.rawp4_Dshw[iShw*4+2], t_std.rawp4_Dshw[iShw*4+3])
pshower.SetPxPyPzE(t_std.p4_Dshw[iShw*4+0], t_std.p4_Dshw[iShw*4+1], t_std.p4_Dshw[iShw*4+2], t_std.p4_Dshw[iShw*4+3])
pD_raw += pshower_raw
pD += pshower
pPi = TLorentzVector(0,0,0,0)
for trk in range(t_std.n_othertrks):
if abs(t_std.rawp4_otherMdcKaltrk[trk*6+4]) != 1:
continue
if t_std.rawp4_otherMdcKaltrk[trk*6+5] != 2:
continue
pPi.SetPxPyPzE(t_std.rawp4_otherMdcKaltrk[trk*6+0], t_std.rawp4_otherMdcKaltrk[trk*6+1], t_std.rawp4_otherMdcKaltrk[trk*6+2], t_std.rawp4_otherMdcKaltrk[trk*6+3])
pPi0 = TLorentzVector(0, 0, 0, 0)
pPi0.SetPxPyPzE(t_std.p4_pi0_save[0], t_std.p4_pi0_save[1], t_std.p4_pi0_save[2], t_std.p4_pi0_save[3])
if D_sample == 'Dplus' and t_std.mode == 200:
if ((t_std.charm == 1 and t_std.rawp4_otherMdcKaltrk[trk*6+4] == -1) or (t_std.charm == -1 and t_std.rawp4_otherMdcKaltrk[trk*6+4] == 1)):
m_runNo[0] = t_std.runNo
m_evtNo[0] = t_std.evtNo
m_mode[0] = t_std.mode
m_charm[0] = t_std.charm
m_charge_pi[0] = t_std.rawp4_otherMdcKaltrk[trk*6+4]
m_rawm_D[0] = pD_raw.M()
m_m_D[0] = pD.M()
m_p_D[0] = pD.P()
m_E_D[0] = pD.E()
m_rm_D[0] = (cms-pD).M()
m_rm2_D[0] = (cms-pD).M2()
m_m_Dpi[0] = (pD+pPi).M()
m_m2_Dpi[0] = (pD+pPi).M2()
m_rm_Dpi[0] = (cms-pD-pPi).M()
m_rm_pi[0] = (cms-pPi).M()
m_chi2_vf[0] = t_std.chi2_vf
m_chi2_kf[0] = t_std.chi2_kf
m_chi2_pi0[0] = t_std.chi2_pi0_save
m_Dpi0 = 999.
rm_Dpi0 = 999.
if pPi0.M() > 0:
m_Dpi0 = (pD+pPi0).M()
rm_Dpi0 = (cms-pD-pPi0).M()
m_m_Dpi0[0] = m_Dpi0
m_rm_Dpi0[0] = rm_Dpi0
m_n_pi0[0] = t_std.n_pi0
m_n_othershws[0] = t_std.n_othershws
m_n_othertrks[0] = t_std.n_othertrks
m_indexmc[0] = t_std.indexmc
for i in range(t_std.indexmc):
m_motheridx[i] = t_std.motheridx[i]
m_pdgid[i] = t_std.pdgid[i]
t.Fill()
if D_sample == 'D0' and (t_std.mode == 0 or t_std.mode == 1 or t_std.mode == 3):
if (t_std.charm == 1 and t_std.rawp4_otherMdcKaltrk[trk*6+4] == 1) or (t_std.charm == -1 and t_std.rawp4_otherMdcKaltrk[trk*6+4] == -1):
m_runNo[0] = t_std.runNo
m_evtNo[0] = t_std.evtNo
m_mode[0] = t_std.mode
m_charm[0] = t_std.charm
m_charge_pi[0] = t_std.rawp4_otherMdcKaltrk[trk*6+4]
m_rawm_D[0] = pD_raw.M()
m_m_D[0] = pD.M()
m_p_D[0] = pD.P()
m_E_D[0] = pD.E()
m_rm_D[0] = (cms-pD).M()
m_rm2_D[0] = (cms-pD).M2()
m_m_Dpi[0] = (pD+pPi).M()
m_m2_Dpi[0] = (pD+pPi).M2()
m_rm_Dpi[0] = (cms-pD-pPi).M()
m_rm_pi[0] = (cms-pPi).M()
m_chi2_vf[0] = t_std.chi2_vf
m_chi2_kf[0] = t_std.chi2_kf
m_chi2_pi0[0] = t_std.chi2_pi0_save
m_Dpi0 = 999.
rm_Dpi0 = 999.
if pPi0.M() > 0:
m_Dpi0 = (pD+pPi0).M()
rm_Dpi0 = (cms-pD-pPi0).M()
m_m_Dpi0[0] = m_Dpi0
m_rm_Dpi0[0] = rm_Dpi0
m_n_pi0[0] = t_std.n_pi0
m_n_othershws[0] = t_std.n_othershws
m_n_othertrks[0] = t_std.n_othertrks
m_indexmc[0] = t_std.indexmc
for i in range(t_std.indexmc):
m_motheridx[i] = t_std.motheridx[i]
m_pdgid[i] = t_std.pdgid[i]
t.Fill()
def save_missing(f_in, cms, t, D_sample, D_type, sample_type):
m_runNo = array('i', [0])
m_evtNo = array('i', [0])
m_mode = array('i', [0])
m_charm = array('i', [0])
m_rawm_D = array('d', [999.])
m_p4_D = array('d', 4*[999.])
m_p4_Dbar = array('d', 4*[999.])
m_p4_pi = array('d', 4*[999.])
m_m_D = array('d', [999.])
m_p_D = array('d', [999.])
m_E_D = array('d', [999.])
m_rm_D = array('d', [999.])
m_rm_Dmiss = array('d', [999.])
m_rm2_D = array('d', [999.])
m_m_Dpi = array('d', [999.])
m_m_Dmisspi = array('d', [999.])
m_m2_Dpi = array('d', [999.])
m_rm_Dpi = array('d', [999.])
m_rm_Dmisspi = array('d', [999.])
m_rm_pi = array('d', [999.])
m_chi2_vf = array('d', [999.])
m_chi2_kf = array('d', [999.])
m_chi2_pi0 = array('d', [999.])
m_m_Dpi0 = array('d', [999.])
m_rm_Dpi0 = array('d', [999.])
m_m_Dmisspi0 = array('d', [999.])
m_rm_Dmisspi0 = array('d', [999.])
m_n_pi0 = array('i', [0])
m_n_othershws = array('i', [0])
m_n_othertrks = array('i', [0])
m_indexmc = array('i', [0])
m_motheridx = array('i', 100*[0])
m_pdgid = array('i', 100*[0])
m_p4_pi_MCTruth = array('d', 4*[0])
m_p4_D_MCTruth = array('d', 4*[0])
m_p4_Dbar_MCTruth = array('d', 4*[0])
m_rm_pi_MCTruth = array('d', [999.])
m_rm_D_MCTruth = array('d', [999.])
m_m_Dpi_MCTruth = array('d', [999.])
if D_sample == 'Dplus' and D_type == 'D' and sample_type == 'signal':
m_p_pi = array('d', [999.])
m_charge_pi = array('d', [999.])
m_costheta_pi = array('d', [999.])
m_phi_pi = array('d', [999.])
m_chi_e_pi = array('d', [999.])
m_chi_mu_pi = array('d', [999.])
m_chi_pi_pi = array('d', [999.])
m_chi_K_pi = array('d', [999.])
m_chi_p_pi = array('d', [999.])
m_prob_e_pi = array('d', [999.])
m_prob_mu_pi = array('d', [999.])
m_prob_pi_pi = array('d', [999.])
m_prob_K_pi = array('d', [999.])
m_prob_p_pi = array('d', [999.])
m_p_DK = array('d', [999.])
m_charge_DK = array('d', [999.])
m_costheta_DK = array('d', [999.])
m_phi_DK = array('d', [999.])
m_chi_e_DK = array('d', [999.])
m_chi_mu_DK = array('d', [999.])
m_chi_pi_DK = array('d', [999.])
m_chi_K_DK = array('d', [999.])
m_chi_p_DK = array('d', [999.])
m_prob_e_DK = array('d', [999.])
m_prob_mu_DK = array('d', [999.])
m_prob_pi_DK = array('d', [999.])
m_prob_K_DK = array('d', [999.])
m_prob_p_DK = array('d', [999.])
m_p_Dpi1 = array('d', [999.])
m_charge_Dpi1 = array('d', [999.])
m_costheta_Dpi1 = array('d', [999.])
m_phi_Dpi1 = array('d', [999.])
m_chi_e_Dpi1 = array('d', [999.])
m_chi_mu_Dpi1 = array('d', [999.])
m_chi_pi_Dpi1 = array('d', [999.])
m_chi_K_Dpi1 = array('d', [999.])
m_chi_p_Dpi1 = array('d', [999.])
m_prob_e_Dpi1 = array('d', [999.])
m_prob_mu_Dpi1 = array('d', [999.])
m_prob_pi_Dpi1 = array('d', [999.])
m_prob_K_Dpi1 = array('d', [999.])
m_prob_p_Dpi1 = array('d', [999.])
m_p_Dpi2 = array('d', [999.])
m_charge_Dpi2 = array('d', [999.])
m_costheta_Dpi2 = array('d', [999.])
m_phi_Dpi2 = array('d', [999.])
m_chi_e_Dpi2 = array('d', [999.])
m_chi_mu_Dpi2 = array('d', [999.])
m_chi_pi_Dpi2 = array('d', [999.])
m_chi_K_Dpi2 = array('d', [999.])
m_chi_p_Dpi2 = array('d', [999.])
m_prob_e_Dpi2 = array('d', [999.])
m_prob_mu_Dpi2 = array('d', [999.])
m_prob_pi_Dpi2 = array('d', [999.])
m_prob_K_Dpi2 = array('d', [999.])
m_prob_p_Dpi2 = array('d', [999.])
t.Branch('runNo', m_runNo, 'm_runNo/I')
t.Branch('evtNo', m_evtNo, 'm_evtNo/I')
t.Branch('mode', m_mode, 'm_mode/I')
t.Branch('charm', m_charm, 'm_charm/I')
t.Branch('rawm_D', m_rawm_D, 'm_rawm_D/D')
t.Branch('p4_D', m_p4_D, 'm_p4_D[4]/D')
t.Branch('p4_Dbar', m_p4_Dbar, 'm_p4_Dbar[4]/D')
t.Branch('p4_pi', m_p4_pi, 'm_p4_pi[4]/D')
t.Branch('m_D', m_m_D, 'm_m_D/D')
t.Branch('p_D', m_p_D, 'm_p_D/D')
t.Branch('E_D', m_E_D, 'm_E_D/D')
t.Branch('rm_D', m_rm_D, 'm_rm_D/D')
t.Branch('rm_Dmiss', m_rm_Dmiss, 'm_rm_Dmiss/D')
t.Branch('rm2_D', m_rm2_D, 'm_rm2_D/D')
t.Branch('m_Dpi', m_m_Dpi, 'm_m_Dpi/D')
t.Branch('m_Dmisspi', m_m_Dmisspi, 'm_m_Dmisspi/D')
t.Branch('m2_Dpi', m_m2_Dpi, 'm_m2_Dpi/D')
t.Branch('rm_Dpi', m_rm_Dpi, 'm_rm_Dpi/D')
t.Branch('rm_Dmisspi', m_rm_Dmisspi, 'm_rm_Dmisspi/D')
t.Branch('rm_pi', m_rm_pi, 'm_rm_pi/D')
t.Branch('chi2_vf', m_chi2_vf, 'm_chi2_vf/D')
t.Branch('chi2_kf', m_chi2_kf, 'm_chi2_kf/D')
t.Branch('chi2_pi0', m_chi2_pi0, 'm_chi2_pi0/D')
t.Branch('m_Dpi0', m_m_Dpi0, 'm_m_Dpi0/D')
t.Branch('rm_Dpi0', m_rm_Dpi0, 'm_rm_Dpi0/D')
t.Branch('m_Dmisspi0', m_m_Dmisspi0, 'm_m_Dmisspi0/D')
t.Branch('rm_Dmisspi0', m_rm_Dmisspi0, 'm_rm_Dmisspi0/D')
t.Branch('n_pi0', m_n_pi0, 'm_n_pi0/I')
t.Branch('n_othertrks', m_n_othertrks, 'm_n_othertrks/I')
t.Branch('n_othershws', m_n_othershws, 'm_n_othershws/I')
t.Branch('indexmc', m_indexmc, 'indexmc/I')
t.Branch('motheridx', m_motheridx, 'motheridx[100]/I')
t.Branch('pdgid', m_pdgid, 'pdgid[100]/I')
t.Branch('p4_pi_MCTruth', m_p4_pi_MCTruth, 'm_p4_pi_MCTruth[4]/D')
t.Branch('p4_D_MCTruth', m_p4_D_MCTruth, 'm_p4_D_MCTruth[4]/D')
t.Branch('p4_Dbar_MCTruth', m_p4_Dbar_MCTruth, 'm_p4_Dbar_MCTruth[4]/D')
t.Branch('rm_pi_MCTruth', m_rm_pi_MCTruth, 'm_rm_pi_MCTruth/D')
t.Branch('rm_D_MCTruth', m_rm_D_MCTruth, 'm_rm_D_MCTruth/D')
t.Branch('m_Dpi_MCTruth', m_m_Dpi_MCTruth, 'm_m_Dpi_MCTruth/D')
if D_sample == 'Dplus' and D_type == 'D' and sample_type == 'signal':
t.Branch('p_pi', m_p_pi, 'm_p_pi/D')
t.Branch('charge_pi', m_charge_pi, 'm_charge_pi/D')
t.Branch('costheta_pi', m_costheta_pi, 'm_costheta_pi/D')
t.Branch('phi_pi', m_phi_pi, 'm_phi_pi/D')
t.Branch('chi_e_pi', m_chi_e_pi, 'm_chi_e_pi/D')
t.Branch('chi_mu_pi', m_chi_mu_pi, 'm_chi_mu_pi/D')
t.Branch('chi_pi_pi', m_chi_pi_pi, 'm_chi_pi_pi/D')
t.Branch('chi_K_pi', m_chi_K_pi, 'm_chi_K_pi/D')
t.Branch('chi_p_pi', m_chi_p_pi, 'm_chi_p_pi/D')
t.Branch('prob_e_pi', m_prob_e_pi, 'm_prob_e_pi/D')
t.Branch('prob_mu_pi', m_prob_mu_pi, 'm_prob_mu_pi/D')
t.Branch('prob_pi_pi', m_prob_pi_pi, 'm_prob_pi_pi/D')
t.Branch('prob_K_pi', m_prob_K_pi, 'm_prob_K_pi/D')
t.Branch('prob_p_pi', m_prob_p_pi, 'm_prob_p_pi/D')
t.Branch('p_DK', m_p_DK, 'm_p_DK/D')
t.Branch('charge_DK', m_charge_DK, 'm_charge_DK/D')
t.Branch('costheta_DK', m_costheta_DK, 'm_costheta_DK/D')
t.Branch('phi_DK', m_phi_DK, 'm_phi_DK/D')
t.Branch('chi_e_DK', m_chi_e_DK, 'm_chi_e_DK/D')
t.Branch('chi_mu_DK', m_chi_mu_DK, 'm_chi_mu_DK/D')
t.Branch('chi_pi_DK', m_chi_pi_DK, 'm_chi_pi_DK/D')
t.Branch('chi_K_DK', m_chi_K_DK, 'm_chi_K_DK/D')
t.Branch('chi_p_DK', m_chi_p_DK, 'm_chi_p_DK/D')
t.Branch('prob_e_DK', m_prob_e_DK, 'm_prob_e_DK/D')
t.Branch('prob_mu_DK', m_prob_mu_DK, 'm_prob_mu_DK/D')
t.Branch('prob_pi_DK', m_prob_pi_DK, 'm_prob_pi_DK/D')
t.Branch('prob_K_DK', m_prob_K_DK, 'm_prob_K_DK/D')
t.Branch('prob_p_DK', m_prob_p_DK, 'm_prob_p_DK/D')
t.Branch('p_Dpi1', m_p_Dpi1, 'm_p_Dpi1/D')
t.Branch('charge_Dpi1', m_charge_Dpi1, 'm_charge_Dpi1/D')
t.Branch('costheta_Dpi1', m_costheta_Dpi1, 'm_costheta_Dpi1/D')
t.Branch('phi_Dpi1', m_phi_Dpi1, 'm_phi_Dpi1/D')
t.Branch('chi_e_Dpi1', m_chi_e_Dpi1, 'm_chi_e_Dpi1/D')
t.Branch('chi_mu_Dpi1', m_chi_mu_Dpi1, 'm_chi_mu_Dpi1/D')
t.Branch('chi_pi_Dpi1', m_chi_pi_Dpi1, 'm_chi_pi_Dpi1/D')
t.Branch('chi_K_Dpi1', m_chi_K_Dpi1, 'm_chi_K_Dpi1/D')
t.Branch('chi_p_Dpi1', m_chi_p_Dpi1, 'm_chi_p_Dpi1/D')
t.Branch('prob_e_Dpi1', m_prob_e_Dpi1, 'm_prob_e_Dpi1/D')
t.Branch('prob_mu_Dpi1', m_prob_mu_Dpi1, 'm_prob_mu_Dpi1/D')
t.Branch('prob_pi_Dpi1', m_prob_pi_Dpi1, 'm_prob_pi_Dpi1/D')
t.Branch('prob_K_Dpi1', m_prob_K_Dpi1, 'm_prob_K_Dpi1/D')
t.Branch('prob_p_Dpi1', m_prob_p_Dpi1, 'm_prob_p_Dpi1/D')
t.Branch('p_Dpi2', m_p_Dpi2, 'm_p_Dpi2/D')
t.Branch('charge_Dpi2', m_charge_Dpi2, 'm_charge_Dpi2/D')
t.Branch('costheta_Dpi2', m_costheta_Dpi2, 'm_costheta_Dpi2/D')
t.Branch('phi_Dpi2', m_phi_Dpi2, 'm_phi_Dpi2/D')
t.Branch('chi_e_Dpi2', m_chi_e_Dpi2, 'm_chi_e_Dpi2/D')
t.Branch('chi_mu_Dpi2', m_chi_mu_Dpi2, 'm_chi_mu_Dpi2/D')
t.Branch('chi_pi_Dpi2', m_chi_pi_Dpi2, 'm_chi_pi_Dpi2/D')
t.Branch('chi_K_Dpi2', m_chi_K_Dpi2, 'm_chi_K_Dpi2/D')
t.Branch('chi_p_Dpi2', m_chi_p_Dpi2, 'm_chi_p_Dpi2/D')
t.Branch('prob_e_Dpi2', m_prob_e_Dpi2, 'm_prob_e_Dpi2/D')
t.Branch('prob_mu_Dpi2', m_prob_mu_Dpi2, 'm_prob_mu_Dpi2/D')
t.Branch('prob_pi_Dpi2', m_prob_pi_Dpi2, 'm_prob_pi_Dpi2/D')
t.Branch('prob_K_Dpi2', m_prob_K_Dpi2, 'm_prob_K_Dpi2/D')
t.Branch('prob_p_Dpi2', m_prob_p_Dpi2, 'm_prob_p_Dpi2/D')
if D_type == 'D' and sample_type == 'signal':
t_std = f_in.Get('STDDmiss_sig_D')
elif D_type == 'Dst' and sample_type == 'signal':
t_std = f_in.Get('STDDmiss_sig_Dst')
elif D_type == 'D' and sample_type == 'background':
t_std = f_in.Get('STDDmiss_bkg_D')
elif D_type == 'Dst' and sample_type == 'background':
t_std = f_in.Get('STDDmiss_bkg_Dst')
nentries = t_std.GetEntries()
for ientry in range(nentries):
t_std.GetEntry(ientry)
if t_std.mode != 200 and t_std.mode != 0 and t_std.mode != 1 and t_std.mode != 3:
continue
pD_raw = TLorentzVector(0, 0, 0, 0)
pD = TLorentzVector(0, 0, 0, 0)
pKpi = TLorentzVector(0, 0, 0, 0)
tag = 0
for iTrk in range(t_std.n_trkD):
ptrack_raw = TLorentzVector(0, 0, 0, 0)
ptrack = TLorentzVector(0, 0, 0, 0)
ptrack_raw.SetPxPyPzE(t_std.rawp4_Dtrk[iTrk*6+0], t_std.rawp4_Dtrk[iTrk*6+1], t_std.rawp4_Dtrk[iTrk*6+2], t_std.rawp4_Dtrk[iTrk*6+3])
ptrack.SetPxPyPzE(t_std.p4_Dtrk[iTrk*4+0], t_std.p4_Dtrk[iTrk*4+1], t_std.p4_Dtrk[iTrk*4+2], t_std.p4_Dtrk[iTrk*4+3])
pD_raw += ptrack_raw
pD += ptrack
ptrack_Kpi = TLorentzVector(0, 0, 0, 0)
if t_std.rawp4_Dtrk[iTrk*6+4] == 1 and t_std.rawp4_Dtrk[iTrk*6+5] == 3 and t_std.mode == 200:
ptrack_Kpi.SetPxPyPzE(t_std.rawp4_Dtrk[iTrk*6+0], t_std.rawp4_Dtrk[iTrk*6+1], t_std.rawp4_Dtrk[iTrk*6+2], t_std.rawp4_Dtrk[iTrk*6+3])
pKpi += ptrack_Kpi
if t_std.rawp4_Dtrk[iTrk*6+4] == -1 and t_std.rawp4_Dtrk[iTrk*6+5] == 3 and t_std.mode == 200:
ptrack_Kpi.SetPxPyPzE(t_std.rawp4_Dtrk[iTrk*6+0], t_std.rawp4_Dtrk[iTrk*6+1], t_std.rawp4_Dtrk[iTrk*6+2], t_std.rawp4_Dtrk[iTrk*6+3])
pKpi += ptrack_Kpi
if t_std.rawp4_Dtrk[iTrk*6+5] == 2 and t_std.mode == 200 and tag == 0:
tag = 1
ptrack_Kpi.SetPxPyPzE(t_std.rawp4_Dtrk[iTrk*6+0], t_std.rawp4_Dtrk[iTrk*6+1], t_std.rawp4_Dtrk[iTrk*6+2], t_std.rawp4_Dtrk[iTrk*6+3])
pKpi += ptrack_Kpi
for iShw in range(t_std.n_shwD):
pshower_raw = TLorentzVector(0, 0, 0, 0)
pshower = TLorentzVector(0, 0, 0, 0)
pshower_raw.SetPxPyPzE(t_std.rawp4_Dshw[iShw*4+0], t_std.rawp4_Dshw[iShw*4+1], t_std.rawp4_Dshw[iShw*4+2], t_std.rawp4_Dshw[iShw*4+3])
pshower.SetPxPyPzE(t_std.p4_Dshw[iShw*4+0], t_std.p4_Dshw[iShw*4+1], t_std.p4_Dshw[iShw*4+2], t_std.p4_Dshw[iShw*4+3])
pD_raw += pshower_raw
pD += pshower
pPi = TLorentzVector(0,0,0,0)
pPi.SetPxPyPzE(t_std.p4_pi[0], t_std.p4_pi[1], t_std.p4_pi[2], t_std.p4_pi[3])
pDmiss = TLorentzVector(0,0,0,0)
pDmiss.SetPxPyPzE(t_std.p4_Dmiss[0], t_std.p4_Dmiss[1], t_std.p4_Dmiss[2], t_std.p4_Dmiss[3])
pPi0 = TLorentzVector(0, 0, 0, 0)
pPi0.SetPxPyPzE(t_std.p4_pi0_save[0], t_std.p4_pi0_save[1], t_std.p4_pi0_save[2], t_std.p4_pi0_save[3])
if D_sample == 'Dplus' and t_std.mode == 200:
m_runNo[0] = t_std.runNo
m_evtNo[0] = t_std.evtNo
m_mode[0] = t_std.mode
m_charm[0] = t_std.charm
m_rawm_D[0] = pD_raw.M()
pDbar = cms-pD-pPi
for i in range(4):
m_p4_D[i] = pD[i]
m_p4_Dbar[i] = pDbar[i]
m_p4_pi[i] = t_std.p4_pi[i]
m_m_D[0] = pD.M()
m_p_D[0] = pD.P()
m_E_D[0] = pD.E()
m_rm_D[0] = (cms-pD).M()
m_rm_Dmiss[0] = (cms-pDmiss).M()
m_rm2_D[0] = (cms-pD).M2()
m_m_Dpi[0] = (pD+pPi).M()
m_m_Dmisspi[0] = (pDmiss+pPi).M()
m_m2_Dpi[0] = (pD+pPi).M2()
m_rm_Dpi[0] = t_std.rm_Dpi
m_rm_Dmisspi[0] = (cms-pDmiss-pPi).M()
m_rm_pi[0] = (cms-pPi).M()
m_chi2_vf[0] = t_std.chi2_vf
m_chi2_kf[0] = t_std.chi2_kf
m_chi2_pi0[0] = t_std.chi2_pi0_save
m_Dpi0 = 999.
rm_Dpi0 = 999.
if pPi0.M() > 0:
m_Dpi0 = (pD+pPi0).M()
rm_Dpi0 = (cms-pD-pPi0).M()
deltaM = 999.
m_Dmisspi0 = 999.
rm_Dmisspi0 = 999.
for iPi0 in range(t_std.n_pi0):
ppi0 = TLorentzVector(0, 0, 0, 0)
ppi0.SetPxPyPzE(t_std.p4_pi0[iPi0*4+0], t_std.p4_pi0[iPi0*4+1], t_std.p4_pi0[iPi0*4+2], t_std.p4_pi0[iPi0*4+3])
if (fabs((pDmiss + ppi0).M() - 2.000685) < deltaM):
deltaM = fabs((pDmiss + ppi0).M() - 2.01026)
m_Dmisspi0 = (pDmiss + ppi0).M()
rm_Dmisspi0 = (cms - pDmiss - ppi0).M()
m_m_Dmisspi0[0] = m_Dmisspi0
m_rm_Dmisspi0[0] = rm_Dmisspi0
m_m_Dpi0[0] = m_Dpi0
m_rm_Dpi0[0] = rm_Dpi0
m_n_pi0[0] = t_std.n_pi0
m_n_othershws[0] = t_std.n_othershws
m_n_othertrks[0] = t_std.n_othertrks
m_indexmc[0] = t_std.indexmc
for i in range(t_std.indexmc):
m_motheridx[i] = t_std.motheridx[i]
m_pdgid[i] = t_std.pdgid[i]
for i in range(4):
m_p4_pi_MCTruth[i] = t_std.p4_pi_MCTruth[i]
m_p4_D_MCTruth[i] = t_std.p4_D_MCTruth[i]
m_p4_Dbar_MCTruth[i] = t_std.p4_Dbar_MCTruth[i]
pPi_MCTruth = TLorentzVector(0,0,0,0)
pPi_MCTruth.SetPxPyPzE(t_std.p4_pi_MCTruth[0], t_std.p4_pi_MCTruth[1], t_std.p4_pi_MCTruth[2], t_std.p4_pi_MCTruth[3])
pD_MCTruth = TLorentzVector(0,0,0,0)
pD_MCTruth.SetPxPyPzE(t_std.p4_D_MCTruth[0], t_std.p4_D_MCTruth[1], t_std.p4_D_MCTruth[2], t_std.p4_D_MCTruth[3])
pDbar_MCTruth = TLorentzVector(0,0,0,0)
pDbar_MCTruth.SetPxPyPzE(t_std.p4_Dbar_MCTruth[0], t_std.p4_Dbar_MCTruth[1], t_std.p4_Dbar_MCTruth[2], t_std.p4_Dbar_MCTruth[3])
m_rm_pi_MCTruth[0] = (pD_MCTruth+pDbar_MCTruth).M()
m_rm_D_MCTruth[0] = (pPi_MCTruth+pDbar_MCTruth).M()
m_m_Dpi_MCTruth[0] = (pPi_MCTruth+pD_MCTruth).M()
if D_sample == 'Dplus' and D_type == 'D' and sample_type == 'signal':
m_p_pi[0] = t_std.pid_trk[14*0 + 0]
m_charge_pi[0] = t_std.pid_trk[14*0 + 1]
m_costheta_pi[0] = t_std.pid_trk[14*0 + 2]
m_phi_pi[0] = t_std.pid_trk[14*0 + 3]
m_chi_e_pi[0] = t_std.pid_trk[14*0 + 4]
m_chi_mu_pi[0] = t_std.pid_trk[14*0 + 5]
m_chi_pi_pi[0] = t_std.pid_trk[14*0 + 6]
m_chi_K_pi[0] = t_std.pid_trk[14*0 + 7]
m_chi_p_pi[0] = t_std.pid_trk[14*0 + 8]
m_prob_e_pi[0] = t_std.pid_trk[14*0 + 9]
m_prob_mu_pi[0] = t_std.pid_trk[14*0 + 10]
m_prob_pi_pi[0] = t_std.pid_trk[14*0 + 11]
m_prob_K_pi[0] = t_std.pid_trk[14*0 + 12]
m_prob_p_pi[0] = t_std.pid_trk[14*0 + 13]
m_p_DK[0] = t_std.pid_trk[14*1 + 0]
m_charge_DK[0] = t_std.pid_trk[14*1 + 1]
m_costheta_DK[0] = t_std.pid_trk[14*1 + 2]
m_phi_DK[0] = t_std.pid_trk[14*1 + 3]
m_chi_e_DK[0] = t_std.pid_trk[14*1 + 4]
m_chi_mu_DK[0] = t_std.pid_trk[14*1 + 5]
m_chi_pi_DK[0] = t_std.pid_trk[14*1 + 6]
m_chi_K_DK[0] = t_std.pid_trk[14*1 + 7]
m_chi_p_DK[0] = t_std.pid_trk[14*1 + 8]
m_prob_e_DK[0] = t_std.pid_trk[14*1 + 9]
m_prob_mu_DK[0] = t_std.pid_trk[14*1 + 10]
m_prob_pi_DK[0] = t_std.pid_trk[14*1 + 11]
m_prob_K_DK[0] = t_std.pid_trk[14*1 + 12]
m_prob_p_DK[0] = t_std.pid_trk[14*1 + 13]
m_p_Dpi1[0] = t_std.pid_trk[14*2 + 0]
m_charge_Dpi1[0] = t_std.pid_trk[14*2 + 1]
m_costheta_Dpi1[0] = t_std.pid_trk[14*2 + 2]
m_phi_Dpi1[0] = t_std.pid_trk[14*2 + 3]
m_chi_e_Dpi1[0] = t_std.pid_trk[14*2 + 4]
m_chi_mu_Dpi1[0] = t_std.pid_trk[14*2 + 5]
m_chi_pi_Dpi1[0] = t_std.pid_trk[14*2 + 6]
m_chi_K_Dpi1[0] = t_std.pid_trk[14*2 + 7]
m_chi_p_Dpi1[0] = t_std.pid_trk[14*2 + 8]
m_prob_e_Dpi1[0] = t_std.pid_trk[14*2 + 9]
m_prob_mu_Dpi1[0] = t_std.pid_trk[14*2 + 10]
m_prob_pi_Dpi1[0] = t_std.pid_trk[14*2 + 11]
m_prob_K_Dpi1[0] = t_std.pid_trk[14*2 + 12]
m_prob_p_Dpi1[0] = t_std.pid_trk[14*2 + 13]
m_p_Dpi2[0] = t_std.pid_trk[14*3 + 0]
m_charge_Dpi2[0] = t_std.pid_trk[14*3 + 1]
m_costheta_Dpi2[0] = t_std.pid_trk[14*3 + 2]
m_phi_Dpi2[0] = t_std.pid_trk[14*3 + 3]
m_chi_e_Dpi2[0] = t_std.pid_trk[14*3 + 4]
m_chi_mu_Dpi2[0] = t_std.pid_trk[14*3 + 5]
m_chi_pi_Dpi2[0] = t_std.pid_trk[14*3 + 6]
m_chi_K_Dpi2[0] = t_std.pid_trk[14*3 + 7]
m_chi_p_Dpi2[0] = t_std.pid_trk[14*3 + 8]
m_prob_e_Dpi2[0] = t_std.pid_trk[14*3 + 9]
m_prob_mu_Dpi2[0] = t_std.pid_trk[14*3 + 10]
m_prob_pi_Dpi2[0] = t_std.pid_trk[14*3 + 11]
m_prob_K_Dpi2[0] = t_std.pid_trk[14*3 + 12]
m_prob_p_Dpi2[0] = t_std.pid_trk[14*3 + 13]
t.Fill()
if D_sample == 'D0' and (t_std.mode == 0 or t_std.mode == 1 or t_std.mode == 3):
m_runNo[0] = t_std.runNo
m_evtNo[0] = t_std.evtNo
m_mode[0] = t_std.mode
m_charm[0] = t_std.charm
m_rawm_D[0] = pD_raw.M()
m_m_D[0] = pD.M()
m_p_D[0] = pD.P()
m_E_D[0] = pD.E()
m_rm_D[0] = (cms-pD).M()
m_rm_Dmiss[0] = (cms-pDmiss).M()
m_rm2_D[0] = (cms-pD).M2()
m_m_Dpi[0] = (pD+pPi).M()
m_m_Dmisspi[0] = (pDmiss+pPi).M()
m_m2_Dpi[0] = (pD+pPi).M2()
m_rm_Dpi[0] = t_std.rm_Dpi
m_rm_Dmisspi[0] = (cms-pDmiss-pPi).M()
m_rm_pi[0] = (cms-pPi).M()
m_chi2_vf[0] = t_std.chi2_vf
m_chi2_kf[0] = t_std.chi2_kf
m_chi2_pi0[0] = t_std.chi2_pi0_save
m_Dpi0 = 999.
rm_Dpi0 = 999.
if pPi0.M() > 0:
m_Dpi0 = (pD+pPi0).M()
rm_Dpi0 = (cms-pD-pPi0).M()
deltaM = 999.
m_Dmisspi0 = 999.
rm_Dmisspi0 = 999.
for iPi0 in range(t_std.n_pi0):
ppi0 = TLorentzVector(0, 0, 0, 0)
ppi0.SetPxPyPzE(t_std.p4_pi0[iPi0*4+0], t_std.p4_pi0[iPi0*4+1], t_std.p4_pi0[iPi0*4+2], t_std.p4_pi0[iPi0*4+3])
if (fabs((pDmiss + ppi0).M() - 2.000685) < deltaM):
deltaM = fabs((pDmiss + ppi0).M() - 2.01026)
m_Dmisspi0 = (pDmiss + ppi0).M()
rm_Dmisspi0 = (cms - pDmiss - ppi0).M()
m_m_Dmisspi0[0] = m_Dmisspi0
m_rm_Dmisspi0[0] = rm_Dmisspi0
m_m_Dpi0[0] = m_Dpi0
m_rm_Dpi0[0] = rm_Dpi0
m_n_pi0[0] = t_std.n_pi0
m_n_othershws[0] = t_std.n_othershws
m_n_othertrks[0] = t_std.n_othertrks
m_indexmc[0] = t_std.indexmc
for i in range(t_std.indexmc):
m_motheridx[i] = t_std.motheridx[i]
m_pdgid[i] = t_std.pdgid[i]
for i in range(4):
m_p4_pi_MCTruth[i] = t_std.p4_pi_MCTruth[i]
m_p4_D_MCTruth[i] = t_std.p4_D_MCTruth[i]
m_p4_Dbar_MCTruth[i] = t_std.p4_Dbar_MCTruth[i]
t.Fill()
def analyze(self, event):
"""Process event, return True (go to next module) or False (fail, go to next event)."""
if self.isMC:
PUWeight = 1. #self.puTool.getWeight(event.Pileup_nTrueInt)
GenWeight = 1.
if 'signal' in self.name.lower():
jetIds = []
for ijet in range(event.nJet):
if event.Jet_pt[ijet] < 30: continue
if abs(event.Jet_eta[ijet]) > 2.5: continue
if event.Jet_jetId[ijet] < 6: continue
if event.Jet_chEmEF[ijet] > 0.9: continue
if (self.year == 2017 or self.year
== 2018) and event.Jet_chEmEF[ijet] > 0.8:
continue
jetIds.append(ijet)
BTagAK4Weight_deepJet = self.btagToolAK4_deepJet.getWeight(
event, jetIds, "central")
BTagAK4Weight_deepJet_up = self.btagToolAK4_deepJet_up.getWeight(
event, jetIds, "up")
BTagAK4Weight_deepJet_down = self.btagToolAK4_deepJet_down.getWeight(
event, jetIds, "down")
self.out.events.Fill(0., BTagAK4Weight_deepJet)
else:
GenWeight = -1. if event.genWeight < 0 else 1.
self.out.events.Fill(0., GenWeight)
try:
LHEWeight = event.LHEWeight_originalXWGTUP
self.out.original.Fill(0., LHEWeight)
except:
self.out.original.Fill(0., -1.)
self.out.pileup.Fill(event.Pileup_nTrueInt)
## Event filter preselection
passedMETFilters = False
try:
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 (
self.isMC or event.Flag_eeBadScFilter
) and event.Flag_ecalBadCalibFilter:
passedMETFilters = True
except:
passedMETFilters = False
if not passedMETFilters: return False
## jet order check
if event.nJet < 2: return False
if event.Jet_pt[0] > event.Jet_pt[1]:
leading1 = 0
leading2 = 1
else:
leading1 = 1
leading2 = 0
for ijet in range(event.nJet)[2:]:
if event.Jet_pt[ijet] > event.Jet_pt[leading1]:
leading2 = leading1
leading1 = ijet
elif event.Jet_pt[ijet] > event.Jet_pt[leading2]:
leading2 = ijet
## Loop over Jets
jetIds = []
jetHT = 0.
jetBTagLoose, jetBTagMedium, jetBTagTight = 0, 0, 0
for ijet in range(event.nJet):
if event.Jet_pt[ijet] < 30: continue
if abs(event.Jet_eta[ijet]) > 2.5: continue
if event.Jet_jetId[ijet] < 6: continue
if event.Jet_chEmEF[ijet] > 0.9: continue
if (self.year == 2017
or self.year == 2018) and event.Jet_chEmEF[ijet] > 0.8:
continue
jetIds.append(ijet)
jetHT += event.Jet_pt[ijet]
if event.Jet_btagDeepFlavB[ijet] >= self.btagLoose:
jetBTagLoose += 1
if event.Jet_btagDeepFlavB[ijet] >= self.btagMedium:
jetBTagMedium += 1
if event.Jet_btagDeepFlavB[ijet] >= self.btagTight:
jetBTagTight += 1
## Jet-based event selections
if len(jetIds) < 2: return False
#if event.Jet_jetId[jetIds[0]] < 2: return False
#if event.Jet_jetId[jetIds[1]] < 2: return False
#if event.MET_pt/jetHT > 0.5: return False
### evaluate BTag weights ## put in beginning of analyze in order to get the weight into the normalization
#if 'signal' in self.name.lower():
# BTagAK4Weight_deepJet = self.btagToolAK4_deepJet.getWeight(event,jetIds)
# BTagAK4Weight_deepJet_up = self.btagToolAK4_deepJet_up.getWeight(event,jetIds)
# BTagAK4Weight_deepJet_down = self.btagToolAK4_deepJet_down.getWeight(event,jetIds)
## Compute dijet quantities
j1_p4 = TLorentzVector()
j1_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[0]], event.Jet_eta[jetIds[0]],
event.Jet_phi[jetIds[0]], event.Jet_mass[jetIds[0]])
j2_p4 = TLorentzVector()
j2_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[1]], event.Jet_eta[jetIds[1]],
event.Jet_phi[jetIds[1]], event.Jet_mass[jetIds[1]])
self.out.jj_mass[0] = (j1_p4 + j2_p4).M()
self.out.jj_deltaEta[0] = abs(event.Jet_eta[jetIds[0]] -
event.Jet_eta[jetIds[1]])
self.out.jj_deltaPhi[0] = abs(
j1_p4.DeltaPhi(j2_p4)
) #abs(event.Jet_phi[jetIds[0]]-event.Jet_phi[jetIds[1]]) this does not account for phi jump from 2pi to 0
## Dijet-based event selections
if self.out.jj_mass[0] < 800:
return False # will need to change this when deriving the trigger efficiency
#if self.out.jj_deltaEta[0]>1.1: return False
j1_p4_lepcorr = j1_p4 * (1. + event.Jet_chEmEF[jetIds[0]] +
event.Jet_muEF[jetIds[0]])
j2_p4_lepcorr = j2_p4 * (1. + event.Jet_chEmEF[jetIds[1]] +
event.Jet_muEF[jetIds[1]])
self.out.jj_mass_lepcorr[0] = (j1_p4_lepcorr + j2_p4_lepcorr).M()
met_p4 = TLorentzVector()
met_p4.SetPtEtaPhiM(event.MET_pt, 0., event.MET_phi, 0.)
j1_p4_metcorr = j1_p4 * (1. + event.MET_pt / j1_p4.Pt() *
math.cos(j1_p4.DeltaPhi(met_p4) + 3.1415))
j2_p4_metcorr = j2_p4 * (1. + event.MET_pt / j2_p4.Pt() *
math.cos(j2_p4.DeltaPhi(met_p4) + 3.1415))
self.out.jj_mass_metcorr[0] = (j1_p4_metcorr + j2_p4_metcorr).M()
wj1_p4 = j1_p4
wj2_p4 = j2_p4
for ijet in range(event.nJet):
if ijet == jetIds[0] or ijet == jetIds[1]: continue
if event.Jet_pt[ijet] < 30 or abs(event.Jet_eta[ijet]) > 2.5:
continue
if event.Jet_jetId[ijet] < 6: continue
if event.Jet_chEmEF[ijet] > 0.9: continue
if (self.year == 2017
or self.year == 2018) and event.Jet_chEmEF[ijet] > 0.8:
continue
j_p4 = TLorentzVector()
j_p4.SetPtEtaPhiM(event.Jet_pt[ijet], event.Jet_eta[ijet],
event.Jet_phi[ijet], event.Jet_mass[ijet])
if j1_p4.DeltaR(j_p4) < 1.1: wj1_p4 += j_p4
if j2_p4.DeltaR(j_p4) < 1.1: wj2_p4 += j_p4
self.out.jj_mass_widejet[0] = (wj1_p4 + wj2_p4).M()
self.out.jj_deltaEta_widejet[0] = abs(wj1_p4.Eta() - wj2_p4.Eta())
nIsoElectrons = 0.
for iel in range(event.nElectron):
if event.Electron_pt[iel] > 50. and abs(
event.Electron_eta[iel]
) < 2.5 and event.Electron_cutBased[iel] >= 2:
nIsoElectrons += 1
nIsoMuons = 0.
for imu in range(event.nMuon):
if event.Muon_pt[imu] > 50. and abs(
event.Muon_eta[imu]) < 2.4 and event.Muon_highPtId[
imu] >= 2 and event.Muon_tkRelIso[imu] < 0.1:
nIsoMuons += 1
ptMuons1, ptMuons2 = 0., 0.
if event.Jet_muonIdx1[jetIds[0]] >= 0 and event.Muon_looseId[
event.Jet_muonIdx1[jetIds[0]]]:
ptMuons1 += event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]]
if event.Jet_muonIdx2[jetIds[0]] >= 0 and event.Muon_looseId[
event.Jet_muonIdx2[jetIds[0]]]:
ptMuons1 += event.Muon_pt[event.Jet_muonIdx2[jetIds[0]]]
if event.Jet_muonIdx1[jetIds[1]] >= 0 and event.Muon_looseId[
event.Jet_muonIdx1[jetIds[1]]]:
ptMuons2 += event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]]
if event.Jet_muonIdx2[jetIds[1]] >= 0 and event.Muon_looseId[
event.Jet_muonIdx2[jetIds[1]]]:
ptMuons2 += event.Muon_pt[event.Jet_muonIdx2[jetIds[1]]]
ptRel1, ptRel2 = 0., 0.
if event.Jet_muonIdx1[jetIds[0]] >= 0:
ptRel1 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[0]]]
if event.Jet_muonIdx1[jetIds[1]] >= 0:
ptRel2 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[1]]]
## Fill jet branches
self.out.njets[0] = len(jetIds)
self.out.jpt_1[0] = event.Jet_pt[jetIds[0]]
self.out.jeta_1[0] = event.Jet_eta[jetIds[0]]
self.out.jphi_1[0] = event.Jet_phi[jetIds[0]]
self.out.jmass_1[0] = event.Jet_mass[jetIds[0]]
#self.out.jCSV_1[0] = event.Jet_btagCSVV2[jetIds[0]]
#self.out.jdeepCSV_1[0] = event.Jet_btagDeepB[jetIds[0]]
self.out.jdeepFlavour_1[0] = event.Jet_btagDeepFlavB[jetIds[0]]
self.out.jnconst_1[0] = event.Jet_nConstituents[jetIds[0]]
self.out.jchf_1[0] = event.Jet_chHEF[jetIds[0]]
self.out.jnhf_1[0] = event.Jet_neHEF[jetIds[0]]
self.out.jcef_1[0] = event.Jet_chEmEF[jetIds[0]]
self.out.jnef_1[0] = event.Jet_neEmEF[jetIds[0]]
self.out.jmuf_1[0] = event.Jet_muEF[jetIds[0]]
self.out.jmuonpt_1[0] = ptMuons1
self.out.jptRel_1[0] = ptRel1
self.out.jnelectrons_1[0] = event.Jet_nElectrons[jetIds[0]]
self.out.jnmuons_1[0] = event.Jet_nMuons[jetIds[0]]
if self.isMC:
self.out.jflavour_1[0] = event.Jet_hadronFlavour[jetIds[0]]
else:
self.out.jflavour_1[0] = -1
self.out.jmask_1[0] = event.Jet_cleanmask[jetIds[0]]
self.out.jid_1[0] = event.Jet_jetId[jetIds[0]]
self.out.jpt_2[0] = event.Jet_pt[jetIds[1]]
self.out.jeta_2[0] = event.Jet_eta[jetIds[1]]
self.out.jphi_2[0] = event.Jet_phi[jetIds[1]]
self.out.jmass_2[0] = event.Jet_mass[jetIds[1]]
#self.out.jCSV_2[0] = event.Jet_btagCSVV2[jetIds[1]]
#self.out.jdeepCSV_2[0] = event.Jet_btagDeepB[jetIds[1]]
self.out.jdeepFlavour_2[0] = event.Jet_btagDeepFlavB[jetIds[1]]
self.out.jnconst_2[0] = event.Jet_nConstituents[jetIds[1]]
self.out.jchf_2[0] = event.Jet_chHEF[jetIds[1]]
self.out.jnhf_2[0] = event.Jet_neHEF[jetIds[1]]
self.out.jcef_2[0] = event.Jet_chEmEF[jetIds[1]]
self.out.jnef_2[0] = event.Jet_neEmEF[jetIds[1]]
self.out.jmuf_2[0] = event.Jet_muEF[jetIds[1]]
self.out.jmuonpt_2[0] = ptMuons2
self.out.jptRel_2[0] = ptRel2
self.out.jnelectrons_2[0] = event.Jet_nElectrons[jetIds[1]]
self.out.jnmuons_2[0] = event.Jet_nMuons[jetIds[1]]
if self.isMC:
self.out.jflavour_2[0] = event.Jet_hadronFlavour[jetIds[1]]
else:
self.out.jflavour_2[0] = -1
self.out.jmask_2[0] = event.Jet_cleanmask[jetIds[1]]
self.out.jid_2[0] = event.Jet_jetId[jetIds[1]]
self.out.jsorted[0] = 0
if leading1 == 0 and leading2 == 1: self.out.jsorted[0] = 1
#self.out.MET_over_SumEt[0] = event.MET_pt/jetHT
if event.nFatJet >= 1 and event.FatJet_pt[0] > 200.:
self.out.fatjetmass_1[0] = event.FatJet_msoftdrop[0]
self.out.fatjettau21_1[0] = (
event.FatJet_tau2[0] /
event.FatJet_tau1[0]) if event.FatJet_tau1[0] > 0. else -1.
self.out.fatjettau21ddt_1[
0] = self.out.fatjettau21_1[0] + 0.082 * ROOT.TMath.Log(
event.FatJet_msoftdrop[0]**2 / event.FatJet_pt[0])
self.out.fatjetHbbvsQCD_1[0] = event.FatJet_deepTagMD_HbbvsQCD[0]
self.out.fatjetWvsQCD_1[0] = event.FatJet_deepTagMD_WvsQCD[0]
self.out.fatjetZHbbvsQCD_1[0] = event.FatJet_deepTagMD_ZHbbvsQCD[0]
self.out.fatjetZbbvsQCD_1[0] = event.FatJet_deepTagMD_ZbbvsQCD[0]
self.out.fatjetZvsQCD_1[0] = event.FatJet_deepTagMD_ZvsQCD[0]
self.out.fatjetbbvsLight_1[0] = event.FatJet_deepTagMD_bbvsLight[0]
if event.nFatJet >= 2 and event.FatJet_pt[1] > 200.:
self.out.fatjetmass_2[0] = event.FatJet_msoftdrop[1]
self.out.fatjettau21_2[0] = (
event.FatJet_tau2[1] /
event.FatJet_tau1[1]) if event.FatJet_tau1[1] > 0. else -1.
self.out.fatjettau21ddt_2[
0] = self.out.fatjettau21_2[0] + 0.082 * ROOT.TMath.Log(
event.FatJet_msoftdrop[1]**2 / event.FatJet_pt[1])
self.out.fatjetHbbvsQCD_2[0] = event.FatJet_deepTagMD_HbbvsQCD[1]
self.out.fatjetWvsQCD_2[0] = event.FatJet_deepTagMD_WvsQCD[1]
self.out.fatjetZHbbvsQCD_2[0] = event.FatJet_deepTagMD_ZHbbvsQCD[1]
self.out.fatjetZbbvsQCD_2[0] = event.FatJet_deepTagMD_ZbbvsQCD[1]
self.out.fatjetZvsQCD_2[0] = event.FatJet_deepTagMD_ZvsQCD[1]
self.out.fatjetbbvsLight_2[0] = event.FatJet_deepTagMD_bbvsLight[1]
self.out.ptBalance[0] = (
event.Jet_pt[jetIds[0]] - event.Jet_pt[jetIds[1]]) / (
event.Jet_pt[jetIds[0]] + event.Jet_pt[jetIds[1]])
self.out.HT[0] = jetHT
self.out.MET[0] = event.MET_pt
self.out.nelectrons[0] = nIsoElectrons
self.out.nmuons[0] = nIsoMuons
self.out.nbtagLoose[0] = jetBTagLoose
self.out.nbtagMedium[0] = jetBTagMedium
self.out.nbtagTight[0] = jetBTagTight
## writing the b-tag category directly into the n-tuple. 0:untagged, 1:loose, 2:medium, 3:tight
self.out.jbtag_WP_1[0] = 0
if event.Jet_btagDeepFlavB[jetIds[0]] > self.btagTight:
self.out.jbtag_WP_1[0] = 3
elif event.Jet_btagDeepFlavB[jetIds[0]] > self.btagMedium:
self.out.jbtag_WP_1[0] = 2
elif event.Jet_btagDeepFlavB[jetIds[0]] > self.btagLoose:
self.out.jbtag_WP_1[0] = 1
self.out.jbtag_WP_2[0] = 0
if event.Jet_btagDeepFlavB[jetIds[1]] > self.btagTight:
self.out.jbtag_WP_2[0] = 3
elif event.Jet_btagDeepFlavB[jetIds[1]] > self.btagMedium:
self.out.jbtag_WP_2[0] = 2
elif event.Jet_btagDeepFlavB[jetIds[1]] > self.btagLoose:
self.out.jbtag_WP_2[0] = 1
## fill trigger branches (different years have different triggers 500<->550, 900<->1050)
try:
self.out.HLT_AK8PFJet500[0] = event.HLT_AK8PFJet500
except:
self.out.HLT_AK8PFJet500[0] = -1
try:
self.out.HLT_PFJet500[0] = event.HLT_PFJet500
except:
self.out.HLT_PFJet500[0] = -1
try:
self.out.HLT_CaloJet500_NoJetID[0] = event.HLT_CaloJet500_NoJetID
except:
self.out.HLT_CaloJet500_NoJetID[0] = -1
try:
self.out.HLT_PFHT900[0] = event.HLT_PFHT900
except:
self.out.HLT_PFHT900[0] = -1
try:
self.out.HLT_AK8PFJet550[0] = event.HLT_AK8PFJet550
except:
self.out.HLT_AK8PFJet550[0] = -1
try:
self.out.HLT_PFJet550[0] = event.HLT_PFJet550
except:
self.out.HLT_PFJet550[0] = -1
try:
self.out.HLT_CaloJet550_NoJetID[0] = event.HLT_CaloJet550_NoJetID
except:
self.out.HLT_CaloJet550_NoJetID[0] = -1
try:
self.out.HLT_PFHT1050[0] = event.HLT_PFHT1050
except:
self.out.HLT_PFHT1050[0] = -1
try:
self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = -1
try:
self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = -1
try:
self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets40_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets100_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets200_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets350_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[0] = -1
## add weights
try:
self.out.btagWeight_DeepCSVB[0] = event.btagWeight_DeepCSVB
except:
self.out.btagWeight_DeepCSVB[0] = -100.
try:
self.out.LHEWeight_originalXWGTUP[
0] = event.LHEWeight_originalXWGTUP
except:
self.out.LHEWeight_originalXWGTUP[0] = -100.
try:
self.out.LHEReweightingWeight[0] = event.LHEReweightingWeight
except:
self.out.LHEReweightingWeight[0] = -100.
try:
self.out.LHEScaleWeight[0] = event.LHEScaleWeight
except:
self.out.LHEScaleWeight[0] = -100.
try:
self.out.PSWeight[0] = event.PSWeight
except:
self.out.PSWeight[0] = -100.
#try:
# self.out.genWeight[0] = event.genWeight
#except:
# self.out.genWeight[0] = -100.
if self.isMC:
self.out.GenWeight[0] = GenWeight
self.out.PUWeight[0] = PUWeight
else:
self.out.GenWeight[0] = 1.
self.out.PUWeight[0] = 1.
if 'signal' in self.name.lower():
self.out.BTagAK4Weight_deepJet[0] = BTagAK4Weight_deepJet
self.out.BTagAK4Weight_deepJet_up[0] = BTagAK4Weight_deepJet_up
self.out.BTagAK4Weight_deepJet_down[0] = BTagAK4Weight_deepJet_down
## event weight lumi
#eventweightlumi = 1.
#if self.isMC:
# eventweightlumi = self.Leq #minimalist approach, store the things to be multiplied later separately into nTuple
# #eventweightlumi = self.Leq * event.LHEWeight_originalXWGTUP
# #eventweightlumi = self.Leq * event.lheweight * event.btagweight #event.puweight
#self.out.eventweightlumi[0] = eventweightlumi
self.out.isMC[0] = int(self.isMC)
self.out.tree.Fill()
return True
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 analyze(self, event):
Wmass = 80.4 # Fixed W mass
OriginTmass = 172.5 # Fixed T mass
## initialize ##
SMTKinVal = [0, 0, 0, 0]
FCNCTKinVal = [0, 0, 0, 0]
consted = 0
# For NPL Selecton
NPLflag = 1
if 'NPL' in self.mode:
if (event._tree.b_out_nGoodLepton != 2
and event._tree.b_out_nVetoLepton > 0):
NPLflag = 0
else:
NPLflag = 1
else:
if (event._tree.b_out_nGoodLepton != 3):
NPLflag = 0
else:
NPLflag = 1
# Check basic event selection
if event._tree.b_out_GoodLeptonCode != 111 or\
not( 2 <= event._tree.b_out_nGoodJet <= 3 ) or\
event._tree.b_out_nBjet < 1 or\
NPLflag == 0:
self.out.fillBranch("KinTop_status", 0)
self.out.fillBranch("KinTopWb_pt", 0)
self.out.fillBranch("KinTopWb_eta", 0)
self.out.fillBranch("KinTopWb_phi", 0)
self.out.fillBranch("KinTopWb_mass", 0)
self.out.fillBranch("KinTopZq_pt", 0)
self.out.fillBranch("KinTopZq_eta", 0)
self.out.fillBranch("KinTopZq_phi", 0)
self.out.fillBranch("KinTopZq_mass", 0)
return True
else:
# Variable construct : Lepton vars = [pt, eta, phi, mass]
Wlepvar = TLorentzVector()
Zlep1var = TLorentzVector()
Zlep2var = TLorentzVector()
Wlepvar.SetPtEtaPhiM(event._tree.b_out_Lepton1_pt,
event._tree.b_out_Lepton1_eta,
event._tree.b_out_Lepton1_phi,
event._tree.b_out_Lepton1_mass)
Zlep1var.SetPtEtaPhiM(event._tree.b_out_Lepton2_pt,
event._tree.b_out_Lepton2_eta,
event._tree.b_out_Lepton2_phi,
event._tree.b_out_Lepton2_mass)
Zlep2var.SetPtEtaPhiM(event._tree.b_out_Lepton3_pt,
event._tree.b_out_Lepton3_eta,
event._tree.b_out_Lepton3_phi,
event._tree.b_out_Lepton3_mass)
# Variable coonstruct : Jet vars = [pt, eta, phi, mass, CSVv2]
#if event._tree._b_out_nGoodJet < 2: continue # nJet >= 2 for tZq reconstruction
bvar = TLorentzVector()
qvar = TLorentzVector()
bvar.SetPtEtaPhiM(event._tree.b_out_GoodJet_pt[0],
event._tree.b_out_GoodJet_eta[0],
event._tree.b_out_GoodJet_phi[0],
event._tree.b_out_GoodJet_mass[0])
qvar.SetPtEtaPhiM(event._tree.b_out_GoodJet_pt[1],
event._tree.b_out_GoodJet_eta[1],
event._tree.b_out_GoodJet_phi[1],
event._tree.b_out_GoodJet_mass[1])
#bjetCSV, qjetCSV = event._tree.b_out_GoodJet_CSVv2[0], event._tree.b_out_GoodJet_CSVv2[1]
bjetDeepFlavB, qjetDeepFlavB = event._tree.b_out_GoodJet_DeepFlavB[
0], event._tree.b_out_GoodJet_DeepFlavB[1]
# Variable condtruct : Neutrino vars = [MET, phi]
metvar = TLorentzVector()
metvar.SetPtEtaPhiM(event._tree.b_out_MET_pt, 0,
event._tree.b_out_MET_phi, 0)
## b jet assign by CSVv2 discriminator
#if ( bjetCSV < qjetCSV ):
# bvar, qvar = qvar, bvar
# bjetCSV, qjetCSV = qjetCSV, bjetCSV
# b jet assign by CSVv2 discriminator
if (bjetDeepFlavB < qjetDeepFlavB):
bvar, qvar = qvar, bvar
bjetDeepFlavB, qjetDeepFlavB = qjetDeepFlavB, bjetDeepFlavB
# pxyzE calculation & construction : [px, py, pz, E]
Zlep1 = self.getKinVar(Zlep1var.Pt(), Zlep1var.Eta(),
Zlep1var.Phi(), 0.)
Zlep2 = self.getKinVar(Zlep2var.Pt(), Zlep2var.Eta(),
Zlep2var.Phi(), 0.)
Wlep = self.getKinVar(Wlepvar.Pt(), Wlepvar.Eta(), Wlepvar.Phi(),
0.) ## Assume lepton mass = 0
bjet = self.getKinVar(bvar.Pt(), bvar.Eta(), bvar.Phi(), bvar.M())
qjet = self.getKinVar(qvar.Pt(), qvar.Eta(), qvar.Phi(), qvar.M())
# MET pxy calculation & construction : [px, py]
metpx = metvar.Pt() * (math.cos(metvar.Phi()))
metpy = metvar.Pt() * (math.sin(metvar.Phi()))
met = [metpx, metpy]
# Calculate pz_neu and E_neu
metpz = self.getSol(Wlep[0], Wlep[1], Wlep[2], Wlep[3], 0., met[0],
met[1], Wmass) # Assume lepton mass = 0
posneuE = math.sqrt((metpx * metpx) + (metpy * metpy) +
(metpz[0] * metpz[0]))
negneuE = math.sqrt((metpx * metpx) + (metpy * metpy) +
(metpz[1] * metpz[1]))
consted = metpz[2] # Reconstructed flag
# SM Top mass construction
SMpxs = [bjet[0], Wlep[0], met[0]]
SMpys = [bjet[1], Wlep[1], met[1]]
posSMpzs = [bjet[2], Wlep[2], metpz[0]]
negSMpzs = [bjet[2], Wlep[2], metpz[1]]
posSMEs = [bjet[3], Wlep[3], posneuE]
negSMEs = [bjet[3], Wlep[3], negneuE]
posTMass = self.getTPEPM(SMpxs, SMpys, posSMpzs, posSMEs)[3]
negTMass = self.getTPEPM(SMpxs, SMpys, negSMpzs, negSMEs)[3]
## Top mass variance comparison and reconsruct SM Top KinVals
if (math.fabs(posTMass - OriginTmass) <
math.fabs(negTMass - OriginTmass)):
SMTMass = posTMass
SMTKinVal = self.getTPEPM(SMpxs, SMpys, posSMpzs, posSMEs)
else:
SMTMass = negTMass
SMTKinVal = self.getTPEPM(SMpxs, SMpys, negSMpzs, negSMEs)
# FCNC Top reconstruction
FCNCpxs = [qjet[0], Zlep1[0], Zlep2[0]]
FCNCpys = [qjet[1], Zlep1[1], Zlep2[1]]
FCNCpzs = [qjet[2], Zlep1[2], Zlep2[2]]
FCNCEs = [qjet[3], Zlep1[3], Zlep2[3]]
FCNCTKinVal = self.getTPEPM(FCNCpxs, FCNCpys, FCNCpzs, FCNCEs)
self.out.fillBranch("KinTop_status", consted)
self.out.fillBranch("KinTopWb_pt", SMTKinVal[0])
self.out.fillBranch("KinTopWb_eta", SMTKinVal[1])
self.out.fillBranch("KinTopWb_phi", SMTKinVal[2])
self.out.fillBranch("KinTopWb_mass", SMTKinVal[3])
self.out.fillBranch("KinTopZq_pt", FCNCTKinVal[0])
self.out.fillBranch("KinTopZq_eta", FCNCTKinVal[1])
self.out.fillBranch("KinTopZq_phi", FCNCTKinVal[2])
self.out.fillBranch("KinTopZq_mass", FCNCTKinVal[3])
## for debugging
#print " Coefficients A/B/aterm/bterm/cterm : ", metpz[3], metpz[4], metpz[5], metpz[6], metpz[7]
#print " Sum pxyzE for top solution : ", SMTKinVal[4], SMTKinVal[5], SMTKinVal[6], SMTKinVal[7]
#print "Z lepton 1 : ", Zlep1
#print "Z lepton 2 : ", Zlep2
#print "W lepton 1 : ", Wlep
#print "b jet : ", bjet
#print "q jet : ", qjet
#print "neu px, py : ", met
#print " Neu Z pos/neg solution : ", metpz[0], metpz[1]
#print "neu pos/neg energy : ", posneuE, negneuE
return True
def getFourVec(pt, eta, phi, E):
vec = TLorentzVector()
vec.SetPtEtaPhiE(pt, eta, phi, E)
return vec
event_header = lines[0].strip()
num_part = int(event_header.split()[0].strip())
if float(event_header.split()[2]) > 0:
a1_1 = [s for s in lines if s.split()[0] == '22']
a1 = a1_1[1::2]
a2 = a1_1[0::2]
b = [s for s in lines if s.split()[0] == '5']
bbar = [s for s in lines if s.split()[0] == '-5']
if a1:
px1 = float(a1[0].split()[6])
py1 = float(a1[0].split()[7])
pz1 = float(a1[0].split()[8])
e1 = float(a1[0].split()[9])
p1 = TLorentzVector(px1, py1, pz1, e1)
if a2:
px2 = float(a2[0].split()[6])
py2 = float(a2[0].split()[7])
pz2 = float(a2[0].split()[8])
e2 = float(a2[0].split()[9])
p2 = TLorentzVector(px2, py2, pz2, e2)
if b:
px3 = float(b[0].split()[6])
py3 = float(b[0].split()[7])
pz3 = float(b[0].split()[8])
e3 = float(b[0].split()[9])
p3 = TLorentzVector(px3, py3, pz3, e3)
def evaluate( self, lp, lm, jets, met = TLorentzVector(),
doIntegration = True, coords = None, **kwargs ):
return self.__call__( lp, lm, jets, met, doIntegration, coords )
def analyze(self, event):
iSkim = 0
eventWeightLumi, lheWeight, stitchWeight, puWeight, qcdnloWeight, qcdnnloWeight, ewknloWeight, topWeight = 1., 1., 1., 1., 1., 1., 1., 1.
triggerWeight, leptonWeight = 1., 1.
MinMuonIso, MaxMuonIso, MinMuonMetDPhi, MaxMuonMetDPhi, MinMuonJetDR = -1., -1., -1., -1., -1.
mZ, mW, mT, ptZ, ptW = -1., -1., -1., -1., -1.
dEtaLL, dPhiLL, dRLL = -1., -1., -1.
mJJ, ptJJ, dEtaJJ, dPhiJJ, dRJJ = -1., -1., -1., -1., -1.
mLLJJ, mNJ = -1., -1.
mHadW, mLepTop1, mLepTop2, mHadTop1, mHadTop2 = -1., -1., -1., -1., -1.
isSingleMuIsoTrigger, isSingleMuTrigger, isDoubleMuonTrigger, isSingleEleIsoTrigger, isSingleEleTrigger = False, False, False, False, False
for t in self.SingleMuIsoTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleMuIsoTrigger = True
for t in self.SingleMuTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleMuTrigger = True
for t in self.DoubleMuonTriggers:
if hasattr(event, t) and getattr(event, t):
isDoubleMuonTrigger = True
for t in self.SingleEleIsoTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleEleIsoTrigger = True
for t in self.SingleEleTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleEleTrigger = True
lheWeight = 1.
if self.isMC:
# Event weight
if not self.isLO and hasattr(event, "LHEWeight_originalXWGTUP"):
lheWeight = event.LHEWeight_originalXWGTUP
GenVpt = self.VptCorr.getGenVpt(
event) if not self.VptCorr is None else 0.
# MC stitching weight
# W+jets inclusive and exclusive
if 'WJetsToLNu_TuneCUETP8M1_13TeV-amcatnloFXFX-pythia8' in self.fileName and 'Summer16' in self.fileName:
if event.LHE_Vpt > 100.: stitchWeight = 0.
# Z+jets and Z+gamma
if self.fileName.startswith(
'ZGTo2LG_TuneCUETP8M1') or self.fileName.startswith(
'ZGToLLG_01J_5f_TuneCP5') or self.fileName.startswith(
'DYJetsToLL_M-50_Tune'):
nGenPhotons = 0
photonPtTh = 15. if self.fileName.startswith(
'ZGTo2LG_TuneCUETP8M1') or self.fileName.startswith(
'DYJetsToLL_M-50_TuneCUETP8M1') else 20.
for i in range(event.nGenPart):
if GenPart_pdgId[i] == 22 and TMath.Odd(
GenPart_statusFlags[i]
) and GenPart_pt > photonPtTh:
nGenPhotons += 1
if self.fileName.startswith('ZG') and nGenPhotons <= 0:
stitchWeight = 0.
if self.fileName.startswith(
'DYJetsToLL_M-50') and nGenPhotons >= 1:
stitchWeight = 0.
# PU weight
puWeight = self.puTool.getWeight(event.Pileup_nTrueInt)
# Higher order correction weights
if not self.VptCorr is None:
if not 'amcatnlo' in self.fileName:
qcdnloWeight = self.VptCorr.getWeightQCDNLO(GenVpt)
qcdnnloWeight = self.VptCorr.getWeightQCDNNLO(GenVpt)
ewknloWeight = self.VptCorr.getWeightEWKNLO(GenVpt)
if 'TTTo' in self.fileName:
Top1_pt, Top2_pt = getTTPt(event)
topWeight = getTTptWeight(Top1_pt, Top2_pt)
self.hists["Events"].Fill(0, lheWeight)
# electrons = Collection(event, "Electron")
# muons = Collection(event, "Muon")
# jets = Collection(event, "Jet")
# eventSum = ROOT.TLorentzVector()
# #select events with at least 2 muons
# if len(muons) >=2 :
# for lep in muons : #loop on muons
# eventSum += lep.p4()
# for lep in electrons : #loop on electrons
# eventSum += lep.p4()
# for j in jets : #loop on jets
# eventSum += j.p4()
# Clean collections
# Electrons
cleanElectron = []
for i in range(event.nElectron):
if event.Electron_pt[i] > 10. and event.Electron_cutBased[i] >= 2:
p4 = TLorentzVector()
p4.SetPtEtaPhiM(event.Electron_pt[i], event.Electron_eta[i],
event.Electron_phi[i], event.Electron_mass[i])
cleanElectron.append(p4)
# Muons
cleanMuon = []
for i in range(event.nMuon):
if event.Muon_pt[i] > 10. and event.Muon_mediumId[
i] and event.Muon_pfRelIso03_all[i] < 0.15:
p4 = TLorentzVector()
p4.SetPtEtaPhiM(event.Muon_pt[i], event.Muon_eta[i],
event.Muon_phi[i], event.Muon_mass[i])
cleanMuon.append(p4)
# Jets and Event variables
cleanJet, cleanBJet, cleanNonBJet = [], [], []
HT30, Nj20, Nj30, Nj40, nBJet = 0., 0, 0, 0, 0
CSVs = []
twoJets, allJets = TLorentzVector(), TLorentzVector()
for i in range(event.nJet):
if event.Jet_jetId[i] >= 6 and abs(event.Jet_eta[i]) < 2.5:
p4 = TLorentzVector()
p4.SetPtEtaPhiM(event.Jet_pt[i], event.Jet_eta[i],
event.Jet_phi[i], event.Jet_mass[i])
# remove overlaps with electrons and muons
cleanFromLeptons = True
for e in range(len(cleanElectron)):
if cleanElectron[e].DeltaR(p4) < 0.4:
cleanFromLeptons = False
for m in range(len(cleanMuon)):
if cleanMuon[m].DeltaR(p4) < 0.4: cleanFromLeptons = False
# fill variables
if cleanFromLeptons:
if event.Jet_pt[i] > 20.:
Nj20 += 1
if event.Jet_pt[i] > 30.:
HT30 += event.Jet_pt[i]
Nj30 += 1
cleanJet.append(p4)
if event.Jet_btagDeepB[i] >= self.btagMedium:
cleanBJet.append(p4)
else:
cleanNonBJet.append(p4)
CSVs.append([i, event.Jet_btagDeepB[i]])
if len(cleanJet) < 2: twoJets += p4
allJets += p4
if event.Jet_pt[i] > 40.:
Nj40 += 1
# b-tag ranking
nBJet = len(cleanBJet)
CSV1, CSV2, CSV3, CSV4, iCSV1, iCSV2, iCSV3, iCSV4 = 0., 0., 0., 0., -1, -1, -1, -1
CSVs.sort(key=lambda x: x[1], reverse=True)
if len(CSVs) > 0: iCSV1, CSV1 = CSVs[0][0], CSVs[0][1]
if len(CSVs) > 1: iCSV2, CSV2 = CSVs[1][0], CSVs[1][1]
if len(CSVs) > 2: iCSV3, CSV3 = CSVs[2][0], CSVs[2][1]
if len(CSVs) > 3: iCSV4, CSV4 = CSVs[3][0], CSVs[3][1]
if len(cleanJet) >= 2:
mJJ = (cleanJet[0] + cleanJet[1]).M()
ptJJ = (cleanJet[0] + cleanJet[1]).Pt()
dEtaJJ = abs(cleanJet[0].Eta() - cleanJet[1].Eta())
dPhiJJ = abs(cleanJet[0].DeltaPhi(cleanJet[1]))
dRJJ = cleanJet[0].DeltaR(cleanJet[1])
mNJ = allJets.M()
Lepton1, Lepton2, Lepton3, Neutrino, MET, LLJJ, Vis = TLorentzVector(
), TLorentzVector(), TLorentzVector(), TLorentzVector(
), TLorentzVector(), TLorentzVector(), TLorentzVector()
MET.SetPtEtaPhiM(event.MET_pt, 0., event.MET_phi, 0.)
# Categorization:
# iSkim = 1: 2 muons (OS or SS)
# iSkim = 2: 1 muon and 1 electron (no OS requirement)
# iSkim = 3: 3 muons (assumed that they are not 3 same-sign)
# iSkim = 4: 2 muons (OS) and 1 electron
# iSkim = 5: 1 muons, 3 jets, >= 1 btag
# iSkim = 6: 2 electrons
# case 3a: 3 lepton CR (3mu)
if iSkim == 0 and event.nMuon >= 3:
if (isSingleMuIsoTrigger or isSingleMuTrigger) and event.Muon_pt[
0] > 27. and event.Muon_pt[1] > 15. and event.Muon_pt[
2] > 15. and event.Muon_mediumId[
0] and event.Muon_mediumId[
1] and event.Muon_mediumId[2]:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Muon_pt[1], event.Muon_eta[1],
event.Muon_phi[1], event.Muon_mass[1])
Lepton3.SetPtEtaPhiM(event.Muon_pt[2], event.Muon_eta[2],
event.Muon_phi[2], event.Muon_mass[2])
if event.Muon_charge[0] * event.Muon_charge[1] < 0:
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
detall = abs(Lepton1.Eta() - Lepton2.Eta())
dphill = abs(Lepton1.DeltaPhi(Lepton2))
drll = Lepton1.DeltaR(Lepton2)
else:
mll = (Lepton1 + Lepton3).M()
ptll = (Lepton1 + Lepton3).Pt()
detall = abs(Lepton1.Eta() - Lepton3.Eta())
dphill = abs(Lepton1.DeltaPhi(Lepton3))
drll = Lepton1.DeltaR(Lepton3)
if mll > 15.:
iSkim = 3
# Variables
mZ, ptZ = mll, ptll
dEtaLL, dPhiLL, dRLL = detall, dphill, drll
MinMuonIso = min(
min(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1]),
event.Muon_pfRelIso03_all[2])
MaxMuonIso = max(
max(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1]),
event.Muon_pfRelIso03_all[2])
MinMuonMetDPhi = min(
min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MaxMuonMetDPhi = max(
max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MinMuonJetDR = min(
min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2)),
getMinMuonJetDR(cleanJet, Lepton3))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2 + Lepton3
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
event.Muon_pt[0], event.Muon_eta[0])
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])
IdSF3 = self.muSFs.getIdSF(event.Muon_pt[2],
event.Muon_eta[2], 2)
IsoSF3 = self.muSFs.getIsoSF(event.Muon_pt[2],
event.Muon_eta[2])
leptonWeight = IdSF1 * IsoSF1 * IdSF2 * IsoSF2 * IdSF3 * IsoSF3
# case 3b: 3 lepton CR (2mu 1e)
if iSkim == 0 and event.nMuon >= 2 and event.nElectron >= 1:
if (isSingleMuIsoTrigger or isSingleMuTrigger) and event.Muon_pt[
0] > 27. and event.Muon_pt[1] > 15. and event.Electron_pt[
0] > 15. and event.Muon_mediumId[
0] and event.Muon_mediumId[
1] and event.Electron_cutBased[
0] >= 2 and event.Muon_charge[
0] * event.Muon_charge[1] < 0:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Muon_pt[1], event.Muon_eta[1],
event.Muon_phi[1], event.Muon_mass[1])
Lepton3.SetPtEtaPhiM(event.Electron_pt[0],
event.Electron_eta[0],
event.Electron_phi[0],
event.Electron_mass[0])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 4
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = min(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MaxMuonIso = max(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MinMuonMetDPhi = min(
min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MaxMuonMetDPhi = max(
max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2 + Lepton3
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
event.Muon_pt[0], event.Muon_eta[0])
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
# case 1: Z->mumu CR (2 mu)
if iSkim == 0 and event.nMuon >= 2:
if (isSingleMuIsoTrigger or isSingleMuTrigger) and event.Muon_pt[
0] > 27. and event.Muon_pt[1] > 7. and event.Muon_mediumId[
0] and event.Muon_mediumId[1]:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Muon_pt[1], event.Muon_eta[1],
event.Muon_phi[1], event.Muon_mass[1])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 1
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = min(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MaxMuonIso = max(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MinMuonMetDPhi = min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MaxMuonMetDPhi = max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
event.Muon_pt[0], event.Muon_eta[0])
IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0],
event.Muon_eta[0], 2)
IdSF2 = self.muSFs.getIdSF(event.Muon_pt[1],
event.Muon_eta[1], 2)
IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0],
event.Muon_eta[0])
IsoSF2 = self.muSFs.getIsoSF(event.Muon_pt[1],
event.Muon_eta[1])
leptonWeight = IdSF1 * IdSF2 * IsoSF1 * IsoSF2
# case 4: Z->ee CR (2 electrons)
if iSkim == 0 and event.nElectron >= 2:
if isSingleEleIsoTrigger and event.Electron_pt[
0] > 35. and event.Electron_pt[
1] > 10. and event.Electron_cutBased[
0] > 0 and event.Electron_cutBased[1] > 0:
Lepton1.SetPtEtaPhiM(event.Electron_pt[0],
event.Electron_eta[0],
event.Electron_phi[0],
event.Electron_mass[0])
Lepton2.SetPtEtaPhiM(event.Electron_pt[1],
event.Electron_eta[1],
event.Electron_phi[1],
event.Electron_mass[1])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 6
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = event.Electron_pfRelIso03_all[0]
MaxMuonIso = event.Electron_pfRelIso03_all[0]
MinMuonMetDPhi = min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MaxMuonMetDPhi = max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2
# Weights
if self.isMC:
triggerWeight = self.elSFs.getTriggerSF(
event.Electron_pt[0], event.Electron_eta[0])
leptonWeight = self.elSFs.getIdIsoSF(
event.Electron_pt[0],
event.Electron_eta[0]) * self.elSFs.getIdIsoSF(
event.Electron_pt[1], event.Electron_eta[1])
# case 2: ttbar and Z OF CR (1 muon and 1 electron)
if iSkim == 0 and event.nMuon >= 1 and event.nElectron >= 1:
if (isSingleMuIsoTrigger or isSingleMuTrigger
) and event.Muon_pt[0] > 27. and event.Electron_pt[
0] > 20. and event.Muon_mediumId[
0] and event.Electron_cutBased[0] >= 2:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Electron_pt[0],
event.Electron_eta[0],
event.Electron_phi[0],
event.Electron_mass[0])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 2
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = event.Muon_pfRelIso03_all[0]
MaxMuonIso = event.Muon_pfRelIso03_all[0]
MinMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MaxMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
Lepton1.Pt(), Lepton1.Eta())
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])
IdIsoSF2 = self.elSFs.getIdIsoSF(
event.Electron_pt[0], event.Electron_eta[0])
leptonWeight = IdSF1 * IsoSF1 * IdIsoSF2
# case 4: ttbar CR (1 muon and >= 3 jets)
if iSkim == 0 and event.nMuon >= 1:
if (isSingleMuIsoTrigger or isSingleMuTrigger
) and event.Muon_pt[0] > 27. and event.Muon_mediumId[
0] and event.Muon_pfRelIso03_all[0] < 0.15:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
pzN = recoverNeutrinoPz(Lepton1, MET)
Neutrino.SetPxPyPzE(MET.Px(), MET.Py(), pzN, MET.Pt())
mW = (Lepton1 + Neutrino).M()
ptW = (Lepton1 + Neutrino).Pt()
mT = math.sqrt(2. * Lepton1.Pt() * MET.Pt() *
(1. - math.cos(Lepton1.DeltaPhi(MET))))
if Nj30 >= 3: # and nBJet >= 1:
iSkim = 5
# Variables
MinMuonIso = event.Muon_pfRelIso03_all[0]
MaxMuonIso = event.Muon_pfRelIso03_all[0]
MinMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MaxMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MinMuonJetDR = getMinMuonJetDR(cleanJet, Lepton1)
LLJJ = twoJets + Lepton1
Vis = allJets + Lepton1
# W and Top reconstruction
if len(cleanBJet) >= 2:
mLepTop1 = (Lepton1 + Neutrino + cleanBJet[0]).M()
mLepTop2 = (Lepton1 + Neutrino + cleanBJet[1]).M()
elif len(cleanBJet) >= 1:
mLepTop1 = (Lepton1 + Neutrino + cleanBJet[0]).M()
mHadTop2 = mHadTop1
if len(cleanNonBJet) >= 2:
mHadW = (cleanNonBJet[0] + cleanNonBJet[1]).M()
if len(cleanBJet) >= 2:
mHadTop1 = (cleanNonBJet[0] + cleanNonBJet[1] +
cleanBJet[0]).M()
mHadTop2 = (cleanNonBJet[0] + cleanNonBJet[1] +
cleanBJet[1]).M()
elif len(cleanBJet) >= 1:
mHadTop1 = (cleanNonBJet[0] + cleanNonBJet[1] +
cleanBJet[0]).M()
mHadTop2 = mHadTop1
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
Lepton1.Pt(), Lepton1.Eta())
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])
leptonWeight = IdSF1 * IsoSF1
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
if iSkim == 0: return False
if self.isMC:
eventWeightLumi = self.lumiWeight * lheWeight * puWeight * topWeight * qcdnloWeight * qcdnnloWeight * ewknloWeight * triggerWeight * leptonWeight
self.out.fillBranch("iSkim", iSkim)
self.out.fillBranch("isMC", self.isMC)
self.out.fillBranch("isSingleMuIsoTrigger", isSingleMuIsoTrigger)
self.out.fillBranch("isSingleMuTrigger", isSingleMuTrigger)
self.out.fillBranch("isDoubleMuonTrigger", isDoubleMuonTrigger)
self.out.fillBranch("isSingleEleIsoTrigger", isSingleEleIsoTrigger)
self.out.fillBranch("isSingleEleTrigger", isSingleEleTrigger)
self.out.fillBranch("passedMETFilters", passedMETFilters)
self.out.fillBranch("nCleanElectron", len(cleanElectron))
self.out.fillBranch("nCleanMuon", len(cleanMuon))
self.out.fillBranch("nCleanJet", len(cleanJet))
self.out.fillBranch("Z_mass", mZ)
self.out.fillBranch("Z_pt", ptZ)
self.out.fillBranch("W_mass", mW)
self.out.fillBranch("W_tmass", mT)
self.out.fillBranch("W_pt", ptW)
self.out.fillBranch("ll_dEta", dEtaLL)
self.out.fillBranch("ll_dPhi", dPhiLL)
self.out.fillBranch("ll_dR", dRLL)
self.out.fillBranch("Wqq_mass", mHadW)
self.out.fillBranch("Tlvb1_mass", mLepTop1)
self.out.fillBranch("Tlvb2_mass", mLepTop2)
self.out.fillBranch("Tqqb1_mass", mHadTop1)
self.out.fillBranch("Tqqb2_mass", mHadTop2)
self.out.fillBranch("jj_mass", mJJ)
self.out.fillBranch("jj_pt", ptJJ)
self.out.fillBranch("jj_dEta", dEtaJJ)
self.out.fillBranch("jj_dPhi", dPhiJJ)
self.out.fillBranch("jj_dR", dRJJ)
self.out.fillBranch("nj_mass", mNJ)
self.out.fillBranch("vis_mass", Vis.M())
self.out.fillBranch("lljj_mass", LLJJ.M())
self.out.fillBranch("minMuonIso", MinMuonIso)
self.out.fillBranch("maxMuonIso", MaxMuonIso)
self.out.fillBranch("minMuonMetDPhi", MinMuonMetDPhi)
self.out.fillBranch("maxMuonMetDPhi", MaxMuonMetDPhi)
self.out.fillBranch("minMuonJetDR", MinMuonJetDR)
self.out.fillBranch("HT30", HT30)
self.out.fillBranch("nj20", Nj20)
self.out.fillBranch("nj30", Nj30)
self.out.fillBranch("nj40", Nj40)
self.out.fillBranch("nBJet", nBJet)
self.out.fillBranch("CSV1", CSV1)
self.out.fillBranch("CSV2", CSV2)
self.out.fillBranch("CSV3", CSV3)
self.out.fillBranch("CSV4", CSV4)
self.out.fillBranch("iCSV1", iCSV1)
self.out.fillBranch("iCSV2", iCSV2)
self.out.fillBranch("iCSV3", iCSV3)
self.out.fillBranch("iCSV4", iCSV4)
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)
return True
def DoMassRecoBoost(ak4Jets, higgsJet, higgsSoftDropMass, leptonP4, nuP4,
higgsMass, topMass, chi2_dR1, chi2_dR2, chi2_higgs1,
chi2_higgs2, chi2_top1, chi2_top2):
ak4JetsP4 = [
TLorentzVector(0.0, 0.0, 0.0, 0.0),
TLorentzVector(0.0, 0.0, 0.0, 0.0)
]
chi2 = 100000.0
dR = 100000.0
minChi2 = 100000.0
topP4 = TLorentzVector(0.0, 0.0, 0.0, 0.0)
higgsP4 = TLorentzVector(0.0, 0.0, 0.0, 0.0)
indexnum = 2
if len(higgsJet) > 0 and len(ak4Jets) > 0:
if len(ak4Jets) >= indexnum and len(higgsJet) >= indexnum:
for i in range(0, indexnum):
for j in range(0, indexnum):
jetsP4PassToChi2 = []
higgsjetsP4PassToChi2 = []
if len(jetsP4PassToChi2) != 0:
jetsP4PassToChi2.clear()
if len(higgsjetsP4PassToChi2) != 0:
higgsjetsP4PassToChi2.clear()
topP4.Clear()
higgsP4.Clear()
ak4JetsP4 = []
higgsJetsP4 = []
jetsP4PassToChi2.append(ak4Jets[i])
higgsjetsP4PassToChi2.append(higgsJet[j])
chi2, dR, topP4, higgsP4 = GetChi2Boosted(
jetsP4PassToChi2, higgsjetsP4PassToChi2,
higgsSoftDropMass, leptonP4, nuP4, topMass, higgsMass,
topP4, higgsP4, dR)
if (chi2 < minChi2):
minChi2 = chi2
chi2_higgs1 = minChi2
chi2_higgs2 = higgsP4
chi2_top1 = minChi2
chi2_top2 = topP4
chi2_dR1 = minChi2
chi2_dR2 = dR
elif len(ak4Jets) < indexnum and len(higgsJet) >= indexnum:
for i in range(0, len(ak4Jets)):
for j in range(0, indexnum):
jetsP4PassToChi2 = []
higgsjetsP4PassToChi2 = []
if len(jetsP4PassToChi2) != 0:
jetsP4PassToChi2.clear()
if len(higgsjetsP4PassToChi2) != 0:
higgsjetsP4PassToChi2.clear()
topP4.Clear()
higgsP4.Clear()
ak4JetsP4 = []
higgsJetsP4 = []
jetsP4PassToChi2.append(ak4Jets[i])
higgsjetsP4PassToChi2.append(higgsJet[j])
chi2, dR, topP4, higgsP4 = GetChi2Boosted(
jetsP4PassToChi2, higgsjetsP4PassToChi2,
higgsSoftDropMass, leptonP4, nuP4, topMass, higgsMass,
topP4, higgsP4, dR)
if (chi2 < minChi2):
minChi2 = chi2
chi2_higgs1 = minChi2
chi2_higgs2 = higgsP4
chi2_top1 = minChi2
chi2_top2 = topP4
chi2_dR1 = minChi2
chi2_dR2 = dR
elif len(ak4Jets) >= indexnum and len(higgsJet) < indexnum:
for i in range(0, indexnum):
for j in range(0, len(higgsJet)):
jetsP4PassToChi2 = []
higgsjetsP4PassToChi2 = []
if len(jetsP4PassToChi2) != 0:
jetsP4PassToChi2.clear()
if len(higgsjetsP4PassToChi2) != 0:
higgsjetsP4PassToChi2.clear()
topP4.Clear()
higgsP4.Clear()
ak4JetsP4 = []
higgsJetsP4 = []
jetsP4PassToChi2.append(ak4Jets[i])
higgsjetsP4PassToChi2.append(higgsJet[j])
chi2, dR, topP4, higgsP4 = GetChi2Boosted(
jetsP4PassToChi2, higgsjetsP4PassToChi2,
higgsSoftDropMass, leptonP4, nuP4, topMass, higgsMass,
topP4, higgsP4, dR)
if (chi2 < minChi2):
minChi2 = chi2
chi2_higgs1 = minChi2
chi2_higgs2 = higgsP4
chi2_top1 = minChi2
chi2_top2 = topP4
chi2_dR1 = minChi2
chi2_dR2 = dR
elif len(ak4Jets) < indexnum and len(higgsJet) < indexnum:
for i in range(0, len(ak4Jets)):
for j in range(0, len(higgsJet)):
jetsP4PassToChi2 = []
higgsjetsP4PassToChi2 = []
if len(jetsP4PassToChi2) != 0:
jetsP4PassToChi2.clear()
if len(higgsjetsP4PassToChi2) != 0:
higgsjetsP4PassToChi2.clear()
topP4.Clear()
higgsP4.Clear()
ak4JetsP4 = []
higgsJetsP4 = []
jetsP4PassToChi2.append(ak4Jets[i])
higgsjetsP4PassToChi2.append(higgsJet[j])
chi2, dR, topP4, higgsP4 = GetChi2Boosted(
jetsP4PassToChi2, higgsjetsP4PassToChi2,
higgsSoftDropMass, leptonP4, nuP4, topMass, higgsMass,
topP4, higgsP4, dR)
if (chi2 < minChi2):
minChi2 = chi2
chi2_higgs1 = minChi2
chi2_higgs2 = higgsP4
chi2_top1 = minChi2
chi2_top2 = topP4
chi2_dR1 = minChi2
chi2_dR2 = dR
return chi2_higgs1, chi2_higgs2, chi2_top2, chi2_dR2
def process(self, event):
event.NUP = -1
event.genPartonHT = 0.
event.NJetWeight = 1
event.geninvmass = -999.
if not self.cfg_comp.isMC:
return True
if not self.hasMCProduct:
return True
self.readCollections(event.input)
self.mchandles['source'].ReallyLoad(event.input)
if not self.mchandles['source'].isValid():
self.hasMCProduct = False
print 'WARNING: No LHEEventProduct from externalLHEProducer present in event'
print ' (fine for sample directly produced in Pythia)'
return True
hep = self.mchandles['source'].product().hepeup()
# For reference: The following worked in run 1, but for run 2 MC,
# the intermediate boson is not saved if it's too far off shell...
# removing the 2 incoming partons, a boson,
# and the 2 partons resulting from the decay of a boson
# njets = event.NUP - 5
event.NJetWeight = 1.
sumpt = 0.
outgoing = []
leptons = []
# print [(a, b) for a, b in zip(hep.ISTUP, hep.IDUP)]
for status, pdg, moth, mom in zip(hep.ISTUP, hep.IDUP, hep.MOTHUP, hep.PUP):
if status == 1 and abs(pdg) in [21, 1, 2, 3, 4, 5, 6]:
sumpt += math.sqrt(mom.x[0]**2 + mom.x[1]**2)
outgoing.append(pdg)
if status == 1 and abs(pdg) in [11, 12, 13, 14, 15, 16]:
l = TLorentzVector(mom.x[0], mom.x[1], mom.x[2], mom.x[3])
leptons.append(l)
njets = len(outgoing)
event.NUP = njets
# event.NUP = 1
if len(leptons) == 2:
event.geninvmass = (leptons[0] + leptons[1]).M()
event.genbosonpt = (leptons[0] + leptons[1]).Pt()
event.genPartonHT = sumpt
if self.applyWeight:
event.NJetWeight = self.weighti[njets]
event.eventWeight *= event.NJetWeight
self.averages['NJetWeight'].add(event.NJetWeight)
if self.cfg_ana.verbose:
print 'NUP, njets, weight', event.NUP, njets, event.NJetWeight
if self.applyWeightFunc:
event.NJetWeight = self.weight_func(njets)
if self.cfg_ana.fillTree:
self.tree.reset()
self.tree.fill('njets', njets)
self.tree.fill('nup', event.NUP)
self.tree.fill('weight', event.NJetWeight)
self.tree.tree.Fill()
self.averages['NUP'].add(event.NUP)
self.averages['NJets'].add(njets)
if self.cfg_ana.fillTree:
self.nup.Fill(event.NUP)
self.njets.Fill(njets)
return True
def costheta_CS(pt1,eta1,phi1,pt2,eta2,phi2): mu1 = TLorentzVector() mu2 = TLorentzVector() Q = TLorentzVector() mu1.SetPtEtaPhiM(pt1, eta1, phi1, 0) mu2.SetPtEtaPhiM(pt2, eta2, phi2, 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 abs(costheta)
def __init__(self, pvec=TLorentzVector(), charge=0, pdgid=-1):
self.SetP(pvec)
self.SetCharge(charge)
self.SetFlav(pdgid)
self.resetValues()
def fsrUncorrected(self):
if not hasattr(self,'fsrPhoton'):
return self
else:
gamma = TLorentzVector( self.fsrPhoton.px(), self.fsrPhoton.py(), self.fsrPhoton.pz(), self.fsrPhoton.energy() )
return self-gamma
########################################
# ct_sim-ct_rec
hist_deltact = TH1D('fHistDeltaCt', '', 200, -10, 10)
hist_deltact.SetDirectory(0)
analyzed_events = 0
counter = 0
# main loop over the events
for ev in tree:
if ev.REvent.fCent > 90.:
continue
# loop over the simulated hypertritons
for sim in ev.SHypertriton:
hyp = TLorentzVector()
deu = TLorentzVector()
p = TLorentzVector()
pi = TLorentzVector()
e_deu = hypot4(sim.fPxDeu, sim.fPyDeu, sim.fPzDeu,
AliPID.ParticleMass(AliPID.kDeuteron))
e_p = hypot4(sim.fPxP, sim.fPyP, sim.fPzP,
AliPID.ParticleMass(AliPID.kProton))
e_pi = hypot4(sim.fPxPi, sim.fPyPi, sim.fPzPi,
AliPID.ParticleMass(AliPID.kPion))
deu.SetXYZM(sim.fPxDeu, sim.fPyDeu, sim.fPzDeu,
AliPID.ParticleMass(AliPID.kDeuteron))
p.SetXYZM(sim.fPxP, sim.fPyP, sim.fPzP,
AliPID.ParticleMass(AliPID.kProton))
def test07CopyContructor(self):
"""Test copy constructor"""
t1 = TLorentzVector(1., 2., 3., -4.)
t2 = TLorentzVector(0., 0., 0., 0.)
t3 = TLorentzVector(t1)
self.assertEqual(t1, t3)
self.assertNotEqual(t1, t2)
for i in range(4):
self.assertEqual(t1[i], t3[i])
if not self.legacy_pyroot:
# Test copy constructor with null pointer
t4 = MakeNullPointer(TLorentzVector)
t4.__init__(TLorentzVector(0, 1, 2, 3))
t5 = MakeNullPointer(TLorentzVector)
TLorentzVector.__init__(t5, TLorentzVector(0, 1, 2, 3))
# Test __assign__ if the object already exists
t6 = TLorentzVector(0, 0, 0, 0)
t6.__assign__(TLorentzVector(0, 1, 2, 3))
t7 = TLorentzVector(0, 0, 0, 0)
TLorentzVector.__assign__(t7, TLorentzVector(0, 1, 2, 3))
for i in range(4):
self.assertEqual(t4[i], t5[i])
self.assertEqual(t6[i], t7[i])
else:
t4 = TLorentzVector(0, 0, 0, 0)
t4.__init__(TLorentzVector(0, 1, 2, 3))
# the following should work exactly as above, but no longer does on some version of ROOT 6
t5 = TLorentzVector(0, 0, 0, 0)
TLorentzVector.__init__(t5, TLorentzVector(0, 1, 2, 3))
for i in range(4):
self.assertEqual(t4[i], t5[i])
leps_mydecay += g_taup_pionn
leps_mydecay.append(gen_neu)
leps_mydecay.append(gen_antineu)
tag_upsilon = True
taup_has_pionn = len(g_taup_pionn) != 0
taum_has_pionn = len(g_taum_pionn) != 0
# tau pions
for genpi in g_taum_pions:
min_ind = None
min_deltaR = 9999
matched_x = False
for i in range(0, len(
rec_pions)): # check if particles correspond to one another based on delta r, charge, and delta pt
recpi = rec_pions[i]
gen_lv = TLorentzVector()
gen_lv.SetPtEtaPhiM(genpi.pt(), genpi.eta(), genpi.phi(), 0.139)
rec_lv = TLorentzVector()
rec_lv.SetPtEtaPhiM(recpi.pt(), recpi.eta(), recpi.phi(), 0.139)
deltaR = gen_lv.DeltaR(rec_lv)
deltaPT = (rec_lv.Pt() - gen_lv.Pt()) / gen_lv.Pt()
if recpi.pdgId() == genpi.pdgId() and abs(deltaR) < 0.1 and abs(deltaPT) < 0.3 and deltaR < min_deltaR and abs(genpi.eta()) < 2.5 and not recpi in matched_pionm:
min_ind = i
matched_x = True
min_deltaR = deltaR
if matched_x:
matched_pionm.append(rec_pions[min_ind])
if taum_has_pionn:
for genph in g_taum_photons:
def jet_processing(jet):
# Find the jet (eta, phi)
center=jet.sum(axis=0)
v_jet=TLorentzVector(center[1], center[2], center[3], center[0])
# Centering parameters
phi=v_jet.Phi()
bv = v_jet.BoostVector()
bv.SetPerp(0)
for n in np.arange(len(jet)):
if np.sum(jet[n,:]) != 0:
v = TLorentzVector(jet[n,1], jet[n,2], jet[n,3], jet[n,0])
v.RotateZ(-phi)
v.Boost(-bv)
jet[n,:] = v[3], v[0], v[1], v[2] #(E,Px,Py,Pz)
# Rotating parameters
weighted_phi=0
weighted_eta=0
for n in np.arange(len(jet)):
if np.sum(jet[n,:]) != 0:
v = TLorentzVector(jet[n,1], jet[n,2], jet[n,3], jet[n,0])
r = np.sqrt(v.Phi()**2 + v.Eta()**2)
if r != 0: #in case there is only one component
weighted_phi += v.Phi() * v.E()/r
weighted_eta += v.Eta() * v.E()/r
#alpha = np.arctan2(weighted_phi, weighted_eta) #approximately align at eta
alpha = np.arctan2(weighted_eta, weighted_phi) #approximately align at phi
for n in np.arange(len(jet)):
if np.sum(jet[n,:]) != 0:
v = TLorentzVector(jet[n,1], jet[n,2], jet[n,3], jet[n,0])
#v.rotate_x(alpha) #approximately align at eta
v.RotateX(-alpha) #approximately align at phi
jet[n,:] = v[3], v[0], v[1], v[2] #(E,Px,Py,Pz)
return jet
hypo = int(line.split()[1])
elif line.startswith("tf_method"):
tf_method = int(line.split()[1])
cfg.transfer_function_method = tf_method
elif line.startswith("int_code"):
print "cfg.int_code", cfg.int_code
int_code = int(line.split()[1])
cfg.int_code = int_code
elif line.startswith("do_minimize"):
print "cfg.", cfg.do_minimize
do_minimize = int(line.split()[1])
cfg.do_minimize = do_minimize
elif line.startswith("memBQuark") or line.startswith("lq"):
jet_type, pt, eta, phi, m, btagflag, match, match_index = line.split()
pt, eta, phi, m, btagflag = tuple(map(float, [pt, eta, phi, m, btagflag]))
v = TLorentzVector()
v.SetPtEtaPhiM(pt, eta, phi, m)
o = MEM.Object(v, MEM.ObjectType.Jet)
o.addObs(MEM.Observable.BTAG, btagflag)
add_tf(eta, o)
mem.push_back_object(o)
#print "jet", pt, eta, phi, m, btagflag
elif line.startswith("memLepton"):
lep_type, pt, eta, phi, m, charge = line.split()
pt, eta, phi, m, charge = tuple(map(float, [pt, eta, phi, m, charge]))
v = TLorentzVector()
v.SetPtEtaPhiM(pt, eta, phi, m)
o = MEM.Object(v, MEM.ObjectType.Lepton)
o.addObs(MEM.Observable.CHARGE, charge)
add_tf(eta, o)
mem.push_back_object(o)
