//______________________________________________________________________________
void AODmerge()
{
// Merging method. No staging and no terminate phase.
TStopwatch timer;
timer.Start();
TString outputDir = "wn.xml";
TString outputFiles = VAR_AOD_MERGE_FILES;
TString mergeExcludes = "";
TObjArray *list = outputFiles.Tokenize(",");
TIter *iter = new TIter(list);
TObjString *str;
TString outputFile;
Bool_t merged = kTRUE;
while((str=(TObjString*)iter->Next())) {
outputFile = str->GetString();
// Skip already merged outputs
if (!gSystem->AccessPathName(outputFile)) {
printf("Output file <%s> found. Not merging again.",outputFile.Data());
continue;
}
if (mergeExcludes.Contains(outputFile.Data())) continue;
merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, 0);
if (!merged) {
printf("ERROR: Cannot merge %s\n", outputFile.Data());
return;
}
}
// all outputs merged, validate
ofstream out;
out.open("outputs_valid_merge", ios::out);
out.close();
timer.Print();
}
void QAmerge(const char *suffix, const char *dir, Int_t stage)
{
// Merging method
TStopwatch timer;
timer.Start();
TString outputDir = dir;
TString outputFiles = Form("QAresults%s.root,EventStat_temp%s.root,RecoQAresults%s.root",suffix,suffix,suffix);
TString mergeExcludes = "";
TObjArray *list = outputFiles.Tokenize(",");
TIter *iter = new TIter(list);
TObjString *str;
TString outputFile;
Bool_t merged = kTRUE;
while((str=(TObjString*)iter->Next())) {
outputFile = str->GetString();
// Skip already merged outputs
if (!gSystem->AccessPathName(outputFile)) {
printf("Output file <%s> found. Not merging again.",outputFile.Data());
continue;
}
if (mergeExcludes.Contains(outputFile.Data())) continue;
merged = IlcAnalysisAlien::MergeOutput(outputFile, outputDir, 10, stage);
if (!merged && !outputFile.Contains("RecoQAresults")) {
printf("ERROR: Cannot merge %s\n", outputFile.Data());
return;
}
}
// read the analysis manager from file
if (!outputDir.Contains("Stage")) {
ofstream out;
out.open("outputs_valid", ios::out);
out.close();
return;
}
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
mgr->SetRunFromPath(mgr->GetRunFromAlienPath(dir));
mgr->SetSkipTerminate(kFALSE);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
IlcLog::SetGlobalLogLevel(IlcLog::kError);
TTree *tree = NULL;
mgr->StartAnalysis("gridterminate", tree);
if (strlen(suffix)) {
if (gSystem->Exec(Form("mv trending.root trending%s.root", suffix)))
::Error("QAmerge", "File trending.root was not produced");
if (gSystem->Exec(Form("mv event_stat.root event_stat%s.root", suffix)))
::Error("QAmerge", "File trending.root was not produced");
}
ofstream out;
out.open("outputs_valid", ios::out);
out.close();
timer.Print();
}
void InitChannels(TTree *tree = (TTree*)gROOT->FindObjectAny("FragmentTree")) {
if(!tree)
return;
TList *list = tree->GetUserInfo();
TIter *iter = new TIter(list);
TChannel *chan = 0;
while(chan = (TChannel*)iter->Next()) {
TChannel *cur_chan = TChannel::GetChannel(chan->GetAddress());
TChannel::CopyChannel(cur_chan,chan);
}
}
void QAmerge(const char *dir, Int_t stage)
{
// Merging method
TStopwatch timer;
timer.Start();
TString outputDir = dir;
TString outputFiles = "QAresults.root,EventStat_temp.root";
TString mergeExcludes = "";
TObjArray *list = outputFiles.Tokenize(",");
TIter *iter = new TIter(list);
TObjString *str;
TString outputFile;
Bool_t merged = kTRUE;
while((str=(TObjString*)iter->Next())) {
outputFile = str->GetString();
// Skip already merged outputs
if (!gSystem->AccessPathName(outputFile)) {
printf("Output file <%s> found. Not merging again.",outputFile.Data());
continue;
}
if (mergeExcludes.Contains(outputFile.Data())) continue;
merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, stage);
if (!merged) {
printf("ERROR: Cannot merge %s\n", outputFile.Data());
continue;
}
}
TString infolog = "fileinfo.log";
AliAnalysisAlien::MergeInfo(infolog, dir);
// read the analysis manager from file
if (!outputDir.Contains("Stage")) {
ofstream out;
out.open("outputs_valid", ios::out);
out.close();
return;
}
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
mgr->SetRunFromPath(mgr->GetRunFromAlienPath(dir));
mgr->SetSkipTerminate(kFALSE);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
AliLog::SetGlobalLogLevel(AliLog::kError);
TTree *tree = NULL;
gROOT->cd();
mgr->StartAnalysis("gridterminate", tree);
ofstream out;
out.open("outputs_valid", ios::out);
out.close();
timer.Print();
}
//______________________________________________________________________________
void AODmerge()
{
// Merging method. No staging and no terminate phase.
TStopwatch timer;
timer.Start();
TString outputDir = "wn.xml";
TString outputFiles = "EventStat_temp.root,AODQA.root,AliAOD.root,AliAOD.VertexingHF.root,AliAODGammaConversion.root,FilterEvents_Trees.root,AliAOD.Muons.root";
TString mergeExcludes = "";
TObjArray *list = outputFiles.Tokenize(",");
TIter *iter = new TIter(list);
TObjString *str;
TString outputFile;
Bool_t merged = kTRUE;
while((str=(TObjString*)iter->Next())) {
outputFile = str->GetString();
// Skip already merged outputs
if (!gSystem->AccessPathName(outputFile)) {
printf("Output file <%s> found. Not merging again.",outputFile.Data());
continue;
}
if (mergeExcludes.Contains(outputFile.Data())) continue;
merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, 0);
if (!merged) {
printf("ERROR: Cannot merge %s\n", outputFile.Data());
continue;
}
}
// all outputs merged, validate
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
mgr->InitAnalysis();
mgr->SetGridHandler(new AliAnalysisAlien);
mgr->StartAnalysis("gridterminate",0);
ofstream out;
out.open("outputs_valid", ios::out);
out.close();
timer.Print();
}
void
makeUnfoldingSystematicsComparisonPlots (int whichobservable, int whichjet, int whichlepton, int inclusive)
{
//Open the file and form the name
string fileSystematics;
string suffix="/gpfs/cms/data/2011/Systematics/postApproval_v58_Journal/";
//string suffix="/tmp/";
if (whichlepton==1) suffix=suffix+"ele/";
if (whichlepton==2) suffix=suffix+"muo/";
// setTDRStyle ();
gStyle->SetErrorX(0);
gStyle->SetPadGridX(0);
gStyle->SetPadGridY(0);
bool absoluteNormalization = true;
int lepton = 3; //1 -> electron, 2-> muon , 3 -> combined reults!
bool addLumiUncertainties = true;
double lumiError = 0.025;
int use_case = whichobservable;
int whichjet = whichjet;
string version = "_v2_32";
//string s = "/afs/infn.it/ts/user/marone/html/ZJets/FinalPlotsForAN/v41/SVDBayes/";
string s="/afs/infn.it/ts/user/marone/html/ZJets/FinalPlotsForAN/v58_Journal/UnfoldingSyst/ele/";
// string s = "/gpfs/cms/users/schizzi/EleMuComparisonPlots/PostUnfolding/";
string eleplotpath = "/gpfs/cms/users/schizzi/Systematics/ele/";
string muoplotpath = "/gpfs/cms/users/schizzi/Systematics/muo/";
gStyle->SetOptStat (0);
TCanvas *plots = new TCanvas ("plots", "EB", 200, 100, 600, 800);
//DATA:
//string elepathFile ="/gpfs/cms/data/2011/Unfolding/testReferenceMu.root";
//string muopathFile ="/gpfs/cms/data/2011/Unfolding/testMu.root";
string elepathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV58_afterCWR.root";
string muopathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV58_BinWidth.root";
string thirdpathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV58_SherpaV2.root";
if (whichlepton==2){
elepathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV58_afterCWRMu.root";
muopathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV58_BinWidthMu.root";
thirdpathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV58_SherpaV2Mu.root";
s="/afs/infn.it/ts/user/marone/html/ZJets/FinalPlotsForAN/v58_Journal/UnfoldingSyst/muo/";
}
//string elepathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV57_3NoSQRT.root";
//string muopathFile ="/gpfs/cms/data/2011/Unfolding/UnfoldingOfficialV57_3NoMCToy.root";
TFile *histof = TFile::Open (elepathFile.c_str ());
histof->cd ("");
TDirectory *dir = gDirectory;
TList *mylist = (TList *) dir->GetListOfKeys ();
TIter iter (mylist);
TObject *tobj = 0;
TFile *histof2 = TFile::Open (thirdpathFile.c_str ());
histof2->cd ("");
TDirectory *dir2 = gDirectory;
TList *mylist2 = (TList *) dir2->GetListOfKeys ();
TIter iter2 (mylist);
TObject *tobj2 = 0;
TFile *histofmuo = TFile::Open (muopathFile.c_str ());
string stringmatch;
string systPathFile;
string systPathFileMuo;
histof->cd ("");
int i = 0; // solo di servizio quando debuggo...
while ((tobj = iter.Next ()))
{
string name = tobj->GetName ();
if (use_case == 1)
{ // Jet Multiplicity
stringmatch = "JetMultiplicityUnfolded";
systPathFile = eleplotpath + "systematicsEff_jetMult" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jetMult" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jetMult" + version + ".txt";
}
if (use_case == 2)
{ // Jet Pt
if (whichjet == 1)
{
stringmatch = "jReco_leading";
systPathFile = eleplotpath + "systematicsEff_jet1Pt" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet1Pt" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet1Pt" + version + ".txt";
}
if (whichjet == 2)
{
stringmatch = "jReco_subleading";
systPathFile = eleplotpath + "systematicsEff_jet2Pt" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet2Pt" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet2Pt" + version + ".txt";
}
if (whichjet == 3)
{
stringmatch = "jReco_subsubleading";
systPathFile = eleplotpath + "systematicsEff_jet3Pt" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet3Pt" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet3Pt" + version + ".txt";
}
if (whichjet == 4)
{
stringmatch = "jReco_subsubsubleading";
systPathFile = eleplotpath + "systematicsEff_jet4Pt" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet4Pt" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet4Pt" + version + ".txt";
}
}
if (use_case == 3) { // Jet Eta
if (whichjet == 1)
{
stringmatch = "jReco_leadingeta";
systPathFile = eleplotpath + "systematicsEff_jet1Eta" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet1Eta" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet1Eta" + version + ".txt";
}
if (whichjet == 2)
{
stringmatch = "jReco_subleadingeta";
systPathFile = eleplotpath + "systematicsEff_jet2Eta" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet2Eta" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet2Eta" + version + ".txt";
}
if (whichjet == 3)
{
stringmatch = "jReco_subsubleadingeta";
systPathFile = eleplotpath + "systematicsEff_jet3Eta" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet3Eta" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet3Eta" + version + ".txt";
}
if (whichjet == 4)
{
stringmatch = "jReco_subsubsubleadingeta";
systPathFile = eleplotpath + "systematicsEff_jet4Eta" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet4Eta" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet4Eta" + version + ".txt";
}
}
if (use_case == 4) { // Ht
if (whichjet == 1)
{
stringmatch = "HReco_leading";
systPathFile = eleplotpath + "systematicsEff_jet1Ht" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet1Ht" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet1Ht" + version + ".txt";
}
if (whichjet == 2)
{
stringmatch = "HReco_subleading";
systPathFile = eleplotpath + "systematicsEff_jet2Ht" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet2Ht" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet2Ht" + version + ".txt";
}
if (whichjet == 3)
{
stringmatch = "HReco_subsubleading";
systPathFile = eleplotpath + "systematicsEff_jet3Ht" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet3Ht" + version + ".txt";
fileSystematics = suffix+"systematicsUnfReweight_jet3Ht" + version + ".txt";
}
if (whichjet == 4)
{
stringmatch = "HReco_subsubsubleading";
fileSystematics = suffix+"systematicsUnfReweight_jet4Ht" + version + ".txt";
systPathFile = eleplotpath + "systematicsEff_jet4Ht" + version + ".txt";
systPathFileMuo = muoplotpath + "systematicsEff_jet4Ht" + version + ".txt";
}
}
if (name == stringmatch) {
cout << "CONFIGURATION:" << endl;
cout << "stringmatch: " <<stringmatch<< endl;
cout << "systPathFile: " <<systPathFile<< endl;
TH1D *leading;
gDirectory->GetObject (name.c_str (), leading);
leading->SetMarkerSize(0.9);
leading->Sumw2();
histofmuo->cd ("");
TH1D *leadingmuo;
gDirectory->GetObject (name.c_str (), leadingmuo);
leadingmuo->SetMarkerSize(0.9);
leadingmuo->Sumw2();
histof2->cd ("");
TH1D *leadingthird;
gDirectory->GetObject (name.c_str (), leadingthird);
leadingmuo->SetMarkerSize(0.9);
leadingmuo->Sumw2();
if (inclusive==1){
TH1D* leadingIncl=turnExclusiveHistoInInclusive(leading);
TH1D* leadingmuoIncl=turnExclusiveHistoInInclusive(leadingmuo);
TH1D* leadingthirdIncl=turnExclusiveHistoInInclusive(leadingthird);
leading=leadingIncl;
leadingmuo=leadingmuoIncl;
leadingthird=leadingthirdIncl;
}
// /// EFFICIENCY Systematics:
// for (int nnbins=1;nnbins<=leading->GetNbinsX ();nnbins++) {
// cout << fabs(leading->GetBinContent(nnbins)-leadingmuo->GetBinContent(nnbins))/(2*leading->GetBinContent(nnbins)) << endl;
// cout << leading->GetBinContent(nnbins)-leadingmuo->GetBinContent(nnbins) << endl;
// }
// read from file ---------------------------------------------
double dat;
ifstream inM;
cout << "reading ... " << systPathFile << endl;
inM.open (systPathFile.c_str ());
std::vector < double >systTmpM;
while (1)
{
inM >> dat;
if (!inM.good ())
break;
systTmpM.push_back (dat);
}
inM.close ();
// ------------------------------------------------------------
// read from file ---------------------------------------------
ifstream inM2;
cout << "reading ... " << systPathFileMuo << endl;
inM2.open (systPathFileMuo.c_str ());
std::vector < double >systTmpMmuo;
while (1)
{
inM2 >> dat;
if (!inM2.good ())
break;
systTmpMmuo.push_back (dat);
}
inM2.close ();
// ------------------------------------------------------------
TH1D *leadingRatioSystematics;
leadingRatioSystematics = (TH1D *) leading->Clone ("leading");
if (systTmpM.size () != leadingRatioSystematics->GetNbinsX ())
cout << "TE SON MONA! WRONG NUMBER OF BINS (# syst from file->" <<systTmpM.size()<<" - # bins->"<<leadingRatioSystematics->GetNbinsX()<<")"<<endl;
for (int i = 0; i < leadingRatioSystematics->GetNbinsX (); i++)
{
//leadingRatioSystematics->SetBinContent(i + 1, 1.0);
//leadingRatioSystematics->SetBinError (i + 1,sqrt(systTmpM[i]*systTmpM[i] + systTmpMmuo[i]*systTmpMmuo[i]));
// leadingRatioSystematics->SetBinContent(i + 1, 1.0);
// leadingRatioSystematics->SetBinError (i + 1,max(systTmpM[i]/100.0,systTmpMmuo[i]/100.0));
}
plots->cd ();
TPad *pad1 = new TPad("pad1","pad1",0.01,0.3,0.99,0.99);
pad1->Draw();
pad1->cd();
pad1->SetTopMargin(0.1);
pad1->SetBottomMargin(0.0);
pad1->SetLeftMargin(0.2);
pad1->SetRightMargin(0.0);
pad1->SetFillStyle(0);
if (use_case !=3) pad1->SetLogy(1);
else pad1->SetLogy(0);
if (use_case ==3){
leading->SetMinimum((0.5-0.05*(whichjet-1))*leading->GetMinimum());
leading->SetMaximum((1.25+0.35*(whichjet-1))*leading->GetMaximum());
}
leading->SetLineColor (kRed+1);
leading->SetMarkerStyle (20);
leading->SetFillColor (kRed+1);
leading->SetMarkerColor (kRed+1);
leading->GetXaxis ()->SetTitleOffset (1.1);
leading->GetXaxis ()->SetTitleSize (0.05);
leading->GetXaxis ()->SetLabelSize (0.0);
leading->GetXaxis ()->SetLabelFont (42);
leading->GetXaxis ()->SetTitleFont (42);
leading->GetYaxis ()->SetTitleOffset (1.);
leading->GetYaxis ()->SetTitleSize (0.07);
leading->GetYaxis ()->SetLabelSize (0.06);
leading->GetYaxis ()->SetLabelFont (42);
leading->GetYaxis ()->SetTitleFont (42);
leading->SetTitle ();
leading->GetXaxis ()->SetTitle ();
if (use_case ==1) {
if (absoluteNormalization) leading->GetYaxis ()->SetTitle ("d#sigma/dN [pb]");
else {
if (lepton == 1) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow e^{+}e^{-}}) d#sigma/dN");
if (lepton == 2) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow #mu^{+}#mu^{-}}) d#sigma/dN");
if (lepton == 3) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow l^{+}l^{-}}) d#sigma/dN");
}
}
if (use_case ==2) {
if (absoluteNormalization) leading->GetYaxis ()->SetTitle ("d#sigma/dp_{T} [pb/GeV]");
else {
if (lepton == 1) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow e^{+}e^{-}}) d#sigma/dp_{T}");
if (lepton == 2) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow #mu^{+}#mu^{-}}) d#sigma/dp_{T}");
if (lepton == 3) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow l^{+}l^{-}}) d#sigma/dp_{T}");
}
}
if (use_case ==3) {
if (absoluteNormalization) leading->GetYaxis ()->SetTitle ("d#sigma/d#eta [pb]");
else {
if (lepton == 1) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow e^{+}e^{-}}) d#sigma/d#eta");
if (lepton == 2) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow #mu^{+}#mu^{-}}) d#sigma/d#eta");
if (lepton == 3) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow l^{+}l^{-}}) d#sigma/d#eta");
}
}
if (use_case ==4) {
if (absoluteNormalization) leading->GetYaxis ()->SetTitle ("d#sigma/dH_{T} [pb/GeV]");
else {
if (lepton == 1) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow e^{+}e^{-}}) d#sigma/dH_{T}");
if (lepton == 2) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow #mu^{+}#mu^{-}}) d#sigma/dH_{T}");
if (lepton == 3) leading->GetYaxis ()->SetTitle ("(1/#sigma_{Z #rightarrow l^{+}l^{-}}) d#sigma/dH_{T}");
}
}
leading->SetFillColor (kBlack);
leading->SetFillStyle (3001);
leading->SetMarkerColor (kBlack);
leading->SetLineColor (kBlack);
leading->SetMarkerStyle (20);
leading->Draw ("E1");
leadingmuo->SetFillColor (kBlue);
leadingmuo->SetFillStyle (3001);
leadingmuo->SetMarkerColor (kBlue);
leadingmuo->SetLineColor (kBlue);
leadingmuo->SetMarkerStyle (21);
leadingmuo->Draw ("E1SAME");
leadingthird->SetFillColor (kRed);
leadingthird->SetFillStyle (3001);
leadingthird->SetMarkerColor (kRed);
leadingthird->SetLineColor (kRed);
leadingthird->SetMarkerStyle (21);
leadingthird->Sumw2();
//for (int j=1; j<=leadingthird->GetNbinsX();j++){
//leadingmuo->SetBinError(j,leadingmuo->GetBinError(j)/4980.0);
//leadingthird->SetBinError(j,sqrt(leadingthird->GetBinContent(j))/(4980.0*100));
//}
leadingthird->Draw ("E1SAME");
//-------------------------------------------
TLegend *legendsx_d;
legendsx_d = new TLegend (0.74, 0.6, 0.98, 0.88);
legendsx_d->SetFillColor (kWhite);
legendsx_d->SetBorderSize (1);
legendsx_d->SetNColumns(1);
legendsx_d->SetTextSize(.040);
legendsx_d->AddEntry (leading, "Central", "PEL");
legendsx_d->AddEntry (leadingmuo, "Sherpa", "PEL");
legendsx_d->AddEntry (leadingthird, "Reweighting", "PEL");
legendsx_d->Draw ("same");
// Draw the ratio plot: ----------------------
leadingRatio = (TH1D *) leading->Clone ("leading");
leadingRatio->Divide(leadingmuo);
leadingRatio2 = (TH1D *) leading->Clone ("leading");
leadingRatio2->Divide(leadingthird);
for (int mem=1; mem<=leadingRatio->GetNbinsX(); mem++) {
cout << "Syst for bin nr." << mem << ":\t" << fabs(leadingRatio->GetBinContent(mem)-1.0)/2 << endl;
}
plots->cd();
TPad *pad3 = new TPad("pad3","pad3",0.01,0.01,0.99,0.30);
pad3->Draw();
pad3->cd();
pad3->SetTopMargin(0.0);
pad3->SetBottomMargin(0.3);
pad3->SetLeftMargin(0.2);
pad3->SetRightMargin(0);
pad3->SetFillStyle(0);
leadingRatio->GetXaxis()->SetLabelFont (42);
leadingRatio->GetXaxis()->SetTitleFont (42);
leadingRatio->GetXaxis()->SetTitleSize(0.11);
leadingRatio->GetXaxis()->SetLabelSize(0.11);
leadingRatio->GetXaxis()->SetTitleOffset (1.1);
leadingRatio->GetYaxis()->SetTitleSize(0.11);
leadingRatio->GetYaxis()->SetLabelSize(0.10);
leadingRatio->GetYaxis()->SetTitleOffset(0.65);
leadingRatio->GetYaxis()->SetTitle("Ratio");
leadingRatio->GetYaxis()->SetNdivisions(5);
leadingRatio->GetYaxis()->SetRangeUser(0.4,1.6);
if (use_case ==1) {
leadingRatio->GetXaxis ()->SetTitle ("Exclusive jet multiplicity");
}
if (use_case ==2) {
if (whichjet == 1) leadingRatio->GetXaxis ()->SetTitle ("Leading jet p_{T} [GeV]");
if (whichjet == 2) leadingRatio->GetXaxis ()->SetTitle ("Second jet p_{T} [GeV]");
if (whichjet == 3) leadingRatio->GetXaxis ()->SetTitle ("Third jet p_{T} [GeV]");
if (whichjet == 4) leadingRatio->GetXaxis ()->SetTitle ("Fourth jet p_{T} [GeV]");
}
if (use_case ==3) {
if (whichjet == 1) leadingRatio->GetXaxis ()->SetTitle ("Leading jet #eta");
if (whichjet == 2) leadingRatio->GetXaxis ()->SetTitle ("Second jet #eta");
if (whichjet == 3) leadingRatio->GetXaxis ()->SetTitle ("Third jet #eta");
if (whichjet == 4) leadingRatio->GetXaxis ()->SetTitle ("Fourth jet #eta");
}
if (use_case ==4) {
if (whichjet == 1) leadingRatio->GetXaxis ()->SetTitle ("H_{T}, N_{jet} >= 1 [GeV]");
if (whichjet == 2) leadingRatio->GetXaxis ()->SetTitle ("H_{T}, N_{jet} >= 2 [GeV]");
if (whichjet == 3) leadingRatio->GetXaxis ()->SetTitle ("H_{T}, N_{jet} >= 3 [GeV]");
if (whichjet == 4) leadingRatio->GetXaxis ()->SetTitle ("H_{T}, N_{jet} >= 4 [GeV]");
}
leadingRatio->SetFillColor (kRed+2);
leadingRatio->SetMarkerColor (kRed+2);
leadingRatio->SetLineColor (kRed+2);
leadingRatio->Draw ("E0");
leadingRatioSystematics->SetFillColor (kGreen+3);
leadingRatioSystematics->SetFillStyle (3004);
leadingRatioSystematics->SetMarkerColor (kGreen+3);
leadingRatioSystematics->SetLineColor (kGreen+3);
leadingRatioSystematics->SetMarkerStyle (1);
//leadingRatioSystematics->Draw ("E3SAME");
leadingRatio->Draw ("E1SAME");
leadingRatio2->SetMarkerColor(kBlue);
leadingRatio2->SetLineColor(kBlue);
leadingRatio2->Draw ("E1SAME");
myfile.open (fileSystematics.c_str());
cout<<"TXT file saved in "<<fileSystematics<<endl;
loopAndDumpEntries(leadingRatio,leadingmuo);
TLine *OLine2 = new TLine(leading->GetXaxis()->GetXmin(),1.,leading->GetXaxis()->GetXmax(),1.);
OLine2->SetLineColor(kBlack);
OLine2->SetLineStyle(2);
OLine2->Draw();
//latexLabel->SetTextSize(0.09);
// latexLabel->DrawLatex(0.2,0.35,"Ratio");
/////////////////////////////////////////////////////
string title1;
title1 = s + "DifferentialX" + stringmatch + ".pdf";
cout << title1 << endl;
plots->Print (title1.c_str ());
plots->Draw();
return;
}
}
std::string generateCodeFromStreamers(std::string url, std::string treeLocation, std::vector<std::string> &classNames, std::string &errorMessage) {
TFile *tfile = TFile::Open(url.c_str());
if (tfile == nullptr || !tfile->IsOpen()) {
errorMessage = std::string("File not found: ") + url;
return std::string();
}
if (tfile->IsZombie()) {
errorMessage = std::string("Not a ROOT file: ") + url;
return std::string();
}
TTreeReader reader(treeLocation.c_str(), tfile);
if (reader.IsZombie()) {
errorMessage = std::string("Not a TTree: ") + treeLocation.c_str() + std::string(" in file: ") + url;
return std::string();
}
TTree *ttree = reader.GetTree();
std::set<std::string> includes;
std::vector<ClassStructure> classes;
TIter listOfBranches = ttree->GetListOfBranches();
for (TBranch *tbranch = (TBranch*)listOfBranches.Next(); tbranch != nullptr; tbranch = (TBranch*)listOfBranches.Next()) {
TClass *tclass = TClass::GetClass(tbranch->GetClassName());
if (tclass != nullptr && tbranch->GetListOfBranches()->GetEntries() > 0)
classesFromBranch(tbranch, tclass, classes, 0, includes);
}
for (int i = 0; i < classes.size(); i++)
classNames.push_back(classes[i].fullName);
tfile->Close();
std::string out;
for (std::set<std::string>::iterator iter = includes.begin(); iter != includes.end(); ++iter)
out += *iter + "\n";
out += "\n";
for (std::vector<ClassStructure>::iterator iter = classes.begin(); iter != classes.end(); ++iter) {
int i = 0;
for (; i < iter->splitName.size() - 1; i++)
out += std::string(i * 2, ' ') + "namespace " + iter->splitName[i] + " {\n";
out += std::string(i * 2, ' ') + "class " + iter->splitName.back() + ";\n";
i--;
for (; i >= 0; i--)
out += std::string(i * 2, ' ') + "}\n";
}
out += "\n";
for (std::vector<ClassStructure>::iterator iter = classes.begin(); iter != classes.end(); ++iter) {
int i = 0;
for (; i < iter->splitName.size() - 1; i++)
out += std::string(i * 2, ' ') + "namespace " + iter->splitName[i] + " {\n";
out += iter->cpp(i * 2) + "\n";
i--;
for (; i >= 0; i--)
out += std::string(i * 2, ' ') + "}\n";
}
for (std::vector<ClassStructure>::iterator iter = classes.begin(); iter != classes.end(); ++iter) {
int i = 0;
for (; i < iter->splitName.size() - 1; i++)
out += std::string(i * 2, ' ') + "namespace " + iter->splitName[i] + " {\n";
out += std::string(i * 2, ' ') + "ClassImp(" + iter->splitName.back() + ")\n";
i--;
for (; i >= 0; i--)
out += std::string(i * 2, ' ') + "}\n";
}
return out;
}
void classesFromBranch(TBranch *tbranch, TClass *tclass, std::vector<ClassStructure> &classes, int prefix, std::set<std::string> &includes) {
std::string className = tclass->GetName();
if (className == std::string("TObject"))
includes.insert("#include \"TObject.h\"");
else if (className == std::string("TRef"))
includes.insert("#include \"TRef.h\"");
else if (className == std::string("TRefArray"))
includes.insert("#include \"TRefArray.h\"");
else if (className == std::string("TH1"))
includes.insert("#include \"TH1.h\"");
else if (className == std::string("TBits")) {
includes.insert("#include \"TBits.h\"");
}
else {
bool classSeen = false;
for (int i = 0; i < classes.size(); i++)
if (classes[i].fullName == className)
classSeen = true;
if (!classSeen) {
TVirtualStreamerInfo *tVirtualStreamerInfo = tclass->GetStreamerInfo();
int version = tVirtualStreamerInfo->GetClassVersion();
ClassStructure classStructure(tclass, version);
if (tVirtualStreamerInfo->GetElements()->GetEntries() == 1 &&
((TStreamerElement*)(tVirtualStreamerInfo->GetElements()->First()))->IsBase() &&
std::string(tVirtualStreamerInfo->GetElements()->First()->GetName()) == std::string("TObjArray")) {
TVirtualStreamerInfo *substreamer = ((TBranchElement*)tbranch)->GetInfo();
if (std::string(substreamer->GetName()) == std::string("TClonesArray")) {
ROOT::Internal::TTreeGeneratorBase ttreeGenerator(tbranch->GetTree(), "");
TString className = ttreeGenerator.GetContainedClassName((TBranchElement*)tbranch, (TStreamerElement*)(substreamer->GetElements()->First()), true);
classesFromBranch(tbranch, TClass::GetClass(className), classes, prefix + std::string(tbranch->GetName()).size() + 1, includes);
}
}
TIter elements = tVirtualStreamerInfo->GetElements();
for (TStreamerElement *tStreamerElement = (TStreamerElement*)elements.Next(); tStreamerElement != nullptr; tStreamerElement = (TStreamerElement*)elements.Next()) {
std::string streamerName = tStreamerElement->GetName();
if (tStreamerElement->IsBase()) {
TClass *elementClass = tStreamerElement->GetClassPointer();
std::string type = elementClass->GetName();
if (type == std::string("TObject")) {
classStructure.bases.push_back(type);
includes.insert(std::string("#include \"") + type + std::string(".h\""));
}
}
else {
TIter listOfBranches = tbranch->GetListOfBranches();
TBranch *subbranch;
for (subbranch = (TBranch*)listOfBranches.Next(); subbranch != nullptr; subbranch = (TBranch*)listOfBranches.Next()) {
std::string branchName = subbranch->GetName();
branchName = branchName.substr(prefix, std::string::npos);
int firstDot = branchName.find('.');
int firstBracket = branchName.find('[');
if (firstDot != std::string::npos && firstBracket != std::string::npos)
branchName = branchName.substr(0, firstDot < firstBracket ? firstDot : firstBracket);
else if (firstDot != std::string::npos)
branchName = branchName.substr(0, firstDot);
else if (firstBracket != std::string::npos)
branchName = branchName.substr(0, firstBracket);
if (branchName == streamerName)
break;
}
if (subbranch == nullptr)
continue;
std::string branchName = subbranch->GetName();
std::string variable = tStreamerElement->GetName();
std::string variableWithArray = subbranch->GetName();
variableWithArray = variableWithArray.substr(prefix, std::string::npos);
variableWithArray = variableWithArray.substr(0, variableWithArray.find('.'));
std::string comment = tStreamerElement->GetTitle();
std::string type;
Bool_t pointer = false;
switch (tStreamerElement->GetType()) {
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kBool:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kBool:
case TVirtualStreamerInfo::kBool:
type = "Bool_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kChar:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kChar:
case TVirtualStreamerInfo::kChar:
type = "Char_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kShort:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kShort:
case TVirtualStreamerInfo::kShort:
type = "Short_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kInt:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kInt:
case TVirtualStreamerInfo::kInt:
type = "Int_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kLong:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kLong:
case TVirtualStreamerInfo::kLong:
type = "Long_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kLong64:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kLong64:
case TVirtualStreamerInfo::kLong64:
type = "Long64_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kFloat:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kFloat:
case TVirtualStreamerInfo::kFloat:
type = "Float_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kFloat16:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kFloat16:
case TVirtualStreamerInfo::kFloat16:
type = "Float16_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kDouble:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kDouble:
case TVirtualStreamerInfo::kDouble:
type = "Double_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kDouble32:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kDouble32:
case TVirtualStreamerInfo::kDouble32:
type = "Double32_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kUChar:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kUChar:
case TVirtualStreamerInfo::kUChar:
type = "UChar_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kUShort:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kUShort:
case TVirtualStreamerInfo::kUShort:
type = "UShort_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kUInt:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kUInt:
case TVirtualStreamerInfo::kUInt:
type = "UInt_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kULong:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kULong:
case TVirtualStreamerInfo::kULong:
type = "ULong_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kULong64:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kULong64:
case TVirtualStreamerInfo::kULong64:
type = "ULong64_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kBits:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kBits:
case TVirtualStreamerInfo::kBits:
type = "UInt_t";
break;
case TVirtualStreamerInfo::kCharStar:
type = "Char_t*";
break;
case TVirtualStreamerInfo::kCounter:
type = "Int_t";
break;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kObjectp:
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kObjectP:
case TVirtualStreamerInfo::kObjectp:
case TVirtualStreamerInfo::kObjectP:
case TVirtualStreamerInfo::kAnyp:
case TVirtualStreamerInfo::kAnyP:
case TVirtualStreamerInfo::kSTL + TVirtualStreamerInfo::kObjectp:
case TVirtualStreamerInfo::kSTL + TVirtualStreamerInfo::kObjectP:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kObject:
case TVirtualStreamerInfo::kObject:
case TVirtualStreamerInfo::kTString:
case TVirtualStreamerInfo::kTNamed:
case TVirtualStreamerInfo::kTObject:
case TVirtualStreamerInfo::kAny:
case TVirtualStreamerInfo::kBase:
case TVirtualStreamerInfo::kSTL:
TClass *elementClass = tStreamerElement->GetClassPointer();
type = elementClass->GetName();
if (elementClass == TClonesArray::Class()) {
ROOT::Internal::TTreeGeneratorBase ttreeGenerator(tbranch->GetTree(), "");
TString className = ttreeGenerator.GetContainedClassName((TBranchElement*)subbranch, tStreamerElement, pointer);
if (className != nullptr) {
TClass *otherClass = TClass::GetClass(className);
classesFromBranch(subbranch, otherClass, classes, variableWithArray.size() + 1, includes);
includes.insert("#include \"TClonesArray.h\"");
}
}
else if (elementClass->GetCollectionProxy() != nullptr && elementClass->GetCollectionProxy()->GetValueClass() != nullptr) {
TClass *otherClass = elementClass->GetCollectionProxy()->GetValueClass();
classesFromBranch(subbranch, otherClass, classes, variableWithArray.size() + 1, includes);
includes.insert(std::string("#include <") + type.substr(0, type.find('<')) + std::string(">"));
}
else
classesFromBranch(subbranch, elementClass, classes, variableWithArray.size() + 1, includes);
}
classStructure.members.push_back(MemberStructure(type, pointer, variable, variableWithArray, comment));
}
}
if (!classStructure.members.empty())
classes.push_back(classStructure);
}
}
}