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)