//************************************************************************************************* //Main part of the macro //************************************************************************************************* void NormalizeHwwNtuple(const string InputFilename, const string datasetName, const string OutputFilename, const int nsel) { TTree* HwwTree = getTreeFromFile(InputFilename.c_str(),nsel); assert(HwwTree); MitNtupleEvent event(HwwTree); Double_t normalizationWeight = getNormalizationWeight(InputFilename, datasetName); //************************************************************************************************* //Create new normalized tree //************************************************************************************************* TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE"); outputFile->cd(); TTree *normalizedTree = HwwTree->CloneTree(0); cout << "Events in the ntuple: " << HwwTree->GetEntries() << endl; for (int n=0; n<HwwTree->GetEntries(); n++) { event.GetEntry(n); event.H_weight = event.H_weight * normalizationWeight; normalizedTree->Fill(); } normalizedTree->Write(); outputFile->Close(); }
//************************************************************************************************* //Main part of the macro //************************************************************************************************* void NormalizeHwwNtuple(const string InputFilename, const string datasetName, const string OutputFilename, const int nsel) { //TTree* HwwTree = getTreeFromFile(InputFilename.c_str(),nsel); //assert(HwwTree); SmurfTree sigEvent; sigEvent.LoadTree(InputFilename.c_str(),nsel); sigEvent.InitTree(0); sigEvent.tree_->SetName("tree"); Double_t normalizationWeight = getNormalizationWeight(InputFilename, datasetName); //************************************************************************************************* //Create new normalized tree //************************************************************************************************* TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE"); outputFile->cd(); TTree *normalizedTree = sigEvent.tree_->CloneTree(0); cout << "Events in the ntuple: " << sigEvent.tree_->GetEntries() << endl; for (int n=0;n<sigEvent.tree_->GetEntries();n++) { sigEvent.tree_->GetEntry(n); if (normalizationWeight < 0){ sigEvent.scale1fb_ = sigEvent.scale1fb_ * 1.0; } else if(nsel == 0){ sigEvent.scale1fb_ = sigEvent.scale1fb_ * normalizationWeight * 1.0; } else if(nsel == 1){ sigEvent.scale1fb_ = sigEvent.scale1fb_ * normalizationWeight * 1.0; } else { sigEvent.scale1fb_ = sigEvent.scale1fb_ * normalizationWeight * 1.0; } normalizedTree->Fill(); } normalizedTree->Write(); outputFile->Close(); }
//************************************************************************************************* //Main part of the macro //************************************************************************************************* void NormalizeElectronNtuple(const string InputFilename, const string datasetName, const string OutputFilename, Int_t sampleType, const string normalizationFile = "") { Double_t normalizationWeight = 0; Bool_t useReweightFactor = kFALSE; TH2F *PtEtaReweightFactor = 0; Double_t overallWJetsNormalizationFactor = 0; //For Normalizing each sample individually if (sampleType == 0 || sampleType >= 10) { TTree* electronTree = getTreeFromFile(InputFilename.c_str()); assert(electronTree); MitNtupleElectron ele(electronTree); normalizationWeight = getNormalizationWeight(InputFilename, datasetName); //************************************************************************************************* //Create new normalized tree //************************************************************************************************* TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE"); outputFile->cd(); TTree *normalizedTree = electronTree->CloneTree(0); for (int n=0;n<electronTree->GetEntries();n++) { ele.GetEntry(n); if (sampleType == 10) { if (ele.electron_branch_passedSelectionCut == 1) { if (datasetName == "s09-wwll10-mc3" || datasetName == "s09-ttbar-mc3") { //for mu-e there should be only 1 electron candidate ele.electron_branch_weight = normalizationWeight; normalizedTree->Fill(); } else if (datasetName == "s09-we-mc3" || datasetName == "s09-wm-mc3" || datasetName == "s09-wt-mc3") { //For the W->enu sample, fill only the fake electron candidates. ele.electron_branch_weight = normalizationWeight; if (ele.electron_branch_electronType < 100) { normalizedTree->Fill(); } } else { cout << "Warning: The specified dataset " << datasetName << " is not recognized to be one of the selection cut samples.\n"; } } } else { //For regular samples just fill all electrons ele.electron_branch_weight = normalizationWeight; normalizedTree->Fill(); } } normalizedTree->Write(); cout << "Original Tree Entries: " << electronTree->GetEntries() << " Normalized Tree Entries: " << normalizedTree->GetEntries() << endl; outputFile->Close(); } //For Normalization of Background sample else if (sampleType == 1) { TTree* electronTree = getTreeFromFile(InputFilename.c_str(), kFALSE); assert(electronTree); MitNtupleElectron ele(electronTree); //************************************************************************************************* //Create new reweighted tree //************************************************************************************************* TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE"); TTree *reweightedTree = electronTree->CloneTree(0); if (normalizationFile == "") { //normalize according to total number of electrons expected in W+Jets/W+gamma bkg Double_t totalWeight = 0; for (int n=0;n<electronTree->GetEntries();n++) { ele.GetEntry(n); totalWeight += ele.electron_branch_weight; } cout << "Input Bkg Ntuple Total Weight = " << totalWeight << endl; normalizationWeight = 1126.5 / totalWeight; } else { //do pt/eta Reweighting TFile *reweightInputFile = new TFile(normalizationFile.c_str(), "READ"); assert(reweightInputFile); TH2F *WJetsFakeElectronPtEta = (TH2F*)reweightInputFile->Get("hWJetsFakeElectronPtEta"); assert(WJetsFakeElectronPtEta); WJetsFakeElectronPtEta = (TH2F*)(WJetsFakeElectronPtEta->Clone()); WJetsFakeElectronPtEta->SetDirectory(0); reweightInputFile->Close(); //Create histogram for reweighting factor PtEtaReweightFactor = (TH2F*)WJetsFakeElectronPtEta->Clone(); PtEtaReweightFactor->SetName("PtEtaReweightFactor"); PtEtaReweightFactor->SetDirectory(0); TH2F *BkgFakeElectronPtEta = new TH2F("BkgFakeElectronPtEta", ";Pt [GeV/c];#eta;" , WJetsFakeElectronPtEta->GetXaxis()->GetNbins(), WJetsFakeElectronPtEta->GetXaxis()->GetBinLowEdge(1), WJetsFakeElectronPtEta->GetXaxis()->GetBinUpEdge(WJetsFakeElectronPtEta->GetXaxis()->GetNbins()), WJetsFakeElectronPtEta->GetYaxis()->GetNbins(), WJetsFakeElectronPtEta->GetYaxis()->GetBinLowEdge(1), WJetsFakeElectronPtEta->GetYaxis()->GetBinUpEdge(WJetsFakeElectronPtEta->GetYaxis()->GetNbins())); BkgFakeElectronPtEta->SetDirectory(0); for (int n=0;n<electronTree->GetEntries();n++) { ele.GetEntry(n); BkgFakeElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight); } PtEtaReweightFactor->Divide(WJetsFakeElectronPtEta, BkgFakeElectronPtEta, 1.0,1.0,"B"); useReweightFactor = kTRUE; } cout << "Reweighting Background Ntuple\n"; outputFile->cd(); //check Reweighting TH2F *ReweightedBkgFakeElectronPtEta = new TH2F("BkgFakeElectronPtEta", ";Pt [GeV/c];#eta;" , 200, 0, 200, 200, -3.0, 3.0); ReweightedBkgFakeElectronPtEta->SetDirectory(0); for (int n=0;n<electronTree->GetEntries();n++) { if (n%250000 == 0) cout << "Entry " << n << endl; ele.GetEntry(n); if (useReweightFactor) { Double_t reweightFactor = PtEtaReweightFactor->GetBinContent(PtEtaReweightFactor->GetXaxis()->FindFixBin(ele.electron_branch_pt),PtEtaReweightFactor->GetYaxis()->FindFixBin(ele.electron_branch_eta)); ele.electron_branch_weight = ele.electron_branch_weight*reweightFactor;//*overallWJetsNormalizationFactor; } else { ele.electron_branch_weight = normalizationWeight; } reweightedTree->Fill(); ReweightedBkgFakeElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight); } reweightedTree->Write(); cout << "Original Tree Entries: " << electronTree->GetEntries() << " Normalized Tree Entries: " << reweightedTree->GetEntries() << endl; outputFile->Close(); TCanvas *cv = new TCanvas("BkgReweightedFakeElectronPtEta", "BkgReweightedFakeElectronPtEta", 0,0,800,600); ReweightedBkgFakeElectronPtEta->ProjectionX()->DrawCopy("E1"); cv->SaveAs("BkgReweightedFakeElectronPt.gif"); ReweightedBkgFakeElectronPtEta->ProjectionY()->DrawCopy("E1"); cv->SaveAs("BkgReweightedFakeElectronEta.gif"); } //For Normalization of Signal sample else if (sampleType == 2) { TTree* electronTree = getTreeFromFile(InputFilename.c_str(), kFALSE); assert(electronTree); MitNtupleElectron ele(electronTree); //************************************************************************************************* //Create new reweighted tree //************************************************************************************************* TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE"); TTree *reweightedTree = electronTree->CloneTree(0); if (normalizationFile == "") { //normalize according to total number of electrons expected in WW -> ee nunu signal Double_t totalWeight = 0; for (int n=0;n<electronTree->GetEntries();n++) { ele.GetEntry(n); totalWeight += ele.electron_branch_weight; } cout << "Input Bkg Ntuple Total Weight = " << totalWeight << endl; normalizationWeight = 1126.5 / totalWeight; } else { //do pt/eta Reweighting TFile *reweightInputFile = new TFile(normalizationFile.c_str(), "READ"); assert(reweightInputFile); TH2F *WWSigElectronPtEta = (TH2F*)reweightInputFile->Get("hWWRealElectronPtEta"); assert(WWSigElectronPtEta); WWSigElectronPtEta = (TH2F*)(WWSigElectronPtEta->Clone()); WWSigElectronPtEta->SetDirectory(0); reweightInputFile->Close(); //Create histogram for reweighting factor PtEtaReweightFactor = (TH2F*)WWSigElectronPtEta->Clone(); PtEtaReweightFactor->SetName("PtEtaReweightFactor"); PtEtaReweightFactor->SetDirectory(0); TH2F *SigSampleElectronPtEta = new TH2F("SigSampleElectronPtEta", ";Pt [GeV/c];#eta;" , WWSigElectronPtEta->GetXaxis()->GetNbins(), WWSigElectronPtEta->GetXaxis()->GetBinLowEdge(1), WWSigElectronPtEta->GetXaxis()->GetBinUpEdge(WWSigElectronPtEta->GetXaxis()->GetNbins()), WWSigElectronPtEta->GetYaxis()->GetNbins(), WWSigElectronPtEta->GetYaxis()->GetBinLowEdge(1), WWSigElectronPtEta->GetYaxis()->GetBinUpEdge(WWSigElectronPtEta->GetYaxis()->GetNbins())); SigSampleElectronPtEta->SetDirectory(0); for (int n=0;n<electronTree->GetEntries();n++) { ele.GetEntry(n); SigSampleElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight); } PtEtaReweightFactor->Divide(WWSigElectronPtEta, SigSampleElectronPtEta, 1.0,1.0,"B"); useReweightFactor = kTRUE; } cout << "Reweighting Signal Ntuple\n"; outputFile->cd(); //check Reweighting TH2F *ReweightedSigRealElectronPtEta = new TH2F("ReweightedSigRealElectronPtEta", ";Pt [GeV/c];#eta;" , 200, 0, 200, 200, -3.0, 3.0); ReweightedSigRealElectronPtEta->SetDirectory(0); for (int n=0;n<electronTree->GetEntries();n++) { if (n%250000 == 0) cout << "Entry " << n << endl; ele.GetEntry(n); if (useReweightFactor) { Double_t reweightFactor = PtEtaReweightFactor->GetBinContent(PtEtaReweightFactor->GetXaxis()->FindFixBin(ele.electron_branch_pt),PtEtaReweightFactor->GetYaxis()->FindFixBin(ele.electron_branch_eta)); ele.electron_branch_weight = ele.electron_branch_weight*reweightFactor;//*overallWJetsNormalizationFactor; } else { ele.electron_branch_weight = normalizationWeight; } reweightedTree->Fill(); ReweightedSigRealElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight); } reweightedTree->Write(); cout << "Original Tree Entries: " << electronTree->GetEntries() << " Normalized Tree Entries: " << reweightedTree->GetEntries() << endl; outputFile->Close(); TCanvas *cv = new TCanvas("BkgReweightedFakeElectronPtEta", "BkgReweightedFakeElectronPtEta", 0,0,800,600); ReweightedSigRealElectronPtEta->ProjectionX()->DrawCopy("E1"); cv->SaveAs("SigReweightedRealElectronPt.gif"); ReweightedSigRealElectronPtEta->ProjectionY()->DrawCopy("E1"); cv->SaveAs("SigReweightedRealElectronEta.gif"); } else { cout << "Warning: Specified sampleType " << sampleType << " is not recognized.\n"; } }
// Main macro function //-------------------------------------------------------------------------------------------------- void NormalizeNtuple(string inputFilename, string datasetName, string outputFilename) { gBenchmark->Start("NormalizeNtuple"); TTree::SetMaxTreeSize(kMaxLong64); // Don't write TObject part of the objects mithep::TEventInfo::Class()->IgnoreTObjectStreamer(); mithep::TMuon::Class()->IgnoreTObjectStreamer(); mithep::TElectron::Class()->IgnoreTObjectStreamer(); mithep::TJet::Class()->IgnoreTObjectStreamer(); mithep::TPhoton::Class()->IgnoreTObjectStreamer(); // Data structures to store info from TTrees mithep::TEventInfo *info = new mithep::TEventInfo(); TClonesArray *muonArr = new TClonesArray("mithep::TMuon"); TClonesArray *electronArr = new TClonesArray("mithep::TElectron"); TClonesArray *jetArr = new TClonesArray("mithep::TJet"); TClonesArray *photonArr = new TClonesArray("mithep::TPhoton"); UInt_t nInputEvts = 0; UInt_t nPassEvts = 0; TFile* outfile = new TFile(outputFilename.c_str(), "RECREATE"); // // Initialize data trees and structs // TTree *outEventTree = new TTree("Events","Events"); outEventTree->Branch("Info", &info); outEventTree->Branch("Muon", &muonArr); outEventTree->Branch("Electron", &electronArr); outEventTree->Branch("PFJet", &jetArr); outEventTree->Branch("Photon", &photonArr); TTree *eventTree = getTreeFromFile(inputFilename.c_str(),"Events"); assert(eventTree); // Set branch address to structures that will store the info eventTree->SetBranchAddress("Info", &info); TBranch *infoBr = eventTree->GetBranch("Info"); eventTree->SetBranchAddress("Muon", &muonArr); TBranch *muonBr = eventTree->GetBranch("Muon"); eventTree->SetBranchAddress("Electron", &electronArr); TBranch *electronBr = eventTree->GetBranch("Electron"); eventTree->SetBranchAddress("PFJet", &jetArr); TBranch *jetBr = eventTree->GetBranch("PFJet"); eventTree->SetBranchAddress("Photon", &photonArr); TBranch *photonBr = eventTree->GetBranch("Photon"); Double_t normalizationWeight = getNormalizationWeight(inputFilename, datasetName); for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) { infoBr->GetEntry(ientry); muonArr->Clear(); muonBr->GetEntry(ientry); electronArr->Clear(); electronBr->GetEntry(ientry); photonArr->Clear(); photonBr->GetEntry(ientry); jetArr->Clear(); jetBr->GetEntry(ientry); if (ientry % 100000 == 0) cout << "Events: " << ientry << endl; nInputEvts++; info->eventweight = info->eventweight * normalizationWeight; outEventTree->Fill(); nPassEvts++; } outfile->Write(); outfile->Close(); delete info; delete muonArr; delete electronArr; delete jetArr; std::cout << outputFilename << " created!" << std::endl; std::cout << " >>> Events processed: " << nInputEvts << std::endl; std::cout << " >>> Events passing: " << nPassEvts << std::endl; gBenchmark->Show("NormalizeNtuple"); }