TTree* GetTTree(const std::string TFILE, const std::string TTREE) {
// Open the TFiles
TFile* mc_tfile = new TFile(TFILE.c_str(), "READ");
if (!mc_tfile || mc_tfile->IsZombie()) {
const std::string ERR = "Could not open the file " + TFILE;
throw std::runtime_error(ERR);
}
// Load the tree
TTree* tree = new TTree();
mc_tfile->GetObject(TTREE.c_str(), tree);
if (!tree || tree->IsZombie()) {
const std::string ERR = "Could not open the TTree " + TTREE;
throw std::runtime_error(ERR);
}
return tree;
}
void doPostProcessing(TString infname, TString outfile, Int_t events,
Float_t xsec, Float_t kfactor,
Float_t filt_eff, bool SortBasketsByEntry = false) {
cout << "Processing File " << infname << endl;
TFile *f = TFile::Open(infname.Data(), "READ");
if (! f || f->IsZombie()) {
cout << "File does not exist!" << endl;
return;
}
TTree* t = (TTree*)f->Get("Events");
if (! t || t->IsZombie()) {
cout << "Tree does not exist!" << endl;
return;
}
//-------------------------------------------------------------
// Removes all non *_CMS2.* branches
//-------------------------------------------------------------`
t->SetBranchStatus("*", 0);
t->SetBranchStatus("*_CMS2.*", 1);
// Removes the branches (if they exist) that we want to replace
//evt_xsec_excl
TString bName = t->GetAlias("evt_xsec_excl");
//cout << "evt_xsec_excl " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_xsec_incl
bName = t->GetAlias("evt_xsec_incl");
//cout << "evt_xsec_incl " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_kfactor
bName = t->GetAlias("evt_kfactor");
//cout << "evt_kfactor " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_nEvts
bName = t->GetAlias("evt_nEvts");
//cout << "evt_nEvts " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_filt_eff
bName = t->GetAlias("evt_filt_eff");
//cout << "evt_filt_eff " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_scale1fb
bName = t->GetAlias("evt_scale1fb");
//cout << "evt_scale1fb " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
TFile *out = TFile::Open(outfile.Data(), "RECREATE");
TTree *clone;
if(SortBasketsByEntry)
clone = t->CloneTree(-1, "fastSortBasketsByEntry");
else
clone = t->CloneTree(-1, "fast");
//-------------------------------------------------------------
//Calculate scaling factor and put variables into tree
Float_t scale1fb = xsec*kfactor*1000*filt_eff/(Float_t)events;
cout << "scale1fb: " << scale1fb << endl;
TBranch* b1 = clone->Branch("evtscale1fb", &scale1fb, "evt_scale1fb/F");
TBranch* b2 = clone->Branch("evtxsecexcl", &xsec, "evt_xsec_excl/F");
TBranch* b3 = clone->Branch("evtxsecincl", &xsec, "evt_xsec_incl/F");
TBranch* b4 = clone->Branch("evtkfactor", &kfactor, "evt_kfactor/F");
TBranch* b5 = clone->Branch("evtnEvts", &events, "evt_nEvts/I");
TBranch* b6 = clone->Branch("evtfilteff", &filt_eff, "evt_filt_eff/F");
clone->SetAlias("evt_scale1fb", "evtscale1fb");
clone->SetAlias("evt_xsec_excl", "evtxsecexcl");
clone->SetAlias("evt_xsec_incl", "evtxsecincl");
clone->SetAlias("evt_kfactor", "evtkfactor");
clone->SetAlias("evt_nEvts", "evtnEvts");
clone->SetAlias("evt_filt_eff", "evtfilteff");
Int_t nentries = t->GetEntries();
for(Int_t i = 0; i < nentries; i++) {
b1->Fill();
b2->Fill();
b3->Fill();
b4->Fill();
b5->Fill();
b6->Fill();
}
//-------------------------------------------------------------
clone->Write();
out->Close();
f->Close();
return;
}
int addAgedVarsTPfinal(TString infname, TString outfile){
cout << "Processing File " << infname << endl;
TFile *f = TFile::Open(infname.Data(), "READ");
if (! f || f->IsZombie()) {
cout << "File does not exist!" << endl;
return 1;
}
TTree* t = (TTree*)f->Get("t");
if (! t || t->IsZombie()) {
cout << "Tree does not exist!" << endl;
return 2;
}
// old branches
Float_t lep1pt;
Float_t lep1eta;
Float_t lep1phi;
Float_t lep2pt;
Float_t lep2eta;
Float_t lep2phi;
Int_t nleps;
Float_t pujetmet;
Float_t pujetmetphi;
Float_t pujetmt;
Int_t nb;
Int_t nbgen;
Int_t ncgen;
Float_t bjet1pt;
Float_t bjet1eta;
Float_t bjet2pt;
Float_t bjet2eta;
TBranch* b_lep1pt;
TBranch* b_lep1eta;
TBranch* b_lep1phi;
TBranch* b_lep2pt;
TBranch* b_lep2eta;
TBranch* b_lep2phi;
TBranch* b_nleps;
TBranch* b_pujetmet;
TBranch* b_pujetmetphi;
TBranch* b_pujetmt;
TBranch* b_nb;
TBranch* b_nbgen;
TBranch* b_ncgen;
TBranch* b_bjet1pt;
TBranch* b_bjet1eta;
TBranch* b_bjet2pt;
TBranch* b_bjet2eta;
// new branches
Float_t agedweight = 1.;
Int_t agednleps = -999;
Float_t agedlep1pt = -999.;
Float_t agedlep1eta = -999.;
Float_t agedlep1phi = -999.;
Float_t smearmet = -999.;
Float_t smearmetphi = -999.;
Float_t smearmt = -999.;
// random generator
TRandom3 rand;
const float sigma = 20.; // smear by 20 GeV
//-------------------------------------------------------------
// Removes all non *_CMS2.* branches
//-------------------------------------------------------------`
t->SetBranchStatus("*", 1);
TFile *out = TFile::Open(outfile.Data(), "RECREATE");
TTree *clone;
clone = t->CloneTree(-1, "fast");
cout << "Cloning to File " << outfile << endl;
//-------------------------------------------------------------
// existing branches
clone->SetBranchAddress("lep1pt" , &lep1pt , &b_lep1pt );
clone->SetBranchAddress("lep1eta" , &lep1eta , &b_lep1eta );
clone->SetBranchAddress("lep1phi" , &lep1phi , &b_lep1phi );
clone->SetBranchAddress("lep2pt" , &lep2pt , &b_lep2pt );
clone->SetBranchAddress("lep2eta" , &lep2eta , &b_lep2eta );
clone->SetBranchAddress("lep2phi" , &lep2phi , &b_lep2phi );
clone->SetBranchAddress("nleps" , &nleps , &b_nleps );
clone->SetBranchAddress("pujetmet" , &pujetmet , &b_pujetmet );
clone->SetBranchAddress("pujetmetphi", &pujetmetphi, &b_pujetmetphi );
clone->SetBranchAddress("pujetmt" , &pujetmt , &b_pujetmt );
clone->SetBranchAddress("nb" , &nb , &b_nb );
clone->SetBranchAddress("nbgen" , &nbgen , &b_nbgen );
clone->SetBranchAddress("ncgen" , &ncgen , &b_ncgen );
clone->SetBranchAddress("bjet1pt" , &bjet1pt , &b_bjet1pt );
clone->SetBranchAddress("bjet1eta" , &bjet1eta , &b_bjet1eta );
clone->SetBranchAddress("bjet2pt" , &bjet2pt , &b_bjet2pt );
clone->SetBranchAddress("bjet2eta" , &bjet2eta , &b_bjet2eta );
// new branches
TBranch* b_agedweight = clone->Branch("agedweight", &agedweight, "agedweight/F");
TBranch* b_agednleps = clone->Branch("agednleps", &agednleps, "agednleps/I");
TBranch* b_agedlep1pt = clone->Branch("agedlep1pt", &agedlep1pt, "agedlep1pt/F");
TBranch* b_agedlep1eta = clone->Branch("agedlep1eta", &agedlep1eta, "agedlep1eta/F");
TBranch* b_agedlep1phi = clone->Branch("agedlep1phi", &agedlep1phi, "agedlep1phi/F");
TBranch* b_smearmet = clone->Branch("smearmet", &smearmet, "smearmet/F");
TBranch* b_smearmetphi = clone->Branch("smearmetphi", &smearmetphi, "smearmetphi/F");
TBranch* b_smearmt = clone->Branch("smearmt", &smearmt, "smearmt/F");
Long64_t nentries = t->GetEntries();
//Long64_t nentries = 100;
for(Long64_t i = 0; i < nentries; i++) {
clone->GetEntry(i);
agedweight = 1.;
// set weight for reduced btagging eff
if (nb == 2) {
// both jets are from heavy flavor - use both SFs
if ((nbgen+ncgen) == 2) {
agedweight *= getBtagSF(bjet1pt,bjet1eta);
agedweight *= getBtagSF(bjet2pt,bjet2eta);
}
// only one HF jet - randomly guess which is fake
else if ((nbgen+ncgen) == 1) {
if (rand.Rndm() > 0.5) agedweight *= getBtagSF(bjet1pt,bjet1eta);
else agedweight *= getBtagSF(bjet2pt,bjet2eta);
}
}
// cout << "nb: " << nb << ", nbgen: " << nbgen << ", ncgen: " << ncgen
// << ", bjet1 pt: " << bjet1pt << ", eta: " << bjet1eta
// << ", bjet2 pt: " << bjet2pt << ", eta: " << bjet2eta
// << ", agedweight: " << agedweight << endl;
// reduce lepton efficiency by 0.84
if (nleps > 0) {
int keeplep1 = 1;
int keeplep2 = 1;
// roll the dice for each lepton
if (rand.Rndm() > 0.84) keeplep1 = 0;
if (nleps == 1 || rand.Rndm() > 0.84) keeplep2 = 0;
agednleps = keeplep1+keeplep2;
// cout << "nleps: " << nleps << ", keeplep1: " << keeplep1
// << ", keeplep2: " << keeplep2 << ", agednleps: " << agednleps << endl;
if (keeplep1 == 1) {
agedlep1pt = lep1pt;
agedlep1eta = lep1eta;
agedlep1phi = lep1phi;
} else if (keeplep2 == 1) {
agedlep1pt = lep2pt;
agedlep1eta = lep2eta;
agedlep1phi = lep2phi;
} else {
agedlep1pt = -999;
agedlep1eta = -999;
agedlep1phi = -999;
}
}
// smear met and propagate to MT
float metx = pujetmet * cos(pujetmetphi);
float mety = pujetmet * sin(pujetmetphi);
float smearmetx = metx + rand.Gaus(0,sigma);
float smearmety = mety + rand.Gaus(0,sigma);
TVector2 smearmetvec(smearmetx,smearmety);
smearmet = smearmetvec.Mod();
smearmetphi = smearmetvec.Phi();
if (agedlep1pt > 0.) {
smearmt = sqrt( 2 * smearmet * agedlep1pt * ( 1 - cos( smearmetphi - agedlep1phi) ) );
} else {
smearmt = -99.;
}
// cout << "pujetmet: " << pujetmet << ", pujetmetphi: " << pujetmetphi
// << ", smearmet: " << smearmet << ", smearmetphi: " << smearmetphi
// << ", pujetmt: " << pujetmt << ", smearmt: " << smearmt << endl;
// fill new branches
b_agedweight->Fill();
b_agednleps->Fill();
b_agedlep1pt->Fill();
b_agedlep1eta->Fill();
b_agedlep1phi->Fill();
b_smearmet->Fill();
b_smearmetphi->Fill();
b_smearmt->Fill();
}
//-------------------------------------------------------------
clone->Write();
out->Close();
f->Close();
cout << "Processed Events: " << nentries << endl;
return 0;
}
