int main (int argc, char** argv) {
// load framework libraries
gSystem->Load( "libFWCoreFWLite" );
//gSystem->Load("libNtupleMakerBEANmaker.so");
AutoLibraryLoader::enable();
int debug = 0; // levels of debug, 10 is large
JobParameters myConfig = parseJobOptions(argc, argv);
TFile * outputFile = new TFile (myConfig.outputFileName.c_str(), "RECREATE");
outputFile->cd();
TTree * summaryTree = new TTree("summaryTree", "Summary Event Values");
fwlite::ChainEvent ev(myConfig.inputFileNames);
HelperLeptonCore lepHelper;
BEANhelper * beanHelper = lepHelper.setupAnalysisParameters("2012_53x", myConfig.sampleName);
sysType::sysType jetSyst = sysType::NA;
if (myConfig.jetSyst == "NA") jetSyst = sysType::NA;
else if (myConfig.jetSyst == "JESUp") jetSyst = sysType::JESup;
else if (myConfig.jetSyst == "JESDown") jetSyst = sysType::JESdown;
else std::cout << "No valid JES corrections specified - using nominal" << std::endl;
muonID::muonID muonTightID = muonID::muonSideTightMVA;
muonID::muonID muonLooseID = muonID::muonSideLooseMVA;
muonID::muonID muonPreselectedID = muonID::muonSide;
electronID::electronID electronTightID = electronID::electronSideTightMVA;
electronID::electronID electronLooseID = electronID::electronSideLooseMVA;
electronID::electronID electronPreselectedID = electronID::electronSide;
tauID::tauID tauTightID = tauID::tauMedium;
tauID::tauID tauLooseID = tauID::tauLoose;
tauID::tauID tauPreselectedID = tauID::tauNonIso;
// collections
GenericCollection<BNelectronCollection> tightElectrons(beanHelper);
GenericCollection<BNelectronCollection> looseElectrons(beanHelper);
GenericCollection<BNelectronCollection> preselectedElectrons(beanHelper);
GenericCollection<BNelectronCollection> tightLooseElectrons(beanHelper);
GenericCollection<BNelectronCollection> loosePreselectedElectrons(beanHelper);
GenericCollection<BNelectronCollection> tightLoosePreselectedElectrons(beanHelper);
GenericCollection<BNmuonCollection> tightMuons(beanHelper);
GenericCollection<BNmuonCollection> looseMuons(beanHelper);
GenericCollection<BNmuonCollection> preselectedMuons(beanHelper);
GenericCollection<BNmuonCollection> tightLooseMuons(beanHelper);
GenericCollection<BNmuonCollection> tightLoosePreselectedMuons(beanHelper);
GenericCollection<BNleptonCollection> tightLeptons(beanHelper);
GenericCollection<BNleptonCollection> looseLeptons(beanHelper);
GenericCollection<BNleptonCollection> preselectedLeptons(beanHelper);
GenericCollection<BNleptonCollection> tightLooseLeptons(beanHelper);
GenericCollection<BNleptonCollection> tightLoosePreselectedLeptons(beanHelper);
GenericCollection<BNtauCollection> tightTaus(beanHelper);
GenericCollection<BNtauCollection> tightLooseTaus(beanHelper);
GenericCollection<BNtauCollection> tightLoosePreselectedTaus(beanHelper);
GenericCollection<BNjetCollection> jets(beanHelper);
GenericCollection<BNjetCollection> jetsByCSV(beanHelper);
GenericCollection<BNjetCollection> looseCSVJets(beanHelper);
GenericCollection<BNjetCollection> mediumCSVJets(beanHelper);
GenericCollection<BNjetCollection> notLooseCSVJets(beanHelper);
GenericCollection<BNjetCollection> jetsForLepMVA(beanHelper);
GenericCollection<BNjetCollection> jetsClosestToLep1(beanHelper);
GenericCollection<BNmetCollection> met(beanHelper);
GenericCollection<BNprimaryvertexCollection> primaryVertexes(beanHelper);
GenericCollection<BNtriggerCollection> hltCollection(beanHelper);
GenericCollection<BNeventCollection> events(beanHelper);
GenericCollection<BNmcparticleCollection> mcParticles(beanHelper);
GenericCollection<BNmcparticleCollection> genHiggsParticles(beanHelper);
GenericCollection<BNmcparticleCollection> genTopParticles(beanHelper);
GenericCollection<BNmcparticleCollection> genAntiTopParticles(beanHelper);
GenericCollection<BNmcparticleCollection> genTTbarParticles(beanHelper);
// declare the kinematic variables that you want to be written out into the tree
vector<ArbitraryVariable*> kinVars;
vector<ArbitraryVariable*> cutVars;
////////////////////////// corrections, weights, etc
CSVWeights myCSV(beanHelper, &(jets.ptrToItems), jetSyst);
kinVars.push_back(&myCSV);
//Btag POG version
vector<pair<string, double>> WPs = {make_pair("CSVT", 0.898), make_pair("CSVM", 0.679), make_pair("CSVL", 0.244)};
BTagWeights myBTagWeights(WPs, &(jets.ptrToItems));
kinVars.push_back(&myBTagWeights);
PUWeights myPU(&lepHelper, &(events.ptrToItems));
kinVars.push_back(&myPU);
TopPtWeights myTopPt(&lepHelper, &(mcParticles.ptrToItems));
kinVars.push_back(&myTopPt);
//Currently, gets ND loose lepton SF; could switch to tight and loose - AWB Feb 12, 2014
//LeptonIDAndIsoScaleFactors myLepIDAndIsoSF(&lepHelper, muonID::muonTight, muonID::muonLoose, electronID::electronTight, electronID::electronLoose);
LeptonIDAndIsoScaleFactors myLepIDAndIsoSF(&lepHelper, muonTightID, muonLooseID, electronTightID, electronLooseID,
&(tightMuons.ptrToItems), &(looseMuons.ptrToItems),
&(tightElectrons.ptrToItems), &(looseElectrons.ptrToItems));
kinVars.push_back(&myLepIDAndIsoSF);
//CERN version
RecoIDIsoSIPSFs myRecoIDIsoSIPSFs(2, &(tightLoosePreselectedLeptons.ptrToItems));
kinVars.push_back(&myRecoIDIsoSIPSFs);
LeptonTriggerScaleFactors
myLepTrig(&lepHelper, &(tightMuons.ptrToItems), &(looseMuons.ptrToItems), &(preselectedMuons.ptrToItems),
&(tightElectrons.ptrToItems), &(looseElectrons.ptrToItems), &(preselectedElectrons.ptrToItems));
kinVars.push_back(&myLepTrig);
TightChargeAndLepMVAScaleFactors myTightChargeAndLepMVASFs(2, &(tightLoosePreselectedLeptons.ptrToItems));
kinVars.push_back(&myTightChargeAndLepMVASFs);
CleanEventVars myClean(&lepHelper, &(events.ptrToItems), &(primaryVertexes.ptrToItems));
kinVars.push_back(&myClean);
CheckTwoLepTrigger checkTrig(&lepHelper, &(hltCollection.ptrToItems));
kinVars.push_back(&checkTrig);
DataDrivenFR<BNleptonCollection>
myDataDrivenFRAllLeptons(&lepHelper, &(tightLoosePreselectedLeptons.ptrToItems), &(mediumCSVJets.ptrToItems), 2, 0.7, "FR_merged_data", "QF_data_el");
kinVars.push_back(&myDataDrivenFRAllLeptons);
DataDrivenFR<BNleptonCollection>
myDataDrivenFRAllLeptonsLoose(&lepHelper, &(tightLoosePreselectedLeptons.ptrToItems), &(mediumCSVJets.ptrToItems), 2, -0.3, "FR_merged_data", "QF_data_el", "_Loose");
kinVars.push_back(&myDataDrivenFRAllLeptonsLoose);
HiggsDecayType myHiggsDecayType(&lepHelper, &(mcParticles.ptrToItems));
kinVars.push_back(&myHiggsDecayType);
TightCharges myTightCharges(&(tightLoosePreselectedLeptons.ptrToItems), "CERN_tight_charge", "all_leptons_by_pt", 2);
kinVars.push_back(&myTightCharges);
//myTightCharges.setCut("pass");
////////////////////////// collection sizes
GenericCollectionSizeVariable<BNjetCollection> numJets(&(jets.ptrToItems), "numJets");
kinVars.push_back(&numJets);
numJets.setCutMin(2);
//cutVars.push_back(&numJets);
GenericCollectionSizeVariable<BNjetCollection> numLooseBJets(&(looseCSVJets.ptrToItems), "numLooseBJets");
kinVars.push_back(&numLooseBJets);
GenericCollectionSizeVariable<BNjetCollection> numMediumBJets(&(mediumCSVJets.ptrToItems), "numMediumBJets");
kinVars.push_back(&numMediumBJets);
GenericCollectionSizeVariable<BNjetCollection> numJetsClosestToLep1(&(jetsClosestToLep1.ptrToItems), "numJetsClosestToLep1");
kinVars.push_back(&numJetsClosestToLep1);
GenericCollectionSizeVariable<BNmuonCollection> numAllMuons(&(tightLoosePreselectedMuons.ptrToItems), "numAllMuons");
kinVars.push_back(&numAllMuons);
GenericCollectionSizeVariable<BNelectronCollection> numAllElectrons(&(tightLoosePreselectedElectrons.ptrToItems), "numAllElectrons");
kinVars.push_back(&numAllElectrons);
GenericCollectionSizeVariable<BNleptonCollection> numAllLeptons(&(tightLoosePreselectedLeptons.ptrToItems), "numAllLeptons");
kinVars.push_back(&numAllLeptons);
GenericCollectionSizeVariable<BNleptonCollection> numTightLooseLeptons(&(tightLooseLeptons.ptrToItems), "numTightLooseLeptons");
kinVars.push_back(&numTightLooseLeptons);
GenericCollectionSizeVariable<BNmuonCollection> numTightMuons(&(tightMuons.ptrToItems), "numTightMuons");
kinVars.push_back(&numTightMuons);
GenericCollectionSizeVariable<BNelectronCollection> numTightElectrons(&(tightElectrons.ptrToItems), "numTightElectrons");
kinVars.push_back(&numTightElectrons);
GenericCollectionSizeVariable<BNleptonCollection> numTightLeptons(&(tightLeptons.ptrToItems), "numTightLeptons");
kinVars.push_back(&numTightLeptons);
if (myConfig.sampleName.find("NP_sideband") == std::string::npos) { //All samples except NP_sideband
std::cout << "Sample is not a sideband" << std::endl;
numTightLeptons.setCutMin(2);
}
else if (myConfig.sampleName.find("NP_sideband") != std::string::npos) { //NP_sideband samples
std::cout << "Sample is a sideband" << std::endl;
//Cut to require opposite-sign leptons
numTightLeptons.setCutMin(0);
}
cutVars.push_back(&numTightLeptons);
GenericCollectionSizeVariable<BNtauCollection> numAllTaus(&(tightLoosePreselectedTaus.ptrToItems), "numAllTaus");
kinVars.push_back(&numAllTaus);
GenericCollectionSizeVariable<BNtauCollection> numTightLooseTaus(&(tightLooseTaus.ptrToItems), "numTightLooseTaus");
kinVars.push_back(&numTightLooseTaus);
GenericCollectionSizeVariable<BNtauCollection> numTightTaus(&(tightTaus.ptrToItems), "numTightTaus");
kinVars.push_back(&numTightTaus);
////////////////////////// lep MVAs
LepMVAs<BNleptonCollection> myLepMVAsTightLeptons(&lepHelper, &(tightLeptons.ptrToItems), "tight_leptons_by_pt", 2);
kinVars.push_back(&myLepMVAsTightLeptons);
LepMVAs<BNleptonCollection> myLepMVAsLooseLeptons(&lepHelper, &(looseLeptons.ptrToItems), "loose_leptons_by_pt", 2);
kinVars.push_back(&myLepMVAsLooseLeptons);
LepMVAs<BNleptonCollection> myLepMVAsPreselectedLeptons(&lepHelper, &(preselectedLeptons.ptrToItems), "preselected_leptons_by_pt", 2);
kinVars.push_back(&myLepMVAsPreselectedLeptons);
LepMVAs<BNleptonCollection> myLepMVAsAllLeptons(&lepHelper, &(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 3);
kinVars.push_back(&myLepMVAsAllLeptons);
LepMVAs<BNmuonCollection> myLepMVAsAllMuons(&lepHelper, &(tightLoosePreselectedMuons.ptrToItems), "all_muons_by_pt", 3);
kinVars.push_back(&myLepMVAsAllMuons);
////////////////////////// composite objects
TwoObjectKinematic<BNleptonCollection, BNmetCollection>
mySumLep1Lep2MetPt("pt", "sum", "sum_lep1pt_lep2pt_met",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 2,
&(met.ptrToItems), "met", 1, 1);
kinVars.push_back(&mySumLep1Lep2MetPt);
TwoObjectKinematic<BNleptonCollection, BNleptonCollection>
myMinMassLepLep("mass", "min", "min_mass_leplep",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99);
kinVars.push_back(&myMinMassLepLep);
TwoObjectKinematic<BNleptonCollection,BNleptonCollection>
myMinMassLepLepSFOS("mass", "min", "min_mass_leplep_SFOS",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
-99, "same_flavour", "opposite_sign");
kinVars.push_back(&myMinMassLepLepSFOS);
TwoObjectKinematic<BNleptonCollection,BNleptonCollection>
myZLikeMassLepLepSFOS("mass", "closest_to", "ZLike_mass_leplep_SFOS",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
91.2, "same_flavour", "opposite_sign");
kinVars.push_back(&myZLikeMassLepLepSFOS);
TwoObjectKinematic<BNleptonCollection, BNleptonCollection>
myMinDeltaRLepLep("deltaR", "min", "min_dR_leplep",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99);
kinVars.push_back(&myMinDeltaRLepLep);
TwoObjectKinematic<BNjetCollection, BNjetCollection>
myHiggsLikeDijetMass110("mass", "closest_to", "higgsLike_dijet_mass",
&(mediumCSVJets.ptrToItems), "medium_btags_by_pt", 1, 99,
&(mediumCSVJets.ptrToItems), "medium_btags_by_pt", 1, 99, 110);
kinVars.push_back(&myHiggsLikeDijetMass110);
TwoObjectKinematic<BNtauCollection, BNjetCollection>
myMinDeltaRTau1Jet("deltaR", "min", "min_deltaR_tau1_jet",
&(tightLoosePreselectedTaus.ptrToItems), "all_taus_by_pt", 1, 1,
&(jets.ptrToItems), "jets_by_pt", 1, 99);
kinVars.push_back(&myMinDeltaRTau1Jet);
TwoObjectKinematic<BNtauCollection, BNleptonCollection>
myMassTau1Leptons("mass", "all_pairs", "",
&(tightLoosePreselectedTaus.ptrToItems), "all_taus_by_pt", 1, 1,
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 2);
kinVars.push_back(&myMassTau1Leptons);
//Variables for CERN same-sign dilepton BDT
TwoObjectKinematic<BNleptonCollection, BNjetCollection>
myMHT("pt", "vector_sum", "mht",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
&(jets.ptrToItems), "jets_by_pt", 1, 99);
kinVars.push_back(&myMHT);
TwoObjectKinematic<BNleptonCollection, BNjetCollection>
myMinDeltaRLep1Jet("deltaR", "min", "min_deltaR_lep1_jet",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 1,
&(jets.ptrToItems), "jets_by_pt", 1, 99);
kinVars.push_back(&myMinDeltaRLep1Jet);
TwoObjectKinematic<BNleptonCollection, BNjetCollection>
myMinDeltaRLep2Jet("deltaR", "min", "min_deltaR_lep2_jet",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 2, 2,
&(jets.ptrToItems), "jets_by_pt", 1, 99);
kinVars.push_back(&myMinDeltaRLep2Jet);
TwoObjectKinematic<BNleptonCollection, BNjetCollection>
myMinDeltaRLep3Jet("deltaR", "min", "mindr_lep3_jet",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 3, 3,
&(jets.ptrToItems), "jets_by_pt", 1, 99);
kinVars.push_back(&myMinDeltaRLep3Jet);
TwoObjectKinematic<BNmetCollection, BNleptonCollection>
myMtMetLep("MT", "all_pairs", "",
&(met.ptrToItems), "met", 1, 1,
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 2);
kinVars.push_back(&myMtMetLep);
TwoObjectKinematic<BNleptonCollection,BNjetCollection>
mySumPt("pt", "sum", "sum_pt",
&(tightLoosePreselectedLeptons.ptrToItems), "all_leptons_by_pt", 1, 99,
&(jets.ptrToItems), "jets_by_pt", 1, 99);
kinVars.push_back(&mySumPt);
int TwoMuon = 0;
int TwoElectron = 0;
int MuonElectron = 0;
Char_t *dataset = (Char_t *)lepHelper.dataset.c_str();
int sampleNumber = (int)lepHelper.sampleNumber;
double weight_Xsec = (double)lepHelper.weight_Xsec;
int nGen = (int)lepHelper.nGen;
double Xsec = (double)lepHelper.Xsec;
summaryTree->Branch("sampleNumber", &sampleNumber);
summaryTree->Branch("weight_Xsec", &weight_Xsec);
summaryTree->Branch("nGen", &nGen);
summaryTree->Branch("Xsec", &Xsec);
summaryTree->Branch("TwoMuon", &TwoMuon);
summaryTree->Branch("TwoElectron", &TwoElectron);
summaryTree->Branch("MuonElectron", &MuonElectron);
summaryTree->Branch("dataset", (void*)dataset, "dataset/C");
////////// all leptons //////////
GenericCollectionMember<int, BNleptonCollection>
allLeptonNumberOfValidTrackerHitsInnerTrack(Reflex::Type::ByName("BNlepton"),
&(tightLoosePreselectedLeptons.ptrToItems),
"numberOfValidTrackerHitsInnerTrack", "all_leptons_by_pt",
KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allLeptonNumberOfValidTrackerHitsInnerTrack);
GenericCollectionMember<double, BNleptonCollection>
allLeptonInnerTkPt(Reflex::Type::ByName("BNlepton"),
&(tightLoosePreselectedLeptons.ptrToItems), "innerTrackPt",
"all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonInnerTkPt);
GenericCollectionMember<double, BNleptonCollection>
allLeptonInnerTkPtError(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems),
"innerTrackPtError", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonInnerTkPtError);
GenericCollectionMember<double, BNleptonCollection>
allLeptonJetDeltaR(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "jetDeltaR", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonJetDeltaR);
GenericCollectionMember<double, BNleptonCollection>
allLeptonJetPtRatio(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "jetPtRatio", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonJetPtRatio);
GenericCollectionMember<double, BNleptonCollection>
allLeptonJetBTagCSV(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "jetBTagCSV", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonJetBTagCSV);
GenericCollectionMember<double, BNleptonCollection>
allLeptonMvaNonTrigV0(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "mvaNonTrigV0", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonMvaNonTrigV0);
GenericCollectionMember<int, BNleptonCollection>
allLeptonNumberOfExpectedInnerHits(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "numberOfExpectedInnerHits", "all_leptons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allLeptonNumberOfExpectedInnerHits);
GenericCollectionMember<int, BNleptonCollection>
allLeptonIsGsfCtfScPixChargeConsistent(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "isGsfCtfScPixChargeConsistent", "all_leptons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allLeptonIsGsfCtfScPixChargeConsistent);
GenericCollectionMember<double, BNleptonCollection>
allLeptonPt(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "pt", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonPt);
GenericCollectionMember<double, BNleptonCollection>
allLeptonTkPT(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "tkPT", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonTkPT);
GenericCollectionMember<double, BNleptonCollection>
allLeptonEta(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "eta", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonEta);
GenericCollectionMember<int, BNleptonCollection>
allLeptonIsMuon(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "isMuon", "all_leptons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allLeptonIsMuon);
GenericCollectionMember<int, BNleptonCollection>
allLeptonIsElectron(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "isElectron", "all_leptons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allLeptonIsElectron);
GenericCollectionMember<int, BNleptonCollection>
allLeptonTkCharge(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "tkCharge", "all_leptons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allLeptonTkCharge);
if (myConfig.sampleName.find("QF_sideband") == std::string::npos) { //All samples except QF_sideband
//Cut to require same-sign leptons
auto tkChargeCut = [] (vector<BranchInfo<int>> vars) { return ((vars[0].branchVal * vars[1].branchVal) > 0 || abs(vars[2].branchVal) == 1 ); };
allLeptonTkCharge.setCut(tkChargeCut);
}
else if (myConfig.sampleName.find("QF_sideband") != std::string::npos) { //QF_sideband samples
//Cut to require opposite-sign leptons
auto tkChargeCut = [] (vector<BranchInfo<int>> vars) { return ((vars[0].branchVal * vars[1].branchVal) < 0); };
allLeptonTkCharge.setCut(tkChargeCut);
}
cutVars.push_back(&allLeptonTkCharge);
GenericCollectionMember<double, BNleptonCollection>
allLeptonSIP(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "SIP", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonSIP);
GenericCollectionMember<double, BNleptonCollection>
allLeptonD0(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "correctedD0Vertex", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonD0);
GenericCollectionMember<double, BNleptonCollection>
allLeptonDZ(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "correctedDZ", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonDZ);
GenericCollectionMember<double, BNleptonCollection>
allLeptonIP(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "IP", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonIP);
GenericCollectionMember<double, BNleptonCollection>
allLeptonIPError(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "IPError", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonIPError);
GenericCollectionMember<double, BNleptonCollection>
allLeptonPhi(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "phi", "all_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&allLeptonPhi);
GenericCollectionMember<int, BNleptonCollection>
allLeptonGlobalMuon(Reflex::Type::ByName("BNlepton"), &(tightLoosePreselectedLeptons.ptrToItems), "isGlobalMuon", "all_leptons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allLeptonGlobalMuon);
////////// all muons //////////
GenericCollectionMember<int, BNmuonCollection>
allMuonPFmuon(Reflex::Type::ByName("BNmuon"), &(tightLoosePreselectedMuons.ptrToItems), "isPFMuon", "all_muons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allMuonPFmuon);
GenericCollectionMember<int, BNmuonCollection>
allMuonGlobalMuon(Reflex::Type::ByName("BNmuon"), &(tightLoosePreselectedMuons.ptrToItems), "isGlobalMuon", "all_muons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allMuonGlobalMuon);
GenericCollectionMember<int, BNmuonCollection>
allMuonTrackerMuon(Reflex::Type::ByName("BNmuon"), &(tightLoosePreselectedMuons.ptrToItems), "isTrackerMuon", "all_muons_by_pt", KinematicVariableConstants::INT_INIT, 4);
kinVars.push_back(&allMuonTrackerMuon);
GenericCollectionMember<double, BNmuonCollection>
allMuonPt(Reflex::Type::ByName("BNmuon"), &(tightLoosePreselectedMuons.ptrToItems), "pt", "all_muons_by_pt", KinematicVariableConstants::FLOAT_INIT, 2);
kinVars.push_back(&allMuonPt);
GenericCollectionMember<double, BNmuonCollection>
allMuonEta(Reflex::Type::ByName("BNmuon"), &(tightLoosePreselectedMuons.ptrToItems), "eta", "all_muons_by_pt", KinematicVariableConstants::FLOAT_INIT, 2);
kinVars.push_back(&allMuonEta);
////////// all electrons //////////
GenericCollectionMember<int, BNelectronCollection>
allElectronNumExpInnerHits(Reflex::Type::ByName("BNelectron"), &(tightLoosePreselectedElectrons.ptrToItems), "numberOfExpectedInnerHits", "all_electrons_by_pt", KinematicVariableConstants::INT_INIT, 2);
kinVars.push_back(&allElectronNumExpInnerHits);
GenericCollectionMember<int, BNelectronCollection>
allElectronPassConvVeto(Reflex::Type::ByName("BNelectron"), &(tightLoosePreselectedElectrons.ptrToItems), "passConvVeto", "all_electrons_by_pt", KinematicVariableConstants::INT_INIT, 2);
kinVars.push_back(&allElectronPassConvVeto);
GenericCollectionMember<double, BNelectronCollection>
allElectronEta(Reflex::Type::ByName("BNelectron"), &(tightLoosePreselectedElectrons.ptrToItems), "eta", "all_electrons_by_pt", KinematicVariableConstants::FLOAT_INIT, 2);
kinVars.push_back(&allElectronEta);
GenericCollectionMember<double, BNelectronCollection>
allElectronPt(Reflex::Type::ByName("BNelectron"), &(tightLoosePreselectedElectrons.ptrToItems), "pt", "all_electrons_by_pt", KinematicVariableConstants::FLOAT_INIT, 2);
kinVars.push_back(&allElectronPt);
////////// tight leptons /////////
GenericCollectionMember<double, BNleptonCollection>
tightLeptonInnerTkPt(Reflex::Type::ByName("BNlepton"), &(tightLeptons.ptrToItems), "innerTrackPt", "tight_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&tightLeptonInnerTkPt);
GenericCollectionMember<double, BNleptonCollection>
tightLeptonInnerTkPtError(Reflex::Type::ByName("BNlepton"), &(tightLeptons.ptrToItems), "innerTrackPtError", "tight_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&tightLeptonInnerTkPtError);
GenericCollectionMember<double, BNleptonCollection>
tightLeptonPt(Reflex::Type::ByName("BNlepton"), &(tightLeptons.ptrToItems), "pt", "tight_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&tightLeptonPt);
GenericCollectionMember<double, BNleptonCollection>
tightLeptonEta(Reflex::Type::ByName("BNlepton"), &(tightLeptons.ptrToItems), "eta", "tight_leptons_by_pt", KinematicVariableConstants::FLOAT_INIT, 4);
kinVars.push_back(&tightLeptonEta);
////////// all taus //////////
GenericCollectionMember<double, BNtauCollection>
allTauPt(Reflex::Type::ByName("BNtau"), &(tightLoosePreselectedTaus.ptrToItems), "pt", "all_taus_by_pt", KinematicVariableConstants::FLOAT_INIT, 2);
kinVars.push_back(&allTauPt);
GenericCollectionMember<double, BNtauCollection>
allTauEta(Reflex::Type::ByName("BNtau"), &(tightLoosePreselectedTaus.ptrToItems), "eta", "all_taus_by_pt", KinematicVariableConstants::FLOAT_INIT, 2);
kinVars.push_back(&allTauEta);
////////// all jets //////////
GenericCollectionMember<double, BNjetCollection>
allJetPt(Reflex::Type::ByName("BNjet"), &(jets.ptrToItems), "pt", "jets_by_pt", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetPt);
GenericCollectionMember<double, BNjetCollection>
allJetEta(Reflex::Type::ByName("BNjet"), &(jets.ptrToItems), "eta", "jets_by_pt", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetEta);
GenericCollectionMember<double, BNjetCollection>
allJetPhi(Reflex::Type::ByName("BNjet"), &(jets.ptrToItems), "phi", "jets_by_pt", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetPhi);
GenericCollectionMember<double, BNjetCollection>
allJetCSV(Reflex::Type::ByName("BNjet"), &(jets.ptrToItems), "btagCombinedSecVertex", "jets_by_pt", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetCSV);
////////// all jets, ordered by CSV //////////
GenericCollectionMember<double, BNjetCollection>
allJetByCSVPt(Reflex::Type::ByName("BNjet"), &(jetsByCSV.ptrToItems), "pt", "jets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetByCSVPt);
GenericCollectionMember<double, BNjetCollection>
allJetByCSVEta(Reflex::Type::ByName("BNjet"), &(jetsByCSV.ptrToItems), "eta", "jets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetByCSVEta);
GenericCollectionMember<double, BNjetCollection>
allJetByCSVPhi(Reflex::Type::ByName("BNjet"), &(jetsByCSV.ptrToItems), "phi", "jets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetByCSVPhi);
GenericCollectionMember<double, BNjetCollection>
allJetByCSVCSV(Reflex::Type::ByName("BNjet"), &(jetsByCSV.ptrToItems), "btagCombinedSecVertex", "jets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&allJetByCSVCSV);
////////// lepMVA jets //////////
GenericCollectionMember<double, BNjetCollection>
lepMVAJetPt(Reflex::Type::ByName("BNjet"), &(jetsForLepMVA.ptrToItems), "pt", "lepMVAjets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&lepMVAJetPt);
GenericCollectionMember<double, BNjetCollection>
lepMVAJetEta(Reflex::Type::ByName("BNjet"), &(jetsForLepMVA.ptrToItems), "eta", "lepMVAjets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&lepMVAJetEta);
GenericCollectionMember<double, BNjetCollection>
lepMVAJetPhi(Reflex::Type::ByName("BNjet"), &(jetsForLepMVA.ptrToItems), "phi", "lepMVAjets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&lepMVAJetPhi);
GenericCollectionMember<double, BNjetCollection>
lepMVAJetCSV(Reflex::Type::ByName("BNjet"), &(jetsForLepMVA.ptrToItems), "btagCombinedSecVertex", "lepMVAjets_by_CSV", KinematicVariableConstants::FLOAT_INIT, 6);
kinVars.push_back(&lepMVAJetCSV);
////////// met //////////
GenericCollectionMember<double, BNmetCollection>
metPt(Reflex::Type::ByName("BNmet"), &(met.ptrToItems), "pt", "met", KinematicVariableConstants::FLOAT_INIT, 1);
kinVars.push_back(&metPt);
// GenericCollectionMember<double, BNmetCollection>
// met1d(Reflex::Type::ByName("BNmet"), &(selectedCollections.metpfType1CorrectedMetBNCollection), "pt", "metpfType1CorrectedMetBN", KinematicVariableConstants::FLOAT_INIT, 1);
// kinVars.push_back(&met1d);
int numExtraPartons = -99;
summaryTree->Branch("numExtraPartons", &numExtraPartons);
////////// event info //////////
GenericCollectionMember<unsigned, BNeventCollection>
runNumber(Reflex::Type::ByName("BNevent"), &(events.ptrToItems), "run", "eventInfo", KinematicVariableConstants::UINT_INIT, 1);
kinVars.push_back(&runNumber);
GenericCollectionMember<unsigned, BNeventCollection>
lumiBlock(Reflex::Type::ByName("BNevent"), &(events.ptrToItems), "lumi", "eventInfo", KinematicVariableConstants::UINT_INIT, 1);
kinVars.push_back(&lumiBlock);
// this is a long inside BNevent: just using keyword long won't work-- needs to be Long64_t
GenericCollectionMember<Long64_t, BNeventCollection>
eventNumber(Reflex::Type::ByName("BNevent"), &(events.ptrToItems), "evt", "eventInfo", KinematicVariableConstants::INT_INIT, 1);
kinVars.push_back(&eventNumber);
MetLD myMetLD(&myMHT, &metPt);
kinVars.push_back(&myMetLD);
FinalBDT myFinalBDT(&allLeptonEta, &allLeptonPt, &myMHT, &myMinDeltaRLep2Jet, &myMtMetLep, &mySumPt);
kinVars.push_back(&myFinalBDT);
if (debug > 9) { cout << "Hooking variables to tree" << endl;}
for (vector<ArbitraryVariable*>::iterator iVar = kinVars.begin();
iVar != kinVars.end();
iVar++) {
(*iVar)->attachToTree (summaryTree);
}
int numEvents = 0;
int numEventsFailCuts = 0;
int numEventsPassCuts = 0;
int printEvery = 1000;
for (ev.toBegin(); !ev.atEnd(); ++ev){
numEvents++;
if ((numEvents > myConfig.maxEvents) && myConfig.maxEvents != -1) break;
if (numEvents == 1 || numEvents % printEvery == 0 )
cout << "Processing event.... " << numEvents << endl;
if (debug > 9) cout << "---------->>>>>> Event " << numEvents << endl;
/////////////////////////////////////////////////////////////
//
// Initialize collections and apply object ids
//
//////////////////////////////////////////////////////////////
jetsForLepMVA.initializeRawItemsSortedByCSV(ev, "BNproducer", "patJetsAK5PF");
tightLoosePreselectedMuons.initializeRawItemsSortedByPt(ev, "BNproducer","selectedPatMuonsLoosePFlow");
tightLoosePreselectedElectrons.initializeRawItemsSortedByPt(ev, "BNproducer","selectedPatElectronsGSF");
lepHelper.applyRochesterCorrections(tightLoosePreselectedMuons.rawItems);
bool applySmearing = !(lepHelper.isData);
if (applySmearing) {
lepHelper.fillMCMatchAny(tightLoosePreselectedMuons.rawItems, mcParticles.rawItems, 0.3);
lepHelper.fillMCMatchAny(tightLoosePreselectedElectrons.rawItems, mcParticles.rawItems, 0.3);
lepHelper.fillMCMatchID(tightLoosePreselectedMuons.rawItems, mcParticles.rawItems, 1.2);
lepHelper.fillMCMatchID(tightLoosePreselectedElectrons.rawItems, mcParticles.rawItems, 1.2);
lepHelper.scaleMCCollectionDZ(tightLoosePreselectedElectrons.rawItems);
lepHelper.scaleMCCollectionDZ(tightLoosePreselectedMuons.rawItems);
lepHelper.scaleMCCollectionDXY(tightLoosePreselectedElectrons.rawItems);
lepHelper.scaleMCCollectionDXY(tightLoosePreselectedMuons.rawItems);
}
lepHelper.fillSIP(tightLoosePreselectedMuons.rawItems, applySmearing);
lepHelper.fillSIP(tightLoosePreselectedElectrons.rawItems, applySmearing);
lepHelper.fillLepJetPtRatio(tightLoosePreselectedMuons.rawItems, jetsForLepMVA.rawItems, applySmearing);
lepHelper.fillLepJetPtRatio(tightLoosePreselectedElectrons.rawItems, jetsForLepMVA.rawItems, applySmearing);
lepHelper.fillLepJetDeltaR(tightLoosePreselectedMuons.rawItems, jetsForLepMVA.rawItems, applySmearing);
lepHelper.fillLepJetDeltaR(tightLoosePreselectedElectrons.rawItems, jetsForLepMVA.rawItems, applySmearing);
lepHelper.fillLepJetBTagCSV(tightLoosePreselectedMuons.rawItems, jetsForLepMVA.rawItems);
lepHelper.fillLepJetBTagCSV(tightLoosePreselectedElectrons.rawItems, jetsForLepMVA.rawItems);
tightLoosePreselectedElectrons.keepSelectedParticles(electronPreselectedID);
tightElectrons.initializeRawItems(tightLoosePreselectedElectrons.rawItems);
tightElectrons.keepSelectedParticles(electronTightID);
tightLooseElectrons.initializeRawItems(tightLoosePreselectedElectrons.rawItems);
tightLooseElectrons.keepSelectedParticles(electronLooseID);
looseElectrons.initializeRawItems(tightLoosePreselectedElectrons.rawItems);
looseElectrons.keepSelectedDifference(electronLooseID, electronTightID);
preselectedElectrons.initializeRawItems(tightLoosePreselectedElectrons.rawItems);
preselectedElectrons.keepSelectedDifference(electronPreselectedID, electronLooseID);
loosePreselectedElectrons.initializeRawItems(tightLoosePreselectedElectrons.rawItems);
loosePreselectedElectrons.addUnion({looseElectrons.items, preselectedElectrons.items});
tightLoosePreselectedMuons.keepSelectedParticles(muonPreselectedID);
tightMuons.initializeRawItems(tightLoosePreselectedMuons.rawItems);
tightMuons.keepSelectedParticles(muonTightID);
looseMuons.initializeRawItems(tightLoosePreselectedMuons.rawItems);
looseMuons.keepSelectedDifference(muonLooseID, muonTightID);
preselectedMuons.initializeRawItems(tightLoosePreselectedMuons.rawItems);
preselectedMuons.keepSelectedDifference(muonPreselectedID, muonLooseID);
tightLooseMuons.initializeRawItems(tightLoosePreselectedMuons.rawItems);
tightLooseMuons.keepSelectedParticles(muonLooseID);
// Require reset before first pushback to avoid keeping leptons from previous event
tightLeptons.resetAndPushBack(tightElectrons.items);
tightLeptons.pushBackAndSort(tightMuons.items);
looseLeptons.resetAndPushBack(looseElectrons.items);
looseLeptons.pushBackAndSort(looseMuons.items);
preselectedLeptons.resetAndPushBack(preselectedElectrons.items);
preselectedLeptons.pushBackAndSort(preselectedMuons.items);
tightLooseLeptons.resetAndPushBack(tightLooseElectrons.items);
tightLooseLeptons.pushBackAndSort(tightLooseMuons.items);
tightLoosePreselectedLeptons.resetAndPushBack(tightLoosePreselectedElectrons.items);
tightLoosePreselectedLeptons.pushBackAndSort(tightLoosePreselectedMuons.items);
tightTaus.initializeRawItemsSortedByPt(ev, "BNproducer","selectedPatTausPFlow");
tightTaus.keepSelectedParticles(tauTightID);
tightLooseTaus.initializeRawItems(tightTaus.rawItems);
tightLooseTaus.keepSelectedParticles(tauTightID);
tightLoosePreselectedTaus.initializeRawItems(tightTaus.rawItems);
tightLoosePreselectedTaus.keepSelectedParticles(tauPreselectedID);
jets.initializeRawItemsSortedByPt(ev, "BNproducer","selectedPatJetsPFlow");
jets.cleanJets(tightLoosePreselectedLeptons.items);
jets.correctRawJets(jetSyst);
jets.keepSelectedJets(25.0, 2.4, jetID::jetLoose, '-');
jetsByCSV.initializeRawItemsSortedByCSV(jets.items);
looseCSVJets.initializeRawItems(jets.rawItems);
looseCSVJets.keepSelectedJets(25.0, 2.4, jetID::jetLoose, 'L');
mediumCSVJets.initializeRawItems(jets.rawItems);
mediumCSVJets.keepSelectedJets(25.0, 2.4, jetID::jetLoose, 'M');
notLooseCSVJets.initializeRawItems(beanHelper->GetDifference(jets.items, looseCSVJets.items));
met.initializeRawItems(ev, "BNproducer","patMETsPFlow");
met.getCorrectedMet(jets);
events.initializeRawItems(ev, "BNproducer", "");
mcParticles.initializeRawItems(ev, "BNproducer", "MCstatus3");
primaryVertexes.initializeRawItems(ev, "BNproducer","offlinePrimaryVertices");
hltCollection.initializeRawItems(ev, "BNproducer", "HLT");
genHiggsParticles.initializeRawItems(mcParticles.rawItems);
auto higgsPDGID = [] (BNmcparticle p) { return (p.id == 25); };
genHiggsParticles.keepSelectedParticles(higgsPDGID);
genTopParticles.initializeRawItems(mcParticles.rawItems);
auto topPDGID = [] (BNmcparticle p) { return (p.id == 6); };
genTopParticles.keepSelectedParticles(topPDGID);
genAntiTopParticles.initializeRawItems(mcParticles.rawItems);
auto antitopPDGID = [] (BNmcparticle p) { return (p.id == -6); };
float lep1_eta = KinematicVariableConstants::FLOAT_INIT;
float lep1_phi = KinematicVariableConstants::FLOAT_INIT;
if (tightLoosePreselectedLeptons.items.size() >= 1) {
lep1_eta = tightLoosePreselectedLeptons.items.at(0)->eta;
lep1_phi = tightLoosePreselectedLeptons.items.at(0)->phi; }
float lep1_jet_deltaR = 0.7;
jetsClosestToLep1.initializeRawItems(jets.items);
auto jetsClosestToLep1Auto = [] (BNjet j, float x, float y, float z) { return (sqrt( pow(j.eta - x, 2)+pow(j.phi - y,2) ) < z); };
jetsClosestToLep1.keepSelectedParticles(jetsClosestToLep1Auto, lep1_eta, lep1_phi, lep1_jet_deltaR);
// reset all the vars
if (debug > 9) cout << "Resetting " << endl;
for (vector<ArbitraryVariable*>::iterator iVar = kinVars.begin();
iVar != kinVars.end();
iVar++) {
(*iVar)->reset();
}
bool passAllCuts = true;
if (debug > 9) cout << "Checking cuts " << endl;
for (vector<ArbitraryVariable*>::iterator iCut = cutVars.begin();
iCut != cutVars.end();
iCut++ ) {
(*iCut)->evaluate();
passAllCuts = passAllCuts && (*iCut)->passCut();
}
// do the lepton cut
passAllCuts = passAllCuts && LeptonCutThisAnalysis(tightLoosePreselectedLeptons.items);
if (!passAllCuts) {
numEventsFailCuts++;
continue; //!!!! Skip The event ///////////////
} else {
numEventsPassCuts++;
}
// Now evaluate the vars
if (debug > 9) cout << "Evaluating vars " << endl;
for (vector<ArbitraryVariable*>::iterator iVar = kinVars.begin();
iVar != kinVars.end();
iVar++) {
(*iVar)->evaluate();
}
if (debug > 9) {
for (vector<ArbitraryVariable*>::iterator iVar = kinVars.begin();
iVar != kinVars.end();
iVar++) {
(*iVar)->print();
cout << endl;
}
}
LeptonVarsThisAnalysis(tightMuons.items, tightElectrons.items, LeptonCutThisAnalysis(tightLoosePreselectedLeptons.items), TwoMuon, TwoElectron, MuonElectron);
getNumExtraPartons(beanHelper, mcParticles.items, numExtraPartons);
if (myConfig.sampleName.find("_0p") != std::string::npos) { //0 parton samples
//Cut to require 0 partons
if (numExtraPartons != 0) {
numEventsFailCuts++;
numEventsPassCuts--;
continue;
}
}
if (debug > 9) cout << "Filling tree " << endl;
summaryTree->Fill();
if (debug > 9) cout << "Done with event " << numEvents << endl;
}// end for each event
cout << "Num Events processed " << numEvents << endl
<< "Passed cuts " << numEventsPassCuts << endl
<< "Failed cuts " << numEventsFailCuts << endl ;
outputFile->Write();
outputFile->Close();
}
///
///________________________________________________________________________________
///
Bool_t
UEJetAreaFinder::find( TClonesArray& Input, vector<UEJetWithArea>& _jets )
{
/// return if no four-vectors are provided
if ( Input.GetSize() == 0 ) return kFALSE;
/// prepare input
std::vector<fastjet::PseudoJet> fjInputs;
fjInputs.reserve ( Input.GetSize() );
int iJet( 0 );
for( int i(0); i < Input.GetSize(); ++i )
{
TLorentzVector *v = (TLorentzVector*)Input.At(i);
if ( TMath::Abs(v->Eta()) > etaRegionInput ) continue;
if ( v->Pt() < ptThreshold ) continue;
fjInputs.push_back (fastjet::PseudoJet (v->Px(), v->Py(), v->Pz(), v->E()) );
fjInputs.back().set_user_index(iJet);
++iJet;
}
/// return if no four-vectors in visible phase space
if ( fjInputs.size() == 0 ) return kFALSE;
/// print out info on current jet algorithm
// cout << endl;
// cout << mJetDefinition->description() << endl;
// cout << theAreaDefinition->description() << endl;
/// return if active area is not chosen to be calculated
if ( ! theAreaDefinition ) return kFALSE;
// cout << "fastjet::ClusterSequenceActiveArea* clusterSequence" << endl;
fastjet::ClusterSequenceArea* clusterSequence
= new fastjet::ClusterSequenceArea (fjInputs, *mJetDefinition, *theAreaDefinition );
// cout << "retrieve jets for selected mode" << endl;
/// retrieve jets for selected mode
double mJetPtMin( 1. );
std::vector<fastjet::PseudoJet> jets( clusterSequence->inclusive_jets (mJetPtMin) );
unsigned int nJets( jets.size() );
if ( nJets == 0 )
{
delete clusterSequence;
return kFALSE;
}
//Double_t ptByArea[ nJets ];
// int columnwidth( 10 );
//cout << "found " << jets.size() << " jets" << endl;
// cout.width( 5 );
// cout << "jet";
// cout.width( columnwidth );
// cout << "eta";
// cout.width( columnwidth );
// cout << "phi";
// cout.width( columnwidth );
// cout << "pT";
// cout.width( columnwidth );
// cout << "jetArea";
// cout.width( 15 );
// cout << "pT / jetArea";
// cout << endl;
_jets.reserve( nJets );
vector< fastjet::PseudoJet > sorted_jets ( sorted_by_pt( jets ));
for ( int i(0); i<nJets; ++i )
{
//ptByArea[i] = jets[i].perp()/clusterSequence->area(jets[i]);
// cout.width( 5 );
// cout << i;
// cout.width( columnwidth );
// cout << jets[i].eta();
// cout.width( columnwidth );
// cout << jets[i].phi();
// cout.width( columnwidth );
// cout << jets[i].perp();
// cout.width( columnwidth );
// cout << clusterSequence->area(jets[i]);
// cout.width( 15 );
// cout << ptByArea[i];
// cout << endl;
/// save
///
/// TLorentzVector
/// area
/// nconstituents
fastjet::PseudoJet jet( sorted_jets[i] );
vector< fastjet::PseudoJet > constituents( clusterSequence->constituents(jet) );
TLorentzVector* mom = new TLorentzVector( jet.px(), jet.py(), jet.pz(), jet.e() );
double area = clusterSequence->area(jet);
// double median = TMath::Median( nJets, ptByArea );
unsigned int nconst = constituents.size();
UEJetWithArea* theJet = new UEJetWithArea( *mom, area, nconst);
//_jets[i] = *theJet;
_jets.push_back( *theJet );
delete mom;
delete theJet;
}
delete clusterSequence;
return kTRUE;
}
