void selectAntiWm(const TString conf="wm.conf", // input file
const TString outputDir="." // output directory
) {
gBenchmark->Start("selectAntiWm");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t PT_CUT = 25;
const Double_t ETA_CUT = 2.4;
const Double_t MUON_MASS = 0.105658369;
const Double_t VETO_PT = 10;
const Double_t VETO_ETA = 2.4;
const Int_t BOSON_ID = 24;
const Int_t LEPTON_ID = 13;
// load trigger menu
const baconhep::TTrigger triggerMenu("../../BaconAna/DataFormats/data/HLT_50nsGRun");
// load pileup reweighting file
TFile *f_rw = TFile::Open("../Tools/pileup_weights_2015B.root", "read");
TH1D *h_rw = (TH1D*) f_rw->Get("npv_rw");
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
vector<TString> snamev; // sample name (for output files)
vector<CSample*> samplev; // data/MC samples
//
// parse .conf file
//
confParse(conf, snamev, samplev);
const Bool_t hasData = (samplev[0]->fnamev.size()>0);
// Create output directory
gSystem->mkdir(outputDir,kTRUE);
const TString ntupDir = outputDir + TString("/ntuples");
gSystem->mkdir(ntupDir,kTRUE);
//
// Declare output ntuple variables
//
UInt_t runNum, lumiSec, evtNum;
UInt_t npv, npu;
UInt_t id_1, id_2;
Double_t x_1, x_2, xPDF_1, xPDF_2;
Double_t scalePDF, weightPDF;
TLorentzVector *genV=0, *genLep=0;
Float_t genVPt, genVPhi, genVy, genVMass;
Float_t genLepPt, genLepPhi;
Float_t scale1fb, puWeight;
Float_t met, metPhi, sumEt, mt, u1, u2;
Float_t tkMet, tkMetPhi, tkSumEt, tkMt, tkU1, tkU2;
Float_t mvaMet, mvaMetPhi, mvaSumEt, mvaMt, mvaU1, mvaU2;
Int_t q;
TLorentzVector *lep=0;
///// muon specific /////
Float_t trkIso, emIso, hadIso;
Float_t pfChIso, pfGamIso, pfNeuIso, pfCombIso;
Float_t d0, dz;
Float_t muNchi2;
UInt_t nPixHits, nTkLayers, nValidHits, nMatch, typeBits;
// Data structures to store info from TTrees
baconhep::TEventInfo *info = new baconhep::TEventInfo();
baconhep::TGenEventInfo *gen = new baconhep::TGenEventInfo();
TClonesArray *genPartArr = new TClonesArray("baconhep::TGenParticle");
TClonesArray *muonArr = new TClonesArray("baconhep::TMuon");
TClonesArray *vertexArr = new TClonesArray("baconhep::TVertex");
TFile *infile=0;
TTree *eventTree=0;
//
// loop over samples
//
for(UInt_t isam=0; isam<samplev.size(); isam++) {
// Assume data sample is first sample in .conf file
// If sample is empty (i.e. contains no ntuple files), skip to next sample
Bool_t isData=kFALSE;
if(isam==0 && !hasData) continue;
else if (isam==0) isData=kTRUE;
// Assume signal sample is given name "wm"
Bool_t isSignal = (snamev[isam].CompareTo("wm",TString::kIgnoreCase)==0);
// flag to reject W->mnu events when selecting wrong-flavor background events
Bool_t isWrongFlavor = (snamev[isam].CompareTo("wx",TString::kIgnoreCase)==0);
CSample* samp = samplev[isam];
//
// Set up output ntuple
//
TString outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.root");
TFile *outFile = new TFile(outfilename,"RECREATE");
TTree *outTree = new TTree("Events","Events");
outTree->Branch("runNum", &runNum, "runNum/i"); // event run number
outTree->Branch("lumiSec", &lumiSec, "lumiSec/i"); // event lumi section
outTree->Branch("evtNum", &evtNum, "evtNum/i"); // event number
outTree->Branch("npv", &npv, "npv/i"); // number of primary vertices
outTree->Branch("npu", &npu, "npu/i"); // number of in-time PU events (MC)
outTree->Branch("id_1", &id_1, "id_1/i"); // PDF info -- parton ID for parton 1
outTree->Branch("id_2", &id_2, "id_2/i"); // PDF info -- parton ID for parton 2
outTree->Branch("x_1", &x_1, "x_1/d"); // PDF info -- x for parton 1
outTree->Branch("x_2", &x_2, "x_2/d"); // PDF info -- x for parton 2
outTree->Branch("xPDF_1", &xPDF_1, "xPDF_1/d"); // PDF info -- x*F for parton 1
outTree->Branch("xPDF_2", &xPDF_2, "xPDF_2/d"); // PDF info -- x*F for parton 2
outTree->Branch("scalePDF", &scalePDF, "scalePDF/d"); // PDF info -- energy scale of parton interaction
outTree->Branch("weightPDF", &weightPDF, "weightPDF/d"); // PDF info -- PDF weight
outTree->Branch("genV", "TLorentzVector", &genV); // GEN boson 4-vector (signal MC)
outTree->Branch("genLep", "TLorentzVector", &genLep); // GEN lepton 4-vector (signal MC)
outTree->Branch("genVPt", &genVPt, "genVPt/F"); // GEN boson pT (signal MC)
outTree->Branch("genVPhi", &genVPhi, "genVPhi/F"); // GEN boson phi (signal MC)
outTree->Branch("genVy", &genVy, "genVy/F"); // GEN boson rapidity (signal MC)
outTree->Branch("genVMass", &genVMass, "genVMass/F"); // GEN boson mass (signal MC)
outTree->Branch("genLepPt", &genLepPt, "genLepPt/F"); // GEN lepton pT (signal MC)
outTree->Branch("genLepPhi", &genLepPhi, "genLepPhi/F"); // GEN lepton phi (signal MC)
outTree->Branch("scale1fb", &scale1fb, "scale1fb/F"); // event weight per 1/fb (MC)
outTree->Branch("puWeight", &puWeight, "puWeight/F"); // scale factor for pileup reweighting (MC)
outTree->Branch("met", &met, "met/F"); // MET
outTree->Branch("metPhi", &metPhi, "metPhi/F"); // phi(MET)
outTree->Branch("sumEt", &sumEt, "sumEt/F"); // Sum ET
outTree->Branch("mt", &mt, "mt/F"); // transverse mass
outTree->Branch("u1", &u1, "u1/F"); // parallel component of recoil
outTree->Branch("u2", &u2, "u2/F"); // perpendicular component of recoil
outTree->Branch("tkMet", &tkMet, "tkMet/F"); // MET (track MET)
outTree->Branch("tkMetPhi", &tkMetPhi, "tkMetPhi/F"); // phi(MET) (track MET)
outTree->Branch("tkSumEt", &tkSumEt, "tkSumEt/F"); // Sum ET (track MET)
outTree->Branch("tkMt", &tkMt, "tkMt/F"); // transverse mass (track MET)
outTree->Branch("tkU1", &tkU1, "tkU1/F"); // parallel component of recoil (track MET)
outTree->Branch("tkU2", &tkU2, "tkU2/F"); // perpendicular component of recoil (track MET)
outTree->Branch("mvaMet", &mvaMet, "mvaMet/F"); // MVA MET
outTree->Branch("mvaMetPhi", &mvaMetPhi, "mvaMetPhi/F"); // phi(MVA MET)
outTree->Branch("mvaSumEt", &mvaSumEt, "mvaSumEt/F"); // Sum ET (MVA MET)
outTree->Branch("mvaMt", &mvaMt, "mvaMt/F"); // transverse mass (MVA MET)
outTree->Branch("mvaU1", &mvaU1, "mvaU1/F"); // parallel component of recoil (mva MET)
outTree->Branch("mvaU2", &mvaU2, "mvaU2/F"); // perpendicular component of recoil (mva MET)
outTree->Branch("q", &q, "q/I"); // lepton charge
outTree->Branch("lep", "TLorentzVector", &lep); // lepton 4-vector
///// muon specific /////
outTree->Branch("trkIso", &trkIso, "trkIso/F"); // track isolation of lepton
outTree->Branch("emIso", &emIso, "emIso/F"); // ECAL isolation of lepton
outTree->Branch("hadIso", &hadIso, "hadIso/F"); // HCAL isolation of lepton
outTree->Branch("pfChIso", &pfChIso, "pfChIso/F"); // PF charged hadron isolation of lepton
outTree->Branch("pfGamIso", &pfGamIso, "pfGamIso/F"); // PF photon isolation of lepton
outTree->Branch("pfNeuIso", &pfNeuIso, "pfNeuIso/F"); // PF neutral hadron isolation of lepton
outTree->Branch("pfCombIso", &pfCombIso, "pfCombIso/F"); // PF combined isolation of lepton
outTree->Branch("d0", &d0, "d0/F"); // transverse impact parameter of lepton
outTree->Branch("dz", &dz, "dz/F"); // longitudinal impact parameter of lepton
outTree->Branch("muNchi2", &muNchi2, "muNchi2/F"); // muon fit normalized chi^2 of lepton
outTree->Branch("nPixHits", &nPixHits, "nPixHits/i"); // number of pixel hits of muon
outTree->Branch("nTkLayers", &nTkLayers, "nTkLayers/i"); // number of tracker layers of muon
outTree->Branch("nMatch", &nMatch, "nMatch/i"); // number of matched segments of muon
outTree->Branch("nValidHits", &nValidHits, "nValidHits/i"); // number of valid muon hits of muon
outTree->Branch("typeBits", &typeBits, "typeBits/i"); // number of valid muon hits of muon
//
// loop through files
//
const UInt_t nfiles = samp->fnamev.size();
for(UInt_t ifile=0; ifile<nfiles; ifile++) {
// Read input file and get the TTrees
cout << "Processing " << samp->fnamev[ifile] << " [xsec = " << samp->xsecv[ifile] << " pb] ... "; cout.flush();
infile = TFile::Open(samp->fnamev[ifile]);
assert(infile);
Bool_t hasJSON = kFALSE;
baconhep::RunLumiRangeMap rlrm;
if(samp->jsonv[ifile].CompareTo("NONE")!=0) {
hasJSON = kTRUE;
rlrm.addJSONFile(samp->jsonv[ifile].Data());
}
eventTree = (TTree*)infile->Get("Events");
assert(eventTree);
eventTree->SetBranchAddress("Info", &info); TBranch *infoBr = eventTree->GetBranch("Info");
eventTree->SetBranchAddress("Muon", &muonArr); TBranch *muonBr = eventTree->GetBranch("Muon");
eventTree->SetBranchAddress("PV", &vertexArr); TBranch *vertexBr = eventTree->GetBranch("PV");
Bool_t hasGen = eventTree->GetBranchStatus("GenEvtInfo");
TBranch *genBr=0, *genPartBr=0;
if(hasGen) {
eventTree->SetBranchAddress("GenEvtInfo", &gen); genBr = eventTree->GetBranch("GenEvtInfo");
eventTree->SetBranchAddress("GenParticle",&genPartArr); genPartBr = eventTree->GetBranch("GenParticle");
}
// Compute MC event weight per 1/fb
const Double_t xsec = samp->xsecv[ifile];
Double_t totalWeight=0;
if (hasGen) {
TH1D *hall = new TH1D("hall", "", 1,0,1);
eventTree->Draw("0.5>>hall", "GenEvtInfo->weight");
totalWeight=hall->Integral();
delete hall;
hall=0;
}
//
// loop over events
//
Double_t nsel=0, nselvar=0;
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
if(ientry%1000000==0) cout << "Processing event " << ientry << ". " << (double)ientry/(double)eventTree->GetEntries()*100 << " percent done with this file." << endl;
Double_t weight=1;
if(xsec>0 && totalWeight>0) weight = xsec/totalWeight;
if(hasGen) {
genPartArr->Clear();
genBr->GetEntry(ientry);
genPartBr->GetEntry(ientry);
weight*=gen->weight;
}
// veto w -> xv decays for signal and w -> mv for bacground samples (needed for inclusive WToLNu sample)
if (isWrongFlavor && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))==LEPTON_ID) continue;
else if (isSignal && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))!=LEPTON_ID) continue;
// check for certified lumi (if applicable)
baconhep::RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
if(hasJSON && !rlrm.hasRunLumi(rl)) continue;
// trigger requirement
if (!isMuonTrigger(triggerMenu, info->triggerBits)) continue;
// good vertex requirement
if(!(info->hasGoodPV)) continue;
//
// SELECTION PROCEDURE:
// (1) Look for 1 good muon matched to trigger
// (2) Reject event if another muon is present passing looser cuts
//
muonArr->Clear();
muonBr->GetEntry(ientry);
Int_t nLooseLep=0;
const baconhep::TMuon *goodMuon=0;
Bool_t passSel=kFALSE;
for(Int_t i=0; i<muonArr->GetEntriesFast(); i++) {
const baconhep::TMuon *mu = (baconhep::TMuon*)((*muonArr)[i]);
if(fabs(mu->eta) > VETO_PT) continue; // loose lepton |eta| cut
if(mu->pt < VETO_ETA) continue; // loose lepton pT cut
// if(passMuonLooseID(mu)) nLooseLep++; // loose lepton selection
if(nLooseLep>1) { // extra lepton veto
passSel=kFALSE;
break;
}
if(fabs(mu->eta) > ETA_CUT) continue; // lepton |eta| cut
if(mu->pt < PT_CUT) continue; // lepton pT cut
if(!passAntiMuonID(mu)) continue; // lepton anti-selection
if(!isMuonTriggerObj(triggerMenu, mu->hltMatchBits, kFALSE)) continue;
passSel=kTRUE;
goodMuon = mu;
}
if(passSel) {
/******** We have a W candidate! HURRAY! ********/
nsel+=weight;
nselvar+=weight*weight;
TLorentzVector vLep;
vLep.SetPtEtaPhiM(goodMuon->pt, goodMuon->eta, goodMuon->phi, MUON_MASS);
//
// Fill tree
//
runNum = info->runNum;
lumiSec = info->lumiSec;
evtNum = info->evtNum;
vertexArr->Clear();
vertexBr->GetEntry(ientry);
npv = vertexArr->GetEntries();
npu = info->nPUmean;
genV = new TLorentzVector(0,0,0,0);
genLep = new TLorentzVector(0,0,0,0);
genVPt = -999;
genVPhi = -999;
genVy = -999;
genVMass = -999;
u1 = -999;
u2 = -999;
tkU1 = -999;
tkU2 = -999;
mvaU1 = -999;
mvaU2 = -999;
id_1 = -999;
id_2 = -999;
x_1 = -999;
x_2 = -999;
xPDF_1 = -999;
xPDF_2 = -999;
scalePDF = -999;
weightPDF = -999;
if(isSignal && hasGen) {
TLorentzVector *gvec=new TLorentzVector(0,0,0,0);
TLorentzVector *glep1=new TLorentzVector(0,0,0,0);
TLorentzVector *glep2=new TLorentzVector(0,0,0,0);
toolbox::fillGen(genPartArr, BOSON_ID, gvec, glep1, glep2,1);
if (gvec && glep1) {
genV = new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(gvec->Pt(),gvec->Eta(),gvec->Phi(),gvec->M());
genLep = new TLorentzVector(0,0,0,0);
genLep->SetPtEtaPhiM(glep1->Pt(),glep1->Eta(),glep1->Phi(),glep1->M());
genVPt = gvec->Pt();
genVPhi = gvec->Phi();
genVy = gvec->Rapidity();
genVMass = gvec->M();
genLepPt = glep1->Pt();
genLepPhi = glep1->Phi();
TVector2 vWPt((genVPt)*cos(genVPhi),(genVPt)*sin(genVPhi));
TVector2 vLepPt(vLep.Px(),vLep.Py());
TVector2 vMet((info->pfMETC)*cos(info->pfMETCphi), (info->pfMETC)*sin(info->pfMETCphi));
TVector2 vU = -1.0*(vMet+vLepPt);
u1 = ((vWPt.Px())*(vU.Px()) + (vWPt.Py())*(vU.Py()))/(genVPt); // u1 = (pT . u)/|pT|
u2 = ((vWPt.Px())*(vU.Py()) - (vWPt.Py())*(vU.Px()))/(genVPt); // u2 = (pT x u)/|pT|
TVector2 vTkMet((info->trkMET)*cos(info->trkMETphi), (info->trkMET)*sin(info->trkMETphi));
TVector2 vTkU = -1.0*(vTkMet+vLepPt);
tkU1 = ((vWPt.Px())*(vTkU.Px()) + (vWPt.Py())*(vTkU.Py()))/(genVPt); // u1 = (pT . u)/|pT|
tkU2 = ((vWPt.Px())*(vTkU.Py()) - (vWPt.Py())*(vTkU.Px()))/(genVPt); // u2 = (pT x u)/|pT|
TVector2 vMvaMet((info->mvaMET)*cos(info->mvaMETphi), (info->mvaMET)*sin(info->mvaMETphi));
TVector2 vMvaU = -1.0*(vMvaMet+vLepPt);
mvaU1 = ((vWPt.Px())*(vMvaU.Px()) + (vWPt.Py())*(vMvaU.Py()))/(genVPt); // u1 = (pT . u)/|pT|
mvaU2 = ((vWPt.Px())*(vMvaU.Py()) - (vWPt.Py())*(vMvaU.Px()))/(genVPt); // u2 = (pT x u)/|pT|
}
id_1 = gen->id_1;
id_2 = gen->id_2;
x_1 = gen->x_1;
x_2 = gen->x_2;
xPDF_1 = gen->xPDF_1;
xPDF_2 = gen->xPDF_2;
scalePDF = gen->scalePDF;
weightPDF = gen->weight;
delete gvec;
delete glep1;
delete glep2;
gvec=0; glep1=0; glep2=0;
}
scale1fb = weight;
puWeight = h_rw->GetBinContent(info->nPUmean+1);
met = info->pfMETC;
metPhi = info->pfMETCphi;
sumEt = 0;
mt = sqrt( 2.0 * (vLep.Pt()) * (info->pfMETC) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->pfMETCphi))) );
tkMet = info->trkMET;
tkMetPhi = info->trkMETphi;
tkSumEt = 0;
tkMt = sqrt( 2.0 * (vLep.Pt()) * (info->trkMET) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->trkMETphi))) );
mvaMet = info->mvaMET;
mvaMetPhi = info->mvaMETphi;
mvaSumEt = 0;
mvaMt = sqrt( 2.0 * (vLep.Pt()) * (info->mvaMET) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->mvaMETphi))) );
q = goodMuon->q;
lep = &vLep;
///// muon specific /////
trkIso = goodMuon->trkIso;
emIso = goodMuon->ecalIso;
hadIso = goodMuon->hcalIso;
pfChIso = goodMuon->chHadIso;
pfGamIso = goodMuon->gammaIso;
pfNeuIso = goodMuon->neuHadIso;
pfCombIso = goodMuon->chHadIso + TMath::Max(goodMuon->neuHadIso + goodMuon->gammaIso -
0.5*(goodMuon->puIso),Double_t(0));
d0 = goodMuon->d0;
dz = goodMuon->dz;
muNchi2 = goodMuon->muNchi2;
nPixHits = goodMuon->nPixHits;
nTkLayers = goodMuon->nTkLayers;
nMatch = goodMuon->nMatchStn;
nValidHits = goodMuon->nValidHits;
typeBits = goodMuon->typeBits;
outTree->Fill();
delete genV;
delete genLep;
genV=0, genLep=0, lep=0;
}
}
delete infile;
infile=0, eventTree=0;
cout << nsel << " +/- " << sqrt(nselvar);
if(isam!=0) cout << " per 1/fb";
cout << endl;
}
outFile->Write();
outFile->Close();
}
delete h_rw;
delete f_rw;
delete info;
delete gen;
delete genPartArr;
delete muonArr;
delete vertexArr;
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << " W -> mu nu" << endl;
cout << " pT > " << PT_CUT << endl;
cout << " |eta| < " << ETA_CUT << endl;
cout << endl;
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
gBenchmark->Show("selectAntiWm");
}
void selectWe(const TString conf="we.conf", // input file
const TString outputDir=".", // output directory
const Bool_t doScaleCorr=0 // apply energy scale corrections?
) {
gBenchmark->Start("selectWe");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t PT_CUT = 25;
const Double_t ETA_CUT = 2.5;
const Double_t ELE_MASS = 0.000511;
const Double_t VETO_PT = 10;
const Double_t VETO_ETA = 2.5;
const Double_t ECAL_GAP_LOW = 1.4442;
const Double_t ECAL_GAP_HIGH = 1.566;
const Double_t escaleNbins = 2;
const Double_t escaleEta[] = { 1.4442, 2.5 };
const Double_t escaleCorr[] = { 0.992, 1.009 };
const Int_t BOSON_ID = 24;
const Int_t LEPTON_ID = 11;
// load trigger menu
const baconhep::TTrigger triggerMenu("../../BaconAna/DataFormats/data/HLT_50nsGRun");
// load pileup reweighting file
TFile *f_rw = TFile::Open("../Tools/pileup_rw_Golden.root", "read");
TH1D *h_rw = (TH1D*) f_rw->Get("h_rw_golden");
TH1D *h_rw_up = (TH1D*) f_rw->Get("h_rw_up_golden");
TH1D *h_rw_down = (TH1D*) f_rw->Get("h_rw_down_golden");
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
vector<TString> snamev; // sample name (for output files)
vector<CSample*> samplev; // data/MC samples
//
// parse .conf file
//
confParse(conf, snamev, samplev);
const Bool_t hasData = (samplev[0]->fnamev.size()>0);
// Create output directory
gSystem->mkdir(outputDir,kTRUE);
const TString ntupDir = outputDir + TString("/ntuples");
gSystem->mkdir(ntupDir,kTRUE);
//
// Declare output ntuple variables
//
UInt_t runNum, lumiSec, evtNum;
UInt_t npv, npu;
UInt_t id_1, id_2;
Double_t x_1, x_2, xPDF_1, xPDF_2;
Double_t scalePDF, weightPDF;
TLorentzVector *genV=0, *genLep=0;
Float_t genVPt, genVPhi, genVy, genVMass;
Float_t genLepPt, genLepPhi;
Float_t scale1fb, puWeight, puWeightUp, puWeightDown;
Float_t met, metPhi, sumEt, mt, u1, u2;
Float_t tkMet, tkMetPhi, tkSumEt, tkMt, tkU1, tkU2;
Float_t mvaMet, mvaMetPhi, mvaSumEt, mvaMt, mvaU1, mvaU2;
Float_t puppiMet, puppiMetPhi, puppiSumEt, puppiMt, puppiU1, puppiU2;
Int_t q;
TLorentzVector *lep=0;
Int_t lepID;
///// electron specific /////
Float_t trkIso, emIso, hadIso;
Float_t pfChIso, pfGamIso, pfNeuIso, pfCombIso;
Float_t sigieie, hovere, eoverp, fbrem, ecalE;
Float_t dphi, deta;
Float_t d0, dz;
UInt_t isConv, nexphits, typeBits;
TLorentzVector *sc=0;
// Data structures to store info from TTrees
baconhep::TEventInfo *info = new baconhep::TEventInfo();
baconhep::TGenEventInfo *gen = new baconhep::TGenEventInfo();
TClonesArray *genPartArr = new TClonesArray("baconhep::TGenParticle");
TClonesArray *electronArr = new TClonesArray("baconhep::TElectron");
TClonesArray *scArr = new TClonesArray("baconhep::TPhoton");
TClonesArray *vertexArr = new TClonesArray("baconhep::TVertex");
TFile *infile=0;
TTree *eventTree=0;
//
// loop over samples
//
for(UInt_t isam=0; isam<samplev.size(); isam++) {
// Assume data sample is first sample in .conf file
// If sample is empty (i.e. contains no ntuple files), skip to next sample
Bool_t isData=kFALSE;
if(isam==0 && !hasData) continue;
else if (isam==0) isData=kTRUE;
// Assume signal sample is given name "we" -- flag to store GEN W kinematics
Bool_t isSignal = (snamev[isam].CompareTo("we",TString::kIgnoreCase)==0);
// flag to reject W->enu events when selecting at wrong-flavor background events
Bool_t isWrongFlavor = (snamev[isam].CompareTo("wx",TString::kIgnoreCase)==0);
CSample* samp = samplev[isam];
//
// Set up output ntuple
//
TString outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.root");
if(isam!=0 && !doScaleCorr) outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.raw.root");
TFile *outFile = new TFile(outfilename,"RECREATE");
TTree *outTree = new TTree("Events","Events");
outTree->Branch("runNum", &runNum, "runNum/i"); // event run number
outTree->Branch("lumiSec", &lumiSec, "lumiSec/i"); // event lumi section
outTree->Branch("evtNum", &evtNum, "evtNum/i"); // event number
outTree->Branch("npv", &npv, "npv/i"); // number of primary vertices
outTree->Branch("npu", &npu, "npu/i"); // number of in-time PU events (MC)
outTree->Branch("id_1", &id_1, "id_1/i"); // PDF info -- parton ID for parton 1
outTree->Branch("id_2", &id_2, "id_2/i"); // PDF info -- parton ID for parton 2
outTree->Branch("x_1", &x_1, "x_1/d"); // PDF info -- x for parton 1
outTree->Branch("x_2", &x_2, "x_2/d"); // PDF info -- x for parton 2
outTree->Branch("xPDF_1", &xPDF_1, "xPDF_1/d"); // PDF info -- x*F for parton 1
outTree->Branch("xPDF_2", &xPDF_2, "xPDF_2/d"); // PDF info -- x*F for parton 2
outTree->Branch("scalePDF", &scalePDF, "scalePDF/d"); // PDF info -- energy scale of parton interaction
outTree->Branch("weightPDF", &weightPDF, "weightPDF/d"); // PDF info -- PDF weight
outTree->Branch("genV", "TLorentzVector", &genV); // GEN boson 4-vector (signal MC)
outTree->Branch("genLep", "TLorentzVector", &genLep); // GEN lepton 4-vector (signal MC)
outTree->Branch("genVPt", &genVPt, "genVPt/F"); // GEN boson pT (signal MC)
outTree->Branch("genVPhi", &genVPhi, "genVPhi/F"); // GEN boson phi (signal MC)
outTree->Branch("genVy", &genVy, "genVy/F"); // GEN boson rapidity (signal MC)
outTree->Branch("genVMass", &genVMass, "genVMass/F"); // GEN boson mass (signal MC)
outTree->Branch("genLepPt", &genLepPt, "genLepPt/F"); // GEN lepton pT (signal MC)
outTree->Branch("genLepPhi", &genLepPhi, "genLepPhi/F"); // GEN lepton phi (signal MC)
outTree->Branch("scale1fb", &scale1fb, "scale1fb/F"); // event weight per 1/fb (MC)
outTree->Branch("puWeight", &puWeight, "puWeight/F"); // scale factor for pileup reweighting (MC)
outTree->Branch("puWeightUp", &puWeightUp, "puWeightUp/F"); // scale factor for pileup reweighting (MC)
outTree->Branch("puWeightDown", &puWeightDown, "puWeightDown/F"); // scale factor for pileup reweighting (MC)
outTree->Branch("met", &met, "met/F"); // MET
outTree->Branch("metPhi", &metPhi, "metPhi/F"); // phi(MET)
outTree->Branch("sumEt", &sumEt, "sumEt/F"); // Sum ET
outTree->Branch("mt", &mt, "mt/F"); // transverse mass
outTree->Branch("u1", &u1, "u1/F"); // parallel component of recoil
outTree->Branch("u2", &u2, "u2/F"); // perpendicular component of recoil
outTree->Branch("tkMet", &tkMet, "tkMet/F"); // MET (track MET)
outTree->Branch("tkMetPhi", &tkMetPhi, "tkMetPhi/F"); // phi(MET) (track MET)
outTree->Branch("tkSumEt", &tkSumEt, "tkSumEt/F"); // Sum ET (track MET)
outTree->Branch("tkMt", &tkMt, "tkMt/F"); // transverse mass (track MET)
outTree->Branch("tkU1", &tkU1, "tkU1/F"); // parallel component of recoil (track MET)
outTree->Branch("tkU2", &tkU2, "tkU2/F"); // perpendicular component of recoil (track MET)
outTree->Branch("mvaMet", &mvaMet, "mvaMet/F"); // MVA MET
outTree->Branch("mvaMetPhi", &mvaMetPhi, "mvaMetPhi/F"); // phi(MVA MET)
outTree->Branch("mvaSumEt", &mvaSumEt, "mvaSumEt/F"); // Sum ET (mva MET)
outTree->Branch("mvaMt", &mvaMt, "mvaMt/F"); // transverse mass (mva MET)
outTree->Branch("mvaU1", &mvaU1, "mvaU1/F"); // parallel component of recoil (mva MET)
outTree->Branch("mvaU2", &mvaU2, "mvaU2/F"); // perpendicular component of recoil (mva MET)
outTree->Branch("puppiMet", &puppiMet, "puppiMet/F"); // Puppi MET
outTree->Branch("puppiMetPhi", &puppiMetPhi,"puppiMetPhi/F"); // phi(Puppi MET)
outTree->Branch("puppiSumEt", &puppiSumEt, "puppiSumEt/F"); // Sum ET (Puppi MET)
outTree->Branch("puppiU1", &puppiU1, "puppiU1/F"); // parallel component of recoil (Puppi MET)
outTree->Branch("puppiU2", &puppiU2, "puppiU2/F"); // perpendicular component of recoil (Puppi MET)
outTree->Branch("q", &q, "q/I"); // lepton charge
outTree->Branch("lep", "TLorentzVector", &lep); // lepton 4-vector
outTree->Branch("lepID", &lepID, "lepID/I"); // lepton PDG ID
///// electron specific /////
outTree->Branch("trkIso", &trkIso, "trkIso/F"); // track isolation of tag lepton
outTree->Branch("emIso", &emIso, "emIso/F"); // ECAL isolation of tag lepton
outTree->Branch("hadIso", &hadIso, "hadIso/F"); // HCAL isolation of tag lepton
outTree->Branch("pfChIso", &pfChIso, "pfChIso/F"); // PF charged hadron isolation of lepton
outTree->Branch("pfGamIso", &pfGamIso, "pfGamIso/F"); // PF photon isolation of lepton
outTree->Branch("pfNeuIso", &pfNeuIso, "pfNeuIso/F"); // PF neutral hadron isolation of lepton
outTree->Branch("pfCombIso", &pfCombIso, "pfCombIso/F"); // PF combined isolation of electron
outTree->Branch("sigieie", &sigieie, "sigieie/F"); // sigma-ieta-ieta of electron
outTree->Branch("hovere", &hovere, "hovere/F"); // H/E of electron
outTree->Branch("eoverp", &eoverp, "eoverp/F"); // E/p of electron
outTree->Branch("fbrem", &fbrem, "fbrem/F"); // brem fraction of electron
outTree->Branch("dphi", &dphi, "dphi/F"); // GSF track - ECAL dphi of electron
outTree->Branch("deta", &deta, "deta/F"); // GSF track - ECAL deta of electron
outTree->Branch("ecalE", &ecalE, "ecalE/F"); // ECAL energy of electron
outTree->Branch("d0", &d0, "d0/F"); // transverse impact parameter of electron
outTree->Branch("dz", &dz, "dz/F"); // longitudinal impact parameter of electron
outTree->Branch("isConv", &isConv, "isConv/i"); // conversion filter flag of electron
outTree->Branch("nexphits", &nexphits, "nexphits/i"); // number of missing expected inner hits of electron
outTree->Branch("typeBits", &typeBits, "typeBits/i"); // electron type of electron
outTree->Branch("sc", "TLorentzVector", &sc); // supercluster 4-vector
//
// loop through files
//
const UInt_t nfiles = samp->fnamev.size();
for(UInt_t ifile=0; ifile<nfiles; ifile++) {
// Read input file and get the TTrees
cout << "Processing " << samp->fnamev[ifile] << " [xsec = " << samp->xsecv[ifile] << " pb] ... ";
cout.flush();
infile = TFile::Open(samp->fnamev[ifile]);
assert(infile);
Bool_t hasJSON = kFALSE;
baconhep::RunLumiRangeMap rlrm;
if(samp->jsonv[ifile].CompareTo("NONE")!=0) {
hasJSON = kTRUE;
rlrm.addJSONFile(samp->jsonv[ifile].Data());
}
eventTree = (TTree*)infile->Get("Events");
assert(eventTree);
eventTree->SetBranchAddress("Info", &info);
TBranch *infoBr = eventTree->GetBranch("Info");
eventTree->SetBranchAddress("Electron", &electronArr);
TBranch *electronBr = eventTree->GetBranch("Electron");
eventTree->SetBranchAddress("PV", &vertexArr);
TBranch *vertexBr = eventTree->GetBranch("PV");
Bool_t hasGen = eventTree->GetBranchStatus("GenEvtInfo");
TBranch *genBr=0, *genPartBr=0;
if(hasGen) {
eventTree->SetBranchAddress("GenEvtInfo", &gen);
genBr = eventTree->GetBranch("GenEvtInfo");
eventTree->SetBranchAddress("GenParticle",&genPartArr);
genPartBr = eventTree->GetBranch("GenParticle");
}
// Compute MC event weight per 1/fb
const Double_t xsec = samp->xsecv[ifile];
Double_t totalWeight=0;
if (hasGen) {
TH1D *hall = new TH1D("hall", "", 1,0,1);
eventTree->Draw("0.5>>hall", "GenEvtInfo->weight");
totalWeight=hall->Integral();
delete hall;
hall=0;
}
//
// loop over events
//
Double_t nsel=0, nselvar=0;
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
if(ientry%1000000==0) cout << "Processing event " << ientry << ". " << (double)ientry/(double)eventTree->GetEntries()*100 << " percent done with this file." << endl;
Double_t weight=1;
if(xsec>0 && totalWeight>0) weight = xsec/totalWeight;
if(hasGen) {
genPartArr->Clear();
genBr->GetEntry(ientry);
genPartBr->GetEntry(ientry);
weight*=gen->weight;
}
// veto w -> xv decays for signal and w -> ev for bacground samples (needed for inclusive WToLNu sample)
if (isWrongFlavor && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))==LEPTON_ID) continue;
else if (isSignal && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))!=LEPTON_ID) continue;
// check for certified lumi (if applicable)
baconhep::RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
if(hasJSON && !rlrm.hasRunLumi(rl)) continue;
// trigger requirement
if (!isEleTrigger(triggerMenu, info->triggerBits, isData)) continue;
// good vertex requirement
if(!(info->hasGoodPV)) continue;
//
// SELECTION PROCEDURE:
// (1) Look for 1 good electron matched to trigger
// (2) Reject event if another electron is present passing looser cuts
//
electronArr->Clear();
electronBr->GetEntry(ientry);
Int_t nLooseLep=0;
const baconhep::TElectron *goodEle=0;
Bool_t passSel=kFALSE;
for(Int_t i=0; i<electronArr->GetEntriesFast(); i++) {
const baconhep::TElectron *ele = (baconhep::TElectron*)((*electronArr)[i]);
// check ECAL gap
if(fabs(ele->scEta)>=ECAL_GAP_LOW && fabs(ele->scEta)<=ECAL_GAP_HIGH) continue;
// apply scale and resolution corrections to MC
Double_t elescEt_corr = ele->scEt;
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0)
elescEt_corr = gRandom->Gaus(ele->scEt*getEleScaleCorr(ele->scEta,0),getEleResCorr(ele->scEta,0));
if(fabs(ele->scEta) > VETO_ETA) continue; // loose lepton |eta| cut
if(elescEt_corr < VETO_PT) continue; // loose lepton pT cut
if(passEleLooseID(ele,info->rhoIso)) nLooseLep++; // loose lepton selection
if(nLooseLep>1) { // extra lepton veto
passSel=kFALSE;
break;
}
if(fabs(ele->scEta) > ETA_CUT) continue; // lepton |eta| cut
if(elescEt_corr < PT_CUT) continue; // lepton pT cut
if(!passEleID(ele,info->rhoIso)) continue; // lepton selection
if(!isEleTriggerObj(triggerMenu, ele->hltMatchBits, kFALSE, isData)) continue;
passSel=kTRUE;
goodEle = ele;
}
if(passSel) {
//******* We have a W candidate! HURRAY! ********
nsel+=weight;
nselvar+=weight*weight;
// apply scale and resolution corrections to MC
Double_t goodElept_corr = goodEle->pt;
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0)
goodElept_corr = gRandom->Gaus(goodEle->pt*getEleScaleCorr(goodEle->scEta,0),getEleResCorr(goodEle->scEta,0));
TLorentzVector vLep(0,0,0,0);
TLorentzVector vSC(0,0,0,0);
// apply scale and resolution corrections to MC
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0) {
vLep.SetPtEtaPhiM(goodElept_corr, goodEle->eta, goodEle->phi, ELE_MASS);
vSC.SetPtEtaPhiM(gRandom->Gaus(goodEle->scEt*getEleScaleCorr(goodEle->scEta,0),getEleResCorr(goodEle->scEta,0)), goodEle->scEta, goodEle->scPhi, ELE_MASS);
} else {
vLep.SetPtEtaPhiM(goodEle->pt,goodEle->eta,goodEle->phi,ELE_MASS);
vSC.SetPtEtaPhiM(goodEle->scEt,goodEle->scEta,goodEle->scPhi,ELE_MASS);
}
//
// Fill tree
//
runNum = info->runNum;
lumiSec = info->lumiSec;
evtNum = info->evtNum;
vertexArr->Clear();
vertexBr->GetEntry(ientry);
npv = vertexArr->GetEntries();
npu = info->nPUmean;
genV = new TLorentzVector(0,0,0,0);
genLep = new TLorentzVector(0,0,0,0);
genVPt = -999;
genVPhi = -999;
genVy = -999;
genVMass = -999;
genLepPt = -999;
genLepPhi = -999;
u1 = -999;
u2 = -999;
tkU1 = -999;
tkU2 = -999;
mvaU1 = -999;
mvaU2 = -999;
puppiU1 = -999;
puppiU2 = -999;
id_1 = -999;
id_2 = -999;
x_1 = -999;
x_2 = -999;
xPDF_1 = -999;
xPDF_2 = -999;
scalePDF = -999;
weightPDF = -999;
if(isSignal && hasGen) {
TLorentzVector *gvec=new TLorentzVector(0,0,0,0);
TLorentzVector *glep1=new TLorentzVector(0,0,0,0);
TLorentzVector *glep2=new TLorentzVector(0,0,0,0);
toolbox::fillGen(genPartArr, BOSON_ID, gvec, glep1, glep2,1);
if (gvec && glep1) {
genV = new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(gvec->Pt(),gvec->Eta(),gvec->Phi(),gvec->M());
genLep = new TLorentzVector(0,0,0,0);
genLep->SetPtEtaPhiM(glep1->Pt(),glep1->Eta(),glep1->Phi(),glep1->M());
genVPt = gvec->Pt();
genVPhi = gvec->Phi();
genVy = gvec->Rapidity();
genVMass = gvec->M();
genLepPt = glep1->Pt();
genLepPhi = glep1->Phi();
TVector2 vWPt((genVPt)*cos(genVPhi),(genVPt)*sin(genVPhi));
TVector2 vLepPt(vLep.Px(),vLep.Py());
TVector2 vMet((info->pfMETC)*cos(info->pfMETCphi), (info->pfMETC)*sin(info->pfMETCphi));
TVector2 vU = -1.0*(vMet+vLepPt);
u1 = ((vWPt.Px())*(vU.Px()) + (vWPt.Py())*(vU.Py()))/(genVPt); // u1 = (pT . u)/|pT|
u2 = ((vWPt.Px())*(vU.Py()) - (vWPt.Py())*(vU.Px()))/(genVPt); // u2 = (pT x u)/|pT|
TVector2 vTkMet((info->trkMET)*cos(info->trkMETphi), (info->trkMET)*sin(info->trkMETphi));
TVector2 vTkU = -1.0*(vTkMet+vLepPt);
tkU1 = ((vWPt.Px())*(vTkU.Px()) + (vWPt.Py())*(vTkU.Py()))/(genVPt); // u1 = (pT . u)/|pT|
tkU2 = ((vWPt.Px())*(vTkU.Py()) - (vWPt.Py())*(vTkU.Px()))/(genVPt); // u2 = (pT x u)/|pT|
TVector2 vMvaMet((info->mvaMET)*cos(info->mvaMETphi), (info->mvaMET)*sin(info->mvaMETphi));
TVector2 vMvaU = -1.0*(vMvaMet+vLepPt);
mvaU1 = ((vWPt.Px())*(vMvaU.Px()) + (vWPt.Py())*(vMvaU.Py()))/(genVPt); // u1 = (pT . u)/|pT|
mvaU2 = ((vWPt.Px())*(vMvaU.Py()) - (vWPt.Py())*(vMvaU.Px()))/(genVPt); // u2 = (pT x u)/|pT|
TVector2 vPuppiMet((info->puppET)*cos(info->puppETphi), (info->puppET)*sin(info->puppETphi));
TVector2 vPuppiU = -1.0*(vPuppiMet+vLepPt);
puppiU1 = ((vWPt.Px())*(vPuppiU.Px()) + (vWPt.Py())*(vPuppiU.Py()))/(genVPt); // u1 = (pT . u)/|pT|
puppiU2 = ((vWPt.Px())*(vPuppiU.Py()) - (vWPt.Py())*(vPuppiU.Px()))/(genVPt); // u2 = (pT x u)/|pT|
}
id_1 = gen->id_1;
id_2 = gen->id_2;
x_1 = gen->x_1;
x_2 = gen->x_2;
xPDF_1 = gen->xPDF_1;
xPDF_2 = gen->xPDF_2;
scalePDF = gen->scalePDF;
weightPDF = gen->weight;
delete gvec;
delete glep1;
delete glep2;
gvec=0;
glep1=0;
glep2=0;
}
scale1fb = weight;
puWeight = h_rw->GetBinContent(h_rw->FindBin(npu));
puWeightUp = h_rw_up->GetBinContent(h_rw_up->FindBin(npu));
puWeightDown = h_rw_down->GetBinContent(h_rw_down->FindBin(npu));
met = info->pfMETC;
metPhi = info->pfMETCphi;
sumEt = 0;
mt = sqrt( 2.0 * (vLep.Pt()) * (info->pfMETC) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->pfMETCphi))) );
tkMet = info->trkMET;
tkMetPhi = info->trkMETphi;
tkSumEt = 0;
tkMt = sqrt( 2.0 * (vLep.Pt()) * (info->trkMET) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->trkMETphi))) );
mvaMet = info->mvaMET;
mvaMetPhi = info->mvaMETphi;
mvaSumEt = 0;
mvaMt = sqrt( 2.0 * (vLep.Pt()) * (info->mvaMET) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->mvaMETphi))) );
// TVector2 vLepPt(vLep.Px(),vLep.Py());
// TVector2 vPuppi((info->puppET)*cos(info->puppETphi), (info->puppET)*sin(info->puppETphi));
// TVector2 vpp; vpp=vPuppi-vLepPt;
puppiMet = info->puppET;
puppiMetPhi = info->puppETphi;
puppiSumEt = 0;
puppiMt = sqrt( 2.0 * (vLep.Pt()) * (info->puppET) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->puppETphi))) );
q = goodEle->q;
lep = &vLep;
///// electron specific /////
sc = &vSC;
trkIso = goodEle->trkIso;
emIso = goodEle->ecalIso;
hadIso = goodEle->hcalIso;
pfChIso = goodEle->chHadIso;
pfGamIso = goodEle->gammaIso;
pfNeuIso = goodEle->neuHadIso;
pfCombIso = goodEle->chHadIso + TMath::Max(goodEle->neuHadIso + goodEle->gammaIso -
(info->rhoIso)*getEffAreaEl(goodEle->scEta), 0.);
sigieie = goodEle->sieie;
hovere = goodEle->hovere;
eoverp = goodEle->eoverp;
fbrem = goodEle->fbrem;
dphi = goodEle->dPhiIn;
deta = goodEle->dEtaIn;
ecalE = goodEle->ecalEnergy;
d0 = goodEle->d0;
dz = goodEle->dz;
isConv = goodEle->isConv;
nexphits = goodEle->nMissingHits;
typeBits = goodEle->typeBits;
outTree->Fill();
delete genV;
delete genLep;
genV=0, genLep=0, lep=0, sc=0;
}
}
delete infile;
infile=0, eventTree=0;
cout << nsel << " +/- " << sqrt(nselvar);
if(isam!=0) cout << " per 1/pb";
cout << endl;
}
outFile->Write();
outFile->Close();
}
delete h_rw;
delete h_rw_up;
delete h_rw_down;
delete f_rw;
delete info;
delete gen;
delete genPartArr;
delete electronArr;
delete vertexArr;
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << " W -> e nu" << endl;
cout << " pT > " << PT_CUT << endl;
cout << " |eta| < " << ETA_CUT << endl;
if(doScaleCorr)
cout << " *** Scale corrections applied ***" << endl;
cout << endl;
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
gBenchmark->Show("selectWe");
}
void selectZee(const TString conf="zee.conf", // input file
const TString outputDir=".", // output directory
const Bool_t doScaleCorr=0 // apply energy scale corrections?
) {
gBenchmark->Start("selectZee");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t MASS_LOW = 40;
const Double_t MASS_HIGH = 200;
const Double_t PT_CUT = 22;
const Double_t ETA_CUT = 2.5;
const Double_t ELE_MASS = 0.000511;
const Double_t ECAL_GAP_LOW = 1.4442;
const Double_t ECAL_GAP_HIGH = 1.566;
const Double_t escaleNbins = 2;
const Double_t escaleEta[] = { 1.4442, 2.5 };
const Double_t escaleCorr[] = { 0.992, 1.009 };
const Int_t BOSON_ID = 23;
const Int_t LEPTON_ID = 11;
// load trigger menu
const baconhep::TTrigger triggerMenu("../../BaconAna/DataFormats/data/HLT_50nsGRun");
// load pileup reweighting file
TFile *f_rw = TFile::Open("../Tools/pileup_rw_76X.root", "read");
// for systematics we need 3
TH1D *h_rw = (TH1D*) f_rw->Get("h_rw_golden");
TH1D *h_rw_up = (TH1D*) f_rw->Get("h_rw_up_golden");
TH1D *h_rw_down = (TH1D*) f_rw->Get("h_rw_down_golden");
if (h_rw==NULL) cout<<"WARNIG h_rw == NULL"<<endl;
if (h_rw_up==NULL) cout<<"WARNIG h_rw == NULL"<<endl;
if (h_rw_down==NULL) cout<<"WARNIG h_rw == NULL"<<endl;
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
enum { eEleEle2HLT=1, eEleEle1HLT1L1, eEleEle1HLT, eEleEleNoSel, eEleSC }; // event category enum
vector<TString> snamev; // sample name (for output files)
vector<CSample*> samplev; // data/MC samples
//
// parse .conf file
//
confParse(conf, snamev, samplev);
const Bool_t hasData = (samplev[0]->fnamev.size()>0);
// Create output directory
gSystem->mkdir(outputDir,kTRUE);
const TString ntupDir = outputDir + TString("/ntuples");
gSystem->mkdir(ntupDir,kTRUE);
//
// Declare output ntuple variables
//
UInt_t runNum, lumiSec, evtNum;
UInt_t matchGen;
UInt_t category;
UInt_t npv, npu;
UInt_t id_1, id_2;
Double_t x_1, x_2, xPDF_1, xPDF_2;
Double_t scalePDF, weightPDF;
TLorentzVector *genV=0;
Float_t genVPt, genVPhi, genVy, genVMass;
Float_t genWeight, PUWeight;
Float_t scale1fb,scale1fbUp,scale1fbDown;
Float_t met, metPhi, sumEt, u1, u2;
Float_t tkMet, tkMetPhi, tkSumEt, tkU1, tkU2;
Float_t mvaMet, mvaMetPhi, mvaSumEt, mvaU1, mvaU2;
Float_t puppiMet, puppiMetPhi, puppiSumEt, puppiU1, puppiU2;
Int_t q1, q2;
TLorentzVector *dilep=0, *lep1=0, *lep2=0;
///// electron specific /////
Float_t trkIso1, emIso1, hadIso1, trkIso2, emIso2, hadIso2;
Float_t pfChIso1, pfGamIso1, pfNeuIso1, pfCombIso1, pfChIso2, pfGamIso2, pfNeuIso2, pfCombIso2;
Float_t sigieie1, hovere1, eoverp1, fbrem1, ecalE1, sigieie2, hovere2, eoverp2, fbrem2, ecalE2;
Float_t dphi1, deta1, dphi2, deta2;
Float_t d01, dz1, d02, dz2;
UInt_t isConv1, nexphits1, typeBits1, isConv2, nexphits2, typeBits2;
TLorentzVector *sc1=0, *sc2=0;
// Data structures to store info from TTrees
baconhep::TEventInfo *info = new baconhep::TEventInfo();
baconhep::TGenEventInfo *gen = new baconhep::TGenEventInfo();
TClonesArray *genPartArr = new TClonesArray("baconhep::TGenParticle");
TClonesArray *electronArr = new TClonesArray("baconhep::TElectron");
TClonesArray *scArr = new TClonesArray("baconhep::TPhoton");
TClonesArray *vertexArr = new TClonesArray("baconhep::TVertex");
TFile *infile=0;
TTree *eventTree=0;
//
// loop over samples
//
for(UInt_t isam=0; isam<samplev.size(); isam++) {
// Assume data sample is first sample in .conf file
// If sample is empty (i.e. contains no ntuple files), skip to next sample
Bool_t isData=kFALSE;
if(isam==0 && !hasData) continue;
else if (isam==0) isData=kTRUE;
// Assume signal sample is given name "zee" - flag to store GEN Z kinematics
Bool_t isSignal = (snamev[isam].CompareTo("zee",TString::kIgnoreCase)==0);
// flag to reject Z->ee events when selecting at wrong-flavor background events
Bool_t isWrongFlavor = (snamev[isam].CompareTo("zxx",TString::kIgnoreCase)==0);
CSample* samp = samplev[isam];
//
// Set up output ntuple
//
TString outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.root");
if(isam!=0 && !doScaleCorr) outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.raw.root");
TFile *outFile = new TFile(outfilename,"RECREATE");
TTree *outTree = new TTree("Events","Events");
outTree->Branch("runNum", &runNum, "runNum/i"); // event run number
outTree->Branch("lumiSec", &lumiSec, "lumiSec/i"); // event lumi section
outTree->Branch("evtNum", &evtNum, "evtNum/i"); // event number
outTree->Branch("matchGen", &matchGen, "matchGen/i"); // event has both leptons matched to MC Z->ll
outTree->Branch("category", &category, "category/i"); // dilepton category
outTree->Branch("id_1", &id_1, "id_1/i"); // PDF info -- parton ID for parton 1
outTree->Branch("id_2", &id_2, "id_2/i"); // PDF info -- parton ID for parton 2
outTree->Branch("x_1", &x_1, "x_1/d"); // PDF info -- x for parton 1
outTree->Branch("x_2", &x_2, "x_2/d"); // PDF info -- x for parton 2
outTree->Branch("xPDF_1", &xPDF_1, "xPDF_1/d"); // PDF info -- x*F for parton 1
outTree->Branch("xPDF_2", &xPDF_2, "xPDF_2/d"); // PDF info -- x*F for parton 2
outTree->Branch("scalePDF", &scalePDF, "scalePDF/d"); // PDF info -- energy scale of parton interaction
outTree->Branch("weightPDF", &weightPDF, "weightPDF/d"); // PDF info -- PDF weight
outTree->Branch("npv", &npv, "npv/i"); // number of primary vertices
outTree->Branch("npu", &npu, "npu/i"); // number of in-time PU events (MC)
outTree->Branch("genV", "TLorentzVector", &genV); // GEN boson 4-vector
outTree->Branch("genVPt", &genVPt, "genVPt/F"); // GEN boson pT (signal MC)
outTree->Branch("genVPhi", &genVPhi, "genVPhi/F"); // GEN boson phi (signal MC)
outTree->Branch("genVy", &genVy, "genVy/F"); // GEN boson rapidity (signal MC)
outTree->Branch("genVMass", &genVMass, "genVMass/F"); // GEN boson mass (signal MC)
outTree->Branch("genWeight", &genWeight, "genWeight/F");
outTree->Branch("PUWeight", &PUWeight, "PUWeight/F");
outTree->Branch("scale1fb", &scale1fb, "scale1fb/F"); // event weight per 1/fb (MC)
outTree->Branch("scale1fbUp", &scale1fbUp, "scale1fbUp/F"); // event weight per 1/fb (MC)
outTree->Branch("scale1fbDown", &scale1fbDown, "scale1fbDown/F"); // event weight per 1/fb (MC)
outTree->Branch("met", &met, "met/F"); // MET
outTree->Branch("metPhi", &metPhi, "metPhi/F"); // phi(MET)
outTree->Branch("sumEt", &sumEt, "sumEt/F"); // Sum ET
outTree->Branch("u1", &u1, "u1/F"); // parallel component of recoil
outTree->Branch("u2", &u2, "u2/F"); // perpendicular component of recoil
outTree->Branch("tkMet", &tkMet, "tkMet/F"); // MET (track MET)
outTree->Branch("tkMetPhi", &tkMetPhi, "tkMetPhi/F"); // phi(MET) (track MET)
outTree->Branch("tkSumEt", &tkSumEt, "tkSumEt/F"); // Sum ET (track MET)
outTree->Branch("tkU1", &tkU1, "tkU1/F"); // parallel component of recoil (track MET)
outTree->Branch("tkU2", &tkU2, "tkU2/F"); // perpendicular component of recoil (track MET)
outTree->Branch("mvaMet", &mvaMet, "mvaMet/F"); // MVA MET
outTree->Branch("mvaMetPhi", &mvaMetPhi, "mvaMetPhi/F"); // phi(MVA MET)
outTree->Branch("mvaSumEt", &mvaSumEt, "mvaSumEt/F"); // Sum ET (mva MET)
outTree->Branch("mvaU1", &mvaU1, "mvaU1/F"); // parallel component of recoil (mva MET)
outTree->Branch("mvaU2", &mvaU2, "mvaU2/F"); // perpendicular component of recoil (mva MET)
outTree->Branch("puppiMet", &puppiMet, "puppiMet/F"); // Puppi MET
outTree->Branch("puppiMetPhi", &puppiMetPhi,"puppiMetPhi/F"); // phi(Puppi MET)
outTree->Branch("puppiSumEt", &puppiSumEt, "puppiSumEt/F"); // Sum ET (Puppi MET)
outTree->Branch("puppiU1", &puppiU1, "puppiU1/F"); // parallel component of recoil (Puppi MET)
outTree->Branch("puppiU2", &puppiU2, "puppiU2/F"); // perpendicular component of recoil (Puppi MET)
outTree->Branch("q1", &q1, "q1/I"); // charge of tag lepton
outTree->Branch("q2", &q2, "q2/I"); // charge of probe lepton
outTree->Branch("dilep", "TLorentzVector", &dilep); // di-lepton 4-vector
outTree->Branch("lep1", "TLorentzVector", &lep1); // tag lepton 4-vector
outTree->Branch("lep2", "TLorentzVector", &lep2); // probe lepton 4-vector
///// electron specific /////
outTree->Branch("trkIso1", &trkIso1, "trkIso1/F"); // track isolation of tag lepton
outTree->Branch("trkIso2", &trkIso2, "trkIso2/F"); // track isolation of probe lepton
outTree->Branch("emIso1", &emIso1, "emIso1/F"); // ECAL isolation of tag lepton
outTree->Branch("emIso2", &emIso2, "emIso2/F"); // ECAL isolation of probe lepton
outTree->Branch("hadIso1", &hadIso1, "hadIso1/F"); // HCAL isolation of tag lepton
outTree->Branch("hadIso2", &hadIso2, "hadIso2/F"); // HCAL isolation of probe lepton
outTree->Branch("pfChIso1", &pfChIso1, "pfChIso1/F"); // PF charged hadron isolation of tag lepton
outTree->Branch("pfChIso2", &pfChIso2, "pfChIso2/F"); // PF charged hadron isolation of probe lepton
outTree->Branch("pfGamIso1", &pfGamIso1, "pfGamIso1/F"); // PF photon isolation of tag lepton
outTree->Branch("pfGamIso2", &pfGamIso2, "pfGamIso2/F"); // PF photon isolation of probe lepton
outTree->Branch("pfNeuIso1", &pfNeuIso1, "pfNeuIso1/F"); // PF neutral hadron isolation of tag lepton
outTree->Branch("pfNeuIso2", &pfNeuIso2, "pfNeuIso2/F"); // PF neutral hadron isolation of probe lepton
outTree->Branch("pfCombIso1", &pfCombIso1, "pfCombIso1/F"); // PF combine isolation of tag lepton
outTree->Branch("pfCombIso2", &pfCombIso2, "pfCombIso2/F"); // PF combined isolation of probe lepton
outTree->Branch("sigieie1", &sigieie1, "sigieie1/F"); // sigma-ieta-ieta of tag
outTree->Branch("sigieie2", &sigieie2, "sigieie2/F"); // sigma-ieta-ieta of probe
outTree->Branch("hovere1", &hovere1, "hovere1/F"); // H/E of tag
outTree->Branch("hovere2", &hovere2, "hovere2/F"); // H/E of probe
outTree->Branch("eoverp1", &eoverp1, "eoverp1/F"); // E/p of tag
outTree->Branch("eoverp2", &eoverp2, "eoverp2/F"); // E/p of probe
outTree->Branch("fbrem1", &fbrem1, "fbrem1/F"); // brem fraction of tag
outTree->Branch("fbrem2", &fbrem2, "fbrem2/F"); // brem fraction of probe
outTree->Branch("dphi1", &dphi1, "dphi1/F"); // GSF track - ECAL dphi of tag
outTree->Branch("dphi2", &dphi2, "dphi2/F"); // GSF track - ECAL dphi of probe
outTree->Branch("deta1", &deta1, "deta1/F"); // GSF track - ECAL deta of tag
outTree->Branch("deta2", &deta2, "deta2/F"); // GSF track - ECAL deta of probe
outTree->Branch("ecalE1", &ecalE1, "ecalE1/F"); // ECAL energy of tag
outTree->Branch("ecalE2", &ecalE2, "ecalE2/F"); // ECAL energy of probe
outTree->Branch("d01", &d01, "d01/F"); // transverse impact parameter of tag
outTree->Branch("d02", &d02, "d02/F"); // transverse impact parameter of probe
outTree->Branch("dz1", &dz1, "dz1/F"); // longitudinal impact parameter of tag
outTree->Branch("dz2", &dz2, "dz2/F"); // longitudinal impact parameter of probe
outTree->Branch("isConv1", &isConv1, "isConv1/i"); // conversion filter flag of tag lepton
outTree->Branch("isConv2", &isConv2, "isConv2/i"); // conversion filter flag of probe lepton
outTree->Branch("nexphits1", &nexphits1, "nexphits1/i"); // number of missing expected inner hits of tag lepton
outTree->Branch("nexphits2", &nexphits2, "nexphits2/i"); // number of missing expected inner hits of probe lepton
outTree->Branch("typeBits1", &typeBits1, "typeBits1/i"); // electron type of tag lepton
outTree->Branch("typeBits2", &typeBits2, "typeBits2/i"); // electron type of probe lepton
outTree->Branch("sc1", "TLorentzVector", &sc1); // tag supercluster 4-vector
outTree->Branch("sc2", "TLorentzVector", &sc2); // probe supercluster 4-vector
//
// loop through files
//
const UInt_t nfiles = samp->fnamev.size();
for(UInt_t ifile=0; ifile<nfiles; ifile++) {
// Read input file and get the TTrees
cout << "Processing " << samp->fnamev[ifile] << " [xsec = " << samp->xsecv[ifile] << " pb] ... " << endl; cout.flush();
infile = TFile::Open(samp->fnamev[ifile]);
assert(infile);
Bool_t hasJSON = kFALSE;
baconhep::RunLumiRangeMap rlrm;
if(samp->jsonv[ifile].CompareTo("NONE")!=0) {
hasJSON = kTRUE;
rlrm.addJSONFile(samp->jsonv[ifile].Data());
}
eventTree = (TTree*)infile->Get("Events");
assert(eventTree);
eventTree->SetBranchAddress("Info", &info); TBranch *infoBr = eventTree->GetBranch("Info");
eventTree->SetBranchAddress("Electron", &electronArr); TBranch *electronBr = eventTree->GetBranch("Electron");
eventTree->SetBranchAddress("Photon", &scArr); TBranch *scBr = eventTree->GetBranch("Photon");
eventTree->SetBranchAddress("PV", &vertexArr); TBranch *vertexBr = eventTree->GetBranch("PV");
Bool_t hasGen = eventTree->GetBranchStatus("GenEvtInfo");
TBranch *genBr=0, *genPartBr=0;
if(hasGen) {
eventTree->SetBranchAddress("GenEvtInfo", &gen); genBr = eventTree->GetBranch("GenEvtInfo");
eventTree->SetBranchAddress("GenParticle",&genPartArr); genPartBr = eventTree->GetBranch("GenParticle");
}
// Compute MC event weight per 1/fb
const Double_t xsec = samp->xsecv[ifile];
Double_t totalWeight=0;
Double_t totalWeightUp=0;
Double_t totalWeightDown=0;
Double_t puWeight=0;
Double_t puWeightUp=0;
Double_t puWeightDown=0;
if (hasGen) {
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
genBr->GetEntry(ientry);
puWeight = h_rw->GetBinContent(h_rw->FindBin(info->nPUmean));
puWeightUp = h_rw_up->GetBinContent(h_rw_up->FindBin(info->nPUmean));
puWeightDown = h_rw_down->GetBinContent(h_rw_down->FindBin(info->nPUmean));
totalWeight+=gen->weight*puWeight;
totalWeightUp+=gen->weight*puWeightUp;
totalWeightDown+=gen->weight*puWeightDown;
}
}
else if (not isData){
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
puWeight = h_rw->GetBinContent(h_rw->FindBin(info->nPUmean));
puWeightUp = h_rw_up->GetBinContent(h_rw_up->FindBin(info->nPUmean));
puWeightDown = h_rw_down->GetBinContent(h_rw_down->FindBin(info->nPUmean));
totalWeight+= 1.0*puWeight;
totalWeightUp+= 1.0*puWeightUp;
totalWeightDown+= 1.0*puWeightDown;
}
}
//
// loop over events
//
Double_t nsel=0, nselvar=0;
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
if(ientry%1000000==0) cout << "Processing event " << ientry << ". " << (double)ientry/(double)eventTree->GetEntries()*100 << " percent done with this file." << endl;
Double_t weight=1;
Double_t weightUp=1;
Double_t weightDown=1;
if(xsec>0 && totalWeight>0) weight = xsec/totalWeight;
if(xsec>0 && totalWeightUp>0) weightUp = xsec/totalWeightUp;
if(xsec>0 && totalWeightDown>0) weightDown = xsec/totalWeightDown;
if(hasGen) {
genPartArr->Clear();
genBr->GetEntry(ientry);
genPartBr->GetEntry(ientry);
puWeight = h_rw->GetBinContent(h_rw->FindBin(info->nPUmean));
puWeightUp = h_rw_up->GetBinContent(h_rw_up->FindBin(info->nPUmean));
puWeightDown = h_rw_down->GetBinContent(h_rw_down->FindBin(info->nPUmean));
weight*=gen->weight*puWeight;
weightUp*=gen->weight*puWeightUp;
weightDown*=gen->weight*puWeightDown;
}
// veto z -> xx decays for signal and z -> ee for bacground samples (needed for inclusive DYToLL sample)
if (isWrongFlavor && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))==LEPTON_ID) continue;
else if (isSignal && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))!=LEPTON_ID) continue;
// check for certified lumi (if applicable)
baconhep::RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
if(hasJSON && !rlrm.hasRunLumi(rl)) continue;
// trigger requirement
if (!isEleTrigger(triggerMenu, info->triggerBits, isData)) continue;
// good vertex requirement
if(!(info->hasGoodPV)) continue;
electronArr->Clear();
electronBr->GetEntry(ientry);
scArr->Clear();
scBr->GetEntry(ientry);
TLorentzVector vTag(0,0,0,0);
TLorentzVector vTagSC(0,0,0,0);
Double_t tagPt=0;
Double_t Pt1=0;
Double_t Pt2=0;
Int_t itag=-1;
Int_t tagscID=-1;
for(Int_t i1=0; i1<electronArr->GetEntriesFast(); i1++) {
const baconhep::TElectron *tag = (baconhep::TElectron*)((*electronArr)[i1]);
// check ECAL gap
if(fabs(tag->scEta)>=ECAL_GAP_LOW && fabs(tag->scEta)<=ECAL_GAP_HIGH) continue;
// apply scale and resolution corrections to MC
Double_t tagscEt_corr = tag->scEt;
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0)
tagscEt_corr = gRandom->Gaus(tag->scEt*getEleScaleCorr(tag->scEta,0),getEleResCorr(tag->scEta,0));
if(tagscEt_corr < PT_CUT) continue; // lepton pT cut
if(fabs(tag->scEta) > ETA_CUT) continue; // lepton |eta| cut
if(!passEleID(tag,info->rhoIso)) continue; // lepton selection
double El_Pt=0;
if(doScaleCorr) {
El_Pt=gRandom->Gaus(tag->pt*getEleScaleCorr(tag->scEta,0),getEleResCorr(tag->scEta,0));
}
else
{
El_Pt=tag->pt;
}
if(El_Pt>Pt1)
{
Pt2=Pt1;
Pt1=El_Pt;
}
else if(El_Pt>Pt2&&El_Pt<Pt1)
{
Pt2=El_Pt;
}
if(!isEleTriggerObj(triggerMenu, tag->hltMatchBits, kFALSE, isData)) continue;
if(El_Pt<tagPt) continue;
tagPt=El_Pt;
itag=i1;
tagscID=tag->scID;
// apply scale and resolution corrections to MC
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0) {
vTag.SetPtEtaPhiM(El_Pt, tag->eta, tag->phi, ELE_MASS);
vTagSC.SetPtEtaPhiM(tagscEt_corr, tag->scEta, tag->scPhi, ELE_MASS);
} else {
vTag.SetPtEtaPhiM(tag->pt, tag->eta, tag->phi, ELE_MASS);
vTagSC.SetPtEtaPhiM(tag->scEt, tag->scEta, tag->scPhi, ELE_MASS);
}
trkIso1 = tag->trkIso;
emIso1 = tag->ecalIso;
hadIso1 = tag->hcalIso;
pfChIso1 = tag->chHadIso;
pfGamIso1 = tag->gammaIso;
pfNeuIso1 = tag->neuHadIso;
pfCombIso1 = tag->chHadIso + TMath::Max(tag->neuHadIso + tag->gammaIso - (info->rhoIso)*getEffAreaEl(tag->scEta), 0.);
sigieie1 = tag->sieie;
hovere1 = tag->hovere;
eoverp1 = tag->eoverp;
fbrem1 = tag->fbrem;
dphi1 = tag->dPhiIn;
deta1 = tag->dEtaIn;
ecalE1 = tag->ecalEnergy;
d01 = tag->d0;
dz1 = tag->dz;
isConv1 = tag->isConv;
nexphits1 = tag->nMissingHits;
typeBits1 = tag->typeBits;
q1 = tag->q;
}
if(tagPt<Pt2) continue;
TLorentzVector vProbe(0,0,0,0); TLorentzVector vProbeSC(0,0,0,0);
Double_t probePt=0;
Int_t iprobe=-1;
Int_t passID=false;
UInt_t icat=0;
const baconhep::TElectron *eleProbe=0;
for(Int_t j=0; j<scArr->GetEntriesFast(); j++) {
const baconhep::TPhoton *scProbe = (baconhep::TPhoton*)((*scArr)[j]);
if(scProbe->scID == tagscID) continue;
// check ECAL gap
if(fabs(scProbe->eta)>=ECAL_GAP_LOW && fabs(scProbe->eta)<=ECAL_GAP_HIGH) continue;
// apply scale and resolution corrections to MC
Double_t scProbept_corr = scProbe->pt;
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0)
scProbept_corr = gRandom->Gaus(scProbe->pt*getEleScaleCorr(scProbe->eta,0),getEleResCorr(scProbe->eta,0));
if(scProbept_corr < PT_CUT) continue; // Supercluster ET cut ("pt" = corrected by PV position)
if(fabs(scProbe->eta) > ETA_CUT) continue; // Supercluster |eta| cuts
for(Int_t i2=0; i2<electronArr->GetEntriesFast(); i2++) {
if(itag==i2) continue;
const baconhep::TElectron *ele = (baconhep::TElectron*)((*electronArr)[i2]);
if(!(ele->typeBits & baconhep::EEleType::kEcalDriven)) continue;
if(scProbe->scID==ele->scID) {
eleProbe = ele;
iprobe = i2;
break;
}
}
double El_Pt=0;
if(doScaleCorr&&eleProbe) {
El_Pt=gRandom->Gaus(eleProbe->pt*getEleScaleCorr(scProbe->eta,0),getEleResCorr(scProbe->eta,0));
}
else if(!doScaleCorr&&eleProbe)
{
El_Pt=eleProbe->pt;
}
else
{
El_Pt=scProbept_corr;
}
if(passID&&eleProbe&&passEleID(eleProbe,info->rhoIso)&&El_Pt<probePt) continue;
if(passID&&eleProbe&&!passEleID(eleProbe,info->rhoIso)) continue;
if(passID&&!eleProbe) continue;
if(!passID&&eleProbe&&!passEleID(eleProbe,info->rhoIso)&&El_Pt<probePt) continue;
if(!passID&&!eleProbe&&El_Pt<probePt) continue;
if(!passID&&eleProbe&&passEleID(eleProbe,info->rhoIso)) passID=true;
probePt=El_Pt;
// apply scale and resolution corrections to MC
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0) {
vProbe.SetPtEtaPhiM((eleProbe) ? gRandom->Gaus(eleProbe->pt*getEleScaleCorr(scProbe->eta,0),getEleResCorr(scProbe->eta,0)) : scProbept_corr,
(eleProbe) ? eleProbe->eta : scProbe->eta,
(eleProbe) ? eleProbe->phi : scProbe->phi,
ELE_MASS);
vProbeSC.SetPtEtaPhiM((eleProbe) ? gRandom->Gaus(eleProbe->scEt*getEleScaleCorr(scProbe->eta,0),getEleResCorr(scProbe->eta,0)) : gRandom->Gaus(scProbe->pt*getEleScaleCorr(scProbe->eta,0),getEleResCorr(scProbe->eta,0)),
scProbe->eta, scProbe->phi, ELE_MASS);
} else {
vProbe.SetPtEtaPhiM((eleProbe) ? eleProbe->pt : scProbe->pt,
(eleProbe) ? eleProbe->eta : scProbe->eta,
(eleProbe) ? eleProbe->phi : scProbe->phi,
ELE_MASS);
vProbeSC.SetPtEtaPhiM((eleProbe) ? eleProbe->scEt : scProbe->pt,
scProbe->eta, scProbe->phi, ELE_MASS);
}
trkIso2 = (eleProbe) ? eleProbe->trkIso : -1;
emIso2 = (eleProbe) ? eleProbe->ecalIso : -1;
hadIso2 = (eleProbe) ? eleProbe->hcalIso : -1;
pfChIso2 = (eleProbe) ? eleProbe->chHadIso : -1;
pfGamIso2 = (eleProbe) ? eleProbe->gammaIso : -1;
pfNeuIso2 = (eleProbe) ? eleProbe->neuHadIso : -1;
pfCombIso2 = (eleProbe) ?
eleProbe->chHadIso + TMath::Max(eleProbe->neuHadIso + eleProbe->gammaIso -
(info->rhoIso)*getEffAreaEl(eleProbe->scEta), 0.) : -1;
sigieie2 = (eleProbe) ? eleProbe->sieie : scProbe->sieie;
hovere2 = (eleProbe) ? eleProbe->hovere : scProbe->hovere;
eoverp2 = (eleProbe) ? eleProbe->eoverp : -1;
fbrem2 = (eleProbe) ? eleProbe->fbrem : -1;
dphi2 = (eleProbe) ? eleProbe->dPhiIn : -999;
deta2 = (eleProbe) ? eleProbe->dEtaIn : -999;
ecalE2 = (eleProbe) ? eleProbe->ecalEnergy : -999;
d02 = (eleProbe) ? eleProbe->d0 : -999;
dz2 = (eleProbe) ? eleProbe->dz : -999;
isConv2 = (eleProbe) ? eleProbe->isConv : 0;
nexphits2 = (eleProbe) ? eleProbe->nMissingHits : 0;
typeBits2 = (eleProbe) ? eleProbe->typeBits : 0;
q2 = (eleProbe) ? eleProbe->q : -q1;
// determine event category
if(eleProbe) {
if(passEleID(eleProbe,info->rhoIso)) {
if(isEleTriggerObj(triggerMenu, eleProbe->hltMatchBits, kFALSE, isData)) {
icat=eEleEle2HLT;
}
else if(isEleTriggerObj(triggerMenu, eleProbe->hltMatchBits, kTRUE, isData)) {
icat=eEleEle1HLT1L1;
}
else { icat=eEleEle1HLT; }
}
else { icat=eEleEleNoSel; }
}
else { icat=eEleSC; }
}
if(q1 == q2) continue; // opposite charge requirement
// mass window
TLorentzVector vDilep = vTag + vProbe;
if((vDilep.M()<MASS_LOW) || (vDilep.M()>MASS_HIGH)) continue;
if(icat==0) continue;
//******** We have a Z candidate! HURRAY! ********
nsel+=weight;
nselvar+=weight*weight;
// Perform matching of dileptons to GEN leptons from Z decay
Int_t glepq1=-99;
Int_t glepq2=-99;
TLorentzVector *gvec=new TLorentzVector(0,0,0,0);
TLorentzVector *glep1=new TLorentzVector(0,0,0,0);
TLorentzVector *glep2=new TLorentzVector(0,0,0,0);
TLorentzVector *gph=new TLorentzVector(0,0,0,0);
Bool_t hasGenMatch = kFALSE;
if(isSignal && hasGen) {
toolbox::fillGen(genPartArr, BOSON_ID, gvec, glep1, glep2,&glepq1,&glepq2,1);
Bool_t match1 = ( ((glep1) && toolbox::deltaR(vTag.Eta(), vTag.Phi(), glep1->Eta(), glep1->Phi())<0.3) ||
((glep2) && toolbox::deltaR(vTag.Eta(), vTag.Phi(), glep2->Eta(), glep2->Phi())<0.3) );
Bool_t match2 = ( ((glep1) && toolbox::deltaR(vProbe.Eta(), vProbe.Phi(), glep1->Eta(), glep1->Phi())<0.3) ||
((glep2) && toolbox::deltaR(vProbe.Eta(), vProbe.Phi(), glep2->Eta(), glep2->Phi())<0.3) );
if(match1 && match2) {
hasGenMatch = kTRUE;
if (gvec!=0) {
genV=new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(gvec->Pt(), gvec->Eta(), gvec->Phi(), gvec->M());
genVPt = gvec->Pt();
genVPhi = gvec->Phi();
genVy = gvec->Rapidity();
genVMass = gvec->M();
}
else {
TLorentzVector tvec=*glep1+*glep2;
genV=new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(tvec.Pt(), tvec.Eta(), tvec.Phi(), tvec.M());
genVPt = tvec.Pt();
genVPhi = tvec.Phi();
genVy = tvec.Rapidity();
genVMass = tvec.M();
}
delete gvec;
delete glep1;
delete glep2;
glep1=0; glep2=0; gvec=0;
}
else {
genV = new TLorentzVector(0,0,0,0);
genVPt = -999;
genVPhi = -999;
genVy = -999;
genVMass = -999;
}
}
if (hasGen) {
id_1 = gen->id_1;
id_2 = gen->id_2;
x_1 = gen->x_1;
x_2 = gen->x_2;
xPDF_1 = gen->xPDF_1;
xPDF_2 = gen->xPDF_2;
scalePDF = gen->scalePDF;
weightPDF = gen->weight;
}
else {
id_1 = -999;
id_2 = -999;
x_1 = -999;
x_2 = -999;
xPDF_1 = -999;
xPDF_2 = -999;
scalePDF = -999;
weightPDF = -999;
}
//
// Fill tree
//
runNum = info->runNum;
lumiSec = info->lumiSec;
evtNum = info->evtNum;
if (hasGenMatch) matchGen=1;
else matchGen=0;
category = icat;
vertexArr->Clear();
vertexBr->GetEntry(ientry);
npv = vertexArr->GetEntries();
npu = info->nPUmean;
genWeight= hasGen ? gen->weight: 1.;
PUWeight = puWeight;
scale1fb = weight;
scale1fbUp = weightUp;
scale1fbDown = weightDown;
met = info->pfMETC;
metPhi = info->pfMETCphi;
sumEt = 0;
tkMet = info->trkMET;
tkMetPhi = info->trkMETphi;
tkSumEt = 0;
mvaMet = info->mvaMET;
mvaMetPhi = info->mvaMETphi;
mvaSumEt = 0;
TVector2 vZPt((vDilep.Pt())*cos(vDilep.Phi()),(vDilep.Pt())*sin(vDilep.Phi()));
puppiMet = info->puppET;
puppiMetPhi = info->puppETphi;
puppiSumEt = 0;
lep1 = &vTag;
lep2 = &vProbe;
dilep = &vDilep;
sc1 = &vTagSC;
sc2 = &vProbeSC;
TVector2 vMet((info->pfMETC)*cos(info->pfMETCphi), (info->pfMETC)*sin(info->pfMETCphi));
TVector2 vU = -1.0*(vMet+vZPt);
u1 = ((vDilep.Px())*(vU.Px()) + (vDilep.Py())*(vU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
u2 = ((vDilep.Px())*(vU.Py()) - (vDilep.Py())*(vU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vTkMet((info->trkMET)*cos(info->trkMETphi), (info->trkMET)*sin(info->trkMETphi));
TVector2 vTkU = -1.0*(vTkMet+vZPt);
tkU1 = ((vDilep.Px())*(vTkU.Px()) + (vDilep.Py())*(vTkU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
tkU2 = ((vDilep.Px())*(vTkU.Py()) - (vDilep.Py())*(vTkU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vMvaMet((info->mvaMET)*cos(info->mvaMETphi), (info->mvaMET)*sin(info->mvaMETphi));
TVector2 vMvaU = -1.0*(vMvaMet+vZPt);
mvaU1 = ((vDilep.Px())*(vMvaU.Px()) + (vDilep.Py())*(vMvaU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
mvaU2 = ((vDilep.Px())*(vMvaU.Py()) - (vDilep.Py())*(vMvaU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vPuppiMet((info->puppET)*cos(info->puppETphi), (info->puppET)*sin(info->puppETphi));
TVector2 vPuppiU = -1.0*(vPuppiMet+vZPt);
puppiU1 = ((vDilep.Px())*(vPuppiU.Px()) + (vDilep.Py())*(vPuppiU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
puppiU2 = ((vDilep.Px())*(vPuppiU.Py()) - (vDilep.Py())*(vPuppiU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
outTree->Fill();
delete genV;
genV=0, dilep=0, lep1=0, lep2=0, sc1=0, sc2=0;
}
delete infile;
infile=0, eventTree=0;
cout << nsel << " +/- " << sqrt(nselvar);
if(!isData) cout << " per 1/fb";
cout << endl;
}
outFile->Write();
outFile->Close();
}
delete h_rw;
delete f_rw;
delete info;
delete gen;
delete genPartArr;
delete electronArr;
delete scArr;
delete vertexArr;
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << " Z -> e e" << endl;
cout << " Mass window: [" << MASS_LOW << ", " << MASS_HIGH << "]" << endl;
cout << " pT > " << PT_CUT << endl;
cout << " |eta| < " << ETA_CUT << endl;
cout << endl;
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
gBenchmark->Show("selectZee");
}
void selectZmm(const TString conf="zmm.conf", // input file
const TString outputDir=".", // output directory
const Bool_t doScaleCorr=0, // apply energy scale corrections
const Bool_t doPU=0
) {
gBenchmark->Start("selectZmm");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t MASS_LOW = 40;
const Double_t MASS_HIGH = 200;
const Double_t PT_CUT = 22;
const Double_t ETA_CUT = 2.4;
const Double_t MUON_MASS = 0.105658369;
const Int_t BOSON_ID = 23;
const Int_t LEPTON_ID = 13;
// load trigger menu
const baconhep::TTrigger triggerMenu("../../BaconAna/DataFormats/data/HLT_50nsGRun");
// load pileup reweighting file
TFile *f_rw = TFile::Open("../Tools/puWeights_76x.root", "read");
TH1D *h_rw = (TH1D*) f_rw->Get("puWeights");
TH1D *h_rw_up = (TH1D*) f_rw->Get("puWeightsUp");
TH1D *h_rw_down = (TH1D*) f_rw->Get("puWeightsDown");
if (h_rw==NULL) cout<<"WARNING h_rw == NULL"<<endl;
if (h_rw_up==NULL) cout<<"WARNING h_rw == NULL"<<endl;
if (h_rw_down==NULL) cout<<"WARNING h_rw == NULL"<<endl;
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
enum { eMuMu2HLT=1, eMuMu1HLT1L1, eMuMu1HLT, eMuMuNoSel, eMuSta, eMuTrk }; // event category enum
vector<TString> snamev; // sample name (for output files)
vector<CSample*> samplev; // data/MC samples
//
// parse .conf file
//
confParse(conf, snamev, samplev);
const Bool_t hasData = (samplev[0]->fnamev.size()>0);
// Create output directory
gSystem->mkdir(outputDir,kTRUE);
const TString ntupDir = outputDir + TString("/ntuples");
gSystem->mkdir(ntupDir,kTRUE);
//
// Declare output ntuple variables
//
UInt_t runNum, lumiSec, evtNum;
UInt_t matchGen;
UInt_t category;
UInt_t npv, npu;
UInt_t id_1, id_2;
Double_t x_1, x_2, xPDF_1, xPDF_2;
Double_t scalePDF, weightPDF;
TLorentzVector *genV=0;
Float_t genVPt, genVPhi, genVy, genVMass;
Float_t genWeight, PUWeight;
Float_t scale1fb,scale1fbUp,scale1fbDown;
Float_t met, metPhi, sumEt, u1, u2;
Float_t tkMet, tkMetPhi, tkSumEt, tkU1, tkU2;
Float_t mvaMet, mvaMetPhi, mvaSumEt, mvaU1, mvaU2;
Float_t puppiMet, puppiMetPhi, puppiSumEt, puppiU1, puppiU2;
Int_t q1, q2;
TLorentzVector *dilep=0, *lep1=0, *lep2=0;
///// muon specific /////
Float_t trkIso1, emIso1, hadIso1, trkIso2, emIso2, hadIso2;
Float_t pfChIso1, pfGamIso1, pfNeuIso1, pfCombIso1, pfChIso2, pfGamIso2, pfNeuIso2, pfCombIso2;
Float_t d01, dz1, d02, dz2;
Float_t muNchi21, muNchi22;
UInt_t nPixHits1, nTkLayers1, nPixHits2, nTkLayers2;
UInt_t nValidHits1, nMatch1, nValidHits2, nMatch2;
UInt_t typeBits1, typeBits2;
TLorentzVector *sta1=0, *sta2=0;
// Data structures to store info from TTrees
baconhep::TEventInfo *info = new baconhep::TEventInfo();
baconhep::TGenEventInfo *gen = new baconhep::TGenEventInfo();
TClonesArray *genPartArr = new TClonesArray("baconhep::TGenParticle");
TClonesArray *muonArr = new TClonesArray("baconhep::TMuon");
TClonesArray *vertexArr = new TClonesArray("baconhep::TVertex");
TFile *infile=0;
TTree *eventTree=0;
//
// loop over samples
//
for(UInt_t isam=0; isam<samplev.size(); isam++) {
// Assume data sample is first sample in .conf file
// If sample is empty (i.e. contains no ntuple files), skip to next sample
Bool_t isData=kFALSE;
if(isam==0 && !hasData) continue;
else if (isam==0) isData=kTRUE;
// Assume signal sample is given name "zmm" - flag to store GEN Z kinematics
Bool_t isSignal = (snamev[isam].CompareTo("zmm",TString::kIgnoreCase)==0);
// flag to reject Z->mm events when selecting at wrong-flavor background events
Bool_t isWrongFlavor = (snamev[isam].CompareTo("zxx",TString::kIgnoreCase)==0);
CSample* samp = samplev[isam];
//
// Set up output ntuple
//
TString outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.root");
if(isam!=0 && !doScaleCorr) outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.raw.root");
TFile *outFile = new TFile(outfilename,"RECREATE");
TTree *outTree = new TTree("Events","Events");
outTree->Branch("runNum", &runNum, "runNum/i"); // event run number
outTree->Branch("lumiSec", &lumiSec, "lumiSec/i"); // event lumi section
outTree->Branch("evtNum", &evtNum, "evtNum/i"); // event number
outTree->Branch("matchGen", &matchGen, "matchGen/i"); // event has both leptons matched to MC Z->ll
outTree->Branch("category", &category, "category/i"); // dilepton category
outTree->Branch("id_1", &id_1, "id_1/i"); // PDF info -- parton ID for parton 1
outTree->Branch("id_2", &id_2, "id_2/i"); // PDF info -- parton ID for parton 2
outTree->Branch("x_1", &x_1, "x_1/d"); // PDF info -- x for parton 1
outTree->Branch("x_2", &x_2, "x_2/d"); // PDF info -- x for parton 2
outTree->Branch("xPDF_1", &xPDF_1, "xPDF_1/d"); // PDF info -- x*F for parton 1
outTree->Branch("xPDF_2", &xPDF_2, "xPDF_2/d"); // PDF info -- x*F for parton 2
outTree->Branch("scalePDF", &scalePDF, "scalePDF/d"); // PDF info -- energy scale of parton interaction
outTree->Branch("weightPDF", &weightPDF, "weightPDF/d"); // PDF info -- PDF weight
outTree->Branch("npv", &npv, "npv/i"); // number of primary vertices
outTree->Branch("npu", &npu, "npu/i"); // number of in-time PU events (MC)
outTree->Branch("genV", "TLorentzVector", &genV); // GEN boson 4-vector (signal MC)
outTree->Branch("genVPt", &genVPt, "genVPt/F"); // GEN boson pT (signal MC)
outTree->Branch("genVPhi", &genVPhi, "genVPhi/F"); // GEN boson phi (signal MC)
outTree->Branch("genVy", &genVy, "genVy/F"); // GEN boson rapidity (signal MC)
outTree->Branch("genVMass", &genVMass, "genVMass/F"); // GEN boson mass (signal MC)
outTree->Branch("genWeight", &genWeight, "genWeight/F");
outTree->Branch("PUWeight", &PUWeight, "PUWeight/F");
outTree->Branch("scale1fb", &scale1fb, "scale1fb/F"); // event weight per 1/fb (MC)
outTree->Branch("scale1fbUp", &scale1fbUp, "scale1fbUp/F"); // event weight per 1/fb (MC)
outTree->Branch("scale1fbDown", &scale1fbDown, "scale1fbDown/F"); // event weight per 1/fb (MC)
outTree->Branch("met", &met, "met/F"); // MET
outTree->Branch("metPhi", &metPhi, "metPhi/F"); // phi(MET)
outTree->Branch("sumEt", &sumEt, "sumEt/F"); // Sum ET
outTree->Branch("u1", &u1, "u1/F"); // parallel component of recoil
outTree->Branch("u2", &u2, "u2/F"); // perpendicular component of recoil
outTree->Branch("tkMet", &tkMet, "tkMet/F"); // MET (track MET)
outTree->Branch("tkMetPhi", &tkMetPhi, "tkMetPhi/F"); // phi(MET) (track MET)
outTree->Branch("tkSumEt", &tkSumEt, "tkSumEt/F"); // Sum ET (track MET)
outTree->Branch("tkU1", &tkU1, "tkU1/F"); // parallel component of recoil (track MET)
outTree->Branch("tkU2", &tkU2, "tkU2/F"); // perpendicular component of recoil (track MET)
outTree->Branch("mvaMet", &mvaMet, "mvaMet/F"); // MVA MET
outTree->Branch("mvaMetPhi", &mvaMetPhi, "mvaMetPhi/F"); // phi(MVA MET)
outTree->Branch("mvaSumEt", &mvaSumEt, "mvaSumEt/F"); // Sum ET (mva MET)
outTree->Branch("mvaU1", &mvaU1, "mvaU1/F"); // parallel component of recoil (mva MET)
outTree->Branch("mvaU2", &mvaU2, "mvaU2/F"); // perpendicular component of recoil (mva MET)
outTree->Branch("puppiMet", &puppiMet, "puppiMet/F"); // Puppi MET
outTree->Branch("puppiMetPhi", &puppiMetPhi,"puppiMetPhi/F"); // phi(Puppi MET)
outTree->Branch("puppiSumEt", &puppiSumEt, "puppiSumEt/F"); // Sum ET (Puppi MET)
outTree->Branch("puppiU1", &puppiU1, "puppiU1/F"); // parallel component of recoil (Puppi MET)
outTree->Branch("puppiU2", &puppiU2, "puppiU2/F"); // perpendicular component of recoil (Puppi MET)
outTree->Branch("q1", &q1, "q1/I"); // charge of tag lepton
outTree->Branch("q2", &q2, "q2/I"); // charge of probe lepton
outTree->Branch("dilep", "TLorentzVector", &dilep); // di-lepton 4-vector
outTree->Branch("lep1", "TLorentzVector", &lep1); // tag lepton 4-vector
outTree->Branch("lep2", "TLorentzVector", &lep2); // probe lepton 4-vector
///// muon specific /////
outTree->Branch("trkIso1", &trkIso1, "trkIso1/F"); // track isolation of tag lepton
outTree->Branch("trkIso2", &trkIso2, "trkIso2/F"); // track isolation of probe lepton
outTree->Branch("emIso1", &emIso1, "emIso1/F"); // ECAL isolation of tag lepton
outTree->Branch("emIso2", &emIso2, "emIso2/F"); // ECAL isolation of probe lepton
outTree->Branch("hadIso1", &hadIso1, "hadIso1/F"); // HCAL isolation of tag lepton
outTree->Branch("hadIso2", &hadIso2, "hadIso2/F"); // HCAL isolation of probe lepton
outTree->Branch("pfChIso1", &pfChIso1, "pfChIso1/F"); // PF charged hadron isolation of tag lepton
outTree->Branch("pfChIso2", &pfChIso2, "pfChIso2/F"); // PF charged hadron isolation of probe lepton
outTree->Branch("pfGamIso1", &pfGamIso1, "pfGamIso1/F"); // PF photon isolation of tag lepton
outTree->Branch("pfGamIso2", &pfGamIso2, "pfGamIso2/F"); // PF photon isolation of probe lepton
outTree->Branch("pfNeuIso1", &pfNeuIso1, "pfNeuIso1/F"); // PF neutral hadron isolation of tag lepton
outTree->Branch("pfNeuIso2", &pfNeuIso2, "pfNeuIso2/F"); // PF neutral hadron isolation of probe lepton
outTree->Branch("pfCombIso1", &pfCombIso1, "pfCombIso1/F"); // PF combined isolation of tag lepton
outTree->Branch("pfCombIso2", &pfCombIso2, "pfCombIso2/F"); // PF combined isolation of probe lepton
outTree->Branch("d01", &d01, "d01/F"); // transverse impact parameter of tag lepton
outTree->Branch("d02", &d02, "d02/F"); // transverse impact parameter of probe lepton
outTree->Branch("dz1", &dz1, "dz1/F"); // longitudinal impact parameter of tag lepton
outTree->Branch("dz2", &dz2, "dz2/F"); // longitudinal impact parameter of probe lepton
outTree->Branch("muNchi21", &muNchi21, "muNchi21/F"); // muon fit normalized chi^2 of tag lepton
outTree->Branch("muNchi22", &muNchi22, "muNchi22/F"); // muon fit normalized chi^2 of probe lepton
outTree->Branch("nPixHits1", &nPixHits1, "nPixHits1/i"); // number of pixel hits of tag muon
outTree->Branch("nPixHits2", &nPixHits2, "nPixHits2/i"); // number of pixel hits of probe muon
outTree->Branch("nTkLayers1", &nTkLayers1, "nTkLayers1/i"); // number of tracker layers of tag muon
outTree->Branch("nTkLayers2", &nTkLayers2, "nTkLayers2/i"); // number of tracker layers of probe muon
outTree->Branch("nMatch1", &nMatch1, "nMatch1/i"); // number of matched segments of tag muon
outTree->Branch("nMatch2", &nMatch2, "nMatch2/i"); // number of matched segments of probe muon
outTree->Branch("nValidHits1", &nValidHits1, "nValidHits1/i"); // number of valid muon hits of tag muon
outTree->Branch("nValidHits2", &nValidHits2, "nValidHits2/i"); // number of valid muon hits of probe muon
outTree->Branch("typeBits1", &typeBits1, "typeBits1/i"); // muon type of tag muon
outTree->Branch("typeBits2", &typeBits2, "typeBits2/i"); // muon type of probe muon
outTree->Branch("sta1", "TLorentzVector", &sta1); // tag standalone muon 4-vector
outTree->Branch("sta2", "TLorentzVector", &sta2); // probe standalone muon 4-vector
//
// loop through files
//
const UInt_t nfiles = samp->fnamev.size();
for(UInt_t ifile=0; ifile<nfiles; ifile++) {
// Read input file and get the TTrees
cout << "Processing " << samp->fnamev[ifile] << " [xsec = " << samp->xsecv[ifile] << " pb] ... "; cout.flush();
infile = TFile::Open(samp->fnamev[ifile]);
assert(infile);
if (samp->fnamev[ifile] == "/dev/null")
{
cout <<"-> Ignoring null input "<<endl;
continue;
}
Bool_t hasJSON = kFALSE;
baconhep::RunLumiRangeMap rlrm;
if(samp->jsonv[ifile].CompareTo("NONE")!=0) {
hasJSON = kTRUE;
rlrm.addJSONFile(samp->jsonv[ifile].Data());
}
eventTree = (TTree*)infile->Get("Events"); assert(eventTree);
eventTree->SetBranchAddress("Info", &info); TBranch *infoBr = eventTree->GetBranch("Info");
eventTree->SetBranchAddress("Muon", &muonArr); TBranch *muonBr = eventTree->GetBranch("Muon");
eventTree->SetBranchAddress("PV", &vertexArr); TBranch *vertexBr = eventTree->GetBranch("PV");
Bool_t hasGen = eventTree->GetBranchStatus("GenEvtInfo");
TBranch *genBr=0, *genPartBr=0;
if(hasGen) {
eventTree->SetBranchAddress("GenEvtInfo", &gen); genBr = eventTree->GetBranch("GenEvtInfo");
eventTree->SetBranchAddress("GenParticle",&genPartArr); genPartBr = eventTree->GetBranch("GenParticle");
}
// Compute MC event weight per 1/fb
const Double_t xsec = samp->xsecv[ifile];
Double_t totalWeight=0;
Double_t totalWeightUp=0;
Double_t totalWeightDown=0;
Double_t puWeight=0;
Double_t puWeightUp=0;
Double_t puWeightDown=0;
if (hasGen) {
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
genBr->GetEntry(ientry);
puWeight = doPU ? h_rw->GetBinContent(h_rw->FindBin(info->nPUmean)) : 1.;
puWeightUp = doPU ? h_rw_up->GetBinContent(h_rw_up->FindBin(info->nPUmean)) : 1.;
puWeightDown = doPU ? h_rw_down->GetBinContent(h_rw_down->FindBin(info->nPUmean)) : 1.;
totalWeight+=gen->weight*puWeight;
totalWeightUp+=gen->weight*puWeightUp;
totalWeightDown+=gen->weight*puWeightDown;
}
}
else if (not isData){
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
puWeight = doPU ? h_rw->GetBinContent(h_rw->FindBin(info->nPUmean)) : 1.;
puWeightUp = doPU ? h_rw_up->GetBinContent(h_rw_up->FindBin(info->nPUmean)) : 1.;
puWeightDown = doPU ? h_rw_down->GetBinContent(h_rw_down->FindBin(info->nPUmean)) : 1.;
totalWeight+= 1.0*puWeight;
totalWeightUp+= 1.0*puWeightUp;
totalWeightDown+= 1.0*puWeightDown;
}
}
//
// loop over events
//
Double_t nsel=0, nselvar=0;
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
if(ientry%1000000==0) cout << "Processing event " << ientry << ". " << (double)ientry/(double)eventTree->GetEntries()*100 << " percent done with this file." << endl;
Double_t weight=1;
Double_t weightUp=1;
Double_t weightDown=1;
if(xsec>0 && totalWeight>0) weight = xsec/totalWeight;
if(xsec>0 && totalWeightUp>0) weightUp = xsec/totalWeightUp;
if(xsec>0 && totalWeightDown>0) weightDown = xsec/totalWeightDown;
if(hasGen) {
genPartArr->Clear();
genBr->GetEntry(ientry);
genPartBr->GetEntry(ientry);
puWeight = doPU ? h_rw->GetBinContent(h_rw->FindBin(info->nPUmean)) : 1.;
puWeightUp = doPU ? h_rw_up->GetBinContent(h_rw_up->FindBin(info->nPUmean)) : 1.;
puWeightDown = doPU ? h_rw_down->GetBinContent(h_rw_down->FindBin(info->nPUmean)) : 1.;
weight*=gen->weight*puWeight;
weightUp*=gen->weight*puWeightUp;
weightDown*=gen->weight*puWeightDown;
}
// veto z -> xx decays for signal and z -> mm for bacground samples (needed for inclusive DYToLL sample)
if (isWrongFlavor && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))==LEPTON_ID) continue;
else if (isSignal && hasGen && fabs(toolbox::flavor(genPartArr, BOSON_ID))!=LEPTON_ID) continue;
// check for certified lumi (if applicable)
baconhep::RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
if(hasJSON && !rlrm.hasRunLumi(rl)) continue;
// trigger requirement
if (!isMuonTrigger(triggerMenu, info->triggerBits)) continue;
// good vertex requirement
if(!(info->hasGoodPV)) continue;
muonArr->Clear();
muonBr->GetEntry(ientry);
TLorentzVector vTag(0,0,0,0);
TLorentzVector vTagSta(0,0,0,0);
Double_t tagPt=0;
Double_t Pt1=0;
Double_t Pt2=0;
Int_t itag=-1;
for(Int_t i1=0; i1<muonArr->GetEntriesFast(); i1++) {
const baconhep::TMuon *tag = (baconhep::TMuon*)((*muonArr)[i1]);
// apply scale and resolution corrections to MC
Double_t tagpt_corr = tag->pt;
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0)
tagpt_corr = gRandom->Gaus(tag->pt*getMuScaleCorr(tag->eta,0),getMuResCorr(tag->eta,0));
if(tagpt_corr < PT_CUT) continue; // lepton pT cut
if(fabs(tag->eta) > ETA_CUT) continue; // lepton |eta| cut
if(!passMuonID(tag)) continue; // lepton selection
double Mu_Pt=0;
if(doScaleCorr) {
Mu_Pt=gRandom->Gaus(tag->pt*getMuScaleCorr(tag->eta,0),getMuResCorr(tag->eta,0));
}
else
{
Mu_Pt=tag->pt;
}
if(Mu_Pt>Pt1)
{
Pt2=Pt1;
Pt1=Mu_Pt;
}
else if(Mu_Pt>Pt2&&Mu_Pt<Pt1)
{
Pt2=Mu_Pt;
}
if(!isMuonTriggerObj(triggerMenu, tag->hltMatchBits, kFALSE)) continue;
if(Mu_Pt<tagPt) continue;
tagPt=Mu_Pt;
itag=i1;
// apply scale and resolution corrections to MC
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0) {
vTag.SetPtEtaPhiM(tagpt_corr,tag->eta,tag->phi,MUON_MASS);
vTagSta.SetPtEtaPhiM(gRandom->Gaus(tag->staPt*getMuScaleCorr(tag->eta,0),getMuResCorr(tag->eta,0)),tag->staEta,tag->staPhi,MUON_MASS);
} else {
vTag.SetPtEtaPhiM(tag->pt,tag->eta,tag->phi,MUON_MASS);
vTagSta.SetPtEtaPhiM(tag->staPt,tag->staEta,tag->staPhi,MUON_MASS);
}
trkIso1 = tag->trkIso;
emIso1 = tag->ecalIso;
hadIso1 = tag->hcalIso;
pfChIso1 = tag->chHadIso;
pfGamIso1 = tag->gammaIso;
pfNeuIso1 = tag->neuHadIso;
pfCombIso1 = tag->chHadIso + TMath::Max(tag->neuHadIso + tag->gammaIso -
0.5*(tag->puIso),Double_t(0));
d01 = tag->d0;
dz1 = tag->dz;
muNchi21 = tag->muNchi2;
nPixHits1 = tag->nPixHits;
nTkLayers1 = tag->nTkLayers;
nMatch1 = tag->nMatchStn;
nValidHits1 = tag->nValidHits;
typeBits1 = tag->typeBits;
q1 = tag->q;
}
if(tagPt<Pt2) continue;
TLorentzVector vProbe(0,0,0,0); TLorentzVector vProbeSta(0,0,0,0);
Double_t probePt=0;
Int_t passID=false;
UInt_t icat=0;
for(Int_t i2=0; i2<muonArr->GetEntriesFast(); i2++) {
if(itag==i2) continue;
const baconhep::TMuon *probe = (baconhep::TMuon*)((*muonArr)[i2]);
// apply scale and resolution corrections to MC
Double_t probept_corr = probe->pt;
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0)
probept_corr = gRandom->Gaus(probe->pt*getMuScaleCorr(probe->eta,0),getMuResCorr(probe->eta,0));
if(probept_corr < PT_CUT) continue; // lepton pT cut
if(fabs(probe->eta) > ETA_CUT) continue; // lepton |eta| cut
double Mu_Pt=probept_corr;
if(passID&&passMuonID(probe)&&Mu_Pt<probePt) continue;
if(passID&&!passMuonID(probe)) continue;
if(!passID&&!passMuonID(probe)&&Mu_Pt<probePt) continue;
if(!passID&&passMuonID(probe)) passID=true;
probePt=Mu_Pt;
// apply scale and resolution corrections to MC
if(doScaleCorr && snamev[isam].CompareTo("data",TString::kIgnoreCase)!=0) {
vProbe.SetPtEtaPhiM(probept_corr,probe->eta,probe->phi,MUON_MASS);
if(probe->typeBits & baconhep::EMuType::kStandalone)
vProbeSta.SetPtEtaPhiM(gRandom->Gaus(probe->staPt*getMuScaleCorr(probe->eta,0),getMuResCorr(probe->eta,0)),probe->staEta,probe->staPhi,MUON_MASS);
} else {
vProbe.SetPtEtaPhiM(probe->pt,probe->eta,probe->phi,MUON_MASS);
if(probe->typeBits & baconhep::EMuType::kStandalone)
vProbeSta.SetPtEtaPhiM(probe->staPt,probe->staEta,probe->staPhi,MUON_MASS);
}
trkIso2 = probe->trkIso;
emIso2 = probe->ecalIso;
hadIso2 = probe->hcalIso;
pfChIso2 = probe->chHadIso;
pfGamIso2 = probe->gammaIso;
pfNeuIso2 = probe->neuHadIso;
pfCombIso2 = probe->chHadIso + TMath::Max(probe->neuHadIso + probe->gammaIso -
0.5*(probe->puIso),Double_t(0));
d02 = probe->d0;
dz2 = probe->dz;
muNchi22 = probe->muNchi2;
nPixHits2 = probe->nPixHits;
nTkLayers2 = probe->nTkLayers;
nMatch2 = probe->nMatchStn;
nValidHits2 = probe->nValidHits;
typeBits2 = probe->typeBits;
q2 = probe->q;
// determine event category
if(passMuonID(probe)) {
if(isMuonTriggerObj(triggerMenu, probe->hltMatchBits, kFALSE)) {
icat=eMuMu2HLT;
}
else if(isMuonTriggerObj(triggerMenu, probe->hltMatchBits, kTRUE)) {
icat=eMuMu1HLT1L1;
}
else {
icat=eMuMu1HLT;
}
}
else if(probe->typeBits & baconhep::EMuType::kGlobal) { icat=eMuMuNoSel; }
else if(probe->typeBits & baconhep::EMuType::kStandalone) { icat=eMuSta; }
else if(probe->nTkLayers>=6 && probe->nPixHits>=1) { icat=eMuTrk; }
}
if(q1 == q2) continue; // opposite charge requirement
// mass window
TLorentzVector vDilep = vTag + vProbe;
if((vDilep.M()<MASS_LOW) || (vDilep.M()>MASS_HIGH)) continue;
if(icat==0) continue;
/******** We have a Z candidate! HURRAY! ********/
nsel+=weight;
nselvar+=weight*weight;
// Perform matching of dileptons to GEN leptons from Z decay
Int_t glepq1=-99;
Int_t glepq2=-99;
TLorentzVector *gvec=new TLorentzVector(0,0,0,0);
TLorentzVector *glep1=new TLorentzVector(0,0,0,0);
TLorentzVector *glep2=new TLorentzVector(0,0,0,0);
TLorentzVector *gph=new TLorentzVector(0,0,0,0);
Bool_t hasGenMatch = kFALSE;
if(isSignal && hasGen) {
toolbox::fillGen(genPartArr, BOSON_ID, gvec, glep1, glep2,&glepq1,&glepq2,1);
Bool_t match1 = ( ((glep1) && toolbox::deltaR(vTag.Eta(), vTag.Phi(), glep1->Eta(), glep1->Phi())<0.5) ||
((glep2) && toolbox::deltaR(vTag.Eta(), vTag.Phi(), glep2->Eta(), glep2->Phi())<0.5) );
Bool_t match2 = ( ((glep1) && toolbox::deltaR(vProbe.Eta(), vProbe.Phi(), glep1->Eta(), glep1->Phi())<0.5) ||
((glep2) && toolbox::deltaR(vProbe.Eta(), vProbe.Phi(), glep2->Eta(), glep2->Phi())<0.5) );
if(match1 && match2) {
hasGenMatch = kTRUE;
if (gvec!=0) {
genV=new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(gvec->Pt(), gvec->Eta(), gvec->Phi(), gvec->M());
genVPt = gvec->Pt();
genVPhi = gvec->Phi();
genVy = gvec->Rapidity();
genVMass = gvec->M();
}
else {
TLorentzVector tvec=*glep1+*glep2;
genV=new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(tvec.Pt(), tvec.Eta(), tvec.Phi(), tvec.M());
genVPt = tvec.Pt();
genVPhi = tvec.Phi();
genVy = tvec.Rapidity();
genVMass = tvec.M();
}
delete gvec;
delete glep1;
delete glep2;
glep1=0; glep2=0; gvec=0;
}
else {
genV = new TLorentzVector(0,0,0,0);
genVPt = -999;
genVPhi = -999;
genVy = -999;
genVMass = -999;
}
}
if (hasGen) {
id_1 = gen->id_1;
id_2 = gen->id_2;
x_1 = gen->x_1;
x_2 = gen->x_2;
xPDF_1 = gen->xPDF_1;
xPDF_2 = gen->xPDF_2;
scalePDF = gen->scalePDF;
weightPDF = gen->weight;
}
else {
id_1 = -999;
id_2 = -999;
x_1 = -999;
x_2 = -999;
xPDF_1 = -999;
xPDF_2 = -999;
scalePDF = -999;
weightPDF = -999;
}
//
// Fill tree
//
runNum = info->runNum;
lumiSec = info->lumiSec;
evtNum = info->evtNum;
if (hasGenMatch) matchGen=1;
else matchGen=0;
category = icat;
vertexArr->Clear();
vertexBr->GetEntry(ientry);
npv = vertexArr->GetEntries();
npu = info->nPUmean;
genWeight= hasGen ? gen->weight: 1.;
PUWeight = puWeight;
scale1fb = weight;
scale1fbUp = weightUp;
scale1fbDown = weightDown;
met = info->pfMETC;
metPhi = info->pfMETCphi;
sumEt = 0;
tkMet = info->trkMET;
tkMetPhi = info->trkMETphi;
tkSumEt = 0;
mvaMet = info->mvaMET;
mvaMetPhi = info->mvaMETphi;
mvaSumEt = 0;
TVector2 vZPt((vDilep.Pt())*cos(vDilep.Phi()),(vDilep.Pt())*sin(vDilep.Phi()));
puppiMet = info->puppET;
puppiMetPhi = info->puppETphi;
puppiSumEt = 0;
lep1 = &vTag;
lep2 = &vProbe;
dilep = &vDilep;
sta1 = &vTagSta;
sta2 = &vProbeSta;
TVector2 vMet((info->pfMETC)*cos(info->pfMETCphi), (info->pfMETC)*sin(info->pfMETCphi));
TVector2 vU = -1.0*(vMet+vZPt);
u1 = ((vDilep.Px())*(vU.Px()) + (vDilep.Py())*(vU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
u2 = ((vDilep.Px())*(vU.Py()) - (vDilep.Py())*(vU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vTkMet((info->trkMET)*cos(info->trkMETphi), (info->trkMET)*sin(info->trkMETphi));
TVector2 vTkU = -1.0*(vTkMet+vZPt);
tkU1 = ((vDilep.Px())*(vTkU.Px()) + (vDilep.Py())*(vTkU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
tkU2 = ((vDilep.Px())*(vTkU.Py()) - (vDilep.Py())*(vTkU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vMvaMet((info->mvaMET)*cos(info->mvaMETphi), (info->mvaMET)*sin(info->mvaMETphi));
TVector2 vMvaU = -1.0*(vMvaMet+vZPt);
mvaU1 = ((vDilep.Px())*(vMvaU.Px()) + (vDilep.Py())*(vMvaU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
mvaU2 = ((vDilep.Px())*(vMvaU.Py()) - (vDilep.Py())*(vMvaU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vPuppiMet((info->puppET)*cos(info->puppETphi), (info->puppET)*sin(info->puppETphi));
TVector2 vPuppiU = -1.0*(vPuppiMet+vZPt);
puppiU1 = ((vDilep.Px())*(vPuppiU.Px()) + (vDilep.Py())*(vPuppiU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
puppiU2 = ((vDilep.Px())*(vPuppiU.Py()) - (vDilep.Py())*(vPuppiU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
outTree->Fill();
delete genV;
genV=0, dilep=0, lep1=0, lep2=0, sta1=0, sta2=0;
}
delete infile;
infile=0, eventTree=0;
cout << nsel << " +/- " << sqrt(nselvar);
if(!isData) cout << " per 1/fb";
cout << endl;
}
outFile->Write();
outFile->Close();
}
delete h_rw;
delete h_rw_up;
delete h_rw_down;
delete f_rw;
delete info;
delete gen;
delete genPartArr;
delete muonArr;
delete vertexArr;
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << " Z -> mu mu" << endl;
cout << " Mass window: [" << MASS_LOW << ", " << MASS_HIGH << "]" << endl;
cout << " pT > " << PT_CUT << endl;
cout << " |eta| < " << ETA_CUT << endl;
cout << endl;
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
gBenchmark->Show("selectZmm");
}
void selectZeeSC(const TString conf="zee_sc.conf", // input file
const TString outputDir=".", // output directory
const Bool_t doScaleCorr=0 // apply energy scale corrections?
) {
gBenchmark->Start("selectZee");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t MASS_LOW = 40;
const Double_t MASS_HIGH = 200;
const Double_t PT_CUT = 25;
const Double_t ETA_CUT = 2.5;
const Double_t ELE_MASS = 0.000511;
const Double_t ECAL_GAP_LOW = 1.4442;
const Double_t ECAL_GAP_HIGH = 1.566;
const Double_t escaleNbins = 6;
const Double_t escaleEta[] = { 0.4, 0.8, 1.2, 1.4442, 2, 2.5 };
const Double_t escaleCorr[] = { 1.00284, 1.00479, 1.00734, 1.00851, 1.00001, 0.982898 };
const Int_t BOSON_ID = 23;
const Int_t LEPTON_ID = 11;
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
enum { ePass=0, eFail }; // event category enum
vector<TString> snamev; // sample name (for output files)
vector<CSample*> samplev; // data/MC samples
//
// parse .conf file
//
confParse(conf, snamev, samplev);
const Bool_t hasData = (samplev[0]->fnamev.size()>0);
// Create output directory
gSystem->mkdir(outputDir,kTRUE);
const TString ntupDir = outputDir + TString("/ntuples");
gSystem->mkdir(ntupDir,kTRUE);
//
// Declare output ntuple variables
//
UInt_t runNum, lumiSec, evtNum;
UInt_t matchGen;
UInt_t category;
UInt_t npv, npu;
UInt_t id_1, id_2;
Double_t x_1, x_2, xPDF_1, xPDF_2;
Double_t scalePDF, weightPDF;
TLorentzVector *genV=0;
Float_t genVPt, genVPhi, genVy, genVMass;
Float_t scale1fb;
Float_t met, metPhi, sumEt, u1, u2;
Float_t tkMet, tkMetPhi, tkSumEt, tkU1, tkU2;
Float_t mvaMet, mvaMetPhi, mvaSumEt, mvaU1, mvaU2;
Float_t ppMet, ppMetPhi, ppSumEt, ppU1, ppU2;
Int_t q1, q2;
TLorentzVector *dilep=0, *lep1=0, *lep2=0;
///// electron specific /////
Float_t trkIso1, emIso1, hadIso1, trkIso2, emIso2, hadIso2;
Float_t pfChIso1, pfGamIso1, pfNeuIso1, pfCombIso1, pfChIso2, pfGamIso2, pfNeuIso2, pfCombIso2;
Float_t sigieie1, hovere1, eoverp1, fbrem1, ecalE1, sigieie2, hovere2, eoverp2, fbrem2, ecalE2;
Float_t dphi1, deta1, dphi2, deta2;
Float_t d01, dz1, d02, dz2;
UInt_t isConv1, nexphits1, typeBits1, isConv2, nexphits2, typeBits2;
TLorentzVector *sc1=0, *sc2=0;
// Data structures to store info from TTrees
baconhep::TEventInfo *info = new baconhep::TEventInfo();
baconhep::TGenEventInfo *gen = new baconhep::TGenEventInfo();
TClonesArray *genPartArr = new TClonesArray("baconhep::TGenParticle");
TClonesArray *electronArr = new TClonesArray("baconhep::TElectron");
TClonesArray *muonArr = new TClonesArray("baconhep::TMuon");
TClonesArray *scArr = new TClonesArray("baconhep::TPhoton");
TFile *infile=0;
TTree *eventTree=0;
//
// loop over samples
//
for(UInt_t isam=0; isam<samplev.size(); isam++) {
// Assume data sample is first sample in .conf file
// If sample is empty (i.e. contains no ntuple files), skip to next sample
if(isam==0 && !hasData) continue;
// Assume signal sample is given name "zee" - flag to store GEN Z kinematics
Bool_t isSignal = (snamev[isam].CompareTo("zee",TString::kIgnoreCase)==0);
// flag to reject Z->ee events when selecting at wrong-flavor background events
Bool_t isWrongFlavor = (snamev[isam].CompareTo("zxx",TString::kIgnoreCase)==0);
CSample* samp = samplev[isam];
//
// Set up output ntuple
//
TString outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.root");
if(isam==0 && !doScaleCorr) outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.raw.root");
TFile *outFile = new TFile(outfilename,"RECREATE");
TTree *outTree = new TTree("Events","Events");
outTree->Branch("runNum", &runNum, "runNum/i"); // event run number
outTree->Branch("lumiSec", &lumiSec, "lumiSec/i"); // event lumi section
outTree->Branch("evtNum", &evtNum, "evtNum/i"); // event number
outTree->Branch("matchGen", &matchGen, "matchGen/i"); // event has both leptons matched to MC Z->ll
outTree->Branch("category", &category, "category/i"); // dilepton category
outTree->Branch("id_1", &id_1, "id_1/i"); // PDF info -- parton ID for parton 1
outTree->Branch("id_2", &id_2, "id_2/i"); // PDF info -- parton ID for parton 2
outTree->Branch("x_1", &x_1, "x_1/d"); // PDF info -- x for parton 1
outTree->Branch("x_2", &x_2, "x_2/d"); // PDF info -- x for parton 2
outTree->Branch("xPDF_1", &xPDF_1, "xPDF_1/d"); // PDF info -- x*F for parton 1
outTree->Branch("xPDF_2", &xPDF_2, "xPDF_2/d"); // PDF info -- x*F for parton 2
outTree->Branch("scalePDF", &scalePDF, "scalePDF/d"); // PDF info -- energy scale of parton interaction
outTree->Branch("weightPDF", &weightPDF, "weightPDF/d"); // PDF info -- PDF weight
outTree->Branch("npv", &npv, "npv/i"); // number of primary vertices
outTree->Branch("npu", &npu, "npu/i"); // number of in-time PU events (MC)
outTree->Branch("genV", "TLorentzVector", &genV); // GEN boson 4-vector
outTree->Branch("genVPt", &genVPt, "genVPt/F"); // GEN boson pT (signal MC)
outTree->Branch("genVPhi", &genVPhi, "genVPhi/F"); // GEN boson phi (signal MC)
outTree->Branch("genVy", &genVy, "genVy/F"); // GEN boson rapidity (signal MC)
outTree->Branch("genVMass", &genVMass, "genVMass/F"); // GEN boson mass (signal MC)
outTree->Branch("scale1fb", &scale1fb, "scale1fb/F"); // event weight per 1/fb (MC)
outTree->Branch("met", &met, "met/F"); // MET
outTree->Branch("metPhi", &metPhi, "metPhi/F"); // phi(MET)
outTree->Branch("sumEt", &sumEt, "sumEt/F"); // Sum ET
outTree->Branch("u1", &u1, "u1/F"); // parallel component of recoil
outTree->Branch("u2", &u2, "u2/F"); // perpendicular component of recoil
outTree->Branch("tkMet", &tkMet, "tkMet/F"); // MET (track MET)
outTree->Branch("tkMetPhi", &tkMetPhi, "tkMetPhi/F"); // phi(MET) (track MET)
outTree->Branch("tkSumEt", &tkSumEt, "tkSumEt/F"); // Sum ET (track MET)
outTree->Branch("tkU1", &tkU1, "tkU1/F"); // parallel component of recoil (track MET)
outTree->Branch("tkU2", &tkU2, "tkU2/F"); // perpendicular component of recoil (track MET)
outTree->Branch("mvaMet", &mvaMet, "mvaMet/F"); // MVA MET
outTree->Branch("mvaMetPhi", &mvaMetPhi, "mvaMetPhi/F"); // phi(MVA MET)
outTree->Branch("mvaSumEt", &mvaSumEt, "mvaSumEt/F"); // Sum ET (mva MET)
outTree->Branch("mvaU1", &mvaU1, "mvaU1/F"); // parallel component of recoil (mva MET)
outTree->Branch("mvaU2", &mvaU2, "mvaU2/F"); // perpendicular component of recoil (mva MET)
outTree->Branch("ppMet", &ppMet, "ppMet/F"); // PUPPI MET
outTree->Branch("ppMetPhi", &ppMetPhi, "ppMetPhi/F"); // phi(PUPPI MET)
outTree->Branch("ppSumEt", &ppSumEt, "ppSumEt/F"); // Sum ET (PUPPI MET)
outTree->Branch("ppU1", &ppU1, "ppU1/F"); // parallel component of recoil (PUPPI MET)
outTree->Branch("ppU2", &ppU2, "ppU2/F"); // perpendicular component of recoil (PUPPI MET)
outTree->Branch("q1", &q1, "q1/I"); // charge of tag lepton
outTree->Branch("q2", &q2, "q2/I"); // charge of probe lepton
outTree->Branch("dilep", "TLorentzVector", &dilep); // di-lepton 4-vector
outTree->Branch("lep1", "TLorentzVector", &lep1); // tag lepton 4-vector
outTree->Branch("lep2", "TLorentzVector", &lep2); // probe lepton 4-vector
///// electron specific /////
outTree->Branch("trkIso1", &trkIso1, "trkIso1/F"); // track isolation of tag lepton
outTree->Branch("trkIso2", &trkIso2, "trkIso2/F"); // track isolation of probe lepton
outTree->Branch("emIso1", &emIso1, "emIso1/F"); // ECAL isolation of tag lepton
outTree->Branch("emIso2", &emIso2, "emIso2/F"); // ECAL isolation of probe lepton
outTree->Branch("hadIso1", &hadIso1, "hadIso1/F"); // HCAL isolation of tag lepton
outTree->Branch("hadIso2", &hadIso2, "hadIso2/F"); // HCAL isolation of probe lepton
outTree->Branch("pfChIso1", &pfChIso1, "pfChIso1/F"); // PF charged hadron isolation of tag lepton
outTree->Branch("pfChIso2", &pfChIso2, "pfChIso2/F"); // PF charged hadron isolation of probe lepton
outTree->Branch("pfGamIso1", &pfGamIso1, "pfGamIso1/F"); // PF photon isolation of tag lepton
outTree->Branch("pfGamIso2", &pfGamIso2, "pfGamIso2/F"); // PF photon isolation of probe lepton
outTree->Branch("pfNeuIso1", &pfNeuIso1, "pfNeuIso1/F"); // PF neutral hadron isolation of tag lepton
outTree->Branch("pfNeuIso2", &pfNeuIso2, "pfNeuIso2/F"); // PF neutral hadron isolation of probe lepton
outTree->Branch("pfCombIso1", &pfCombIso1, "pfCombIso1/F"); // PF combine isolation of tag lepton
outTree->Branch("pfCombIso2", &pfCombIso2, "pfCombIso2/F"); // PF combined isolation of probe lepton
outTree->Branch("sigieie1", &sigieie1, "sigieie1/F"); // sigma-ieta-ieta of tag
outTree->Branch("sigieie2", &sigieie2, "sigieie2/F"); // sigma-ieta-ieta of probe
outTree->Branch("hovere1", &hovere1, "hovere1/F"); // H/E of tag
outTree->Branch("hovere2", &hovere2, "hovere2/F"); // H/E of probe
outTree->Branch("eoverp1", &eoverp1, "eoverp1/F"); // E/p of tag
outTree->Branch("eoverp2", &eoverp2, "eoverp2/F"); // E/p of probe
outTree->Branch("fbrem1", &fbrem1, "fbrem1/F"); // brem fraction of tag
outTree->Branch("fbrem2", &fbrem2, "fbrem2/F"); // brem fraction of probe
outTree->Branch("dphi1", &dphi1, "dphi1/F"); // GSF track - ECAL dphi of tag
outTree->Branch("dphi2", &dphi2, "dphi2/F"); // GSF track - ECAL dphi of probe
outTree->Branch("deta1", &deta1, "deta1/F"); // GSF track - ECAL deta of tag
outTree->Branch("deta2", &deta2, "deta2/F"); // GSF track - ECAL deta of probe
outTree->Branch("ecalE1", &ecalE1, "ecalE1/F"); // ECAL energy of tag
outTree->Branch("ecalE2", &ecalE2, "ecalE2/F"); // ECAL energy of probe
outTree->Branch("d01", &d01, "d01/F"); // transverse impact parameter of tag
outTree->Branch("d02", &d02, "d02/F"); // transverse impact parameter of probe
outTree->Branch("dz1", &dz1, "dz1/F"); // longitudinal impact parameter of tag
outTree->Branch("dz2", &dz2, "dz2/F"); // longitudinal impact parameter of probe
outTree->Branch("isConv1", &isConv1, "isConv1/i"); // conversion filter flag of tag lepton
outTree->Branch("isConv2", &isConv2, "isConv2/i"); // conversion filter flag of probe lepton
outTree->Branch("nexphits1", &nexphits1, "nexphits1/i"); // number of missing expected inner hits of tag lepton
outTree->Branch("nexphits2", &nexphits2, "nexphits2/i"); // number of missing expected inner hits of probe lepton
outTree->Branch("typeBits1", &typeBits1, "typeBits1/i"); // electron type of tag lepton
outTree->Branch("typeBits2", &typeBits2, "typeBits2/i"); // electron type of probe lepton
outTree->Branch("sc1", "TLorentzVector", &sc1); // tag supercluster 4-vector
outTree->Branch("sc2", "TLorentzVector", &sc2); // probe supercluster 4-vector
//
// loop through files
//
const UInt_t nfiles = samp->fnamev.size();
for(UInt_t ifile=0; ifile<nfiles; ifile++) {
// Read input file and get the TTrees
cout << "Processing " << samp->fnamev[ifile] << " [xsec = " << samp->xsecv[ifile] << " pb] ... " << endl; cout.flush();
infile = TFile::Open(samp->fnamev[ifile]);
assert(infile);
const baconhep::TTrigger triggerMenu("../../BaconAna/DataFormats/data/HLT_50nsGRun");
UInt_t trigger, trigObjL1, trigObjHLT;
if (isam==0) {
trigger = triggerMenu.getTriggerBit("HLT_Ele23_WPLoose_Gsf_v*"); //data trigger
trigObjL1 = 1; //data
trigObjHLT = 2; //data
}
else {
trigger = triggerMenu.getTriggerBit("HLT_Ele23_WP75_Gsf_v*");
trigObjL1 = 4; //triggerMenu.getTriggerObjectBit("HLT_Ele22_WP75_Gsf_v*", "hltL1sL1SingleEG20");
trigObjHLT = 5; //triggerMenu.getTriggerObjectBit("HLT_Ele23_WP75_Gsf_v*", "hltEle23WP75GsfTrackIsoFilter");
}
//Bool_t hasJSON = kFALSE;
//baconhep::RunLumiRangeMap rlrm;
//if(samp->jsonv[ifile].CompareTo("NONE")!=0) {
//hasJSON = kTRUE;
//rlrm.AddJSONFile(samp->jsonv[ifile].Data());
//}
eventTree = (TTree*)infile->Get("Events");
assert(eventTree);
eventTree->SetBranchAddress("Info", &info); TBranch *infoBr = eventTree->GetBranch("Info");
eventTree->SetBranchAddress("Electron", &electronArr); TBranch *electronBr = eventTree->GetBranch("Electron");
eventTree->SetBranchAddress("Muon", &muonArr); TBranch *muonBr = eventTree->GetBranch("Muon");
eventTree->SetBranchAddress("Photon", &scArr); TBranch *scBr = eventTree->GetBranch("Photon");
Bool_t hasGen = eventTree->GetBranchStatus("GenEvtInfo");
TBranch *genBr=0, *genPartBr=0;
if(hasGen) {
eventTree->SetBranchAddress("GenEvtInfo", &gen); genBr = eventTree->GetBranch("GenEvtInfo");
eventTree->SetBranchAddress("GenParticle",&genPartArr); genPartBr = eventTree->GetBranch("GenParticle");
}
// Compute MC event weight per 1/fb
const Double_t xsec = samp->xsecv[ifile];
Double_t totalWeight=1;
if (hasGen) {
TH1D *hall = new TH1D("hall", "", 1,0,1);
eventTree->Draw("0.5>>hall", "GenEvtInfo->weight");
totalWeight=hall->Integral();
delete hall;
hall=0;
}
//
// loop over events
//
Double_t nsel=0, nselvar=0;
for(UInt_t ientry=0; ientry<eventTree->GetEntries()/10; ientry++) {
infoBr->GetEntry(ientry);
if(ientry%1000000==0) cout << "Processing event " << ientry << ". " << (double)ientry/(double)eventTree->GetEntries()*100 << " percent done with this file." << endl;
Double_t weight=1;
if(xsec>0 && totalWeight>0) weight = xsec/totalWeight;
if(hasGen) {
genPartArr->Clear();
genBr->GetEntry(ientry);
genPartBr->GetEntry(ientry);
weight*=gen->weight;
}
// veto z -> xx decays for signal and z -> ee for bacground samples (needed for inclusive DYToLL sample)
if (isWrongFlavor && hasGen && toolbox::flavor(genPartArr, BOSON_ID)==LEPTON_ID) continue;
else if (isSignal && hasGen && toolbox::flavor(genPartArr, BOSON_ID)!=LEPTON_ID) continue;
// check for certified lumi (if applicable)
//baconhep::RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
//if(hasJSON && !rlrm.HasRunLumi(rl)) continue;
// trigger requirement
if(!(info->triggerBits[trigger])) continue;
// good vertex requirement
if(!(info->hasGoodPV)) continue;
//
// SELECTION PROCEDURE:
// (1) Find a good electron matched to trigger -> this will be the "tag"
// (2) Pair the tag with Supercluster probes which form a tag+probe mass inside
// the Z window and divide candidates into exclusive categories as follows:
// (a) if probe SC is part of a good electron matched to trigger -> EleEle2HLT category
// (b) if probe SC is part of a good electron not matched to trigger -> EleEle1HLT category
// (c) if probe SC is part of an electron failing selection cuts -> EleEleNoSel category
// (d) if probe SC is not part of an ECAL driven electron -> EleSC category
//
TLorentzVector *gvec=new TLorentzVector(0,0,0,0);
TLorentzVector *glep1=new TLorentzVector(0,0,0,0);
TLorentzVector *glep2=new TLorentzVector(0,0,0,0);
toolbox::fillGen(genPartArr, BOSON_ID, gvec, glep1, glep2,1);
electronArr->Clear();
electronBr->GetEntry(ientry);
scArr->Clear();
scBr->GetEntry(ientry);
for(Int_t i1=0; i1<electronArr->GetEntriesFast(); i1++) {
const baconhep::TElectron *tag = (baconhep::TElectron*)((*electronArr)[i1]);
// check ECAL gap
if(fabs(tag->scEta)>=ECAL_GAP_LOW && fabs(tag->scEta)<=ECAL_GAP_HIGH) continue;
if (!(((glep1) && toolbox::deltaR(tag->eta, tag->phi, glep1->Eta(), glep1->Phi())<0.1) ||
((glep2) && toolbox::deltaR(tag->eta, tag->phi, glep2->Eta(), glep2->Phi())<0.1))) continue;
Double_t escale1=1;
if(doScaleCorr && isam==0) {
for(UInt_t ieta=0; ieta<escaleNbins; ieta++) {
if(fabs(tag->scEta)<escaleEta[ieta]) {
escale1 = escaleCorr[ieta];
break;
}
}
}
if(escale1*(tag->scEt) < PT_CUT) continue; // lepton pT cut
if(fabs(tag->scEta) > ETA_CUT) continue; // lepton |eta| cut
if(!passEleID(tag,info->rhoIso)) continue; // lepton selection
if(!(tag->hltMatchBits[trigObjHLT])) continue; // check trigger matching
TLorentzVector vTag; vTag.SetPtEtaPhiM(tag->pt, tag->eta, tag->phi, ELE_MASS);
TLorentzVector vTagSC; vTagSC.SetPtEtaPhiM(tag->scEt, tag->scEta, tag->scPhi, ELE_MASS);
muonArr->Clear();
muonBr->GetEntry(ientry);
for(Int_t j=0; j<muonArr->GetEntriesFast(); j++) {
const baconhep::TMuon *tkProbe = (baconhep::TMuon*)((*muonArr)[j]);
if (tkProbe->typeBits & baconhep::EMuType::kGlobal) continue;
if (toolbox::deltaR(tkProbe->eta, tkProbe->phi, tag->eta, tag->phi)<0.1) continue;
if (!( ((glep1) && toolbox::deltaR(tkProbe->eta, tkProbe->phi, glep1->Eta(), glep1->Phi())<0.1) ||
((glep2) && toolbox::deltaR(tkProbe->eta, tkProbe->phi, glep2->Eta(), glep2->Phi())<0.1) ) ) continue;
// check ECAL gap
if(fabs(tkProbe->eta)>=ECAL_GAP_LOW && fabs(tkProbe->eta)<=ECAL_GAP_HIGH) continue;
if(tkProbe->pt < PT_CUT) continue; // Track pT cut
if(fabs(tkProbe->eta) > ETA_CUT) continue; // track |eta| cuts
const baconhep::TPhoton *scProbe=0;
Int_t iprobe=-1;
for(Int_t i2=0; i2<scArr->GetEntriesFast(); i2++) {
const baconhep::TPhoton *sc = (baconhep::TPhoton*)((*scArr)[i2]);
if (toolbox::deltaR(tkProbe->eta, tkProbe->phi, sc->eta, sc->phi)<0.1) {
scProbe=sc;
iprobe=i2;
break;
}
}
TLorentzVector vProbe(0,0,0,0);
vProbe.SetPtEtaPhiM(tkProbe->pt, tkProbe->eta, tkProbe->phi, ELE_MASS);
TLorentzVector vProbeSC(0,0,0,0);
vProbeSC.SetPtEtaPhiM((scProbe) ? scProbe->scEt : tkProbe->pt,
tkProbe->eta, tkProbe->phi, ELE_MASS);
// mass window
TLorentzVector vDilep = vTag + vProbe;
if((vDilep.M()<MASS_LOW) || (vDilep.M()>MASS_HIGH)) continue;
// determine event category
UInt_t icat=0;
if(scProbe) icat=ePass;
else icat=eFail;
//******** We have a Z candidate! HURRAY! ********
nsel+=weight;
nselvar+=weight*weight;
// Perform matching of dileptons to GEN leptons from Z decay
Bool_t hasGenMatch = kFALSE;
if(isSignal && hasGen) {
Bool_t match1 = ( ((glep1) && toolbox::deltaR(tag->eta, tag->phi, glep1->Eta(), glep1->Phi())<0.1) ||
((glep2) && toolbox::deltaR(tag->eta, tag->phi, glep2->Eta(), glep2->Phi())<0.1) );
Bool_t match2 = ( ((glep1) && toolbox::deltaR(vProbe.Eta(), vProbe.Phi(), glep1->Eta(), glep1->Phi())<0.1) ||
((glep2) && toolbox::deltaR(vProbe.Eta(), vProbe.Phi(), glep2->Eta(), glep2->Phi())<0.1) );
if(match1 && match2) {
hasGenMatch = kTRUE;
if (gvec!=0) {
genV=new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(gvec->Pt(), gvec->Eta(), gvec->Phi(), gvec->M());
genVPt = gvec->Pt();
genVPhi = gvec->Phi();
genVy = gvec->Rapidity();
genVMass = gvec->M();
}
else {
TLorentzVector tvec=*lep1+*lep2;
genV=new TLorentzVector(0,0,0,0);
genV->SetPtEtaPhiM(tvec.Pt(), tvec.Eta(), tvec.Phi(), tvec.M());
genVPt = tvec.Pt();
genVPhi = tvec.Phi();
genVy = tvec.Rapidity();
genVMass = tvec.M();
}
delete gvec;
delete glep1;
delete glep2;
glep1=0; glep2=0; gvec=0;
}
else {
genV = new TLorentzVector(0,0,0,0);
genVPt = -999;
genVPhi = -999;
genVy = -999;
genVMass = -999;
}
}
if (hasGen) {
id_1 = gen->id_1;
id_2 = gen->id_2;
x_1 = gen->x_1;
x_2 = gen->x_2;
xPDF_1 = gen->xPDF_1;
xPDF_2 = gen->xPDF_2;
scalePDF = gen->scalePDF;
weightPDF = gen->weight;
}
else {
id_1 = -999;
id_2 = -999;
x_1 = -999;
x_2 = -999;
xPDF_1 = -999;
xPDF_2 = -999;
scalePDF = -999;
weightPDF = -999;
}
//
// Fill tree
//
runNum = info->runNum;
lumiSec = info->lumiSec;
evtNum = info->evtNum;
if (hasGenMatch) matchGen=1;
else matchGen=0;
category = icat;
npv = 0;
npu = info->nPU;
scale1fb = weight;
met = info->pfMET;
metPhi = info->pfMETphi;
sumEt = 0;
tkMet = info->trkMET;
tkMetPhi = info->trkMETphi;
tkSumEt = 0;
mvaMet = info->mvaMET;
mvaMetPhi = info->mvaMETphi;
mvaSumEt = 0;
ppMet = 0;
ppMetPhi = 0;
ppSumEt = 0;
lep1 = &vTag;
lep2 = &vProbe;
dilep = &vDilep;
q1 = tag->q;
q2 = (tkProbe) ? tkProbe->q : -(tag->q);
TVector2 vZPt((vDilep.Pt())*cos(vDilep.Phi()),(vDilep.Pt())*sin(vDilep.Phi()));
TVector2 vMet((info->pfMET)*cos(info->pfMETphi), (info->pfMET)*sin(info->pfMETphi));
TVector2 vU = -1.0*(vMet+vZPt);
u1 = ((vDilep.Px())*(vU.Px()) + (vDilep.Py())*(vU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
u2 = ((vDilep.Px())*(vU.Py()) - (vDilep.Py())*(vU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vTkMet((info->trkMET)*cos(info->trkMETphi), (info->trkMET)*sin(info->trkMETphi));
TVector2 vTkU = -1.0*(vTkMet+vZPt);
tkU1 = ((vDilep.Px())*(vTkU.Px()) + (vDilep.Py())*(vTkU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
tkU2 = ((vDilep.Px())*(vTkU.Py()) - (vDilep.Py())*(vTkU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
TVector2 vMvaMet((info->mvaMET)*cos(info->mvaMETphi), (info->mvaMET)*sin(info->mvaMETphi));
TVector2 vMvaU = -1.0*(vMvaMet+vZPt);
mvaU1 = ((vDilep.Px())*(vMvaU.Px()) + (vDilep.Py())*(vMvaU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
mvaU2 = ((vDilep.Px())*(vMvaU.Py()) - (vDilep.Py())*(vMvaU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
//TVector2 vPpMet((info->ppMET)*cos(info->ppMETphi), (info->ppMET)*sin(info->ppMETphi));
//TVector2 vPpU = -1.0*(vPpMet+vZPt);
//ppU1 = ((vDilep.Px())*(vPpU.Px()) + (vDilep.Py())*(vPpU.Py()))/(vDilep.Pt()); // u1 = (pT . u)/|pT|
//ppU2 = ((vDilep.Px())*(vPpU.Py()) - (vDilep.Py())*(vPpU.Px()))/(vDilep.Pt()); // u2 = (pT x u)/|pT|
///// electron specific /////
sc1 = &vTagSC;
trkIso1 = tag->trkIso;
emIso1 = tag->ecalIso;
hadIso1 = tag->hcalIso;
pfChIso1 = tag->chHadIso;
pfGamIso1 = tag->gammaIso;
pfNeuIso1 = tag->neuHadIso;
pfCombIso1 = tag->chHadIso + TMath::Max(tag->neuHadIso + tag->gammaIso -
(info->rhoIso)*getEffAreaEl(tag->eta), 0.);
/* sigieie1 = tag->sieie;
hovere1 = tag->hovere;
eoverp1 = tag->eoverp;
fbrem1 = tag->fbrem;
dphi1 = tag->dPhiIn;
deta1 = tag->dEtaIn;
ecalE1 = 0;
d01 = tag->d0;
dz1 = tag->dz;
isConv1 = tag->isConv;
nexphits1 = tag->nMissingHits;
typeBits1 = tag->typeBits;*/
sc2 = &vProbeSC;
trkIso2 = (tkProbe) ? tkProbe->trkIso : -1;
emIso2 = (tkProbe) ? tkProbe->ecalIso : -1;
hadIso2 = (tkProbe) ? tkProbe->hcalIso : -1;
pfChIso2 = (tkProbe) ? tkProbe->chHadIso : -1;
pfGamIso2 = (tkProbe) ? tkProbe->gammaIso : -1;
pfNeuIso2 = (tkProbe) ? tkProbe->neuHadIso : -1;
pfCombIso2 = (tkProbe) ?
tkProbe->chHadIso + TMath::Max(tkProbe->neuHadIso + tkProbe->gammaIso -
(info->rhoIso)*getEffAreaEl(tkProbe->eta), 0.) : -1;
/* sigieie2 = (tkProbe) ? tkProbe->sieie : scProbe->sieie;
hovere2 = (tkProbe) ? tkProbe->hovere : scProbe->hovere;
eoverp2 = (tkProbe) ? tkProbe->eoverp : -1;
fbrem2 = (tkProbe) ? tkProbe->fbrem : -1;
dphi2 = (tkProbe) ? tkProbe->dPhiIn : -999;
deta2 = (tkProbe) ? tkProbe->dEtaIn : -999;
ecalE2 = (tkProbe) ? 0 : -999;
d02 = (tkProbe) ? tkProbe->d0 : -999;
dz2 = (tkProbe) ? tkProbe->dz : -999;
isConv2 = (tkProbe) ? tkProbe->isConv : 0;
nexphits2 = (tkProbe) ? tkProbe->nMissingHits : 0;
typeBits2 = (tkProbe) ? tkProbe->typeBits : 0; */
outTree->Fill();
delete genV;
genV=0, dilep=0, lep1=0, lep2=0, sc1=0, sc2=0;
}
}
}
delete infile;
infile=0, eventTree=0;
cout << nsel << " +/- " << sqrt(nselvar);
if(isam!=0) cout << " per 1/fb";
cout << endl;
}
outFile->Write();
outFile->Close();
}
delete info;
delete gen;
delete genPartArr;
delete electronArr;
delete scArr;
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << " Z -> e e" << endl;
cout << " Mass window: [" << MASS_LOW << ", " << MASS_HIGH << "]" << endl;
cout << " pT > " << PT_CUT << endl;
cout << " |eta| < " << ETA_CUT << endl;
if(doScaleCorr)
cout << " *** Scale corrections applied ***" << endl;
cout << endl;
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
gBenchmark->Show("selectZee");
}
