//*************************************************************************************************
//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");
}