int main( int argc, const char* argv[] ){
// List of arguments:
// 0: The executable itself
// 1: The number of times JetMET is smeared (not smeared if equal to 1)
// 2: The scale and type of JES shift (if fabs(x) < 0.5, shift by eta, else absolute
// fixme: Depracated
float JES_JetMET = 1.0;
string xmlFileName = string ("./MyMassAnalysis.xml");
for (int i=1;i<argc;++i) {
if (strncmp(argv[i],"-c",2)==0) xmlFileName = string(argv[i+1]);
if (strncmp(argv[i],"-h",2)==0) {
cout << " -c xm_config_file\n";
exit(1);
}
}
cout<<"#########################"<<endl;
cout<<"Beginning of the program"<<endl;
cout<<"#########################"<<endl;
//////////////////////
//Global variables
//////////////////////
// GEN
TH1F * histoGenTopRapidity1 = new TH1F("GenTopRapidity1", "GenTopRapidity1", 100, -5, 5);
TH1F * histoGenTopRapidity2 = new TH1F("GenTopRapidity2", "GenTopRapidity2", 100, -5, 5);
TH1F * histoGenTopMass1 = new TH1F("GenTopMass1", "GenTopMass1", 200, 0, 200);
TH1F * histoGenTopMass2 = new TH1F("GenTopMass2", "GenTopMass2", 200, 0, 200);
TH2F * histoGenTopMass1VsTopMass2 = new TH2F("GenTopMass1VsTopMass2", "GenTopMass1VsTopMass2", 200, 0, 200, 200, 0, 200);
TH1F * histoGenDelta_y = new TH1F("GenDelta_y", "GenDelta_y", 400, -2, 2);
TH1F * histoGenTTRapidity = new TH1F("GenTTRapidity", "GenTTRapidity", 500, -2.5, 2.5);
TH1F * histoGenTTPt = new TH1F("GenTTPt", "GenTTPt", 250, 0, 250);
TH1F * histoGenTTMass = new TH1F("GenTTMass", "GenTTMass", 100, 0, 1000);
TH2F * histoGenDelta_yVsTTRapidity = new TH2F("GenDelta_yVsTTRapidity", "GenDelta_yVsTTRapidity", 10, -2, 2, 5, -2.5, 2.5);
TH2F * histoGenDelta_yVsTTPt = new TH2F("GenDelta_yVsTTPt", "GenDelta_yVsTTPt", 10, -2, 2, 5, 0, 250);
TH2F * histoGenDelta_yVsTTMass = new TH2F("GenDelta_yVsTTMass", "GenDelta_yVsTTMass", 10, -2, 2, 5, 0, 1000);
TH1F * histoGenN_plusTTRapidity = new TH1F("GenN_plusTTRapidity", "GenN_plusTTRapidity", 20, -2.5, 2.5);
histoGenN_plusTTRapidity->Sumw2();
TH1F * histoGenN_plusTTPt = new TH1F("GenN_plusTTPt", "GenN_plusTTPt", 20, 0, 250);
histoGenN_plusTTPt->Sumw2();
TH1F * histoGenN_plusTTMass = new TH1F("GenN_plusTTMass", "GenN_plusTTMass", 20, 0, 1000);
histoGenN_plusTTMass->Sumw2();
TH1F * histoGenN_minusTTRapidity = new TH1F("GenN_minusTTRapidity", "GenN_minusTTRapidity", 20, -2.5, 2.5);
histoGenN_minusTTRapidity->Sumw2();
TH1F * histoGenN_minusTTPt = new TH1F("GenN_minusTTPt", "GenN_minusTTPt", 20, 0, 250);
histoGenN_minusTTPt->Sumw2();
TH1F * histoGenN_minusTTMass = new TH1F("GenN_minusTTMass", "GenN_minusTTMass", 20, 0, 1000);
histoGenN_minusTTMass->Sumw2();
TH1F * histoGenN_plusMinusN_minusTTRapidity = new TH1F("GenN_plusMinusN_minusTTRapidity", "GenN_plusMinusN_minusTTRapidity", 20, -2.5, 2.5);
histoGenN_plusMinusN_minusTTRapidity->Sumw2();
TH1F * histoGenN_plusPlusN_minusTTRapidity = new TH1F("GenN_plusPlusN_minusTTRapidity", "GenN_plusPlusN_minusTTRapidity", 20, -2.5, 2.5);
histoGenN_plusPlusN_minusTTRapidity->Sumw2();
TH1F * histoGenN_plusMinusN_minusTTPt = new TH1F("GenN_plusMinusN_minusTTPt", "GenN_plusMinusN_minusTTPt", 20, 0, 250);
histoGenN_plusMinusN_minusTTPt->Sumw2();
TH1F * histoGenN_plusPlusN_minusTTPt = new TH1F("GenN_plusPlusN_minusTTPt", "GenN_plusPlusN_minusTTPt", 20, 0, 250);
histoGenN_plusPlusN_minusTTPt->Sumw2();
TH1F * histoGenN_plusMinusN_minusTTMass = new TH1F("GenN_plusMinusN_minusTTMass", "GenN_plusMinusN_minusTTMass", 20, 0, 1000);
histoGenN_plusMinusN_minusTTMass->Sumw2();
TH1F * histoGenN_plusPlusN_minusTTMass = new TH1F("GenN_plusPlusN_minusTTMass", "GenN_plusPlusN_minusTTMass", 20, 0, 1000);
histoGenN_plusPlusN_minusTTMass->Sumw2();
TH1F * histoGenA_cTTRapidity = new TH1F("GenA_cTTRapidity", "GenA_cTTRapidity", 20, -2.5, 2.5);
histoGenA_cTTRapidity->Sumw2();
TH1F * histoGenA_cTTPt = new TH1F("GenA_cTTPt", "GenA_cTTPt", 20, 0, 250);
histoGenA_cTTPt->Sumw2();
TH1F * histoGenA_cTTMass = new TH1F("GenA_cTTMass", "GenA_cTTMass", 20, 0, 1000);
histoGenA_cTTMass->Sumw2();
// Fine binning
TH2F * histoFineBinning_GenDelta_yVsTTRapidity = new TH2F("FineBinning_GenDelta_yVsTTRapidity", "FineBinning_GenDelta_yVsTTRapidity", 200, -2, 2, 500, -2.5, 2.5);
TH2F * histoFineBinning_GenDelta_yVsTTPt = new TH2F("FineBinning_GenDelta_yVsTTPt", "FineBinning_GenDelta_yVsTTPt", 200, -2, 2, 250, 0, 250);
TH2F * histoFineBinning_GenDelta_yVsTTMass = new TH2F("FineBinning_GenDelta_yVsTTMass", "FineBinning_GenDelta_yVsTTMass", 200, -2, 2, 100, 0, 1000);
TH1F * histoFineBinning_GenN_plusTTRapidity = new TH1F("FineBinning_GenN_plusTTRapidity", "FineBinning_GenN_plusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_GenN_plusTTRapidity->Sumw2();
TH1F * histoFineBinning_GenN_plusTTPt = new TH1F("FineBinning_GenN_plusTTPt", "FineBinning_GenN_plusTTPt", 250, 0, 250);
histoFineBinning_GenN_plusTTPt->Sumw2();
TH1F * histoFineBinning_GenN_plusTTMass = new TH1F("FineBinning_GenN_plusTTMass", "FineBinning_GenN_plusTTMass", 100, 0, 1000);
histoFineBinning_GenN_plusTTMass->Sumw2();
TH1F * histoFineBinning_GenN_minusTTRapidity = new TH1F("FineBinning_GenN_minusTTRapidity", "FineBinning_GenN_minusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_GenN_minusTTRapidity->Sumw2();
TH1F * histoFineBinning_GenN_minusTTPt = new TH1F("FineBinning_GenN_minusTTPt", "FineBinning_GenN_minusTTPt", 250, 0, 250);
histoFineBinning_GenN_minusTTPt->Sumw2();
TH1F * histoFineBinning_GenN_minusTTMass = new TH1F("FineBinning_GenN_minusTTMass", "FineBinning_GenN_minusTTMass", 100, 0, 1000);
histoFineBinning_GenN_minusTTMass->Sumw2();
TH1F * histoFineBinning_GenN_plusMinusN_minusTTRapidity = new TH1F("FineBinning_GenN_plusMinusN_minusTTRapidity", "FineBinning_GenN_plusMinusN_minusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_GenN_plusMinusN_minusTTRapidity->Sumw2();
TH1F * histoFineBinning_GenN_plusPlusN_minusTTRapidity = new TH1F("FineBinning_GenN_plusPlusN_minusTTRapidity", "FineBinning_GenN_plusPlusN_minusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_GenN_plusPlusN_minusTTRapidity->Sumw2();
TH1F * histoFineBinning_GenN_plusMinusN_minusTTPt = new TH1F("FineBinning_GenN_plusMinusN_minusTTPt", "FineBinning_GenN_plusMinusN_minusTTPt", 250, 0, 250);
histoFineBinning_GenN_plusMinusN_minusTTPt->Sumw2();
TH1F * histoFineBinning_GenN_plusPlusN_minusTTPt = new TH1F("FineBinning_GenN_plusPlusN_minusTTPt", "FineBinning_GenN_plusPlusN_minusTTPt", 250, 0, 250);
histoFineBinning_GenN_plusPlusN_minusTTPt->Sumw2();
TH1F * histoFineBinning_GenN_plusMinusN_minusTTMass = new TH1F("FineBinning_GenN_plusMinusN_minusTTMass", "FineBinning_GenN_plusMinusN_minusTTMass", 100, 0, 1000);
histoFineBinning_GenN_plusMinusN_minusTTMass->Sumw2();
TH1F * histoFineBinning_GenN_plusPlusN_minusTTMass = new TH1F("FineBinning_GenN_plusPlusN_minusTTMass", "FineBinning_GenN_plusPlusN_minusTTMass", 100, 0, 1000);
histoFineBinning_GenN_plusPlusN_minusTTMass->Sumw2();
TH1F * histoFineBinning_GenA_cTTRapidity = new TH1F("FineBinning_GenA_cTTRapidity", "FineBinning_GenA_cTTRapidity", 500, -2.5, 2.5);
histoFineBinning_GenA_cTTRapidity->Sumw2();
TH1F * histoFineBinning_GenA_cTTPt = new TH1F("FineBinning_GenA_cTTPt", "FineBinning_GenA_cTTPt", 250, 0, 250);
histoFineBinning_GenA_cTTPt->Sumw2();
TH1F * histoFineBinning_GenA_cTTMass = new TH1F("FineBinning_GenA_cTTMass", "FineBinning_GenA_cTTMass", 100, 0, 1000);
histoFineBinning_GenA_cTTMass->Sumw2();
// RECO
TH1F * histoRecoTopRapidity1 = new TH1F("RecoTopRapidity1", "RecoTopRapidity1", 100, -5, 5);
TH1F * histoRecoTopRapidity2 = new TH1F("RecoTopRapidity2", "RecoTopRapidity2", 100, -5, 5);
TH1F * histoRecoLeptonRapidity1 = new TH1F("RecoLeptonRapidity1", "RecoLeptonRapidity1", 100, -5, 5);
TH1F * histoRecoLeptonRapidity2 = new TH1F("RecoLeptonRapidity2", "RecoLeptonRapidity2", 100, -5, 5);
TH1F * histoRecoTopMass1 = new TH1F("RecoTopMass1", "RecoTopMass1", 300, 0, 300);
TH1F * histoRecoTopMass2 = new TH1F("RecoTopMass2", "RecoTopMass2", 300, 0, 300);
TH2F * histoRecoTopMass1VsTopMass2 = new TH2F("RecoTopMass1VsTopMass2", "RecoTopMass1VsTopMass2", 300, 0, 300, 300, 0, 300);
TH1F * histoRecoDelta_y = new TH1F("RecoDelta_y", "RecoDelta_y", 400, -2, 2);
TH1F * histoRecoTTRapidity = new TH1F("RecoTTRapidity", "RecoTTRapidity", 500, -2.5, 2.5);
TH1F * histoRecoTTPt = new TH1F("RecoTTPt", "RecoTTPt", 250, 0, 250);
TH1F * histoRecoTTMass = new TH1F("RecoTTMass", "RecoTTMass", 100, 0, 1000);
TH2F * histoRecoDelta_yVsTTRapidity = new TH2F("RecoDelta_yVsTTRapidity", "RecoDelta_yVsTTRapidity", 10, -2, 2, 5, -2.5, 2.5);
TH2F * histoRecoDelta_yVsTTPt = new TH2F("RecoDelta_yVsTTPt", "RecoDelta_yVsTTPt", 10, -2, 2, 5, 0, 250);
TH2F * histoRecoDelta_yVsTTMass = new TH2F("RecoDelta_yVsTTMass", "RecoDelta_yVsTTMass", 10, -2, 2, 5, 0, 1000);
TH1F * histoRecoN_plusTTRapidity = new TH1F("RecoN_plusTTRapidity", "RecoN_plusTTRapidity", 20, -2.5, 2.5);
histoRecoN_plusTTRapidity->Sumw2();
TH1F * histoRecoN_plusTTPt = new TH1F("RecoN_plusTTPt", "RecoN_plusTTPt", 20, 0, 250);
histoRecoN_plusTTPt->Sumw2();
TH1F * histoRecoN_plusTTMass = new TH1F("RecoN_plusTTMass", "RecoN_plusTTMass", 20, 0, 1000);
histoRecoN_plusTTMass->Sumw2();
TH1F * histoRecoN_minusTTRapidity = new TH1F("RecoN_minusTTRapidity", "RecoN_minusTTRapidity", 20, -2.5, 2.5);
histoRecoN_minusTTRapidity->Sumw2();
TH1F * histoRecoN_minusTTPt = new TH1F("RecoN_minusTTPt", "RecoN_minusTTPt", 20, 0, 250);
histoRecoN_minusTTPt->Sumw2();
TH1F * histoRecoN_minusTTMass = new TH1F("RecoN_minusTTMass", "RecoN_minusTTMass", 20, 0, 1000);
histoRecoN_minusTTMass->Sumw2();
TH1F * histoRecoN_plusMinusN_minusTTRapidity = new TH1F("RecoN_plusMinusN_minusTTRapidity", "RecoN_plusMinusN_minusTTRapidity", 20, -2.5, 2.5);
histoRecoN_plusMinusN_minusTTRapidity->Sumw2();
TH1F * histoRecoN_plusPlusN_minusTTRapidity = new TH1F("RecoN_plusPlusN_minusTTRapidity", "RecoN_plusPlusN_minusTTRapidity", 20, -2.5, 2.5);
histoRecoN_plusPlusN_minusTTRapidity->Sumw2();
TH1F * histoRecoN_plusMinusN_minusTTPt = new TH1F("RecoN_plusMinusN_minusTTPt", "RecoN_plusMinusN_minusTTPt", 20, 0, 250);
histoRecoN_plusMinusN_minusTTPt->Sumw2();
TH1F * histoRecoN_plusPlusN_minusTTPt = new TH1F("RecoN_plusPlusN_minusTTPt", "RecoN_plusPlusN_minusTTPt", 20, 0, 250);
histoRecoN_plusPlusN_minusTTPt->Sumw2();
TH1F * histoRecoN_plusMinusN_minusTTMass = new TH1F("RecoN_plusMinusN_minusTTMass", "RecoN_plusMinusN_minusTTMass", 20, 0, 1000);
histoRecoN_plusMinusN_minusTTMass->Sumw2();
TH1F * histoRecoN_plusPlusN_minusTTMass = new TH1F("RecoN_plusPlusN_minusTTMass", "RecoN_plusPlusN_minusTTMass", 20, 0, 1000);
histoRecoN_plusPlusN_minusTTMass->Sumw2();
TH1F * histoRecoA_cTTRapidity = new TH1F("RecoA_cTTRapidity", "RecoA_cTTRapidity", 20, -2.5, 2.5);
histoRecoA_cTTRapidity->Sumw2();
TH1F * histoRecoA_cTTPt = new TH1F("RecoA_cTTPt", "RecoA_cTTPt", 20, 0, 250);
histoRecoA_cTTPt->Sumw2();
TH1F * histoRecoA_cTTMass = new TH1F("RecoA_cTTMass", "RecoA_cTTMass", 20, 0, 1000);
histoRecoA_cTTMass->Sumw2();
// Fine binning
TH2F * histoFineBinning_RecoDelta_yVsTTRapidity = new TH2F("FineBinning_RecoDelta_yVsTTRapidity", "FineBinning_RecoDelta_yVsTTRapidity", 200, -2, 2, 500, -2.5, 2.5);
TH2F * histoFineBinning_RecoDelta_yVsTTPt = new TH2F("FineBinning_RecoDelta_yVsTTPt", "FineBinning_RecoDelta_yVsTTPt", 200, -2, 2, 250, 0, 250);
TH2F * histoFineBinning_RecoDelta_yVsTTMass = new TH2F("FineBinning_RecoDelta_yVsTTMass", "FineBinning_RecoDelta_yVsTTMass", 200, -2, 2, 100, 0, 1000);
TH1F * histoFineBinning_RecoN_plusTTRapidity = new TH1F("FineBinning_RecoN_plusTTRapidity", "FineBinning_RecoN_plusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_RecoN_plusTTRapidity->Sumw2();
TH1F * histoFineBinning_RecoN_plusTTPt = new TH1F("FineBinning_RecoN_plusTTPt", "FineBinning_RecoN_plusTTPt", 250, 0, 250);
histoFineBinning_RecoN_plusTTPt->Sumw2();
TH1F * histoFineBinning_RecoN_plusTTMass = new TH1F("FineBinning_RecoN_plusTTMass", "FineBinning_RecoN_plusTTMass", 100, 0, 1000);
histoFineBinning_RecoN_plusTTMass->Sumw2();
TH1F * histoFineBinning_RecoN_minusTTRapidity = new TH1F("FineBinning_RecoN_minusTTRapidity", "FineBinning_RecoN_minusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_RecoN_minusTTRapidity->Sumw2();
TH1F * histoFineBinning_RecoN_minusTTPt = new TH1F("FineBinning_RecoN_minusTTPt", "FineBinning_RecoN_minusTTPt", 250, 0, 250);
histoFineBinning_RecoN_minusTTPt->Sumw2();
TH1F * histoFineBinning_RecoN_minusTTMass = new TH1F("FineBinning_RecoN_minusTTMass", "FineBinning_RecoN_minusTTMass", 100, 0, 1000);
histoFineBinning_RecoN_minusTTMass->Sumw2();
TH1F * histoFineBinning_RecoN_plusMinusN_minusTTRapidity = new TH1F("FineBinning_RecoN_plusMinusN_minusTTRapidity", "FineBinning_RecoN_plusMinusN_minusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Sumw2();
TH1F * histoFineBinning_RecoN_plusPlusN_minusTTRapidity = new TH1F("FineBinning_RecoN_plusPlusN_minusTTRapidity", "FineBinning_RecoN_plusPlusN_minusTTRapidity", 500, -2.5, 2.5);
histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Sumw2();
TH1F * histoFineBinning_RecoN_plusMinusN_minusTTPt = new TH1F("FineBinning_RecoN_plusMinusN_minusTTPt", "FineBinning_RecoN_plusMinusN_minusTTPt", 250, 0, 250);
histoFineBinning_RecoN_plusMinusN_minusTTPt->Sumw2();
TH1F * histoFineBinning_RecoN_plusPlusN_minusTTPt = new TH1F("FineBinning_RecoN_plusPlusN_minusTTPt", "FineBinning_RecoN_plusPlusN_minusTTPt", 250, 0, 250);
histoFineBinning_RecoN_plusPlusN_minusTTPt->Sumw2();
TH1F * histoFineBinning_RecoN_plusMinusN_minusTTMass = new TH1F("FineBinning_RecoN_plusMinusN_minusTTMass", "FineBinning_RecoN_plusMinusN_minusTTMass", 100, 0, 1000);
histoFineBinning_RecoN_plusMinusN_minusTTMass->Sumw2();
TH1F * histoFineBinning_RecoN_plusPlusN_minusTTMass = new TH1F("FineBinning_RecoN_plusPlusN_minusTTMass", "FineBinning_RecoN_plusPlusN_minusTTMass", 100, 0, 1000);
histoFineBinning_RecoN_plusPlusN_minusTTMass->Sumw2();
TH1F * histoFineBinning_RecoA_cTTRapidity = new TH1F("FineBinning_RecoA_cTTRapidity", "FineBinning_RecoA_cTTRapidity", 500, -2.5, 2.5);
histoFineBinning_RecoA_cTTRapidity->Sumw2();
TH1F * histoFineBinning_RecoA_cTTPt = new TH1F("FineBinning_RecoA_cTTPt", "FineBinning_RecoA_cTTPt", 250, 0, 250);
histoFineBinning_RecoA_cTTPt->Sumw2();
TH1F * histoFineBinning_RecoA_cTTMass = new TH1F("FineBinning_RecoA_cTTMass", "FineBinning_RecoA_cTTMass", 100, 0, 1000);
histoFineBinning_RecoA_cTTMass->Sumw2();
// RECO vs GEN
TH2F * histoRecoVsGenTopRapidity1 = new TH2F("RecoVsGenTopRapidity1", "RecoVsGenTopRapidity1", 100, -5, 5, 100, -5, 5);
TH2F * histoRecoVsGenTopRapidity2 = new TH2F("RecoVsGenTopRapidity2", "RecoVsGenTopRapidity2", 100, -5, 5, 100, -5, 5);
TH2F * histoRecoVsGenTopMass1 = new TH2F("RecoVsGenTopMass1", "RecoVsGenTopMass1", 300, 0, 300, 200, 0, 200);
TH2F * histoRecoVsGenTopMass2 = new TH2F("RecoVsGenTopMass2", "RecoVsGenTopMass2", 300, 0, 300, 200, 0, 200);
TH1F * histoRecoMinusGenDivGenTopRapidity1 = new TH1F("RecoMinusGenDivGenTopRapidity1", "RecoMinusGenDivGenTopRapidity1", 100, -3, 3);
TH1F * histoRecoMinusGenDivGenTopRapidity2 = new TH1F("RecoMinusGenDivGenTopRapidity2", "RecoMinusGenDivGenTopRapidity2", 100, -3, 3);
TH1F * histoRecoMinusGenDivGenLeptonRapidity1 = new TH1F("RecoMinusGenDivGenLeptonRapidity1", "RecoMinusGenDivGenLeptonRapidity1", 100, -3, 3);
TH1F * histoRecoMinusGenDivGenLeptonRapidity2 = new TH1F("RecoMinusGenDivGenLeptonRapidity2", "RecoMinusGenDivGenLeptonRapidity2", 100, -3, 3);
TH1F * histoRecoMinusGenDivGenTopMass1 = new TH1F("RecoMinusGenDivGenTopMass1", "RecoMinusGenDivGenTopMass1", 100, -3, 3);
TH1F * histoRecoMinusGenDivGenTopMass2 = new TH1F("RecoMinusGenDivGenTopMass2", "RecoMinusGenDivGenTopMass2", 100, -3, 3);
TH2F * histoFineBinning_RecoVsGenDelta_y = new TH2F("FineBinning_RecoVsGenDelta_y", "FineBinning_RecoVsGenDelta_y", 400, -2, 2, 400, -2, 2); // Migration Matrix
TH2F * histoRecoVsGenDelta_y = new TH2F("RecoVsGenDelta_y", "RecoVsGenDelta_y", 8, -2, 2, 16, -2, 2); // Migration Matrix
TH1F * histoRecoMinusGenDivGenDelta_y = new TH1F("RecoMinusGenDivGenDelta_y", "RecoMinusGenDivGenDelta_y", 100, -3, 3);
TH2F * histoRecoVsGenTTRapidity = new TH2F("RecoVsGenTTRapidity", "RecoVsGenTTRapidity", 500, -2.5, 2.5, 500, -2.5, 2.5);
TH1F * histoRecoMinusGenDivGenTTRapidity = new TH1F("RecoMinusGenDivGenTTRapidity", "RecoMinusGenDivGenTTRapidity", 100, -3, 3);
TH2F * histoRecoVsGenTTPt = new TH2F("RecoVsGenTTPt", "RecoVsGenTTPt", 250, 0, 250, 250, 0, 250);
TH1F * histoRecoMinusGenDivGenTTPt = new TH1F("RecoMinusGenDivGenTTPt", "RecoMinusGenDivGenTTPt", 100, -3, 3);
TH2F * histoRecoVsGenTTMass = new TH2F("RecoVsGenTTMass", "RecoVsGenTTMass", 100, 0, 1000, 100, 0, 1000);
TH1F * histoRecoMinusGenDivGenTTMass = new TH1F("RecoMinusGenDivGenTTMass", "RecoMinusGenDivGenTTMass", 100, -3, 3);
TH1F * histoDelta_yEfficiencyN = new TH1F("Delta_yEfficiencyN", "Delta_yEfficiencyN", 10, -2, 2);
TH1F * histoDelta_yEfficiencyD = new TH1F("Delta_yEfficiencyD", "Delta_yEfficiencyD", 10, -2, 2);
TH1F * histoDelta_yEfficiency = new TH1F("Delta_yEfficiency", "Delta_yEfficiency", 10, -2, 2);
TH2F * histoDelta_yVsTTRapidityEfficiency = new TH2F("Delta_yVsTTRapidityEfficiency", "Delta_yVsTTRapidityEfficiency", 10, -2, 2, 5, -2.5, 2.5);
TH2F * histoDelta_yVsTTPtEfficiency = new TH2F("Delta_yVsTTPtEfficiency", "Delta_yVsTTPtEfficiency", 10, -2, 2, 5, 0, 250);
TH2F * histoDelta_yVsTTMassEfficiency = new TH2F("Delta_yVsTTMassEfficiency", "Delta_yVsTTMassEfficiency", 10, -2, 2, 5, 0, 1000);
// Fine binning
TH1F * histoFineBinning_Delta_yEfficiencyN = new TH1F("FineBinning_Delta_yEfficiencyN", "FineBinning_Delta_yEfficiencyN", 200, -2, 2);
TH1F * histoFineBinning_Delta_yEfficiencyD = new TH1F("FineBinning_Delta_yEfficiencyD", "FineBinning_Delta_yEfficiencyD", 200, -2, 2);
TH1F * histoFineBinning_Delta_yEfficiency = new TH1F("FineBinning_Delta_yEfficiency", "FineBinning_Delta_yEfficiency", 200, -2, 2);
TH2F * histoFineBinning_Delta_yVsTTRapidityEfficiency = new TH2F("FineBinning_Delta_yVsTTRapidityEfficiency", "FineBinning_Delta_yVsTTRapidityEfficiency", 200, -2, 2, 500, -2.5, 2.5);
TH2F * histoFineBinning_Delta_yVsTTPtEfficiency = new TH2F("FineBinning_Delta_yVsTTPtEfficiency", "FineBinning_Delta_yVsTTPtEfficiency", 200, -2, 2, 250, 0, 250);
TH2F * histoFineBinning_Delta_yVsTTMassEfficiency = new TH2F("FineBinning_Delta_yVsTTMassEfficiency", "FineBinning_Delta_yVsTTMassEfficiency", 200, -2, 2, 100, 0, 1000);
vector < Dataset > datasets;
DiLeptonSelection sel;
float Luminosity = 0;
// 0: MC - 1: Data - 2 Data & MC
int DataType = 0;
int verbosity = -1;
// Analysis variables
int step;
//4-vectors
vector < TLorentzVector > nu1;
vector < TLorentzVector > nu2;
// TLorentzVector lvTop1_aux;
//TLorentzVector lvTop2_aux;
//////////////////////
//////////////////////
// Initialisation
//////////////////////
AnalysisEnvironmentLoader anaEL (xmlFileName);
anaEL.LoadSamples (datasets); // now the list of datasets written in the xml file is known
anaEL.LoadDiLeptonSelection (sel); // now the parameters for the selection are given to the selection
anaEL.LoadGeneralInfo(DataType, Luminosity, verbosity );
float weight_MC;
int nEvents;
int firstEvent;
int initialEvents;
anaEL.LoadAnalysisInfo("Run", "firstEvent", firstEvent);
anaEL.LoadAnalysisInfo("Run", "nEvents", nEvents);
anaEL.LoadAnalysisInfo("Run", "initialEvents", initialEvents);
string channelName;
anaEL.LoadAnalysisInfo("MassAnalysis", "ChannelName", channelName);
anaEL.LoadWeight (sel); // now the parameters for SFBweight are initialized (for b-tag!)
//******************************************
//Load Scale Factors for lepton efficiencies
//******************************************
sel.LoadElScaleFactors();
sel.LoadMuScaleFactors();
sel.InitJESUnc();
bool nonskimmed = false;
TopTree::NTEvent * event = 0;
TFile * TupleFile = new TFile("TupleFileSkimmed_TTbarSemileptonicPowheg.root","RECREATE");
float mttbar_rec, mttbar_gen;
float diffysquare_rec, diffysquare_gen;
float diffabseta_rec, diffabseta_gen;
float weight;
float pt_ttbar, pt_ttbar_gen;
float pz_ttbar, pz_ttbar_gen;
float eta_ttbar_rec, eta_ttbar_gen;
float y_ttbar_rec, y_ttbar_gen;
float diffabsy_rec, diffabsy_gen;
TTree *tree = new TTree("Tuple","Tuple");
tree->Branch("mttbar_rec",&mttbar_rec,"mttbar_rec/F");
tree->Branch("mttbar_gen",&mttbar_gen,"mttbar_gen/F");
tree->Branch("diffysquare_rec",&diffysquare_rec,"diffysquare_rec/F");
tree->Branch("diffysquare_gen",&diffysquare_gen,"diffysquare_gen/F");
tree->Branch("diffabseta_rec",&diffabseta_rec,"diffabseta_rec/F");
tree->Branch("diffabseta_gen",&diffabseta_gen,"diffabseta_gen/F");
tree->Branch("weight",&weight,"weight/F");
tree->Branch("pt_ttbar",&pt_ttbar,"pt_ttbar/F");
tree->Branch("pt_ttbar_gen",&pt_ttbar_gen,"pt_ttbar_gen/F");
tree->Branch("pz_ttbar",&pz_ttbar,"pz_ttbar/F");
tree->Branch("pz_ttbar_gen",&pz_ttbar_gen,"pz_ttbar_gen/F");
tree->Branch("eta_ttbar_rec",&eta_ttbar_rec,"eta_ttbar_rec/F");
tree->Branch("eta_ttbar_gen",&eta_ttbar_gen,"eta_ttbar_gen/F");
tree->Branch("y_ttbar_rec",&y_ttbar_rec,"y_ttbar_rec/F");
tree->Branch("y_ttbar_gen",&y_ttbar_gen,"y_ttbar_gen/F");
tree->Branch("diffabsy_rec",&diffabsy_rec,"diffabsy_rec/F");
tree->Branch("diffabsy_gen",&diffabsy_gen,"diffabsy_gen/F");
//////////////////////
//LOOP OVER THE DATASETS
//////////////////////
if(verbosity>0) {
cout<<"#########################"<<endl;
cout<<" Loop over the datasets "<<endl;
cout<<"#########################"<<endl;
}
float num_mttbar_eff = 0.;
float den_mttbar_eff = 0.;
for (unsigned int d = 0; d < datasets.size (); d++) {
weight_MC = datasets[d].NormFactor()*Luminosity;
if(datasets[d].isData() == true) weight_MC = 1.; cout << "isDATA" << endl;
AMWT amwt(anaEL, datasets[d].isData());
TString sample_name(datasets[d].Name());
bool isData = datasets[d].isData ();
datasets[d].eventTree ()->SetBranchAddress ("NTEvent",&event);
cout << "Sample : " << sample_name<< endl;
cout << "Data : " << isData<< endl;
unsigned int nEventsSample = (int) (datasets[d].eventTree ()->GetEntries ());
unsigned int endEventToRun;
if (firstEvent>nEventsSample) firstEvent = nEventsSample;
if ((nEvents==-1)||((nEvents+firstEvent)>nEventsSample)) endEventToRun = nEventsSample;
else endEventToRun = nEvents+firstEvent;
cout << "Events to run: number / first / last / all: " << endEventToRun-firstEvent
<< " / " << firstEvent << " / " << endEventToRun
<< " / " << nEventsSample << endl;
// Standard parameters for doFullSelection:
bool applyEEScale = false; float EEScaleParam = 1.; bool applyEEResol = false; float EEResolParam = 1.;
bool applyMEScale = false; float MEScaleParam = 1.; bool applyMEResol = false; float MEResolParam = 1.;
bool applyMETS = false; float METScale = 1.;
bool applyJES = false; float JESParam = 1.;
bool applyJER = false; float JERFactor = 0.;
//////////////////////
//LOOP OVER THE EVENTS
//////////////////////
float N_plus_reco = 0;
float N_minus_reco = 0;
float N_plus_gen = 0;
float N_minus_gen = 0;
mttbar_rec = 0;
mttbar_gen = 0;
diffysquare_rec = 0;
diffysquare_gen = 0;
diffabseta_rec = 0;
diffabseta_gen = 0;
weight = weight_MC;
pt_ttbar = 0;
pt_ttbar_gen = 0;
pz_ttbar = 0;
pz_ttbar_gen = 0;
eta_ttbar_rec = 0;
eta_ttbar_gen = 0;
y_ttbar_rec = 0;
y_ttbar_gen = 0;
diffabsy_rec = 0;
diffabsy_gen = 0;
for (unsigned int ievt = firstEvent; ievt < endEventToRun; ievt++) {
// for (unsigned int ievt = 0; ievt < 10; ievt++) {
datasets[d].eventTree ()->GetEntry (ievt);
if(ievt%1000 == 0) cout << "number of processed events " << ievt << endl;
if (verbosity >= 1) cout << "Event : "<< event->runNb<<" , " << event->lumiblock <<" , " << event->eventNb<<endl;
if(!(event->TMEME == 10010 || event->TMEME == 10001 || event->TMEME == 1 || event->TMEME == 10 || event->TMEME == 10000 || event->TMEME == 11000 || event->TMEME == 10100 )) continue;
string candType;
vector<NTElectron> candElec;
vector<NTMuon> candMuon;
//Load event for the selection
sel.LoadEvent(event);
int finalCut = sel.doFullSelection(&(datasets[d]), channelName, false, /*print*/ verbosity,
false, false, -1., -1., applyJES, JESParam,
applyEEScale, EEScaleParam, applyEEResol, EEResolParam,
applyMEScale, MEScaleParam,
applyJER, JERFactor, applyMETS, METScale);
TLorentzVector lvTop1_gen;
TLorentzVector lvTop2_gen;
TLorentzVector lvTop1plusTop2_gen;
float yt_gen = 0.;
float ytbar_gen = 0.;
float Delta_y_gen = 0.;
if(datasets[d].Name() == "TTJets_Sig"){
lvTop1_gen = (event->topAndDecays)[0].p4_t_gen;
lvTop2_gen = (event->topAndDecays)[1].p4_t_gen;
lvTop1plusTop2_gen = lvTop1_gen + lvTop2_gen;
/////////////////////////
//// GENERATOR LEVEL ////
/////////////////////////
histoGenTopRapidity1->Fill(lvTop1_gen.Rapidity());
histoGenTopRapidity2->Fill(lvTop2_gen.Rapidity());
histoGenTopMass1->Fill(lvTop1_gen.M());
histoGenTopMass2->Fill(lvTop2_gen.M());
histoGenTopMass1VsTopMass2->Fill(lvTop1_gen.M(),lvTop2_gen.M());
yt_gen = lvTop1_gen.Rapidity();
if(yt_gen<0.) yt_gen = (-1)*yt_gen;
ytbar_gen = lvTop2_gen.Rapidity();
if(ytbar_gen<0.) ytbar_gen = (-1)*ytbar_gen;
Delta_y_gen = yt_gen - ytbar_gen;
// cout << "Delta_y_gen:" << Delta_y_gen << endl;
histoGenDelta_y->Fill(Delta_y_gen);
histoDelta_yEfficiencyD->Fill(Delta_y_gen);
histoFineBinning_Delta_yEfficiencyD->Fill(Delta_y_gen);
if(Delta_y_gen>0.){
N_plus_gen++;
histoGenN_plusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
histoGenN_plusTTPt->Fill(lvTop1plusTop2_gen.Perp());
histoGenN_plusTTMass->Fill(lvTop1plusTop2_gen.M());
histoFineBinning_GenN_plusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
histoFineBinning_GenN_plusTTPt->Fill(lvTop1plusTop2_gen.Perp());
histoFineBinning_GenN_plusTTMass->Fill(lvTop1plusTop2_gen.M());
}
if(Delta_y_gen<0.){
N_minus_gen++;
histoGenN_minusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
histoGenN_minusTTPt->Fill(lvTop1plusTop2_gen.Perp());
histoGenN_minusTTMass->Fill(lvTop1plusTop2_gen.M());
histoFineBinning_GenN_minusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
histoFineBinning_GenN_minusTTPt->Fill(lvTop1plusTop2_gen.Perp());
histoFineBinning_GenN_minusTTMass->Fill(lvTop1plusTop2_gen.M());
}
histoGenTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
histoGenTTPt->Fill(lvTop1plusTop2_gen.Perp());
histoGenTTMass->Fill(lvTop1plusTop2_gen.M());
histoGenDelta_yVsTTRapidity->Fill(Delta_y_gen, lvTop1plusTop2_gen.Rapidity());
histoGenDelta_yVsTTPt->Fill(Delta_y_gen, lvTop1plusTop2_gen.Perp());
histoGenDelta_yVsTTMass->Fill(Delta_y_gen, lvTop1plusTop2_gen.M());
histoFineBinning_GenDelta_yVsTTRapidity->Fill(Delta_y_gen, lvTop1plusTop2_gen.Rapidity());
histoFineBinning_GenDelta_yVsTTPt->Fill(Delta_y_gen, lvTop1plusTop2_gen.Perp());
histoFineBinning_GenDelta_yVsTTMass->Fill(Delta_y_gen, lvTop1plusTop2_gen.M());
if(nonskimmed == true){
mttbar_gen = lvTop1plusTop2_gen.M();
diffysquare_gen = yt_gen*yt_gen - ytbar_gen*ytbar_gen;
diffabseta_gen = fabs(lvTop1_gen.Eta()) - fabs(lvTop2_gen.Eta());
pt_ttbar_gen = lvTop1plusTop2_gen.Perp();
pz_ttbar_gen = lvTop1plusTop2_gen.Pz();
eta_ttbar_gen = lvTop1plusTop2_gen.Eta();
y_ttbar_gen = lvTop1plusTop2_gen.Rapidity();
diffabsy_gen = fabs(lvTop1_gen.Rapidity()) - fabs(lvTop2_gen.Rapidity());
}
}
if (finalCut >6) {
if(nonskimmed == false){
if(datasets[d].Name() == "TTJets_Sig"){
mttbar_gen = lvTop1plusTop2_gen.M();
diffysquare_gen = yt_gen*yt_gen - ytbar_gen*ytbar_gen;
diffabseta_gen = fabs(lvTop1_gen.Eta()) - fabs(lvTop2_gen.Eta());
pt_ttbar_gen = lvTop1plusTop2_gen.Perp();
pz_ttbar_gen = lvTop1plusTop2_gen.Pz();
eta_ttbar_gen = lvTop1plusTop2_gen.Eta();
y_ttbar_gen = lvTop1plusTop2_gen.Rapidity();
diffabsy_gen = fabs(lvTop1_gen.Rapidity()) - fabs(lvTop2_gen.Rapidity());
}
}
sel.GetLeptonPair(candMuon, candElec, candType);
for(unsigned int i=0; i<candMuon.size(); i++){
if(candMuon[i].Charge == +1) histoRecoLeptonRapidity1->Fill(candMuon[i].p4.Rapidity());
if(candMuon[i].Charge == -1) histoRecoLeptonRapidity2->Fill(candMuon[i].p4.Rapidity());
}
for(unsigned int j=0; j<candElec.size(); j++){
if(candElec[j].Charge == +1) histoRecoLeptonRapidity1->Fill(candElec[j].p4.Rapidity());
if(candElec[j].Charge == -1) histoRecoLeptonRapidity2->Fill(candElec[j].p4.Rapidity());
}
TLorentzVector lvTop1_reco;
TLorentzVector lvTop2_reco;
TLorentzVector lvTop1plusTop2_reco;
TopMassVariables * tmv = amwt.findMass(sel, lvTop1_reco, lvTop2_reco);
lvTop1plusTop2_reco = lvTop1_reco + lvTop2_reco;
////////////////////
/// RECO LEVEL /////
////////////////////
histoRecoTopRapidity1->Fill(lvTop1_reco.Rapidity());
histoRecoTopRapidity2->Fill(lvTop2_reco.Rapidity());
histoRecoTopMass1->Fill(lvTop1_reco.M());
histoRecoTopMass2->Fill(lvTop2_reco.M());
histoRecoTopMass1VsTopMass2->Fill(lvTop1_reco.M(),lvTop2_reco.M());
float yt_reco = lvTop1_reco.Rapidity();
if(yt_reco<0.) yt_reco = (-1)*yt_reco;
float ytbar_reco = lvTop2_reco.Rapidity();
if(ytbar_reco<0.) ytbar_reco = (-1)*ytbar_reco;
float Delta_y_reco = yt_reco - ytbar_reco;
// cout << "Delta_y_reco:" << Delta_y_reco << endl;
histoRecoDelta_y->Fill(Delta_y_reco);
histoDelta_yEfficiencyN->Fill(Delta_y_reco);
histoFineBinning_Delta_yEfficiencyN->Fill(Delta_y_reco);
if(Delta_y_reco>0.){
N_plus_reco++;
histoRecoN_plusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
histoRecoN_plusTTPt->Fill(lvTop1plusTop2_reco.Perp());
histoRecoN_plusTTMass->Fill(lvTop1plusTop2_reco.M());
histoFineBinning_RecoN_plusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
histoFineBinning_RecoN_plusTTPt->Fill(lvTop1plusTop2_reco.Perp());
histoFineBinning_RecoN_plusTTMass->Fill(lvTop1plusTop2_reco.M());
}
if(Delta_y_reco<0.){
N_minus_reco++;
histoRecoN_minusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
histoRecoN_minusTTPt->Fill(lvTop1plusTop2_reco.Perp());
histoRecoN_minusTTMass->Fill(lvTop1plusTop2_reco.M());
histoFineBinning_RecoN_minusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
histoFineBinning_RecoN_minusTTPt->Fill(lvTop1plusTop2_reco.Perp());
histoFineBinning_RecoN_minusTTMass->Fill(lvTop1plusTop2_reco.M());
}
histoRecoTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
histoRecoTTPt->Fill(lvTop1plusTop2_reco.Perp());
histoRecoTTMass->Fill(lvTop1plusTop2_reco.M());
histoRecoDelta_yVsTTRapidity->Fill(Delta_y_reco, lvTop1plusTop2_reco.Rapidity());
histoRecoDelta_yVsTTPt->Fill(Delta_y_reco, lvTop1plusTop2_reco.Perp());
histoRecoDelta_yVsTTMass->Fill(Delta_y_reco, lvTop1plusTop2_reco.M());
histoFineBinning_RecoDelta_yVsTTRapidity->Fill(Delta_y_reco, lvTop1plusTop2_reco.Rapidity());
histoFineBinning_RecoDelta_yVsTTPt->Fill(Delta_y_reco, lvTop1plusTop2_reco.Perp());
histoFineBinning_RecoDelta_yVsTTMass->Fill(Delta_y_reco, lvTop1plusTop2_reco.M());
if(nonskimmed == false){
mttbar_rec = lvTop1plusTop2_reco.M();
diffysquare_rec = yt_reco*yt_reco - ytbar_reco*ytbar_reco;
diffabseta_rec = fabs(lvTop1_reco.Eta()) - fabs(lvTop2_reco.Eta());
pt_ttbar = lvTop1plusTop2_reco.Perp();
pz_ttbar = lvTop1plusTop2_reco.Pz();
eta_ttbar_rec = lvTop1plusTop2_reco.Eta();
y_ttbar_rec = lvTop1plusTop2_reco.Rapidity();
diffabsy_rec = fabs(lvTop1_reco.Rapidity()) - fabs(lvTop2_reco.Rapidity());
}
////////////////////////
// RECO VS GEN LEVEL ///
////////////////////////
if(datasets[d].Name() == "TTJets_Sig"){
histoRecoVsGenTopRapidity1->Fill(lvTop1_reco.Rapidity(), lvTop1_gen.Rapidity());
histoRecoVsGenTopRapidity2->Fill(lvTop2_reco.Rapidity(), lvTop2_gen.Rapidity());
histoRecoVsGenTopMass1->Fill(lvTop1_reco.M(), lvTop1_gen.M());
histoRecoVsGenTopMass2->Fill(lvTop2_reco.M(), lvTop2_gen.M());
histoRecoMinusGenDivGenTopRapidity1->Fill((lvTop1_reco.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity());
histoRecoMinusGenDivGenTopRapidity2->Fill((lvTop2_reco.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity());
for(unsigned int i=0; i<candMuon.size(); i++){
if(candMuon[i].Charge == +1) histoRecoMinusGenDivGenLeptonRapidity1->Fill((candMuon[i].p4.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity());
if(candMuon[i].Charge == -1) histoRecoMinusGenDivGenLeptonRapidity2->Fill((candMuon[i].p4.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity());
}
for(unsigned int j=0; j<candElec.size(); j++){
if(candElec[j].Charge == +1) histoRecoMinusGenDivGenLeptonRapidity1->Fill((candElec[j].p4.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity());
if(candElec[j].Charge == -1) histoRecoMinusGenDivGenLeptonRapidity2->Fill((candElec[j].p4.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity());
}
histoRecoMinusGenDivGenTopMass1->Fill((lvTop1_reco.M() - lvTop1_gen.M())/lvTop1_gen.M());
histoRecoMinusGenDivGenTopMass2->Fill((lvTop2_reco.M() - lvTop2_gen.M())/lvTop2_gen.M());
histoRecoVsGenDelta_y->Fill(Delta_y_reco, Delta_y_gen);
histoFineBinning_RecoVsGenDelta_y->Fill(Delta_y_reco, Delta_y_gen);
histoRecoMinusGenDivGenDelta_y->Fill((Delta_y_reco - Delta_y_gen)/Delta_y_gen);
histoRecoVsGenTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity(),lvTop1plusTop2_gen.Rapidity());
histoRecoMinusGenDivGenTTRapidity->Fill((lvTop1plusTop2_reco.Rapidity() - lvTop1plusTop2_gen.Rapidity())/lvTop1plusTop2_gen.Rapidity());
histoRecoVsGenTTPt->Fill(lvTop1plusTop2_reco.Perp(),lvTop1plusTop2_gen.Perp());
histoRecoMinusGenDivGenTTPt->Fill((lvTop1plusTop2_reco.Perp() - lvTop1plusTop2_gen.Perp())/lvTop1plusTop2_gen.Perp());
histoRecoVsGenTTMass->Fill(lvTop1plusTop2_reco.M(),lvTop1plusTop2_gen.M());
histoRecoMinusGenDivGenTTMass->Fill((lvTop1plusTop2_reco.M() - lvTop1plusTop2_gen.M())/lvTop1plusTop2_gen.M());
}
// tmv->printAll();
delete tmv;
if(nonskimmed == false && mttbar_rec > 60.){ tree->Fill(); num_mttbar_eff += weight_MC;}
if(nonskimmed == false) den_mttbar_eff += weight_MC;
}
if(nonskimmed == true) tree->Fill();
} // end of loop over evts
float A_C_reco = (N_plus_reco - N_minus_reco)/(N_plus_reco + N_minus_reco);
float A_C_gen = (N_plus_gen - N_minus_gen)/(N_plus_gen + N_minus_gen);
cout << "A_C_gen:" << A_C_gen << endl;
cout << "A_C_reco:" << A_C_reco << endl;
histoGenN_plusMinusN_minusTTRapidity->Add(histoGenN_plusTTRapidity);
histoGenN_plusMinusN_minusTTRapidity->Add(histoGenN_minusTTRapidity,-1);
histoGenN_plusPlusN_minusTTRapidity->Add(histoGenN_plusTTRapidity);
histoGenN_plusPlusN_minusTTRapidity->Add(histoGenN_minusTTRapidity);
histoGenA_cTTRapidity->Divide(histoGenN_plusMinusN_minusTTRapidity, histoGenN_plusPlusN_minusTTRapidity);
histoGenN_plusMinusN_minusTTPt->Add(histoGenN_plusTTPt);
histoGenN_plusMinusN_minusTTPt->Add(histoGenN_minusTTPt,-1);
histoGenN_plusPlusN_minusTTPt->Add(histoGenN_plusTTPt);
histoGenN_plusPlusN_minusTTPt->Add(histoGenN_minusTTPt);
histoGenA_cTTPt->Divide(histoGenN_plusMinusN_minusTTPt, histoGenN_plusPlusN_minusTTPt);
histoGenN_plusMinusN_minusTTMass->Add(histoGenN_plusTTMass);
histoGenN_plusMinusN_minusTTMass->Add(histoGenN_minusTTMass,-1);
histoGenN_plusPlusN_minusTTMass->Add(histoGenN_plusTTMass);
histoGenN_plusPlusN_minusTTMass->Add(histoGenN_minusTTMass);
histoGenA_cTTMass->Divide(histoGenN_plusMinusN_minusTTMass, histoGenN_plusPlusN_minusTTMass);
histoRecoN_plusMinusN_minusTTRapidity->Add(histoRecoN_plusTTRapidity);
histoRecoN_plusMinusN_minusTTRapidity->Add(histoRecoN_minusTTRapidity,-1);
histoRecoN_plusPlusN_minusTTRapidity->Add(histoRecoN_plusTTRapidity);
histoRecoN_plusPlusN_minusTTRapidity->Add(histoRecoN_minusTTRapidity);
histoRecoA_cTTRapidity->Divide(histoRecoN_plusMinusN_minusTTRapidity, histoRecoN_plusPlusN_minusTTRapidity);
histoRecoN_plusMinusN_minusTTPt->Add(histoRecoN_plusTTPt);
histoRecoN_plusMinusN_minusTTPt->Add(histoRecoN_minusTTPt,-1);
histoRecoN_plusPlusN_minusTTPt->Add(histoRecoN_plusTTPt);
histoRecoN_plusPlusN_minusTTPt->Add(histoRecoN_minusTTPt);
histoRecoA_cTTPt->Divide(histoRecoN_plusMinusN_minusTTPt, histoRecoN_plusPlusN_minusTTPt);
histoRecoN_plusMinusN_minusTTMass->Add(histoRecoN_plusTTMass);
histoRecoN_plusMinusN_minusTTMass->Add(histoRecoN_minusTTMass,-1);
histoRecoN_plusPlusN_minusTTMass->Add(histoRecoN_plusTTMass);
histoRecoN_plusPlusN_minusTTMass->Add(histoRecoN_minusTTMass);
histoRecoA_cTTMass->Divide(histoRecoN_plusMinusN_minusTTMass, histoRecoN_plusPlusN_minusTTMass);
histoFineBinning_GenN_plusMinusN_minusTTRapidity->Add(histoFineBinning_GenN_plusTTRapidity);
histoFineBinning_GenN_plusMinusN_minusTTRapidity->Add(histoFineBinning_GenN_minusTTRapidity,-1);
histoFineBinning_GenN_plusPlusN_minusTTRapidity->Add(histoFineBinning_GenN_plusTTRapidity);
histoFineBinning_GenN_plusPlusN_minusTTRapidity->Add(histoFineBinning_GenN_minusTTRapidity);
histoFineBinning_GenA_cTTRapidity->Divide(histoFineBinning_GenN_plusMinusN_minusTTRapidity, histoFineBinning_GenN_plusPlusN_minusTTRapidity);
histoFineBinning_GenN_plusMinusN_minusTTPt->Add(histoFineBinning_GenN_plusTTPt);
histoFineBinning_GenN_plusMinusN_minusTTPt->Add(histoFineBinning_GenN_minusTTPt,-1);
histoFineBinning_GenN_plusPlusN_minusTTPt->Add(histoFineBinning_GenN_plusTTPt);
histoFineBinning_GenN_plusPlusN_minusTTPt->Add(histoFineBinning_GenN_minusTTPt);
histoFineBinning_GenA_cTTPt->Divide(histoFineBinning_GenN_plusMinusN_minusTTPt, histoFineBinning_GenN_plusPlusN_minusTTPt);
histoFineBinning_GenN_plusMinusN_minusTTMass->Add(histoFineBinning_GenN_plusTTMass);
histoFineBinning_GenN_plusMinusN_minusTTMass->Add(histoFineBinning_GenN_minusTTMass,-1);
histoFineBinning_GenN_plusPlusN_minusTTMass->Add(histoFineBinning_GenN_plusTTMass);
histoFineBinning_GenN_plusPlusN_minusTTMass->Add(histoFineBinning_GenN_minusTTMass);
histoFineBinning_GenA_cTTMass->Divide(histoFineBinning_GenN_plusMinusN_minusTTMass, histoFineBinning_GenN_plusPlusN_minusTTMass);
histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Add(histoFineBinning_RecoN_plusTTRapidity);
histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Add(histoFineBinning_RecoN_minusTTRapidity,-1);
histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Add(histoFineBinning_RecoN_plusTTRapidity);
histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Add(histoFineBinning_RecoN_minusTTRapidity);
histoFineBinning_RecoA_cTTRapidity->Divide(histoFineBinning_RecoN_plusMinusN_minusTTRapidity, histoFineBinning_RecoN_plusPlusN_minusTTRapidity);
histoFineBinning_RecoN_plusMinusN_minusTTPt->Add(histoFineBinning_RecoN_plusTTPt);
histoFineBinning_RecoN_plusMinusN_minusTTPt->Add(histoFineBinning_RecoN_minusTTPt,-1);
histoFineBinning_RecoN_plusPlusN_minusTTPt->Add(histoFineBinning_RecoN_plusTTPt);
histoFineBinning_RecoN_plusPlusN_minusTTPt->Add(histoFineBinning_RecoN_minusTTPt);
histoFineBinning_RecoA_cTTPt->Divide(histoFineBinning_RecoN_plusMinusN_minusTTPt, histoFineBinning_RecoN_plusPlusN_minusTTPt);
histoFineBinning_RecoN_plusMinusN_minusTTMass->Add(histoFineBinning_RecoN_plusTTMass);
histoFineBinning_RecoN_plusMinusN_minusTTMass->Add(histoFineBinning_RecoN_minusTTMass,-1);
histoFineBinning_RecoN_plusPlusN_minusTTMass->Add(histoFineBinning_RecoN_plusTTMass);
histoFineBinning_RecoN_plusPlusN_minusTTMass->Add(histoFineBinning_RecoN_minusTTMass);
histoFineBinning_RecoA_cTTMass->Divide(histoFineBinning_RecoN_plusMinusN_minusTTMass, histoFineBinning_RecoN_plusPlusN_minusTTMass);
histoDelta_yEfficiency->Divide(histoDelta_yEfficiencyN, histoDelta_yEfficiencyD);
histoFineBinning_Delta_yEfficiency->Divide(histoFineBinning_Delta_yEfficiencyN, histoFineBinning_Delta_yEfficiencyD);
for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) {
for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) {
float value = histoRecoDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2);
histoDelta_yVsTTRapidityEfficiency->SetBinContent(bin_index1, bin_index2, value);
float value_fb = histoFineBinning_RecoDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2);
histoFineBinning_Delta_yVsTTRapidityEfficiency->SetBinContent(bin_index1, bin_index2, value_fb);
}
}
for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) {
for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) {
float value = histoRecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2);
histoDelta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value);
float value_fb = histoFineBinning_RecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2);
histoFineBinning_Delta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value_fb);
}
}
for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) {
for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) {
float value = histoRecoDelta_yVsTTMass->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTMass->GetBinContent(bin_index1,bin_index2);
histoDelta_yVsTTMassEfficiency->SetBinContent(bin_index1, bin_index2, value);
float value_fb = histoFineBinning_RecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2);
histoFineBinning_Delta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value_fb);
}
}
} // end of loop over the datasets
// if(verbosity>0) {
cout<<"#########################"<<endl;
cout<<" End of the program "<<endl;
cout<<"#########################"<<endl;
// }
tree->Print();
TupleFile->Write();
TupleFile->Close();
TFile * fileCA = new TFile("ChargeAsymmetryResults_Skimmed_TTbarSemileptonicPowheg.root","RECREATE");
// fileCA->cd();
// GEN
histoGenTopRapidity1->Write();
histoGenTopRapidity2->Write();
histoGenTopMass1->Write();
histoGenTopMass2->Write();
histoGenTopMass1VsTopMass2->Write();
histoGenDelta_y->Write();
histoGenTTRapidity->Write();
histoGenTTPt->Write();
histoGenTTMass->Write();
histoGenDelta_yVsTTRapidity->Write();
histoGenDelta_yVsTTPt->Write();
histoGenDelta_yVsTTMass->Write();
histoGenN_plusTTRapidity->Write();
histoGenN_plusTTPt->Write();
histoGenN_plusTTMass->Write();
histoGenN_minusTTRapidity->Write();
histoGenN_minusTTPt->Write();
histoGenN_minusTTMass->Write();
histoGenN_plusMinusN_minusTTRapidity->Write();
histoGenN_plusPlusN_minusTTRapidity->Write();
histoGenN_plusMinusN_minusTTPt->Write();
histoGenN_plusPlusN_minusTTPt->Write();
histoGenN_plusMinusN_minusTTMass->Write();
histoGenN_plusPlusN_minusTTMass->Write();
histoGenA_cTTRapidity->Write();
histoGenA_cTTPt->Write();
histoGenA_cTTMass->Write();
histoFineBinning_GenDelta_yVsTTRapidity->Write();
histoFineBinning_GenDelta_yVsTTPt->Write();
histoFineBinning_GenDelta_yVsTTMass->Write();
histoFineBinning_GenN_plusTTRapidity->Write();
histoFineBinning_GenN_plusTTPt->Write();
histoFineBinning_GenN_plusTTMass->Write();
histoFineBinning_GenN_minusTTRapidity->Write();
histoFineBinning_GenN_minusTTPt->Write();
histoFineBinning_GenN_minusTTMass->Write();
histoFineBinning_GenN_plusMinusN_minusTTRapidity->Write();
histoFineBinning_GenN_plusPlusN_minusTTRapidity->Write();
histoFineBinning_GenN_plusMinusN_minusTTPt->Write();
histoFineBinning_GenN_plusPlusN_minusTTPt->Write();
histoFineBinning_GenN_plusMinusN_minusTTMass->Write();
histoFineBinning_GenN_plusPlusN_minusTTMass->Write();
histoFineBinning_GenA_cTTRapidity->Write();
histoFineBinning_GenA_cTTPt->Write();
histoFineBinning_GenA_cTTMass->Write();
// RECO
histoRecoTopRapidity1->Write();
histoRecoTopRapidity2->Write();
histoRecoLeptonRapidity1->Write();
histoRecoLeptonRapidity2->Write();
histoRecoTopMass1->Write();
histoRecoTopMass2->Write();
histoRecoTopMass1VsTopMass2->Write();
histoRecoDelta_y->Write();
histoRecoTTRapidity->Write();
histoRecoTTPt->Write();
histoRecoTTMass->Write();
histoRecoDelta_yVsTTRapidity->Write();
histoRecoDelta_yVsTTPt->Write();
histoRecoDelta_yVsTTMass->Write();
histoRecoN_plusTTRapidity->Write();
histoRecoN_plusTTPt->Write();
histoRecoN_plusTTMass->Write();
histoRecoN_minusTTRapidity->Write();
histoRecoN_minusTTPt->Write();
histoRecoN_minusTTMass->Write();
histoRecoN_plusMinusN_minusTTRapidity->Write();
histoRecoN_plusPlusN_minusTTRapidity->Write();
histoRecoN_plusMinusN_minusTTPt->Write();
histoRecoN_plusPlusN_minusTTPt->Write();
histoRecoN_plusMinusN_minusTTMass->Write();
histoRecoN_plusPlusN_minusTTMass->Write();
histoRecoA_cTTRapidity->Write();
histoRecoA_cTTPt->Write();
histoRecoA_cTTMass->Write();
histoFineBinning_RecoDelta_yVsTTRapidity->Write();
histoFineBinning_RecoDelta_yVsTTPt->Write();
histoFineBinning_RecoDelta_yVsTTMass->Write();
histoFineBinning_RecoN_plusTTRapidity->Write();
histoFineBinning_RecoN_plusTTPt->Write();
histoFineBinning_RecoN_plusTTMass->Write();
histoFineBinning_RecoN_minusTTRapidity->Write();
histoFineBinning_RecoN_minusTTPt->Write();
histoFineBinning_RecoN_minusTTMass->Write();
histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Write();
histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Write();
histoFineBinning_RecoN_plusMinusN_minusTTPt->Write();
histoFineBinning_RecoN_plusPlusN_minusTTPt->Write();
histoFineBinning_RecoN_plusMinusN_minusTTMass->Write();
histoFineBinning_RecoN_plusPlusN_minusTTMass->Write();
histoFineBinning_RecoA_cTTRapidity->Write();
histoFineBinning_RecoA_cTTPt->Write();
histoFineBinning_RecoA_cTTMass->Write();
// RECO vs GEN
histoRecoVsGenTopRapidity1->Write();
histoRecoVsGenTopRapidity2->Write();
histoRecoMinusGenDivGenLeptonRapidity1->Write();
histoRecoMinusGenDivGenLeptonRapidity2->Write();
histoRecoMinusGenDivGenTopRapidity1->Write();
histoRecoMinusGenDivGenTopRapidity2->Write();
histoRecoVsGenTopMass1->Write();
histoRecoVsGenTopMass2->Write();
histoRecoMinusGenDivGenTopMass1->Write();
histoRecoMinusGenDivGenTopMass2->Write();
histoRecoVsGenDelta_y->Write();
histoFineBinning_RecoVsGenDelta_y->Write();
histoRecoMinusGenDivGenDelta_y->Write();
histoRecoVsGenTTRapidity->Write();
histoRecoMinusGenDivGenTTRapidity->Write();
histoRecoVsGenTTPt->Write();
histoRecoMinusGenDivGenTTPt->Write();
histoRecoVsGenTTMass->Write();
histoRecoMinusGenDivGenTTMass->Write();
histoDelta_yEfficiencyN->Write();
histoDelta_yEfficiencyD->Write();
histoDelta_yEfficiency->Write();
histoDelta_yVsTTRapidityEfficiency->Write();
histoDelta_yVsTTPtEfficiency->Write();
histoDelta_yVsTTMassEfficiency->Write();
histoFineBinning_Delta_yEfficiencyN->Write();
histoFineBinning_Delta_yEfficiencyD->Write();
histoFineBinning_Delta_yEfficiency->Write();
histoFineBinning_Delta_yVsTTRapidityEfficiency->Write();
histoFineBinning_Delta_yVsTTPtEfficiency->Write();
histoFineBinning_Delta_yVsTTMassEfficiency->Write();
// fileCA->Write();
fileCA->Close();
delete fileCA;
cout << "num_mttbar_eff = " << num_mttbar_eff << endl;
cout << "den_mttbar_eff = " << den_mttbar_eff << endl;
cout << "mttbar_eff = " << num_mttbar_eff / den_mttbar_eff << endl;
return (0);
}
int main ()
{
cout<<"#########################"<<endl;
cout<<"Beginning of the program"<<endl;
cout<<"#########################"<<endl;
//////////////////////
//Global variables
//////////////////////
vector < Dataset > datasets;
DiLeptonSelection sel;
float Luminosity = 0;
// 0: MC - 1: Data - 2 Data & MC
int DataType = 0;
int verbosity = -1;
//////////////////////
//////////////////////
// Initialisation
//////////////////////
string xmlFileName = string ("../../config/MyVar.xml");
AnalysisEnvironmentLoader anaEL (xmlFileName);
anaEL.LoadSamples (datasets); // now the list of datasets written in the xml file is known
anaEL.LoadDiLeptonSelection (sel); // now the parameters for the selection are given to the selection
anaEL.LoadGeneralInfo(DataType, Luminosity, verbosity );
anaEL.LoadWeight (sel); // now the parameters for SFBweight are initialized (for b-tag!)
TopTree::NTEvent * event = 0;
//dataset weights
double Dweight[101];
for(int k0=0; k0<5; ++k0) {
for(int k1=0; k1<101; ++k1) {
Dweight[k1] = 0.;
}
}
vector<string> CutName;
vector<string> VecChannelName;
// Here define the studied channel (ee/mumu/emu)
string ChannelName = "mumu"; // "mumu", "ee", "emu"
int ITypeMC = -1;
int ICut = -1;
int IChannel = -1;
if ( ChannelName == "mumu" ) IChannel = 0;
if ( ChannelName == "ee" ) IChannel = 1;
if ( ChannelName == "emu" ) IChannel = 2;
int nbins = 200;
float minx = 0.;
float maxx = 350;
cout<<"The verbosity mode is "<<verbosity <<endl;
cout<<"The luminosity is equal to "<< Luminosity<<endl;
cout<<"The DataType is ";
switch(DataType){
case 0:
cout<<"MC"<<endl;
break;
case 1:
cout<<"Data"<<endl;
break;
case 2:
cout<<"Data & MC"<<endl;
break;
default:
cout<<" unknown"<<endl;
break;
}
//////////////////////
HistoManager MyhistoManager;
MyhistoManager.LoadDatasets(datasets);
// std::vector<TH1F> PATElecPt;
// std::vector<TH1F> PATElecRelIso;
// std::vector<TH1F> PATMuonPt;
// std::vector<TH1F> PATMuonRelIso;
std::vector<TH1F> PFElecPt;
std::vector<TH1F> PFElecNeutralHadIso;
std::vector<TH1F> PFElecChargedHadIso;
std::vector<TH1F> PFElecPhotonIso;
std::vector<TH1F> PFElecTrackIso;
std::vector<TH1F> PFElecRelIso;
std::vector<TH1F> PFElecEcalDriven;
std::vector<TH1F> PFElecGsfEl;
std::vector<TH1F> PFElecD0;
std::vector<TH1F> PFElecId90;
std::vector<TH1F> PFElecConv;
std::vector<TH1F> PFElecRelIsoRhoCorrected;
std::vector<TH1F> PFElecRelIsoNeutralRhoCorrected;
std::vector<TH1F> PFMuonPt;
std::vector<TH1F> PFMuonNeutralHadIso;
std::vector<TH1F> PFMuonChargedHadIso;
std::vector<TH1F> PFMuonPhotonIso;
std::vector<TH1F> PFMuonTrackIso;
std::vector<TH1F> PFMuonRelIso;
std::vector<TH1F> PFMuonType;
std::vector<TH1F> PFMuonChi2;
std::vector<TH1F> PFMuonTrValHit;
std::vector<TH1F> PFMuonValHit;
std::vector<TH1F> PFMuonD0;
std::vector<TH1F> PFMuonZvx;
std::vector<TH1F> PFMuonRelIsoRhoCorrected;
std::vector<TH1F> PFMuonRelIsoNeutralRhoCorrected;
std::vector<TH1F> TMEME;
// std::vector<TH1F> PATElecPt_FromW;
// std::vector<TH1F> PATElecRelIso_FromW;
// std::vector<TH1F> PATMuonPt_FromW;
// std::vector<TH1F> PATMuonRelIso_FromW;
// std::vector<TH1F> PATElecPt_FromW_Cut015;
// std::vector<TH1F> PATMuonPt_FromW_Cut015;
std::vector<TH1F> PFElecPt_FromW;
std::vector<TH1F> PFElecNeutralHadIso_FromW;
std::vector<TH1F> PFElecChargedHadIso_FromW;
std::vector<TH1F> PFElecPhotonIso_FromW;
std::vector<TH1F> PFElecTrackIso_FromW;
std::vector<TH1F> PFElecRelIso_FromW;
std::vector<TH1F> PFMuonPt_FromW;
std::vector<TH1F> PFMuonNeutralHadIso_FromW;
std::vector<TH1F> PFMuonChargedHadIso_FromW;
std::vector<TH1F> PFMuonPhotonIso_FromW;
std::vector<TH1F> PFMuonTrackIso_FromW;
std::vector<TH1F> PFMuonRelIso_FromW;
std::vector<TH1F> PFElecPt_FromW_Cut015;
std::vector<TH1F> PFMuonPt_FromW_Cut015;
std::vector<TH1F> PFMuonType_FromW;
// std::vector<TH1F> PATElecPt_FromBC;
// std::vector<TH1F> PATElecRelIso_FromBC;
// std::vector<TH1F> PATMuonPt_FromBC;
// std::vector<TH1F> PATMuonRelIso_FromBC;
// std::vector<TH1F> PATElecPt_FromBC_Cut015;
// std::vector<TH1F> PATMuonPt_FromBC_Cut015;
std::vector<TH1F> PFElecPt_FromBC;
std::vector<TH1F> PFElecNeutralHadIso_FromBC;
std::vector<TH1F> PFElecChargedHadIso_FromBC;
std::vector<TH1F> PFElecPhotonIso_FromBC;
std::vector<TH1F> PFElecTrackIso_FromBC;
std::vector<TH1F> PFElecRelIso_FromBC;
std::vector<TH1F> PFMuonPt_FromBC;
std::vector<TH1F> PFMuonNeutralHadIso_FromBC;
std::vector<TH1F> PFMuonChargedHadIso_FromBC;
std::vector<TH1F> PFMuonPhotonIso_FromBC;
std::vector<TH1F> PFMuonTrackIso_FromBC;
std::vector<TH1F> PFMuonRelIso_FromBC;
std::vector<TH1F> PFElecPt_FromBC_Cut015;
std::vector<TH1F> PFMuonPt_FromBC_Cut015;
std::vector<TH1F> PFMuonType_FromBC;
//////////////////////
//LOOP OVER THE DATASETS
//////////////////////
if(verbosity>0) {
cout<<"#########################"<<endl;
cout<<" Loop over the datasets "<<endl;
cout<<"#########################"<<endl;
}
for (unsigned int d = 0; d < datasets.size (); d++) {
datasets[d].eventTree ()->SetBranchAddress ("NTEvent",&event);
unsigned int nEvents = (int) (datasets[d].eventTree ()->GetEntries ());
cout << "NEvents = " << nEvents << endl;
// MyhistoManager.CreateHisto(PATElecPt, "PATElecPt" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATElecRelIso, "PATElecRelIso" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
// MyhistoManager.CreateHisto(PATMuonPt, "PATMuonPt" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATMuonRelIso, "PATMuonRelIso" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFElecPt, "PFElecPt" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFElecNeutralHadIso, "PFElecNeutralHadIso" ,datasets[d].Name(),"NeutralHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecChargedHadIso, "PFElecChargedHadIso" ,datasets[d].Name(),"ChargedHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecPhotonIso, "PFElecPhotonIso" ,datasets[d].Name(),"PhotonIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecTrackIso, "PFElecTrackIso" ,datasets[d].Name(),"TrackIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecRelIso, "PFElecRelIso" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFElecEcalDriven, "PFElecEcalDriven" ,datasets[d].Name(),"isEcalDriven","Entries",2,-0.5,1.5);
MyhistoManager.CreateHisto(PFElecGsfEl, "PFElecGsfEl" ,datasets[d].Name(),"isGsfEl","Entries",2,-0.5,1.5);
MyhistoManager.CreateHisto(PFElecD0, "PFElecD0" ,datasets[d].Name(),"D0","Entries",50,0.,1.);
MyhistoManager.CreateHisto(PFElecId90, "PFElecId90" ,datasets[d].Name(),"isId90","Entries",2,-0.5,1.5);
MyhistoManager.CreateHisto(PFElecConv, "PFElecConv" ,datasets[d].Name(),"isConv","Entries",2,-0.5,1.5);
MyhistoManager.CreateHisto(PFElecRelIsoRhoCorrected, "PFElecRelIsoRhoCorrected" ,datasets[d].Name(),"RelIsoRhoCorrected","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFElecRelIsoNeutralRhoCorrected, "PFElecRelIsoNeutralRhoCorrected",datasets[d].Name(),"RelIsoNeutralRhoCorrected","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFMuonPt, "PFMuonPt" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFMuonNeutralHadIso, "PFMuonNeutralHadIso" ,datasets[d].Name(),"NeutralHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonChargedHadIso, "PFMuonChargedHadIso" ,datasets[d].Name(),"ChargedHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonPhotonIso, "PFMuonPhotonIso" ,datasets[d].Name(),"PhotonIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonTrackIso, "PFMuonTrackIso" ,datasets[d].Name(),"TrackIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonRelIso, "PFMuonRelIso" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(TMEME, "TMEME" ,datasets[d].Name(),"TMEME","Entries",1000,0.,30000);
MyhistoManager.CreateHisto(PFMuonType, "PFMuonType" ,datasets[d].Name(),"Type","Entries",120,0.,119);
MyhistoManager.CreateHisto(PFMuonChi2, "PFMuonChi2" ,datasets[d].Name(),"Chi2","Entries",50,0.,50);
MyhistoManager.CreateHisto(PFMuonTrValHit, "PFMuonTrValHit" ,datasets[d].Name(),"TrValHit","Entries",50,0.,50);
MyhistoManager.CreateHisto(PFMuonValHit, "PFMuonValHit" ,datasets[d].Name(),"ValHit","Entries",50,0.,50);
MyhistoManager.CreateHisto(PFMuonD0, "PFMuonD0" ,datasets[d].Name(),"D0","Entries",50,0.,1.);
MyhistoManager.CreateHisto(PFMuonZvx, "PFMuonZvx" ,datasets[d].Name(),"D0","Entries",50,0.,1);
MyhistoManager.CreateHisto(PFMuonRelIsoRhoCorrected, "PFMuonRelIsoRhoCorrected" ,datasets[d].Name(),"RelIsoRhoCorrected","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFMuonRelIsoNeutralRhoCorrected, "PFMuonRelIsoNeutralRhoCorrected",datasets[d].Name(),"RelIsoNeutralRhoCorrected","Entries",50,0.,1.0);
// MyhistoManager.CreateHisto(PATElecPt_FromW, "PATElecPt_FromW" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATElecRelIso_FromW, "PATElecRelIso_FromW" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
// MyhistoManager.CreateHisto(PATMuonPt_FromW, "PATMuonPt_FromW" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATMuonRelIso_FromW, "PATMuonRelIso_FromW" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
// MyhistoManager.CreateHisto(PATElecPt_FromW_Cut015, "PATElecPt_FromW_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATMuonPt_FromW_Cut015, "PATMuonPt_FromW_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFElecPt_FromW, "PFElecPt_FromW" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFElecNeutralHadIso_FromW, "PFElecNeutralHadIso_FromW" ,datasets[d].Name(),"NeutralHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecChargedHadIso_FromW, "PFElecChargedHadIso_FromW" ,datasets[d].Name(),"ChargedHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecPhotonIso_FromW, "PFElecPhotonIso_FromW" ,datasets[d].Name(),"PhotonIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecTrackIso_FromW, "PFElecTrackIso_FromW" ,datasets[d].Name(),"TrackIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecRelIso_FromW, "PFElecRelIso_FromW" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFMuonPt_FromW, "PFMuonPt_FromW" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFMuonNeutralHadIso_FromW, "PFMuonNeutralHadIso_FromW" ,datasets[d].Name(),"NeutralHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonChargedHadIso_FromW, "PFMuonChargedHadIso_FromW" ,datasets[d].Name(),"ChargedHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonPhotonIso_FromW, "PFMuonPhotonIso_FromW" ,datasets[d].Name(),"PhotonIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonTrackIso_FromW, "PFMuonTrackIso_FromW" ,datasets[d].Name(),"TrackIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonRelIso_FromW, "PFMuonRelIso_FromW" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFElecPt_FromW_Cut015, "PFElecPt_FromW_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFMuonPt_FromW_Cut015, "PFMuonPt_FromW_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFMuonType_FromW, "PFMuonType_FromW" ,datasets[d].Name(),"Type","Entries",120,0.,119);
// MyhistoManager.CreateHisto(PATElecPt_FromBC, "PATElecPt_FromBC" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATElecRelIso_FromBC, "PATElecRelIso_FromBC" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
// MyhistoManager.CreateHisto(PATMuonPt_FromBC, "PATMuonPt_FromBC" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATMuonRelIso_FromBC, "PATMuonRelIso_FromBC" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
// MyhistoManager.CreateHisto(PATElecPt_FromBC_Cut015, "PATElecPt_FromBC_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
// MyhistoManager.CreateHisto(PATMuonPt_FromBC_Cut015, "PATMuonPt_FromBC_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFElecPt_FromBC, "PFElecPt_FromBC" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFElecNeutralHadIso_FromBC, "PFElecNeutralHadIso_FromBC" ,datasets[d].Name(),"NeutralHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecChargedHadIso_FromBC, "PFElecChargedHadIso_FromBC" ,datasets[d].Name(),"ChargedHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecPhotonIso_FromBC, "PFElecPhotonIso_FromBC" ,datasets[d].Name(),"PhotonIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecTrackIso_FromBC, "PFElecTrackIso_FromBC" ,datasets[d].Name(),"TrackIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFElecRelIso_FromBC, "PFElecRelIso_FromBC" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFMuonPt_FromBC, "PFMuonPt_FromBC" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFMuonNeutralHadIso_FromBC, "PFMuonNeutralHadIso_FromBC" ,datasets[d].Name(),"NeutralHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonChargedHadIso_FromBC, "PFMuonChargedHadIso_FromBC" ,datasets[d].Name(),"ChargedHadIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonPhotonIso_FromBC, "PFMuonPhotonIso_FromBC" ,datasets[d].Name(),"PhotonIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonTrackIso_FromBC, "PFMuonTrackIso_FromBC" ,datasets[d].Name(),"TrackIso","Entries",100,0.,10.0);
MyhistoManager.CreateHisto(PFMuonRelIso_FromBC, "PFMuonRelIso_FromBC" ,datasets[d].Name(),"RelIso","Entries",50,0.,1.0);
MyhistoManager.CreateHisto(PFElecPt_FromBC_Cut015, "PFElecPt_FromBC_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFMuonPt_FromBC_Cut015, "PFMuonPt_FromBC_Cut015" ,datasets[d].Name(),"Pt","Entries",50,0.,100);
MyhistoManager.CreateHisto(PFMuonType_FromBC, "PFMuonType_FromBC" ,datasets[d].Name(),"Type","Entries",120,0.,199);
//////////////////////
//LOOP OVER THE EVENTS
//////////////////////
for (unsigned int ievt = 0; ievt < nEvents; ievt++) {
float weight = 1.;
datasets[d].eventTree ()->GetEntry (ievt);
// cout << "event number=" << event->eventNb << endl;
// cout << "normfactor=" << datasets[d].NormFactor() << endl;
// cout << "Xsection=" << datasets[d].Xsection() << endl;
// cout << "NofEvtsToRunOver=" << datasets[d].NofEvtsToRunOver() << endl;
MyhistoManager.FillHisto(TMEME, "TMEME",event->TMEME,datasets[d].Name(),true,1.0);
if(ievt%10000 == 0) cout << "number of processed events " << ievt << endl;
//if(ievt > 50000) break;
//Load event for the selection
sel.LoadEvent(event);
//Collection of selected objects
vector<NTVertex> selVertices = sel.GetSelectedVertex();
vector<NTElectron> selElectrons = sel.GetSelectedElectronsNoIso();
vector<NTMuon> selMuons = sel.GetSelectedMuonsNoIso();
vector<NTJet> selJets = sel.GetSelectedJets();
NTMET met = sel.GetMET();
//Candidate pair of lepton
string CandType; // ee - emu - mumum or false
vector<NTElectron> candElec;
vector<NTMuon> candMuon;
sel.GetLeptonPair(candMuon, candElec, CandType );
TLorentzVector DiLepton_mumu;
for(unsigned int i=0;i<candMuon.size();i++) DiLepton_mumu+=candMuon[i].p4;
TLorentzVector DiLepton_ee;
for(unsigned int i=0;i<candElec.size();i++) DiLepton_ee+=candElec[i].p4;
TLorentzVector DiLepton_emu;
for(unsigned int i=0;i<candMuon.size();i++) DiLepton_emu+=candMuon[i].p4;
for(unsigned int i=0;i<candElec.size();i++) DiLepton_emu+=candElec[i].p4;
float InvDilMass = 0;
if (ChannelName=="mumu") InvDilMass = DiLepton_mumu.M();
if (ChannelName=="ee") InvDilMass = DiLepton_ee.M();
if (ChannelName=="emu") InvDilMass = DiLepton_emu.M();
// keep only Z mass peak
if ( InvDilMass<76 || InvDilMass>106 ) continue;
//Manage DY samples to avoid overlaps
double dileptInvMass = 0;
if( (event->zAndDecays).size() > 0){
TLorentzVector dilept = (event->zAndDecays)[0].p4_Lep1_gen + (event->zAndDecays)[0].p4_Lep2_gen;
dileptInvMass = dilept.M();
}
if(datasets[d].Name()=="Zjets" && dileptInvMass < 50 ) cout << "problem !!!" << endl;
if(datasets[d].Name()=="Zjets" && dileptInvMass < 50) continue;
if(datasets[d].Name()=="DYToMuMu_M-20" && (dileptInvMass > 50 || dileptInvMass < 20) ) continue;
if(datasets[d].Name()=="DYToEE_M-20" && (dileptInvMass > 50 || dileptInvMass < 20) ) continue;
if(datasets[d].Name()=="DYToTauTau_M-20" && (dileptInvMass > 50 || dileptInvMass < 20) ) continue;
if(datasets[d].Name()=="DYToMuMu_M-10To20" && dileptInvMass > 20) continue;
if(datasets[d].Name()=="DYToEE_M-10To20" && dileptInvMass > 20) continue;
if(datasets[d].Name()=="DYToTauTau_M-10To20" && dileptInvMass > 20) continue;
double weightITypeMC = Luminosity*datasets[d].Xsection()/datasets[d].getNSkimmedEvent();
if ( datasets[d].Name()=="DataEG" || datasets[d].Name()=="DataMu") weightITypeMC = 1;
bool IsSignal = false;
int LastStep = 0;
bool IsData = false;
if ( datasets[d].Name()=="TTbar" ) {
if ( ChannelName=="mumu" ) {
if ( event->TMEME==20 || event->TMEME==11010 || event->TMEME==22000 ) IsSignal = true;
if ( !(event->TMEME==20 || event->TMEME==11010 || event->TMEME==22000) ) IsSignal = false;
}
if ( ChannelName=="ee" ) {
if ( event->TMEME==2 || event->TMEME==10101 || event->TMEME==20200 ) IsSignal = true;
if ( !(event->TMEME==2 || event->TMEME==10101 || event->TMEME==20200) ) IsSignal = false;
}
if ( ChannelName=="emu" ) {
if ( event->TMEME==11 || event->TMEME==21100 || event->TMEME==11001 || event->TMEME==10110 ) IsSignal = true;
if ( !(event->TMEME==11 || event->TMEME==21100 || event->TMEME==11001 || event->TMEME==10110) ) IsSignal = false;
}
}
if ( datasets[d].Name()=="TTbar" ) {
if (IsSignal ) { ITypeMC = 0; Dweight[ITypeMC]= weightITypeMC;
}
else { ITypeMC = 1; Dweight[ITypeMC]= weightITypeMC;
}
}
if ( datasets[d].Name()=="Zjets" ||
datasets[d].Name()=="DYToMuMu_M-20" ||
datasets[d].Name()=="DYToEE_M-20" ||
datasets[d].Name()=="DYToTauTau_M-20" ||
datasets[d].Name()=="DYToMuMu_M-10To20" ||
datasets[d].Name()=="DYToEE_M-10To20" ||
datasets[d].Name()=="DYToTauTau_M-10To20"
) {
ITypeMC = 2; IsSignal = false; Dweight[ITypeMC]= weightITypeMC;
}
if ( datasets[d].Name()=="WjetsMu" ||
datasets[d].Name()=="WjetsE" ||
datasets[d].Name()=="WjetsTau"
) {
ITypeMC = 3; IsSignal = false; Dweight[ITypeMC]= weightITypeMC;
}
if ( datasets[d].Name()=="SingleToptW" ) {
ITypeMC = 4; IsSignal = false; Dweight[ITypeMC]= weightITypeMC;
}
if ( datasets[d].Name()=="WZ" || datasets[d].Name()=="WW" || datasets[d].Name()=="ZZ" ) {
ITypeMC = 5; IsSignal = false; Dweight[ITypeMC]= weightITypeMC;
}
if ( datasets[d].Name()=="DYee" ) {
ITypeMC = 6; IsSignal = false; Dweight[ITypeMC]= weightITypeMC;
}
if ( datasets[d].Name()=="DYmumu" ) {
ITypeMC = 7; IsSignal = false; Dweight[ITypeMC]= weightITypeMC;
}
if ( datasets[d].Name()=="QCD1" ||
datasets[d].Name()=="QCD2" ||
datasets[d].Name()=="QCD3" ||
datasets[d].Name()=="QCD4" ||
datasets[d].Name()=="QCD5" ||
datasets[d].Name()=="QCD6" ||
datasets[d].Name()=="QCD7" ||
datasets[d].Name()=="QCD8" ||
datasets[d].Name()=="QCD9" ||
datasets[d].Name()=="QCD10" ||
datasets[d].Name()=="QCD11" ||
datasets[d].Name()=="QCD12" ||
datasets[d].Name()=="QCD13"
) {
ITypeMC = 8; IsSignal = false; Dweight[ITypeMC]= weightITypeMC;
}
if ( datasets[d].Name()=="DataEG" || datasets[d].Name()=="DataMu") {
ITypeMC = 100; IsData = true; Dweight[ITypeMC]= weightITypeMC;
}
sel.passTriggerSelection ( &datasets[d], ChannelName);
for(unsigned int i=0;i<selElectrons.size();i++){
NTElectron el = selElectrons[i];
// vector<NTElectron> allElec = event->electrons;
// for(unsigned int i=0;i<allElec.size();i++){
// NTElectron el = allElec[i];
// weight = 1.0;
IsSignal = false;
if ( event->TMEME==2 || event->TMEME==10101 || event->TMEME==20200 ||event->TMEME==11 || event->TMEME==21100 ||
event->TMEME==11001 || event->TMEME==10110 ) IsSignal = true;
// MyhistoManager.FillHisto(PATElecPt, "PATElecPt",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// MyhistoManager.FillHisto(PATElecRelIso, "PATElecRelIso",el.CombinedRelIso03(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecPt, "PFElecPt",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecNeutralHadIso, "PFElecNeutralHadIso",el.PATNeutralHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecChargedHadIso, "PFElecChargedHadIso",el.PATChargedHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecPhotonIso, "PFElecPhotonIso",el.PATPhotonIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecTrackIso, "PFElecTrackIso",el.PATTrackIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecRelIso, "PFElecRelIso",(el.PATTrackIso+el.PATChargedHadronIso+el.PATNeutralHadronIso)/el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
int isEcalDriven = (el.isEcalDriven ==1);
MyhistoManager.FillHisto(PFElecEcalDriven, "PFElecEcalDriven",isEcalDriven,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
int isGsfEl = (el.isGsfElectron ==1);
MyhistoManager.FillHisto(PFElecGsfEl, "PFElecGsfEl",isGsfEl,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecD0, "PFElecD0",el.D0,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
int isId90 = 0;
if ( el.elecIdWP90_r & 0x1 ) isId90 =1;
MyhistoManager.FillHisto(PFElecId90, "PFElecId90",isId90,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
int isConv = 1;
if (el.elecIdWP90_r & 0x4 ) isConv =0;
MyhistoManager.FillHisto(PFElecConv, "PFElecConv",isConv,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecRelIsoRhoCorrected, "PFElecRelIsoRhoCorrected",el.RelIso03PFRhoCorrected(event->rho_PUUE_dens),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecRelIsoNeutralRhoCorrected, "PFElecRelIsoNeutralRhoCorrected",el.RelIso03PFNeutralRhoCorrected(event->rho_PUUE_dens),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
if ( el.LeptonOrigin == 1 ) {
// MyhistoManager.FillHisto(PATElecPt_FromW, "PATElecPt_FromW",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// MyhistoManager.FillHisto(PATElecRelIso_FromW, "PATElecRelIso_FromW",el.CombinedRelIso03(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecPt_FromW, "PFElecPt_FromW",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecNeutralHadIso_FromW, "PFElecNeutralHadIso_FromW",el.PATNeutralHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecChargedHadIso_FromW, "PFElecChargedHadIso_FromW",el.PATChargedHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecPhotonIso_FromW, "PFElecPhotonIso_FromW",el.PATPhotonIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecTrackIso_FromW, "PFElecTrackIso_FromW",el.PATTrackIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecRelIso_FromW, "PFElecRelIso_FromW",(el.PATTrackIso+el.PATChargedHadronIso+el.PATNeutralHadronIso)/el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// if (el.CombinedRelIso03()<0.15) {
// MyhistoManager.FillHisto(PATElecPt_FromW_Cut015, "PATElecPt_FromW_Cut015",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// }
if ((el.PATTrackIso+el.PATChargedHadronIso+el.PATNeutralHadronIso)/el.p4.Pt()<0.15) {
MyhistoManager.FillHisto(PFElecPt_FromW_Cut015, "PFElecPt_FromW_Cut015",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
}
}
if ( el.LeptonOrigin >= 100 ) {
// MyhistoManager.FillHisto(PATElecPt_FromBC, "PATElecPt_FromBC",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// MyhistoManager.FillHisto(PATElecRelIso_FromBC, "PATElecRelIso_FromBC",el.CombinedRelIso03(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecPt_FromBC, "PFElecPt_FromBC",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecNeutralHadIso_FromBC, "PFElecNeutralHadIso_FromBC",el.PATNeutralHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecChargedHadIso_FromBC, "PFElecChargedHadIso_FromBC",el.PATChargedHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecPhotonIso_FromBC, "PFElecPhotonIso_FromBC",el.PATPhotonIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecTrackIso_FromBC, "PFElecTrackIso_FromBC",el.PATTrackIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFElecRelIso_FromBC, "PFElecRelIso_FromBC",(el.PATTrackIso+el.PATChargedHadronIso+el.PATNeutralHadronIso)/el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// if (el.CombinedRelIso03()<0.15) {
// MyhistoManager.FillHisto(PATElecPt_FromBC_Cut015, "PATElecPt_FromBC_Cut015",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// }
if ((el.PATTrackIso+el.PATChargedHadronIso+el.PATNeutralHadronIso)/el.p4.Pt()<0.15) {
MyhistoManager.FillHisto(PFElecPt_FromBC_Cut015, "PFElecPt_FromBC_Cut015",el.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
}
}
// std::cout<<"PFElecRelIso "<<(el.PATTrackIso+el.PATChargedHadronIso+el.PATNeutralHadronIso)/el.p4.Pt()<<std::endl;
// std::cout<<"el.PATTrackIso "<<(el.PATTrackIso)<<std::endl;
// std::cout<<"el.PATChargedHadronIso "<<(el.PATChargedHadronIso)<<std::endl;
// std::cout<<"el.PATNeutralHadronIso "<<(el.PATNeutralHadronIso)<<std::endl;
// std::cout<<"el.PATPhotonIso "<<(el.PATPhotonIso)<<std::endl;
// if ( el.p4.Pt()>10 ) std::cout<<"el.LeptonOrigin "<<(el.LeptonOrigin)<<std::endl;
}
for(unsigned int i=0;i<selMuons.size();i++){
NTMuon mu = selMuons[i];
// vector<NTMuon> allMuon = event->muons;
// for(unsigned int i=0;i<allMuon.size();i++){
// NTMuon mu = allMuon[i];
// weight = 1.0;
IsSignal = false;
if ( event->TMEME==20 || event->TMEME==11010 || event->TMEME==22000 ||event->TMEME==11 || event->TMEME==21100 ||
event->TMEME==11001 || event->TMEME==10110 ) IsSignal=true;
// MyhistoManager.FillHisto(PATMuonPt, "PATMuonPt",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// MyhistoManager.FillHisto(PATMuonRelIso, "PATMuonRelIso",mu.RelIso03(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonPt, "PFMuonPt",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonNeutralHadIso, "PFMuonNeutralHadIso",mu.PATNeutralHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonChargedHadIso, "PFMuonChargedHadIso",mu.PATChargedHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonPhotonIso, "PFMuonPhotonIso",mu.PATPhotonIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonTrackIso, "PFMuonTrackIso",mu.PATTrackIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonRelIso, "PFMuonRelIso",(mu.PATTrackIso+mu.PATChargedHadronIso+mu.PATNeutralHadronIso)/mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
int isMuon = 0 ;
if ( mu.MuonType>=100 ) isMuon += 1;
if ( (mu.MuonType-(mu.MuonType/10)*10) !=0 ) isMuon += 10 ;
if ( mu.MuonType>=100 && (mu.MuonType-(mu.MuonType/10)*10) !=0 ) isMuon += 100;
MyhistoManager.FillHisto(PFMuonType, "PFMuonType",isMuon,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonChi2, "PFMuonChi2",mu.Chi2,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonTrValHit, "PFMuonTrValHit",mu.NTrValidHits,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonValHit, "PFMuonValHit",mu.NValidHits,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonD0, "PFMuonD0",mu.D0Inner,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
if (selVertices.size()>0 ) MyhistoManager.FillHisto(PFMuonZvx, "PFMuonZvx",fabs( mu.vertex.Z() - selVertices[0].p3.Z()),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonRelIsoRhoCorrected,"PFMuonRelIsoRhoCorrected",mu.RelIso03PFRhoCorrected(event->rho_PUUE_dens),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonRelIsoNeutralRhoCorrected, "PFMuonRelIsoNeutralRhoCorrected",mu.RelIso03PFNeutralRhoCorrected(event->rho_PUUE_dens),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
if ( mu.LeptonOrigin == 1 ) {
// MyhistoManager.FillHisto(PATMuonPt_FromW, "PATMuonPt_FromW",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// MyhistoManager.FillHisto(PATMuonRelIso_FromW, "PATMuonRelIso_FromW",mu.RelIso03(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonPt_FromW, "PFMuonPt_FromW",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonNeutralHadIso_FromW, "PFMuonNeutralHadIso_FromW",mu.PATNeutralHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonChargedHadIso_FromW, "PFMuonChargedHadIso_FromW",mu.PATChargedHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonPhotonIso_FromW, "PFMuonPhotonIso_FromW",mu.PATPhotonIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonTrackIso_FromW, "PFMuonTrackIso_FromW",mu.PATTrackIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonRelIso_FromW, "PFMuonRelIso_FromW",(mu.PATTrackIso+mu.PATChargedHadronIso+mu.PATNeutralHadronIso)/mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
int isMuon = 0 ;
if ( mu.MuonType>=100 ) isMuon += 1;
if ( (mu.MuonType-(mu.MuonType/10)*10) !=0 ) isMuon += 10 ;
if ( mu.MuonType>=100 && (mu.MuonType-(mu.MuonType/10)*10) !=0 ) isMuon += 100;
MyhistoManager.FillHisto(PFMuonType_FromW, "PFMuonType_FromW",isMuon,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// if (mu.RelIso03()<0.15) {
// MyhistoManager.FillHisto(PATMuonPt_FromW_Cut015, "PATMuonPt_FromW_Cut015",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// }
if ((mu.PATTrackIso+mu.PATChargedHadronIso+mu.PATNeutralHadronIso)/mu.p4.Pt()<0.15) {
MyhistoManager.FillHisto(PFMuonPt_FromW_Cut015, "PFMuonPt_FromW_Cut015",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
}
}
if ( mu.LeptonOrigin >= 100 ) {
// MyhistoManager.FillHisto(PATMuonPt_FromBC, "PATMuonPt_FromBC",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// MyhistoManager.FillHisto(PATMuonRelIso_FromBC, "PATMuonRelIso_FromBC",mu.RelIso03(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonPt_FromBC, "PFMuonPt_FromBC",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonNeutralHadIso_FromBC, "PFMuonNeutralHadIso_FromBC",mu.PATNeutralHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonChargedHadIso_FromBC, "PFMuonChargedHadIso_FromBC",mu.PATChargedHadronIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonPhotonIso_FromBC, "PFMuonPhotonIso_FromBC",mu.PATPhotonIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonTrackIso_FromBC, "PFMuonTrackIso_FromBC",mu.PATTrackIso,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
MyhistoManager.FillHisto(PFMuonRelIso_FromBC, "PFMuonRelIso_FromBC",(mu.PATTrackIso+mu.PATChargedHadronIso+mu.PATNeutralHadronIso)/mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
int isMuon = 0 ;
if ( mu.MuonType>=100 ) isMuon += 1;
if ( (mu.MuonType-(mu.MuonType/10)*10) !=0 ) isMuon += 10 ;
if ( mu.MuonType>=100 && (mu.MuonType-(mu.MuonType/10)*10) !=0 ) isMuon += 100;
MyhistoManager.FillHisto(PFMuonType_FromBC, "PFMuonType_FromBC",isMuon,datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// if (mu.RelIso03()<0.15) {
// MyhistoManager.FillHisto(PATMuonPt_FromBC_Cut015, "PATMuonPt_FromBC_Cut015",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
// }
if ((mu.PATTrackIso+mu.PATChargedHadronIso+mu.PATNeutralHadronIso)/mu.p4.Pt()<0.15) {
MyhistoManager.FillHisto(PFMuonPt_FromBC_Cut015, "PFMuonPt_FromBC_Cut015",mu.p4.Pt(),datasets[d].Name(),IsSignal,Dweight[ITypeMC]);
}
}
// std::cout<<"PFMuonRelIso "<<(mu.PATTrackIso+mu.PATChargedHadronIso+mu.PATNeutralHadronIso)/mu.p4.Pt()<<std::endl;
// std::cout<<"mu.PATTrackIso "<<(mu.PATTrackIso)<<std::endl;
// std::cout<<"mu.PATChargedHadronIso "<<(mu.PATChargedHadronIso)<<std::endl;
// std::cout<<"mu.PATNeutralHadronIso "<<(mu.PATNeutralHadronIso)<<std::endl;
// std::cout<<"mu.PATPhotonIso "<<(mu.PATPhotonIso)<<std::endl;
}
} // end of loop over evts
} // end of loop over the datasets
// // PF electron
// TH1F PFElecRelIsoEff_FromW_TTbarSig ("PFElecRelIsoEff_FromW_TTbarSig","PFElecRelIsoEff_FromW_TTbarSig",50,0.,1.0);
// TH1F PFElecRelIsoEff_FromBC_TTbarBkg ("PFElecRelIsoEff_FromBC_TTbarBkg","PFElecRelIsoEff_FromBC_TTbarBkg",50,0.,1.0);
// TH1F h1 ("h1","h1",50,0.,1.0);
// TH1F h2 ("h2","h2",50,0.,1.0);
// MyhistoManager.GetHisto(PFElecRelIso_FromW,"PFElecRelIso_FromW_TTbarSig",h1);
// MyhistoManager.GetHisto(PFElecRelIso_FromBC,"PFElecRelIso_FromBC_TTbarBkg",h2);
//
// const int maxbin=200;
// float X[maxbin];
// float Y[maxbin];
// EffCompute(h1,PFElecRelIsoEff_FromW_TTbarSig,h2,PFElecRelIsoEff_FromBC_TTbarBkg,X,Y);
// TGraph* PFElecRelIsoPerf = new TGraph(h1.GetNbinsX(), X, Y);
// PFElecRelIsoPerf->SetName("PFElecRelIsoPerf");
// // PAT electron
// TH1F PATElecRelIsoEff_FromW_TTbarSig ("PATElecRelIsoEff_FromW_TTbarSig","PATElecRelIsoEff_FromW_TTbarSig",50,0.,1.0);
// TH1F PATElecRelIsoEff_FromBC_TTbarBkg ("PATElecRelIsoEff_FromBC_TTbarBkg","PATElecRelIsoEff_FromBC_TTbarBkg",50,0.,1.0);
// TH1F h3 ("h3","h3",50,0.,1.0);
// TH1F h4 ("h4","h4",50,0.,1.0);
// MyhistoManager.GetHisto(PATElecRelIso_FromW,"PATElecRelIso_FromW_TTbarSig",h3);
// MyhistoManager.GetHisto(PATElecRelIso_FromBC,"PATElecRelIso_FromBC_TTbarBkg",h4);
//
// EffCompute(h3,PATElecRelIsoEff_FromW_TTbarSig,h4,PATElecRelIsoEff_FromBC_TTbarBkg,X,Y);
// TGraph* PATElecRelIsoPerf = new TGraph(h3.GetNbinsX(), X, Y);
// PATElecRelIsoPerf->SetName("PATElecRelIsoPerf");
// // PF muon
// TH1F PFMuonRelIsoEff_FromW_TTbarSig ("PFMuonRelIsoEff_FromW_TTbarSig","PFMuonRelIsoEff_FromW_TTbarSig",50,0.,1.0);
// TH1F PFMuonRelIsoEff_FromBC_TTbarBkg ("PFMuonRelIsoEff_FromBC_TTbarBkg","PFMuonRelIsoEff_FromBC_TTbarBkg",50,0.,1.0);
// TH1F h5 ("h5","h5",50,0.,1.0);
// TH1F h6 ("h6","h6",50,0.,1.0);
// MyhistoManager.GetHisto(PFMuonRelIso_FromW,"PFMuonRelIso_FromW_TTbarSig",h5);
// MyhistoManager.GetHisto(PFMuonRelIso_FromBC,"PFMuonRelIso_FromBC_TTbarBkg",h6);
//
// EffCompute(h5,PFMuonRelIsoEff_FromW_TTbarSig,h6,PFMuonRelIsoEff_FromBC_TTbarBkg,X,Y);
// TGraph* PFMuonRelIsoPerf = new TGraph(h5.GetNbinsX(), X, Y);
// PFMuonRelIsoPerf->SetName("PFMuonRelIsoPerf");
// // PAT muon
// TH1F PATMuonRelIsoEff_FromW_TTbarSig ("PATMuonRelIsoEff_FromW_TTbarSig","PATMuonRelIsoEff_FromW_TTbarSig",50,0.,1.0);
// TH1F PATMuonRelIsoEff_FromBC_TTbarBkg ("PATMuonRelIsoEff_FromBC_TTbarBkg","PATMuonRelIsoEff_FromBC_TTbarBkg",50,0.,1.0);
// TH1F h7 ("h7","h7",50,0.,1.0);
// TH1F h8 ("h8","h8",50,0.,1.0);
// MyhistoManager.GetHisto(PATMuonRelIso_FromW,"PATMuonRelIso_FromW_TTbarSig",h7);
// MyhistoManager.GetHisto(PATMuonRelIso_FromBC,"PATMuonRelIso_FromBC_TTbarBkg",h8);
//
// EffCompute(h7,PATMuonRelIsoEff_FromW_TTbarSig,h8,PATMuonRelIsoEff_FromBC_TTbarBkg,X,Y);
// TGraph* PATMuonRelIsoPerf = new TGraph(h7.GetNbinsX(), X, Y);
// PATMuonRelIsoPerf->SetName("PATMuonRelIsoPerf");
if(verbosity>0) {
cout<<"#########################"<<endl;
cout<<" Write output root file "<<endl;
cout<<"#########################"<<endl;
}
string ofilename = string("MyVar")+string("_")+ChannelName+string(".root");
TFile* fout = new TFile(ofilename.c_str(),"RECREATE");
MyhistoManager.WriteMyHisto(TMEME,"all");
// MyhistoManager.WriteMyHisto(PATElecPt,"all");
// MyhistoManager.WriteMyHisto(PATElecRelIso,"all");
// MyhistoManager.WriteMyHisto(PATMuonPt,"all");
// MyhistoManager.WriteMyHisto(PATMuonRelIso,"all");
MyhistoManager.WriteMyHisto(PFElecPt,"all");
MyhistoManager.WriteMyHisto(PFElecNeutralHadIso,"all");
MyhistoManager.WriteMyHisto(PFElecChargedHadIso,"all");
MyhistoManager.WriteMyHisto(PFElecPhotonIso,"all");
MyhistoManager.WriteMyHisto(PFElecTrackIso,"all");
MyhistoManager.WriteMyHisto(PFElecRelIso,"all");
MyhistoManager.WriteMyHisto(PFElecEcalDriven,"all");
MyhistoManager.WriteMyHisto(PFElecGsfEl,"all");
MyhistoManager.WriteMyHisto(PFElecD0,"all");
MyhistoManager.WriteMyHisto(PFElecId90,"all");
MyhistoManager.WriteMyHisto(PFElecConv,"all");
MyhistoManager.WriteMyHisto(PFElecRelIsoRhoCorrected,"all");
MyhistoManager.WriteMyHisto(PFElecRelIsoNeutralRhoCorrected,"all");
MyhistoManager.WriteMyHisto(PFMuonPt,"all");
MyhistoManager.WriteMyHisto(PFMuonNeutralHadIso,"all");
MyhistoManager.WriteMyHisto(PFMuonChargedHadIso,"all");
MyhistoManager.WriteMyHisto(PFMuonPhotonIso,"all");
MyhistoManager.WriteMyHisto(PFMuonTrackIso,"all");
MyhistoManager.WriteMyHisto(PFMuonRelIso,"all");
MyhistoManager.WriteMyHisto(PFMuonType,"all");
MyhistoManager.WriteMyHisto(PFMuonChi2,"all");
MyhistoManager.WriteMyHisto(PFMuonTrValHit,"all");
MyhistoManager.WriteMyHisto(PFMuonValHit,"all");
MyhistoManager.WriteMyHisto(PFMuonD0,"all");
MyhistoManager.WriteMyHisto(PFMuonZvx,"all");
MyhistoManager.WriteMyHisto(PFMuonRelIsoRhoCorrected,"all");
MyhistoManager.WriteMyHisto(PFMuonRelIsoNeutralRhoCorrected,"all");
// MyhistoManager.WriteMyHisto(PATElecPt_FromW,"all");
// MyhistoManager.WriteMyHisto(PATElecRelIso_FromW,"all");
// MyhistoManager.WriteMyHisto(PATMuonPt_FromW,"all");
// MyhistoManager.WriteMyHisto(PATMuonRelIso_FromW,"all");
// MyhistoManager.WriteMyHisto(PATElecPt_FromW_Cut015,"all");
// MyhistoManager.WriteMyHisto(PATMuonPt_FromW_Cut015,"all");
MyhistoManager.WriteMyHisto(PFElecPt_FromW,"all");
MyhistoManager.WriteMyHisto(PFElecNeutralHadIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFElecChargedHadIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFElecPhotonIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFElecTrackIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFElecRelIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFMuonPt_FromW,"all");
MyhistoManager.WriteMyHisto(PFMuonNeutralHadIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFMuonChargedHadIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFMuonPhotonIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFMuonTrackIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFMuonRelIso_FromW,"all");
MyhistoManager.WriteMyHisto(PFElecPt_FromW_Cut015,"all");
MyhistoManager.WriteMyHisto(PFMuonPt_FromW_Cut015,"all");
MyhistoManager.WriteMyHisto(PFMuonType_FromW,"all");
// MyhistoManager.WriteMyHisto(PATElecPt_FromBC,"all");
// MyhistoManager.WriteMyHisto(PATElecRelIso_FromBC,"all");
// MyhistoManager.WriteMyHisto(PATMuonPt_FromBC,"all");
// MyhistoManager.WriteMyHisto(PATMuonRelIso_FromBC,"all");
// MyhistoManager.WriteMyHisto(PATElecPt_FromBC_Cut015,"all");
// MyhistoManager.WriteMyHisto(PATMuonPt_FromBC_Cut015,"all");
MyhistoManager.WriteMyHisto(PFElecPt_FromBC,"all");
MyhistoManager.WriteMyHisto(PFElecNeutralHadIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFElecChargedHadIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFElecPhotonIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFElecTrackIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFElecRelIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFMuonPt_FromBC,"all");
MyhistoManager.WriteMyHisto(PFMuonNeutralHadIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFMuonChargedHadIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFMuonPhotonIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFMuonTrackIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFMuonRelIso_FromBC,"all");
MyhistoManager.WriteMyHisto(PFElecPt_FromBC_Cut015,"all");
MyhistoManager.WriteMyHisto(PFMuonPt_FromBC_Cut015,"all");
MyhistoManager.WriteMyHisto(PFMuonType_FromBC,"all");
// PFElecRelIsoEff_FromW_TTbarSig.Write();
// PFElecRelIsoEff_FromBC_TTbarBkg.Write();
// PFMuonRelIsoEff_FromW_TTbarSig.Write();
// PFMuonRelIsoEff_FromBC_TTbarBkg.Write();
// PATElecRelIsoEff_FromW_TTbarSig.Write();
// PATElecRelIsoEff_FromBC_TTbarBkg.Write();
// PATMuonRelIsoEff_FromW_TTbarSig.Write();
// PATMuonRelIsoEff_FromBC_TTbarBkg.Write();
// PFElecRelIsoPerf->Write();
// PFMuonRelIsoEff_FromW_TTbarSig.Write();
// PFMuonRelIsoEff_FromBC_TTbarBkg.Write();
// PFMuonRelIsoPerf->Write();
// PATElecRelIsoPerf->Write();
// PATMuonRelIsoPerf->Write();
fout->Close();
delete fout;
if(verbosity>0) {
cout<<"#########################"<<endl;
cout<<" End of the program "<<endl;
cout<<"#########################"<<endl;
}
return (0);
}
