int main() {
// Get7 a map of the histograms of the Z Masses
const std::string file_name = "/data/whybee0a/user/lesko_2/fermi/MadWithInitial/Mad2016_8_25/results/AllMHWithMothers.root";
// Open the file and load the tree
const std::string TreeName = "ZFinder/Combined Gen Cuts Reco/Combined Gen Cuts Reco";
TTree* tree = GetTTree(file_name, TreeName);
TBranch* reco = tree->GetBranch("reco");
TLeaf* PhiStar = reco->GetLeaf("z_phistar_born");
TLeaf* Mom1 = reco->GetLeaf("z_mom1PDG");
TLeaf* Mom2 = reco->GetLeaf("z_mom2PDG");
TLeaf* PenUltimateMom1 = reco->GetLeaf("z_penultimate1PDG");
TLeaf* PenUltimateMom2 = reco->GetLeaf("z_penultimate2PDG");
TLeaf* Z_YBorn = reco->GetLeaf("z_yBorn");
ExploreTree(tree, Mom1, PenUltimateMom1, Mom2, PenUltimateMom2);
TBranch* event_info = tree->GetBranch("event_info");
//TLeaf* EVNumb = event_info->GetLeaf("event_number");
// Pack into a hitogram
for (int w = 0; w < 2; w++) {
string PlotName;
TLeaf* MomOrPenUltimateMom1 = w == 0 ? Mom1 : PenUltimateMom1;
TLeaf* MomOrPenUltimateMom2 = w == 0 ? Mom2 : PenUltimateMom2;
vector<string> NamesOfPlots;
NamesOfPlots.push_back("UpQuarkPair"); //0
NamesOfPlots.push_back("DownQuarkPair"); //1
NamesOfPlots.push_back("StrangeQuarkPair"); //2
NamesOfPlots.push_back("CharmQuarkPair"); //3
NamesOfPlots.push_back("BottomQuarkPair"); //4
NamesOfPlots.push_back("SingleQuark"); //5
NamesOfPlots.push_back("Gluon"); //6
NamesOfPlots.push_back("TwoQuarks"); //7
NamesOfPlots.push_back("TwoAntiQuarks"); //8
NamesOfPlots.push_back("QuarkAntiQuarkPair"); //9
NamesOfPlots.push_back("QuarkAntiQuarkNotPair"); //10
NamesOfPlots.push_back("Quark Quark And AntiQuark AntiQuark"); //11
NamesOfPlots.push_back("Broken");
map<string, TH1*> AllPlots;
AllPlots[NamesOfPlots[0]] = new TH1D(NamesOfPlots[0].c_str(), NamesOfPlots[0].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[1]] = new TH1D(NamesOfPlots[1].c_str(), NamesOfPlots[1].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[2]] = new TH1D(NamesOfPlots[2].c_str(), NamesOfPlots[2].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[3]] = new TH1D(NamesOfPlots[3].c_str(), NamesOfPlots[3].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[4]] = new TH1D(NamesOfPlots[4].c_str(), NamesOfPlots[4].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[5]] = new TH1D(NamesOfPlots[5].c_str(), NamesOfPlots[5].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[6]] = new TH1D(NamesOfPlots[6].c_str(), NamesOfPlots[6].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[7]] = new TH1D(NamesOfPlots[7].c_str(), NamesOfPlots[7].c_str(), nphistar, phistarBins); //Two quarks
AllPlots[NamesOfPlots[8]] = new TH1D(NamesOfPlots[8].c_str(), NamesOfPlots[8].c_str(), nphistar, phistarBins); //Two Anti quarks
AllPlots[NamesOfPlots[9]] = new TH1D(NamesOfPlots[9].c_str(), NamesOfPlots[9].c_str(), nphistar, phistarBins); //
AllPlots[NamesOfPlots[10]] = new TH1D(NamesOfPlots[10].c_str(), NamesOfPlots[10].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[11]] = new TH1D(NamesOfPlots[11].c_str(), NamesOfPlots[11].c_str(), nphistar, phistarBins);
AllPlots[NamesOfPlots[12]] = new TH1D(NamesOfPlots[12].c_str(), NamesOfPlots[12].c_str(), nphistar, phistarBins);
map<string, TH1*> RatioPlots; //using normalized versions of the pairs to see shape changes
cout << "test 1" << endl;
//Vector<TH1*> YplotsFromParents;
//YplotsFromParents.push_back(new TH1D("YSeperatedUpQuarkPair", "UpQuarkPair", nY, yBins));
//YplotsFromParents.push_back(new TH1D("YSeperatedDownQuarkPair", "DownQuarkPair", nY, yBins));
//YplotsFromParents.push_back(new TH1D("YSeperatedStrangeQuarkPair", "StrangeQuarkPair", nY, yBins));
//YplotsFromParents.push_back(new TH1D("YSeperatedCharmQuarkPair", "CharmQuarkPair", nY, yBins));
//YplotsFromParents.push_back(new TH1D("YSeperatedBottomQuarkPair", "BottomQuarkPair", nY, yBins));
//YplotsFromParents.push_back(new TH1D("YSeperatedGluonQuarkPair", "GluonQuarkPair", nY, yBins));
//YplotsFromParents.push_back(new TH1D("YSeperatedGluon", "Gluon", nY, yBins));
//YplotsFromParents.push_back(new TH1D("YSeperatedUnmatchingQuarks", "UnmatchingQuarks", nY, yBins));
//TH2D* Parents = new TH2D("ParentsPDGId", "Parents PDGID", 28, -6.5, 21.5, 28, -6.5, 21.5);
TH2D* ProductionVsY = new TH2D("ProductionVsY", "ProductionVsY", 7, 0, 7, 6, yBins);
for (int i = 0; i < tree->GetEntries(); i++) {
tree->GetEntry(i);
if(PhiStar->GetValue()==-1)continue;
if (fabs(MomOrPenUltimateMom1->GetValue()) == 1 && -MomOrPenUltimateMom1->GetValue() == MomOrPenUltimateMom2->GetValue()) {
AllPlots["QuarkAntiQuarkPair"]->Fill(PhiStar->GetValue());
AllPlots["UpQuarkPair"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(0.1, Z_YBorn->GetValue()
);
} else if (fabs(MomOrPenUltimateMom1->GetValue()) == 2 && -MomOrPenUltimateMom1->GetValue() == MomOrPenUltimateMom2->GetValue()) {
AllPlots["QuarkAntiQuarkPair"]->Fill(PhiStar->GetValue());
AllPlots["DownQuarkPair"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(1.1, Z_YBorn->GetValue());
} else if (fabs(MomOrPenUltimateMom1->GetValue()) == 3 && -MomOrPenUltimateMom1->GetValue() == MomOrPenUltimateMom2->GetValue()) {
AllPlots["QuarkAntiQuarkPair"]->Fill(PhiStar->GetValue());
AllPlots["StrangeQuarkPair"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(2.1, Z_YBorn->GetValue());
} else if (fabs(MomOrPenUltimateMom1->GetValue()) == 4 && -MomOrPenUltimateMom1->GetValue() == MomOrPenUltimateMom2->GetValue()) {
AllPlots["QuarkAntiQuarkPair"]->Fill(PhiStar->GetValue());
AllPlots["CharmQuarkPair"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(3.1, Z_YBorn->GetValue());
} else if (fabs(MomOrPenUltimateMom1->GetValue()) == 5 && -MomOrPenUltimateMom1->GetValue() == MomOrPenUltimateMom2->GetValue()) {
AllPlots["QuarkAntiQuarkPair"]->Fill(PhiStar->GetValue());
AllPlots["BottomQuarkPair"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(4.1, Z_YBorn->GetValue());
} else if ((MomOrPenUltimateMom1->GetValue() == 21 && fabs(MomOrPenUltimateMom2->GetValue()) < 7) || (MomOrPenUltimateMom2->GetValue() == 21 && fabs(MomOrPenUltimateMom1->GetValue()) < 7)) {
AllPlots["SingleQuark"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(6.1, Z_YBorn->GetValue());
} else if (fabs(MomOrPenUltimateMom1->GetValue()) == 21 && MomOrPenUltimateMom1->GetValue() == MomOrPenUltimateMom2->GetValue()) {
AllPlots["Gluon"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(6.1, Z_YBorn->GetValue());
} else if ((MomOrPenUltimateMom1->GetValue()) < 7 && (MomOrPenUltimateMom1->GetValue()) > 0 && (MomOrPenUltimateMom2->GetValue()) < 7 && (MomOrPenUltimateMom2->GetValue()) > 0) {
AllPlots["TwoQuarks"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(7.1, Z_YBorn->GetValue());
} else if ((MomOrPenUltimateMom1->GetValue()) > -7 && (MomOrPenUltimateMom1->GetValue()) < 0 && (MomOrPenUltimateMom2->GetValue()) > -7 && (MomOrPenUltimateMom2->GetValue()) < 0) {
AllPlots["TwoAntiQuarks"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(7.1, Z_YBorn->GetValue());
} else if (fabs(MomOrPenUltimateMom1->GetValue()) < 7 && fabs(MomOrPenUltimateMom1->GetValue()) < 7) {
AllPlots["QuarkAntiQuarkNotPair"]->Fill(PhiStar->GetValue());
ProductionVsY->Fill(7.1, Z_YBorn->GetValue());
} else {
cout << "SOmething broke" << endl;
AllPlots["Broken"]->Fill(PhiStar->GetValue());
}
}
{
cout<<"Our first bin is "<<AllPlots["UpQuarkPair"]->GetBinContent(1)<<endl;
}
cout << "test 2" << endl;
AllPlots["Quark Quark And AntiQuark AntiQuark"]->Add(AllPlots["TwoAntiQuarks"]);
cout << "test 2.1" << endl;
AllPlots["Quark Quark And AntiQuark AntiQuark"] ->Add(AllPlots["TwoQuarks"]);
TH1D* AllQuarksNorm = (TH1D*) AllPlots["QuarkAntiQuarkPair"]->Clone("Devisor");
AllQuarksNorm->Scale(1 / AllQuarksNorm->Integral());
for (int i = 0; i < 5; i++) {
string NewName = "Ratio" + NamesOfPlots[i];
RatioPlots[NewName] = (TH1D*) AllPlots[NamesOfPlots[i]]->Clone(NewName.c_str());
RatioPlots[NewName]->Scale(1 / RatioPlots[NewName]->Integral());
RatioPlots[NewName]->Divide(AllQuarksNorm);
}
cout << "test 3" << endl;
for (size_t i = 0; i < AllPlots.size(); i++) {
for (size_t j = 1; j <= nphistar; j++) {
AllPlots[NamesOfPlots[i]]->SetBinContent(j, AllPlots[NamesOfPlots[i]]->GetBinContent(j) / (phistarBins[j] - phistarBins[j - 1]));
}
}
cout << "test 4" << endl;
for (size_t i = 0; i < NamesOfPlots.size(); i++) {
TCanvas canvas("canvas", "canvas", 1000, 1000);
canvas.cd();
canvas.SetLogx();
canvas.SetLogy();
gStyle->SetCanvasColor(0);
gStyle->SetStatBorderSize(1);
gStyle->SetOptStat("");
gStyle->SetOptFit();
AllPlots[NamesOfPlots[i]]->GetXaxis()->SetRangeUser(.004, 10);
AllPlots[NamesOfPlots[i]]->Draw();
AllPlots[NamesOfPlots[i]]->SetLineWidth(2);
string SaveName = NamesOfPlots[i];
SaveName = 0 == w ? "Mom_" + SaveName : "PenUltimate_" + SaveName;
string WithType = "PhiStarPlots/Mompng/" + SaveName + ".png";
canvas.Print(WithType.c_str());
WithType = "PhiStarPlots/MomPDF/" + SaveName + ".pdf";
canvas.Print(WithType.c_str());
WithType = "PhiStarPlots/MomC/" + SaveName + ".C";
canvas.Print(WithType.c_str());
//if (i == 8)canvas.Print("Broken.png");
}
cout << "test 5" << endl;
TCanvas canvas("c2", "c2", 1000, 1000);
canvas.cd();
canvas.SetLogx();
canvas.SetLogy();
gStyle->SetCanvasColor(0);
gStyle->SetStatBorderSize(1);
gStyle->SetOptStat("");
AllPlots[NamesOfPlots[0]]->SetLineColor(kBlack);
AllPlots[NamesOfPlots[1]]->SetLineColor(kBlue);
AllPlots[NamesOfPlots[2]]->SetLineColor(kRed);
AllPlots[NamesOfPlots[3]]->SetLineColor(kGreen + 1);
AllPlots[NamesOfPlots[4]]->SetLineColor(kMagenta + 1);
AllPlots[NamesOfPlots[5]]->SetLineColor(kOrange + 1);
AllPlots[NamesOfPlots[6]]->SetLineColor(TColor::GetColor("#a65628"));
AllPlots["Quark Quark And AntiQuark AntiQuark"]->SetLineColor(TColor::GetColor("#999999"));
if (w == 0) {
AllPlots[NamesOfPlots[0]]->SetTitle("");
AllPlots[NamesOfPlots[0]]->SetXTitle("#phi^{*}");
AllPlots[NamesOfPlots[0]]->GetXaxis()->CenterTitle();
AllPlots[NamesOfPlots[0]]->Draw();
AllPlots[NamesOfPlots[5]]->Draw("same");
} else {
AllPlots[NamesOfPlots[5]]->SetTitle("");
AllPlots[NamesOfPlots[5]]->SetXTitle("#phi^{*}");
AllPlots[NamesOfPlots[5]]->GetXaxis()->CenterTitle();
AllPlots[NamesOfPlots[5]]->Draw();
AllPlots[NamesOfPlots[0]]->Draw("same");
}
AllPlots[NamesOfPlots[1]]->Draw("same");
AllPlots[NamesOfPlots[2]]->Draw("same");
if (w == 0) {
AllPlots[NamesOfPlots[3]]->Draw("same");
AllPlots[NamesOfPlots[4]]->Draw("same");
}
AllPlots[NamesOfPlots[6]]->Draw("same");
AllPlots["Quark Quark And AntiQuark AntiQuark"]->Draw("same");
TLegend* leg = new TLegend(0.7, 0.70, 0.87, 0.89);
leg->AddEntry(AllPlots[NamesOfPlots[0]], "u#bar{u}");
leg->AddEntry(AllPlots[NamesOfPlots[1]], "d#bar{d}");
leg->AddEntry(AllPlots[NamesOfPlots[2]], "s#bar{s}");
if (w == 0) {
leg->AddEntry(AllPlots[NamesOfPlots[3]], "c#bar{c}");
leg->AddEntry(AllPlots[NamesOfPlots[4]], "b#bar{b}");
}
leg->AddEntry(AllPlots[NamesOfPlots[5]], "qg or #bar{q}g");
leg->AddEntry(AllPlots[NamesOfPlots[6]], "gg");
//leg->AddEntry(AllPlots[8], "Broken");NamesOfPlots[0]], "Up");
leg->AddEntry(AllPlots[NamesOfPlots[11]], "qq or #bar{q}#bar{q}");
leg->SetFillColor(0);
leg->SetLineColor(0);
leg->Draw("same");
PlotName = w == 0 ? "Mom_AllLines.pn" : "PenUltimate_AllLines";
string WithType = "PhiStarPlots/Mompng/" + PlotName + ".png";
canvas.Print(WithType.c_str());
WithType = "PhiStarPlots/MomPDF/" + PlotName + ".pdf";
canvas.Print(WithType.c_str());
WithType = "PhiStarPlots/MomC/" + PlotName + ".C";
canvas.Print(WithType.c_str());
TCanvas canvas3("c3", "c3", 1000, 1000);
canvas3.cd();
canvas3.SetLogz();
gStyle->SetCanvasColor(0);
gStyle->SetStatBorderSize(1);
gStyle->SetOptStat("");
cout << "test last" << endl;
ProductionVsY->Draw("colz");
PlotName = w == 0 ? "Mom_TwoDCompProductionToY" : "PenUltimate_TwoDCompProductionToY";
WithType = "PhiStarPlots/Mompng/" + PlotName + ".png";
canvas3.Print(WithType.c_str());
WithType = "PhiStarPlots/MomPDF/" + PlotName + ".pdf";
canvas3.Print(WithType.c_str());
WithType = "PhiStarPlots/MomC/" + PlotName + ".C";
canvas3.Print(WithType.c_str());
cout << "test 7" << endl;
TCanvas canvas4("c4", "c4", 1000, 1000); //Ratio Plots
canvas4.Divide(1, 3 + 2 * (1 - w));
//canvas4.SetLogx();
//canvas4.SetLogy();
for (int i = 0; i < 3 + 2 * (1 - w); i++) {
string NewName = "Ratio" + NamesOfPlots[i];
TPad * p = (TPad *) canvas4.cd(i + 1);
p->SetLogx();
RatioPlots[NewName]->GetXaxis()->SetRangeUser(.004, 10);
RatioPlots[NewName]->GetXaxis()->SetTitle("#phi^{*}");
RatioPlots[NewName]->GetXaxis()->CenterTitle();
cout << "OUR FIRST BIN IS: " << RatioPlots[NewName]->GetBinContent(1) << endl;
RatioPlots[NewName]->Draw();
}
//canvas4.cd(0);
PlotName = w == 0 ? "Mom_RatioPlots" : "PenUltimate_RatioPlots";
WithType = "PhiStarPlots/Mompng/" + PlotName + ".png";
canvas4.Print(WithType.c_str());
WithType = "PhiStarPlots/MomPDF/" + PlotName + ".pdf";
canvas4.Print(WithType.c_str());
WithType = "PhiStarPlots/MomC/" + PlotName + ".C";
canvas4.Print(WithType.c_str());
string FileName = w == 0 ? "Mom_PhiStarSeperated.root" : "PenUltimate_PhiStarSeperated.root";
TFile SavedHistos(FileName.c_str(), "recreate");
for (size_t i = 0; i < NamesOfPlots.size(); i++) {
AllPlots[NamesOfPlots[i]]->Write();
}
SavedHistos.Write();
}
return EXIT_SUCCESS;
}
void QA_Draw_CEMC_G4Hit(
const char *qa_file_name_new =
"/phenix/u/jinhuang/links/ePHENIX_work/sPHENIX_work/production_analysis_updates/spacal1d/fieldmap/G4Hits_sPHENIX_pi-_eta0.30_32GeV-0000.root_qa.root",
const char *qa_file_name_ref =
"/phenix/u/jinhuang/links/ePHENIX_work/sPHENIX_work/production_analysis_updates/spacal1d/fieldmap/G4Hits_sPHENIX_pi+_eta0.30_32GeV-0000.root_qa.root")
{
SetsPhenixStyle();
TVirtualFitter::SetDefaultFitter("Minuit2");
TFile *qa_file_new = new TFile(qa_file_name_new);
assert(qa_file_new->IsOpen());
TFile *qa_file_ref = NULL;
if (qa_file_name_ref)
{
qa_file_ref = new TFile(qa_file_name_ref);
assert(qa_file_ref->IsOpen());
}
TCanvas *c1 = new TCanvas("QA_Draw_CEMC_G4Hit", "QA_Draw_CEMC_G4Hit", 1800, 900);
c1->Divide(4, 2);
int idx = 1;
TPad *p;
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogz();
TH2F *h_QAG4Sim_CEMC_G4Hit_XY = (TH2F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_XY", "TH2F");
assert(h_QAG4Sim_CEMC_G4Hit_XY);
h_QAG4Sim_CEMC_G4Hit_XY->GetYaxis()->SetTitleOffset(1.5);
h_QAG4Sim_CEMC_G4Hit_XY->Draw("COLZ");
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogz();
TH2F *h_QAG4Sim_CEMC_G4Hit_RZ = (TH2F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_RZ", "TH2F");
assert(h_QAG4Sim_CEMC_G4Hit_RZ);
h_QAG4Sim_CEMC_G4Hit_RZ->GetYaxis()->SetTitleOffset(1.5);
h_QAG4Sim_CEMC_G4Hit_RZ->Draw("COLZ");
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogz();
{
TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =
(TH2F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);
TH1D *proj_new =
h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionX(
"qa_file_new_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_px");
proj_new->Scale(1. / proj_new->GetSum());
TH1D *proj_ref = NULL;
if (qa_file_ref)
{
TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =
(TH2F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);
proj_ref = h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionX(
"qa_file_ref_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_px");
proj_ref->Scale(1. / proj_ref->GetSum());
}
proj_new->GetYaxis()->SetTitle("Normalized energy distribution");
proj_new->GetXaxis()->SetRangeUser(-10, 10);
DrawReference(proj_new, proj_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogz();
{
TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =
(TH2F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);
TH1D *proj_new =
h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionY(
"qa_file_new_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_py");
proj_new->Scale(1. / proj_new->GetSum());
TH1D *proj_ref = NULL;
if (qa_file_ref)
{
TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =
(TH2F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);
proj_ref = h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionY(
"qa_file_ref_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_py");
proj_ref->Scale(1. / proj_ref->GetSum());
}
proj_new->GetYaxis()->SetTitle("Normalized energy distribution");
proj_new->GetXaxis()->SetRangeUser(-10, 10);
DrawReference(proj_new, proj_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogx();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_HitTime", "TH1F");
assert(h_new);
h_new->Rebin(5);
h_new->Scale(1. / h_new->GetSum());
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_HitTime", "TH1F");
assert(h_ref);
h_ref->Rebin(5);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Normalized energy per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogx();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_FractionTruthEnergy", "TH1F");
assert(h_new);
h_new->Rebin(20);
h_new->Sumw2();
h_new->Scale(1. / h_new->GetSum());
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_FractionTruthEnergy", "TH1F");
assert(h_ref);
h_ref->Rebin(20);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Probability per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogz();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_VSF", "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / h_new->GetSum());
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_VSF", "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Sumw2();
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Probability per bin");
h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogz();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_FractionEMVisibleEnergy", "TH1F");
assert(h_new);
h_new->Rebin(4);
h_new->Sumw2();
h_new->Scale(1. / h_new->GetSum());
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_CEMC_G4Hit_FractionEMVisibleEnergy", "TH1F");
assert(h_ref);
h_ref->Rebin(4);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Probability per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);
SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);
}
void FastVsSlowSimRes() {
Int_t plusTPC =0;
gROOT->LoadMacro("~/fig_template.C"); // figure style
myOptions(0);
gROOT->ForceStyle();
TCanvas *myCan = new TCanvas("myCan");
myCan->Draw();
myCan->cd();
TPad *myPad = new TPad("myPad", "The pad",0,0,1,1);
myPadSetUp(myPad,0.15,0.04,0.04,0.15);
myPad->Draw(); myPad->cd();
myPad->SetGridx(); myPad->SetGridy(); myPad->SetLogx();
// TLegend *leg = new TLegend(0.7,160,20,290,"","brCDN");
TLegend *leg = new TLegend(0.44,160,1.7,290,"","brCDN");
leg->SetFillColor(0);
// Current ITS +++++++++++++++++++++++++++++++++++++++++
DetectorK its("ALICE","ITS");
its.MakeAliceCurrent(0,plusTPC);
its.SetMaxRadiusOfSlowDetectors(0.1);
its.SolveViaBilloir(0);
Int_t color=1; Int_t linewidth=2;
TGraph *c[6];
TGraph *d[6];
Int_t pi =0;
d[pi] = its.GetGraphPointingResolution(1,color,linewidth);
d[pi]->SetLineStyle(2);
// d[pi]->GetYaxis()->SetTitle("Pointing resolution #sigma [#mum]");
// d[pi]->SetTitle("Pointing resolution .vs. Pt");
// d[pi]->Draw("AC");
c[pi] = its.GetGraphPointingResolution(0,color,linewidth);
c[pi]->SetMinimum(-1);
c[pi]->Draw("AC");
leg->AddEntry(c[pi],"FastTool: Current ITS","l");
// leg->AddEntry(d[pi],"in z - Current ITS","l");
// Current ITS +++++++++++++++++++++++++++++++++++++++++
Int_t color=3; Int_t linewidth=2;
Int_t pi =2;
DetectorK its("ALICE","ITS");
its.MakeAliceCurrent(0,plusTPC);
its.SetRadius("bpipe",2.0);
its.AddLayer("spd0", 2.2,1,1,1);
its.SetRadius("spd0",2.2); its.SetRadiationLength("spd0",X0); its.SetResolution("spd0",resRPhi,resZ);
its.SetRadius("spd1",4.8); its.SetRadiationLength("spd1",X0); its.SetResolution("spd1",resRPhi,resZ);
its.SetRadius("spd2",9.1); its.SetRadiationLength("spd2",X0); its.SetResolution("spd2",resRPhi,resZ);
its.SetMaxRadiusOfSlowDetectors(0.1);
its.SolveViaBilloir(0);
d[pi] = its.GetGraphPointingResolution(1,color,linewidth);
d[pi]->SetLineStyle(2);
// d[pi]->Draw("C");
c[pi] = its.GetGraphPointingResolution(0,color,linewidth);
c[pi]->Draw("C");
leg->AddEntry(c[pi],"FastTool: \"New SPDs\"","l");
// leg->AddEntry(d[pi],"in z - \"New SPDs\"","l");
// ALL NEW +++++++++++++++++++++++++++++++++++++++++++
color=2; Int_t linewidth=2;
Int_t pi =1;
// for a 0.8,0.2 weight configuration
DetectorK *itsU = new DetectorK((char*)"ALICE",(char*)"ITS");
itsU->AddLayer((char*)"bpipe", 2.0,0.0022); // beam pipe
itsU->AddLayer((char*)"vertex", 0, 0); // dummy vertex for matrix calculation
itsU->AddLayer("ddd1", 2.2 , X0, resRPhi, resZ);
itsU->AddLayer("ddd2", 3.8 , X0, resRPhi, resZ);
itsU->AddLayer("ddd3", 6.8 , X0, resRPhi, resZ);
itsU->AddLayer("ddd4", 12.4 , X0, resRPhi, resZ);
itsU->AddLayer("ddd5", 23.5 , X0, resRPhi, resZ);
itsU->AddLayer("ddd6", 39.6 , X0, resRPhi, resZ);
itsU->AddLayer("ddd7", 43.0 , X0, resRPhi, resZ);
if(plusTPC) itsU->AddTPC(0.1,0.1);
itsU->SetMaxRadiusOfSlowDetectors(0.1);
itsU->SolveViaBilloir(0);
itsU->PrintLayout();
d[pi] = itsU->GetGraphPointingResolution(1,color,linewidth);
d[pi]->SetLineStyle(2);
// d[pi]->Draw("C");
c[pi] = itsU->GetGraphPointingResolution(0,color,linewidth);
c[pi]->SetMaximum(150);
c[pi]->Draw("C");
leg->AddEntry(c[pi],"FastTool: \"All New\" ","l");
// leg->AddEntry(d[pi],"in z - \"All New\" ","l");
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TFile f1("root/FastVsSlow_CurrentITS-PbPb-fran.root");
TFile f2("root/FastVsSlow_NewSPDs-PbPb-fran.root");
TFile f3("root/FastVsSlow_AllNew-PbPb-fran.root");
TGraphErrors *dca1 = (TGraphErrors*)f1.Get("dca");
TGraphErrors *dca2 = (TGraphErrors*)f2.Get("dca");
TGraphErrors *dca3 = (TGraphErrors*)f3.Get("dca");
dca1->SetMarkerStyle(21); dca1->SetMarkerColor(1);
dca2->SetMarkerStyle(21); dca2->SetMarkerColor(3);
dca3->SetMarkerStyle(21); dca3->SetMarkerColor(2);
leg->AddEntry(dca1,"FullMC: Current ITS","PE");
leg->AddEntry(dca2,"FullMC: \"New SPDs\"","PE");
leg->AddEntry(dca3,"FullMC: \"All New\" ","PE");
dca1->Draw("APE"); dca1->SetMinimum(-1); dca1->SetMaximum(300);
dca2->Draw("PE");
dca3->Draw("PE");
c[0]->Draw("C");
c[1]->Draw("C");
c[2]->Draw("C");
leg->Draw();
myCan->SaveAs(Form("FastVsSlowSim-Res-%d.pdf",plusTPC));
myCan->SaveAs(Form("FastVsSlowSim-Res-%d.eps",plusTPC));
}
void compareInDir(TFile* f1, TFile* f2, std::string dirName,unsigned int logmod=0, unsigned int dOpt=1){
TCanvas* cv = 0;
TPad* pH = 0;
TPad* pD = 0;
TPaveText* pt = 0;
// std::cout<<"Start with "<<dirName.c_str()<<std::endl;
// cv->Print("diff.ps[");
TDirectory* d1 = f1->GetDirectory(dirName.c_str());
TDirectory* d2 = f2->GetDirectory(dirName.c_str());
if (d1==0 || d2 == 0){
std::cout<<"ERROR: "<<dirName.c_str()<<" not found"<<std::endl;
return;
}
// std::cout<<"\t\t "<<d1->GetName()<<std::endl;
TList* list1 = d1->GetListOfKeys();
TIterator* keyIt1 = list1->MakeIterator();
TObject* obj;
while ((obj = keyIt1->Next())){
TObject* obj1 = d1->Get(obj->GetName());
if(obj1 == 0){
// std::cout<<"ERROR: failed to read in "<<d1->GetName()<<" / "<<obj->GetName()<<std::endl;
continue;
}
// std::cout<<d1->GetName()<<"/"<<obj->GetName()<<std::endl;
if (! obj1->InheritsFrom(TH1::Class())) continue;
TObject* obj2 = d2->Get(obj1->GetName());
if (obj2 == 0){
// std::cout<<"WARNING: failed to get"<<d1->GetName()<<"/"<<obj1->GetName()<<std::endl;
continue;
}
TH1* h1 = (TH1*)obj1;
TH1* h2 = (TH1*)obj2;
// std::cout<<"Will check "<<dirName.c_str()<<"/"<<h1->GetName()<<" dOpt "<<dOpt<<std::endl;
if(h1->Integral() == 0 && h2->Integral() == 0){
// std::cout<<"Integral is 0: "<<d1->GetName()<<"/"<<obj1->GetName()<<std::endl;
continue;
}
// if (TString(h1->GetTitle()).Index("ffic")<0) continue;
bool isProf = obj1->InheritsFrom(TProfile::Class());
bool isH2 = obj1->InheritsFrom(TH2::Class());
double bDiff = 0;
if(!isH2){
unsigned int nX1 = h1->GetNbinsX();
// std::cout<<"\t is 1D with nBins "<<nX1<<std::endl;
for(unsigned int iB=0; iB<=nX1+1; ++iB){
if(h1->GetBinError(iB)==0 && h1->GetBinContent(iB)!=0) h1->SetBinError(iB,1e-3*fabs(h1->GetBinContent(iB)));
if(h2->GetBinError(iB)==0 && h2->GetBinContent(iB)!=0) h2->SetBinError(iB,1e-3*fabs(h2->GetBinContent(iB)));
bDiff +=fabs(h1->GetBinContent(iB) - h2->GetBinContent(iB));
}
} else {
unsigned int nX1 = h1->GetNbinsX();
unsigned int nY1 = h1->GetNbinsY();
// std::cout<<"\t is 2D with nBins "<<nX1<<" : "<<nY1<<std::endl;
for(unsigned int iB=0; iB<=nX1+1; ++iB){
for(unsigned int jB=0; jB<=nY1+1; ++jB){
if(h1->GetBinError(iB,jB)==0 && h1->GetBinContent(iB,jB)!=0) h1->SetBinError(iB,jB,1e-3*fabs(h1->GetBinContent(iB,jB)));
if(h2->GetBinError(iB,jB)==0 && h2->GetBinContent(iB,jB)!=0) h2->SetBinError(iB,jB,1e-3*fabs(h2->GetBinContent(iB,jB)));
bDiff +=fabs(h1->GetBinContent(iB,jB) - h2->GetBinContent(iB,jB));
}
}
}
double ksProb = 0;
if (bDiff == 0) ksProb = 1;
else ksProb = h1->KolmogorovTest(h2);
if (dOpt%10 == 0 && bDiff ==0 ) continue;
if (dOpt%10 == 1 && (bDiff ==0 || 1.-ksProb <1e-12) ) continue;
if (dOpt%10 == 2 && (bDiff ==0 || ksProb >0.1 )) continue;
if (dOpt%10 == 3 && (bDiff ==0 || 1.-ksProb < 0.001 )) continue;
if (dOpt%10 == 4 && (bDiff ==0 || ksProb >0.9 )) continue;
if (dOpt%10 == 5 && (bDiff ==0 || ksProb >0.5 )) continue;
if (cv == 0){
cv = new TCanvas(dirName.c_str(),dirName.c_str());
cv->cd();
pH = new TPad("head","head", 0, 0.93, 1, 1);
pH->Draw();
pH->cd();
pt = new TPaveText(0,0,1,1); pt->SetFillColor(0);
pt->AddText(dirName.c_str());
pt->Draw();
cv->cd();
pD = new TPad("dis","dis", 0, 0.0, 1, 0.93);
pD->Draw();
pD->cd();
}
pD->Clear();
pD->cd();
std::cout<<"Save : "<<dirName.c_str()<<"/"<<h1->GetName()<<std::endl;
if (! isH2){
h1->SetLineWidth(2);
h1->SetLineColor(1);
h1->SetMarkerColor(1);
h2->SetLineColor(2);
h2->SetMarkerColor(2);
// if (h1->GetNbinsX() > 25) h1 = h1->Rebin();
// if (h2->GetNbinsX() > 25) h2 = h2->Rebin();
// if (h1->GetNbinsX() > 50) h1 = h1->Rebin(5);
// if (h2->GetNbinsX() > 50) h2 = h2->Rebin(5);
double max1 = h1->GetMaximum();
double max2 = h2->GetMaximum();
double min1 = h1->GetMinimum();
double min2 = h2->GetMinimum();
if (max2> max1) h1->SetMaximum(max2+0.15*fabs(max2));
if (min2 < min1) h1->SetMinimum(min2-0.15*fabs(min2));
// pD->SetLogy();
if ((logmod&1)) pD->SetLogx();
if ((logmod&2)) pD->SetLogy();
h1->Draw();
h2->Draw("sames");
if (std::string(h1->GetName())==std::string("reconstruction_step_module_total")
|| std::string(h1->GetName())==std::string("validation_step_module_total")){
TPaveText ksPt(0,0, 0.35, 0.04, "NDC"); ksPt.SetBorderSize(0); ksPt.SetFillColor(0);
ksPt.AddText(Form("P(KS)=%g, diffBins=%g, eblk %g ered %g",ksProb, bDiff, h1->GetEntries(), h2->GetEntries()));
// ksPt.AddText(h1->GetName());
ksPt.Draw();
cv->Print("diff.ps");
int nX = h1->GetNbinsX();
TAxis* h1Ax = h1->GetXaxis();
int nRanges = nX/20 + 1;
double h1Int = h1->Integral();
float curBMargin = pD->GetBottomMargin();
pD->SetBottomMargin(0.3);
for (int iR = 0; iR < nRanges; iR++){
h1Ax->SetRange(iR*20+1, iR*20+20);
double bDiffL = 0;
double max1L = -1;
double max2L = -1;
double min1L = h1->GetMaximum();
double min2L = h2->GetMaximum();
for (int iBL = iR*20+1; iBL<= iR*20+20; ++iBL){
double h1L = h1->GetBinContent(iBL);
double h2L = h2->GetBinContent(iBL);
bDiffL += std::abs(h1L-h2L);
if (max1L < h1L) max1L = h1L;
if (max2L < h2L) max2L = h2L;
if (min1L > h1L) min1L = h1L;
if (min2L > h2L) min2L = h2L;
}
if (max2L> max1L) h1->SetMaximum(max2L+0.15*std::abs(max2L));
else h1->SetMaximum(max1L+0.15*std::abs(max1L));
if (min2L < min1L) h1->SetMinimum(min2L-0.15*std::abs(min2L));
else h1->SetMinimum(min1L-0.15*std::abs(min1L));
h1->Draw();
h2->Draw("sames");
TPaveText ksPtL(0,0, 0.35, 0.04, "NDC"); ksPtL.SetBorderSize(0); ksPtL.SetFillColor(0);
ksPtL.AddText(Form("P(KS)=%g, diffBinsL=%g(%g), eblk %g ered %g",ksProb, bDiffL, bDiffL/h1Int, h1->GetEntries(), h2->GetEntries()));
ksPtL.Draw();
cv->Print("diff.ps");
}
pD->SetBottomMargin(curBMargin);
}
}
if (isH2){
pD->Divide(2);
pD->cd(1);
h1->Draw("colz");
pD->cd(2);
h2->Draw("colz");
}
TPaveText ksPt(0,0, 0.55, 0.06, "NDC"); ksPt.SetBorderSize(0); ksPt.SetFillColor(0);
ksPt.AddText(Form("P(KS)=%g, diffBins=%g, eblk %g ered %g",ksProb, bDiff, h1->GetEntries(), h2->GetEntries()));
ksPt.AddText(h1->GetName());
ksPt.Draw();
cv->Print("diff.ps");
cv->Print("diff.pdf");
}
// std::cout<<"Done in "<<dirName.c_str()<<std::endl;
// delete pH; delete pD;
if (cv) delete cv;
// cv->Print("diff.ps]");
}
void EMCDistribution_PeakSample_Fast(bool full_gain = false)
{
const TString gain = "RAW";
TString hname = "EMCDistribution_" + gain + TString(full_gain ? "_FullGain" : "") + cuts;
TH2 *h2 = NULL;
{
if (full_gain)
{
h2 = new TH2F(hname,
Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 100,
.05 * 100, 25 * 100, 64, -.5, 63.5);
QAHistManagerDef::useLogBins(h2->GetXaxis());
}
else
{
h2 = new TH2F(hname,
Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 260,
-.2 * 100, 5 * 100, 64, -.5, 63.5);
}
T->Draw(
"TOWER_" + gain + "_CEMC[].get_bineta() + 8* TOWER_" + gain + "_CEMC[].get_binphi():(TOWER_RAW_CEMC[].signal_samples[10] - TOWER_RAW_CEMC[].signal_samples[0])*(-1)>>" + hname, "", "goff");
}
TText *t;
TCanvas *c1 = new TCanvas(
"EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts,
"EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts, 1800, 950);
c1->Divide(8, 8, 0., 0.01);
int idx = 1;
TPad *p;
for (int iphi = 8 - 1; iphi >= 0; iphi--)
{
for (int ieta = 0; ieta < 8; ieta++)
{
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
if (full_gain)
{
p->SetLogx();
}
p->SetGridx(0);
p->SetGridy(0);
TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(full_gain ? "_FullGain" : "");
TH1 *h = h2->ProjectionX(hname, ieta + 8 * iphi + 1,
ieta + 8 * iphi + 1); // axis bin number is encoded as ieta+8*iphi+1
h->SetLineWidth(0);
h->SetLineColor(kBlue + 3);
h->SetFillColor(kBlue + 3);
h->GetXaxis()->SetTitleSize(.09);
h->GetXaxis()->SetLabelSize(.08);
h->GetYaxis()->SetLabelSize(.08);
h->Draw();
if (full_gain)
h->Fit("x*gaus", "M");
else
h->Fit("landau", "M");
double peak = -1;
TF1 *fit = ((TF1 *) (h->GetListOfFunctions()->At(0)));
if (fit)
{
fit->SetLineColor(kRed);
peak = fit->GetParameter(1);
}
cout << Form("Finished <Col%d Row%d> = %.1f", ieta, iphi, peak)
<< endl;
TText *t = new TText(.9, .9,
Form("<Col%d Row%d> = %.1f", ieta, iphi, peak));
t->SetTextAlign(33);
t->SetTextSize(.15);
t->SetNDC();
t->Draw();
}
}
SaveCanvas(c1,
TString(_file0->GetName()) + TString("_DrawPrototype3EMCalTower_") + TString(c1->GetName()), false);
}
void QA_Draw_Jet_Spectrum(
//
// const char * jet = "h_QAG4SimJet_AntiKt_Tower_r07",
const char *jet = "h_QAG4SimJet_AntiKt_Truth_r07",
const char *qa_file_name_new =
"data/G4sPHENIXCells_250jets25GeV.root_qa.root",
const char *qa_file_name_ref =
"data/G4sPHENIXCells_2000jets25GeV.root_qa.root")
{
SetsPhenixStyle();
TVirtualFitter::SetDefaultFitter("Minuit2");
TFile *qa_file_new = new TFile(qa_file_name_new);
assert(qa_file_new->IsOpen());
TFile *qa_file_ref = NULL;
if (qa_file_name_ref)
{
qa_file_ref = new TFile(qa_file_name_ref);
assert(qa_file_ref->IsOpen());
}
// obtain normalization
double Nevent_new = 1;
double Nevent_ref = 1;
if (qa_file_new)
{
TH1D *h_norm = (TH1D *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Normalization"), "TH1D");
assert(h_norm);
Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin("Event"));
}
if (qa_file_ref)
{
TH1D *h_norm = (TH1D *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Normalization"), "TH1D");
assert(h_norm);
Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin("Event"));
}
TCanvas *c1 = new TCanvas(TString("QA_Draw_Jet_Spectrum_") + TString(jet),
TString("QA_Draw_Jet_Spectrum_") + TString(jet), 1800, 1000);
c1->Divide(4, 2);
int idx = 1;
TPad *p;
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_eta"), "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_eta"), "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_phi"), "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_phi"), "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_Et"), "TH1F");
assert(h_new);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_Et"), "TH1F");
assert(h_ref);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_Mass"), "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_Mass"), "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogx();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_CompSize"), "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_CompSize"), "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_CEMC_Ratio"), "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_CEMC_Ratio"), "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_CEMC_HCalIN_Ratio"), "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_CEMC_HCalIN_Ratio"), "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
if (TString(jet).Contains("Truth"))
{
// truth jets
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(
TString(jet) + TString("_Leading_Leakage_Ratio"), "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / Nevent_new);
TH1F *h_ref = NULL;
if (qa_file_ref)
{
h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
TString(jet) + TString("_Leading_Leakage_Ratio"), "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / Nevent_ref);
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Count / event / bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
}
// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);
SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);
}
void
QA_Draw_HCALIN_TowerCluster(
const char * qa_file_name_new =
"/phenix/u/jinhuang/links/ePHENIX_work/sPHENIX_work/production_analysis_updates/spacal1d/fieldmap/G4Hits_sPHENIX_pi-_eta0.30_32GeV-0000.root_qa.root",
const char * qa_file_name_ref =
"/phenix/u/jinhuang/links/ePHENIX_work/sPHENIX_work/production_analysis_updates/spacal1d/fieldmap/G4Hits_sPHENIX_pi+_eta0.30_32GeV-0000.root_qa.root")
{
SetOKStyle();
gStyle->SetOptStat(0);
gStyle->SetOptFit(1111);
TVirtualFitter::SetDefaultFitter("Minuit2");
TFile * qa_file_new = new TFile(qa_file_name_new);
assert(qa_file_new->IsOpen());
TFile * qa_file_ref = NULL;
if (qa_file_name_ref)
{
qa_file_ref = new TFile(qa_file_name_ref);
assert(qa_file_ref->IsOpen());
}
TCanvas *c1 = new TCanvas("QA_Draw_HCALIN_TowerCluster",
"QA_Draw_HCALIN_TowerCluster", 1800, 900);
c1->Divide(4, 2);
int idx = 1;
TPad * p;
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogx();
p->SetLogy();
{
TH1F * h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_1x1", "TH1F");
assert(h_new);
h_new->Scale(1. / h_new->GetSum());
TH1F * h_ref = NULL;
if (qa_file_ref)
{
TH1F * h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_1x1", "TH1F");
assert(h_ref);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Normalized tower count per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogx();
p->SetLogy();
{
TH1F * h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_3x3", "TH1F");
assert(h_new);
h_new->Scale(1. / h_new->GetSum());
TH1F * h_ref = NULL;
if (qa_file_ref)
{
TH1F * h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_3x3", "TH1F");
assert(h_ref);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Normalized tower count per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogx();
p->SetLogy();
{
TH1F * h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_1x1_max", "TH1F");
assert(h_new);
h_new->Rebin(40);
h_new->Sumw2();
h_new->Scale(1. / h_new->GetSum());
TH1F * h_ref = NULL;
if (qa_file_ref)
{
TH1F * h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_1x1_max", "TH1F");
assert(h_ref);
h_ref->Rebin(40);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Probability per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogx();
p->SetLogy();
{
TH1F * h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_4x4_max", "TH1F");
assert(h_new);
h_new->Rebin(40);
h_new->Sumw2();
h_new->Scale(1. / h_new->GetSum());
TH1F * h_ref = NULL;
if (qa_file_ref)
{
TH1F * h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_HCALIN_Tower_4x4_max", "TH1F");
assert(h_ref);
h_ref->Rebin(40);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Probability per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogz();
TH2F * h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =
(TH2F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);
h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->GetYaxis()->SetTitleOffset(
1.5);
// h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->GetXaxis()->SetRangeUser(-5,
// 5);
// h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->GetYaxis()->SetRangeUser(-5,
// 5);
h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->Draw("COLZ");
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogz();
{
TH2F * h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =
(TH2F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);
TH1D * proj_new =
h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionX(
"qa_file_new_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_px");
proj_new->Rebin(4);
proj_new->Scale(1. / proj_new->GetSum());
TH1D * proj_ref = NULL;
if (qa_file_ref)
{
TH2F * h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =
(TH2F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);
proj_ref =
h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionX(
"qa_file_ref_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_px");
proj_ref->Rebin(4);
proj_ref->Scale(1. / proj_ref->GetSum());
}
proj_new->GetYaxis()->SetTitleOffset(1.);
proj_new->GetXaxis()->SetTitleOffset(1.);
proj_new->GetYaxis()->SetTitle("Normalized energy distribution");
// proj_new->GetXaxis()->SetRangeUser(-10, 10);
DrawReference(proj_new, proj_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
// p->SetLogz();
{
TH2F * h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =
(TH2F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);
TH1D * proj_new =
h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionY(
"qa_file_new_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_py");
proj_new->Rebin(4);
proj_new->Scale(1. / proj_new->GetSum());
TH1D * proj_ref = NULL;
if (qa_file_ref)
{
TH2F * h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =
(TH2F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection", "TH2F");
assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);
proj_ref =
h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionY(
"qa_file_ref_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_py");
proj_ref->Rebin(4);
proj_ref->Scale(1. / proj_ref->GetSum());
}
proj_new->GetYaxis()->SetTitleOffset(1.);
proj_new->GetXaxis()->SetTitleOffset(1.);
proj_new->GetYaxis()->SetTitle("Normalized energy distribution");
// proj_new->GetXaxis()->SetRangeUser(-10, 10);
DrawReference(proj_new, proj_ref);
}
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
{
TH1F * h_new = (TH1F *) qa_file_new->GetObjectChecked(
"h_QAG4Sim_HCALIN_Cluster_BestMatchERatio", "TH1F");
assert(h_new);
h_new->Rebin(2);
h_new->Sumw2();
h_new->Scale(1. / h_new->GetSum());
TH1F * h_ref = NULL;
if (qa_file_ref)
{
TH1F * h_ref = (TH1F *) qa_file_ref->GetObjectChecked(
"h_QAG4Sim_HCALIN_Cluster_BestMatchERatio", "TH1F");
assert(h_ref);
h_ref->Rebin(2);
h_ref->Scale(1. / h_ref->GetSum());
}
h_new->GetYaxis()->SetTitleOffset(1.5);
h_new->GetYaxis()->SetTitle("Probability per bin");
// h_new->GetXaxis()->SetRangeUser(-0, .1);
DrawReference(h_new, h_ref);
}
PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);
SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);
}
void ATLASCMSCOMPARISON(TString quantity="ttbarMass"){
bool cmssim=true;
// ---
// canvas style
// ---
TStyle myStyle("HHStyle","HHStyle");
setHHStyle(myStyle);
myStyle.SetErrorX(0.5);
myStyle.cd();
gROOT->SetStyle("HHStyle");
gStyle->SetEndErrorSize(10);
gStyle->SetOptFit(0);
// ---
// top Pt 7 TeV
// ---
int Nbins7=7;
if( quantity=="topPt" ) Nbins7=7;
else if(quantity=="ttbarMass") Nbins7=5;
else if(quantity=="ttbarY" ) Nbins7=6;
// CMS data
TGraphAsymmErrors* CMSdata7 = new TGraphAsymmErrors(Nbins7);
if(quantity=="topPt"){
CMSdata7->SetPoint( 0, 25.0 , 0.004032 );
CMSdata7->SetPoint( 1, 75.0 , 0.006746 );
CMSdata7->SetPoint( 2, 125.0, 0.004737 );
CMSdata7->SetPoint( 3, 175.0, 0.002506 );
CMSdata7->SetPoint( 4, 225.0, 0.001140 );
CMSdata7->SetPoint( 5, 300.0, 0.000334 );
CMSdata7->SetPoint( 6, 575.0, 0.000019 );
CMSdata7->SetPointError( 0, 25., 25., ( 5.5/100)*0.004032, ( 5.5/100)*0.004032 );
CMSdata7->SetPointError( 1, 25., 25., ( 4.1/100)*0.006746, ( 4.1/100)*0.006746 );
CMSdata7->SetPointError( 2, 25., 25., ( 4.0/100)*0.004737, ( 4.0/100)*0.004737 );
CMSdata7->SetPointError( 3, 25., 25., ( 5.4/100)*0.002506, ( 5.4/100)*0.002506 );
CMSdata7->SetPointError( 4, 25., 25., ( 5.6/100)*0.001140, ( 5.6/100)*0.001140 );
CMSdata7->SetPointError( 5, 50., 50., ( 8.4/100)*0.000334, ( 8.4/100)*0.000334 );
CMSdata7->SetPointError( 6, 225.,225., (14.1/100)*0.000019, (14.1/100)*0.000019 );
}
else if(quantity=="ttbarMass"){
CMSdata7->SetPoint( 0, 350.0 , 0.002588 );
CMSdata7->SetPoint( 1, 500.0 , 0.002685 );
CMSdata7->SetPoint( 2, 625.0 , 0.000953 );
CMSdata7->SetPoint( 3, 825.0 , 0.000232 );
CMSdata7->SetPoint( 4, 1725.0, 0.000008 );
CMSdata7->SetPointError( 0, 100., 100., ( 4.9 /100)*0.002588, (4.9 /100)*0.002588 );
CMSdata7->SetPointError( 1, 50. , 50. , ( 6.9 /100)*0.002685, (6.9 /100)*0.002685 );
CMSdata7->SetPointError( 2, 75. , 75. , ( 7.7 /100)*0.000953, (7.7 /100)*0.000953 );
CMSdata7->SetPointError( 3, 125., 125., ( 14.4/100)*0.000232, (14.4/100)*0.000232 );
CMSdata7->SetPointError( 4, 775., 775., ( 27.6/100)*0.000008, (27.6/100)*0.000008 );
}
else if(quantity=="ttbarY"){
CMSdata7->SetPoint( 0, -1.75, 0.082140 );
CMSdata7->SetPoint( 1, -0.75, 0.318979 );
CMSdata7->SetPoint( 2, -0.25, 0.427823 );
CMSdata7->SetPoint( 3, 0.25, 0.44591 );
CMSdata7->SetPoint( 4, 0.75, 0.318820 );
CMSdata7->SetPoint( 5, 1.75, 0.080457 );
CMSdata7->SetPointError( 0, 0.75, 0.75, (8.1/100)*0.082140, (8.1/100)*0.082140 );
CMSdata7->SetPointError( 1, 0.25, 0.25, (3.3/100)*0.318979, (3.3/100)*0.318979 );
CMSdata7->SetPointError( 2, 0.25, 0.25, (3.0/100)*0.427823, (3.0/100)*0.427823 );
CMSdata7->SetPointError( 3, 0.25, 0.25, (3.5/100)*0.44591 , (3.5/100)*0.44591 );
CMSdata7->SetPointError( 4, 0.25, 0.25, (3.5/100)*0.318820, (3.5/100)*0.318820 );
CMSdata7->SetPointError( 5, 0.75, 0.75, (5.9/100)*0.080457, (5.9/100)*0.080457 );
}
CMSdata7->SetLineWidth(3.);
CMSdata7->SetMarkerSize(1.2);
CMSdata7->SetMarkerStyle(24);
CMSdata7->SetLineStyle(1);
CMSdata7->SetMarkerColor(kBlue);
CMSdata7->SetLineColor(kBlue);
CMSdata7->SetFillStyle(3004);
CMSdata7->SetFillColor(kBlue);
// CMS MadGraph+Pythia(Z2*)
TGraphAsymmErrors* CMSMadGraph7 = new TGraphAsymmErrors(Nbins7);
if(quantity=="topPt"){
CMSMadGraph7->SetPoint( 0, 25.0 , 0.003331 );
CMSMadGraph7->SetPoint( 1, 75.0 , 0.006495 );
CMSMadGraph7->SetPoint( 2, 125.0, 0.005077 );
CMSMadGraph7->SetPoint( 3, 175.0, 0.002748 );
CMSMadGraph7->SetPoint( 4, 225.0, 0.001282 );
CMSMadGraph7->SetPoint( 5, 300.0, 0.000413 );
CMSMadGraph7->SetPoint( 6, 575.0, 0.000027 );
CMSMadGraph7->SetPointError( 0, 25., 25., 0., 0. );
CMSMadGraph7->SetPointError( 1, 25., 25., 0., 0. );
CMSMadGraph7->SetPointError( 2, 25., 25., 0., 0. );
CMSMadGraph7->SetPointError( 3, 25., 25., 0., 0. );
CMSMadGraph7->SetPointError( 4, 25., 25., 0., 0. );
CMSMadGraph7->SetPointError( 5, 50., 50., 0., 0. );
CMSMadGraph7->SetPointError( 6, 225., 225., 0., 0. );
}
else if(quantity=="ttbarMass"){
CMSMadGraph7->SetPoint( 0, 350.0 , 0.002541 );
CMSMadGraph7->SetPoint( 1, 500.0 , 0.002759 );
CMSMadGraph7->SetPoint( 2, 625.0 , 0.000988 );
CMSMadGraph7->SetPoint( 3, 825.0 , 0.000222 );
CMSMadGraph7->SetPoint( 4, 1725.0, 0.000008 );
CMSMadGraph7->SetPointError( 0, 100., 100., 0., 0. );
CMSMadGraph7->SetPointError( 1, 50. , 50. , 0., 0. );
CMSMadGraph7->SetPointError( 2, 75. , 75. , 0., 0. );
CMSMadGraph7->SetPointError( 3, 125., 125., 0., 0. );
CMSMadGraph7->SetPointError( 4, 775., 775., 0., 0. );
}
else if(quantity=="ttbarY"){
CMSMadGraph7->SetPoint( 0, -1.75, 0.088374 );
CMSMadGraph7->SetPoint( 1, -0.75, 0.319964 );
CMSMadGraph7->SetPoint( 2, -0.25, 0.414022 );
CMSMadGraph7->SetPoint( 3, 0.25, 0.415108 );
CMSMadGraph7->SetPoint( 4, 0.75, 0.320370 );
CMSMadGraph7->SetPoint( 5, 1.75, 0.088218 );
CMSMadGraph7->SetPointError( 0, 0.75, 0.75, 0., 0. );
CMSMadGraph7->SetPointError( 1, 0.25, 0.25, 0., 0. );
CMSMadGraph7->SetPointError( 2, 0.25, 0.25, 0., 0. );
CMSMadGraph7->SetPointError( 3, 0.25, 0.25, 0., 0. );
CMSMadGraph7->SetPointError( 4, 0.25, 0.25, 0., 0. );
CMSMadGraph7->SetPointError( 5, 0.75, 0.75, 0., 0. );
}
CMSMadGraph7->SetLineWidth(3.);
CMSMadGraph7->SetMarkerSize(1.2);
CMSMadGraph7->SetLineStyle(1);
CMSMadGraph7->SetMarkerStyle(20);
CMSMadGraph7->SetMarkerColor(kAzure+6);
CMSMadGraph7->SetLineColor(kAzure+6);
// ATLAS data
TGraphAsymmErrors* ATLASdata7 = new TGraphAsymmErrors(Nbins7);
if(quantity=="topPt"){
ATLASdata7->SetPoint( 0, 25.0 , 0.0034 );
ATLASdata7->SetPoint( 1, 75.0 , 0.0067 );
ATLASdata7->SetPoint( 2, 125.0, 0.0052 );
ATLASdata7->SetPoint( 3, 175.0, 0.00266 );
ATLASdata7->SetPoint( 4, 225.0, 0.00114 );
ATLASdata7->SetPoint( 5, 300.0, 0.00033 );
ATLASdata7->SetPoint( 6, 575.0, 0.000018);
ATLASdata7->SetPointError( 0, 25., 25., (4.47 /100)*0.0034 , (4.47 /100)*0.0034 );
ATLASdata7->SetPointError( 1, 25., 25., (1.41 /100)*0.0067 , (1.41 /100)*0.0067 );
ATLASdata7->SetPointError( 2, 25., 25., (2.83 /100)*0.0052 , (2.83 /100)*0.0052 );
ATLASdata7->SetPointError( 3, 25., 25., (3.61 /100)*0.00266 , (3.61 /100)*0.00266 );
ATLASdata7->SetPointError( 4, 25., 25., (3.61 /100)*0.00114 , (3.61 /100)*0.00114 );
ATLASdata7->SetPointError( 5, 50., 50., (5.83 /100)*0.00033 , (5.83 /100)*0.00033 );
ATLASdata7->SetPointError( 6, 225., 225., (11.66/100)*0.000018, (11.66/100)*0.000018 );
}
else if(quantity=="ttbarMass"){
ATLASdata7->SetPoint( 0, 350.0 , 0.00250 );
ATLASdata7->SetPoint( 1, 500.0 , 0.00273 );
ATLASdata7->SetPoint( 2, 625.0 , 0.00102 );
ATLASdata7->SetPoint( 3, 825.0 , 0.00023 );
ATLASdata7->SetPoint( 4, 1725.0, 0.0000076 );
ATLASdata7->SetPointError( 0, 100., 100., 0.00008 , 0.00008 );
ATLASdata7->SetPointError( 1, 50. , 50. , 0.00007 , 0.00007 );
ATLASdata7->SetPointError( 2, 75. , 75. , 0.00004 , 0.00004 );
ATLASdata7->SetPointError( 3, 125., 125., 0.00001 , 0.00001 );
ATLASdata7->SetPointError( 4, 775., 775., 0.0000005, 0.0000005 );
}
else if(quantity=="ttbarY"){
ATLASdata7->SetPoint( 0, -1.75, 0.081 );
ATLASdata7->SetPoint( 1, -0.75, 0.321 );
ATLASdata7->SetPoint( 2, -0.25, 0.436 );
ATLASdata7->SetPoint( 3, 0.25, 0.423 );
ATLASdata7->SetPoint( 4, 0.75, 0.321 );
ATLASdata7->SetPoint( 5, 1.75, 0.087 );
ATLASdata7->SetPointError( 0, 0.75, 0.75, 0.003, 0.003);
ATLASdata7->SetPointError( 1, 0.25, 0.25, 0.009, 0.009);
ATLASdata7->SetPointError( 2, 0.25, 0.25, 0.009, 0.009);
ATLASdata7->SetPointError( 3, 0.25, 0.25, 0.007, 0.007);
ATLASdata7->SetPointError( 4, 0.25, 0.25, 0.005, 0.005);
ATLASdata7->SetPointError( 5, 0.75, 0.75, 0.005, 0.005);
}
ATLASdata7->SetLineWidth(3.);
ATLASdata7->SetMarkerSize(1.2);
ATLASdata7->SetMarkerStyle(22);
ATLASdata7->SetLineStyle(2);
ATLASdata7->SetMarkerColor(kRed);
ATLASdata7->SetLineColor(kRed);
ATLASdata7->SetFillStyle(3005);
ATLASdata7->SetFillColor(kRed);
// ---
// dummy plots for axis
// ---
// create variable bin edges
std::map<TString, std::vector<double> > binning_ = makeVariableBinning(false);
std::vector<double> newTopBins_;
if(quantity=="topPt"){
newTopBins_.push_back(0.);
newTopBins_.push_back(50.);
newTopBins_.push_back(100.);
newTopBins_.push_back(150.);
newTopBins_.push_back(200.);
newTopBins_.push_back(250.);
newTopBins_.push_back(350.);
newTopBins_.push_back(800.);
}
else if(quantity=="ttbarMass"){
newTopBins_.push_back(250.);
newTopBins_.push_back(450.);
newTopBins_.push_back(550.);
newTopBins_.push_back(700.);
newTopBins_.push_back(950.);
newTopBins_.push_back(2500.);
}
else if(quantity=="ttbarY" ){
newTopBins_.push_back(-2.5);
newTopBins_.push_back(-1.0);
newTopBins_.push_back(-0.5);
newTopBins_.push_back(0. );
newTopBins_.push_back(0.5 );
newTopBins_.push_back(1.0 );
newTopBins_.push_back(2.5 );
}
binning_[quantity]=newTopBins_;
double start=0.;
double range=800.;
int Nfinebins=800;
if(quantity=="topPt"){ Nfinebins=800; start=0.; range=800.;}
else if(quantity=="ttbarMass"){ Nfinebins=2250; start=250.; range=2500.; }
else if(quantity=="ttbarY" ){ Nfinebins=500 ; start=-2.5; range=2.5;}
TH1F* dummy= new TH1F("","",Nfinebins,start,range);
reBinTH1F(*dummy, binning_[quantity], 0);
histogramStyle(*dummy, kSig);
TString label="p_{T}^{t} [GeV]";
TString label2="p_{T}^{t}";
if(quantity=="topPt"){label="p_{T}^{t} [GeV]"; label2="p_{T}^{t}";}
else if(quantity=="ttbarMass"){ label="m^{t#bar{t}} [GeV]"; label2="m^{t#bar{t}}"; }
else if(quantity=="ttbarY" ){ label="y^{t#bar{t}}"; label2=label; }
dummy->GetXaxis()->SetTitle(label);
dummy->GetYaxis()->SetTitle(TString("#frac{1}{#sigma} #frac{d#sigma}{")+label2+"}");
double max=0.01;
double min=0.;
if(quantity=="topPt" ){max=0.01 ; min=0.;}
if(quantity=="ttbarMass"){max=0.004; min=0.;}
if(quantity=="ttbarY" ){max=1.0 ; min=0.;}
dummy->SetMaximum(max);
dummy->SetMinimum(min);
TH1F* A=convertToHist(ATLASdata7, dummy, Nbins7);
TH1F* C=convertToHist(CMSdata7 , dummy, Nbins7);
histogramStyle(*A, kSig, true, 1.2, kRed);
A->SetLineWidth(3.);
A->SetMarkerSize(1.2);
A->SetMarkerStyle(22);
A->SetLineStyle(1);
A->SetMarkerColor(kRed);
A->SetLineColor(kRed);
A->SetFillStyle(3005);
histogramStyle(*C, kSig, true, 1.2, kBlue);
C->SetLineWidth(3.);
C->SetMarkerSize(1.2);
C->SetMarkerStyle(24);
C->SetLineStyle(1);
C->SetMarkerColor(kBlue);
C->SetLineColor(kBlue);
C->SetFillStyle(3004);
TH1F* M=convertToHist(CMSMadGraph7 , dummy, Nbins7);
histogramStyle(*M, kSig, false, 1.2, kAzure+6);
M->SetLineWidth(3.);
M->SetMarkerSize(1.2);
M->SetMarkerStyle(22);
M->SetLineStyle(1);
M->SetMarkerColor(kAzure+6);
M->SetLineColor(kAzure+6);
// ---
// legend
// ---
TLegend *leg0 = new TLegend(0.45, 0.65, 0.95, 0.85);
leg0->SetFillStyle(0);
leg0->SetBorderSize(0);
leg0->SetHeader("#sqrt{s}=7TeV data (e/#mu channel)");
TLegend *leg1=(TLegend*)leg0->Clone();
if(cmssim) leg0->AddEntry( CMSMadGraph7, "CMS MadGraph+Pythia(Z2*)", "LP");
leg0->AddEntry( CMSdata7 , "CMS data in ATLAS binning" , "LP");
leg0->AddEntry( ATLASdata7 , "ATLAS data" , "LP");
leg1->AddEntry( ATLASdata7 , "ATLAS (ATLAS-CONF-2013-099)" , "FP");
leg1->AddEntry( CMSdata7 , "CMS (TOP-11-013 in ATLAS binning)" , "FP");
if(cmssim) leg1->AddEntry( CMSMadGraph7, "CMS MadGraph+Pythia(Z2*)", "LP");
// ---
// privatworklabel
// ---
TPaveText *privatworklabel = new TPaveText();
privatworklabel -> SetX1NDC(gStyle->GetPadLeftMargin());
privatworklabel -> SetY1NDC(1.0-gStyle->GetPadTopMargin());
privatworklabel -> SetX2NDC(1.0-gStyle->GetPadRightMargin());
privatworklabel -> SetY2NDC(1.0);
privatworklabel -> SetTextFont(42);
privatworklabel -> AddText("private work");
privatworklabel->SetFillStyle(0);
privatworklabel->SetBorderSize(0);
privatworklabel->SetTextSize(0.04);
privatworklabel->SetTextAlign(32);
// canvas
std::vector<TCanvas*> plotCanvas_;
// a) linear
addCanvas(plotCanvas_);
plotCanvas_[plotCanvas_.size()-1]->cd(0);
plotCanvas_[plotCanvas_.size()-1]->SetTitle(quantity+" measurement comparison");
// drawing
dummy->Draw("axis");
if(cmssim) CMSMadGraph7->Draw("p e1 same");
ATLASdata7 ->Draw("p e2 same");
CMSdata7 ->Draw("p e2 same");
leg0 ->Draw("same");
privatworklabel->Draw("same");
// b) log scale
TH1F* dummy2=(TH1F*)dummy->Clone();
dummy2->SetMinimum(0.00001);
dummy2->SetMaximum(max*10);
addCanvas(plotCanvas_);
plotCanvas_[plotCanvas_.size()-1]->cd(0);
plotCanvas_[plotCanvas_.size()-1]->SetTitle(quantity+" measurement comparison");
plotCanvas_[plotCanvas_.size()-1]->SetLogy();
// drawing
dummy2->Draw("axis");
if(cmssim) CMSMadGraph7->Draw("p e1 same");
CMSdata7 ->Draw("p e2 same");
ATLASdata7 ->Draw("p e2 same");
leg0 ->Draw("same");
privatworklabel->Draw("same");
// c) both data with bands
addCanvas(plotCanvas_);
plotCanvas_[plotCanvas_.size()-1]->cd(0);
plotCanvas_[plotCanvas_.size()-1]->SetTitle(quantity+" measurement comparison");
// drawing
dummy->Draw("axis");
//DrawSteps(C, "e2 same");
//C->Draw("e2 same");
//DrawSteps(A, "e2 same");
//A->Draw("e2 same");
if(cmssim) CMSMadGraph7->Draw("p e1 same");
CMSdata7 ->Draw("p e2 same");
ATLASdata7 ->Draw("p e2 same");
// new pad for log plot
TPad *rPad = new TPad("rPad","",0.4,0.15,0.95,0.85);
rPad->SetFillStyle(0);
rPad->SetFillColor(0);
rPad->SetBorderSize(0);
rPad->SetBorderMode(0);
rPad->SetLogy(0);
rPad->SetLogx(0);
rPad->SetTicky(1);
rPad->Draw("");
rPad->cd();
// log plot curves
rPad->SetLogy();
dummy2->Draw("axis");
if(cmssim) CMSMadGraph7->Draw("p e1 same");
CMSdata7 ->Draw("p e2 same");
ATLASdata7 ->Draw("p e2 same");
leg1->Draw("same");
privatworklabel->Draw("same");
// d) both data with ratio
addCanvas(plotCanvas_);
plotCanvas_[plotCanvas_.size()-1]->cd(0);
plotCanvas_[plotCanvas_.size()-1]->SetTitle(quantity+" measurement comparison");
// drawing
dummy->Draw("axis");
if(cmssim) CMSMadGraph7->Draw("p e1 same");
//DrawSteps(C, "e2 same");
//C->Draw("e2 same");
//DrawSteps(A, "e2 same");
//A->Draw("e2 same");
CMSdata7 ->Draw("p e2 same");
ATLASdata7 ->Draw("p e2 same");
leg1 ->Draw("same");
privatworklabel->Draw("same");
std::vector<double> errA_;
for(int bin=1; bin<=Nbins7; ++bin){
errA_.push_back((ATLASdata7->GetY()[bin-1]/CMSdata7->GetY()[bin-1])*((ATLASdata7->GetErrorYhigh(bin-1)/ATLASdata7->GetY()[bin-1])));
}
std::vector<double> errC_;
for(int bin=1; bin<=Nbins7; ++bin){
errC_.push_back((CMSdata7->GetErrorYhigh(bin-1)/CMSdata7->GetY()[bin-1]));
}
if(cmssim){
std::vector<double> errM_;
for(int bin=1; bin<=Nbins7; ++bin){
errM_.push_back(0.);
//errM_.push_back((CMSMadGraph7->GetY()[bin-1]/CMSdata7->GetY()[bin-1])*((CMSMadGraph7->GetErrorYhigh(bin-1)/CMSMadGraph7->GetY()[bin-1])));
}
drawRatio(M, C, 0.5, 1.5, myStyle, 0, errM_, "x", "CMS data", "hist ", kAzure+6, false, 0.7);
drawRatio(C, C, 0.5, 1.5, myStyle, 0, errC_, "x", "CMS data", "p e2 same" , kBlue, true, 0.7);
}
else drawRatio(C, C, 0.5, 1.5, myStyle, 0, errC_, "x", "CMS data", "p e2" , kBlue, true, 0.7);
drawRatio(A, C, 0.5, 1.5, myStyle, 0, errA_, "x", "CMS data", "p e2 same", kRed , true, 0.7);
//saving
TString path="./diffXSecFromSignal/plots/combined/2012/comparisonATLAS/";
plotCanvas_[0]->Print(path+quantity+"ATLASvsCMS7TeV.eps");
plotCanvas_[0]->Print(path+quantity+"ATLASvsCMS7TeV.png");
plotCanvas_[1]->Print(path+quantity+"ATLASvsCMS7TeVLog.eps");
plotCanvas_[1]->Print(path+quantity+"ATLASvsCMS7TeVLog.png");
plotCanvas_[2]->Print(path+quantity+"ATLASvsCMS7TeVNoratio.eps");
plotCanvas_[2]->Print(path+quantity+"ATLASvsCMS7TeVNoratio.png");
plotCanvas_[plotCanvas_.size()-1]->Print(path+quantity+"ATLASvsCMS7TeVratio.eps");
plotCanvas_[plotCanvas_.size()-1]->Print(path+quantity+"ATLASvsCMS7TeVratio.png");
plotCanvas_[plotCanvas_.size()-1]->SetTitle(quantity);
saveToRootFile("ATLASvsCMSDataComparisonPlots.root", plotCanvas_[plotCanvas_.size()-1], true, 0,"");
}
void macro_MakeQcdClosureTest()
{
// parameters //////////////////////////////////////////////////////////////
//TFile input("./emuSpec_19619pb-1.root", "open");
TFile input("test_19619pb-1.root", "open");
input.cd();
TParameter<float> *lumi = (TParameter<float> *)input.Get("lumi");
const int nBins = 75;
const bool usePu = 1;
const bool useWeight = 1;
const int qcdEst = 1; // estimation method of QCD contribution. none(0), from SS spectrum(1), from fake rate(2)
int eRegion = 2; // electron region EB(0), EE(1), EB+EE(2)
bool plotSign[3];
plotSign[0] = 1; // all
plotSign[1] = 1; // SS same sign
plotSign[2] = 1; // OS opposite sign
bool plotType[2];
plotType[0] = 1; // emu spectrum
plotType[1] = 1; // cumulative emu spectrum
const bool plotPull = 0; // plot (data-bkg)/bkg
const bool plotPullBelowSpec = 0; // plot (data-bkg)/bkg below spectrum
const bool logPlotX = 0;
const bool logPlotY = 1;
const bool prelim = 1;
const bool groupedPlot = 0;
const bool overflowBin = 1;
float xRangeMin = 60.;
float xRangeMax = 1200.;
//float xRangeMin = 0.;
//float xRangeMax = 1500.;
float yRangeMin[6] = {0.002, 0.002, 0.002, 0.4, 0.4, 0.4};
float yRangeMax[6] = {30, 10, 30, 3000, 1000, 3000};
float yRangeMinRatio[3] = {-0.7, -0.7, -0.7};
float yRangeMaxRatio[3] = {0.7, 0.7, 0.7};
float fitMin = xRangeMin;
float fitMax = 1100.; // set to highest bin with a data point
float xRangeMinRatio = fitMin;
float xRangeMaxRatio = fitMax;
// output file formats
const bool savePull = 0;
const bool saveSpec = 0;
const bool saveCumSpec = 0;
const bool saveAsPdf = 0;
const bool saveAsPng = 1;
const bool saveAsRoot = 0;
const char *fileNameExtra = "";
//const char *fileNameExtra = "madgraphTTbar_";
const char *plotDir = "./plottemp/";
// plot style
int wjetColour= TColor::GetColor("#ffd324");
int jetBkgColour = TColor::GetColor("#ffff66");
int font = 42; //62
////////////////////////////////////////////////////////////////////////////
// systematic errors
float systErrLumi = ((TParameter<float> *)input.Get("systErrLumi"))->GetVal();
systErrLumi = 0.; // since we normalize to the Z peak
float systErrEff = ((TParameter<float> *)input.Get("systErrEff"))->GetVal(); // muon err & ele err
THashList *systErrMCs = (THashList *)input.Get("systErrMCs");
vector<float> systErrMC;
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTtbar"))->GetVal()); // NNLO ttbar
//systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTtbar700to1000"))->GetVal()); // NLO ttbar700to1000
//systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTtbar1000up"))->GetVal()); // NLO ttbar1000up
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcDyTauTau"))->GetVal()); //z->tt
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcWW"))->GetVal()); //WW
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcWZ"))->GetVal()); //WZ
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcZZ"))->GetVal()); //ZZ
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcTW"))->GetVal()); //tW
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcDyMuMu"))->GetVal()); //Z->mm
systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcDyEE"))->GetVal()); //Z->ee
if (qcdEst == 2) systErrMC.push_back(0.4); // qcd error
else systErrMC.push_back(((TParameter<float> *)systErrMCs->FindObject("systErrMcWJets"))->GetVal()); //WJets
// to keep the histogram when the file is closed
TH1::AddDirectory(kFALSE);
TH1::SetDefaultSumw2(kTRUE);
TString histoSign[3] = {"", "SS_", "OS_"};
TString xAxisTitle[3] = {"m(e#mu)", "m(e^{#pm}#mu^{#pm})", "m(e^{#pm}#mu^{#mp})"};
TString nameSuffix[2] = {"", "cumul"};
TString titleSuffix[2] = {"", " - Cumulative"};
vector<TH1F *> emuMass_wjets;
vector<TH1F *> emuMass_qcd;
vector<TH1F *> emuMass_qcdFromFake;
// define the binning
vector<float> binning;
if (logPlotX) {
//for (float bin = 0.; bin < 100.; bin += 5.)
// binning.push_back(bin);
for (float bin = 0.; bin < 200.; bin += 10.)
binning.push_back(bin);
for (float bin = 200.; bin < 400.; bin += 20.)
binning.push_back(bin);
for (float bin = 400.; bin < 500.; bin += 25.)
binning.push_back(bin);
for (float bin = 500.; bin <= 620.; bin += 40.)
binning.push_back(bin);
binning.push_back(670.);
binning.push_back(720.);
binning.push_back(780.);
binning.push_back(840.);
binning.push_back(920.);
binning.push_back(1000.);
binning.push_back(1100.);
binning.push_back(1220.);
binning.push_back(1380.);
binning.push_back(1500.);
} else {
//for (float bin = 0.; bin <= 1500.; bin += 20.)
// binning.push_back(bin);
for (float bin = 0.; bin < 200.; bin += 20.)
binning.push_back(bin);
for (float bin = 200.; bin < 400.; bin += 40.)
binning.push_back(bin);
for (float bin = 400.; bin < 700.; bin += 50.)
binning.push_back(bin);
for (float bin = 700.; bin < 1000.; bin += 75.)
binning.push_back(bin);
for (float bin = 1000.; bin < 1200.; bin += 100.)
binning.push_back(bin);
for (float bin = 1200.; bin <= 1500.; bin += 150.)
binning.push_back(bin);
}
THashList *mcWeights = (THashList *)input.Get("mcWeights");
TParameter<float> *mcWeight = (TParameter<float> *)mcWeights->FindObject("ttbar");
TParameter<float> *mcWeight700to1000 = (TParameter<float> *)mcWeights->FindObject("ttbar700to1000");
TParameter<float> *mcWeight1000up = (TParameter<float> *)mcWeights->FindObject("ttbar1000up");
float totMcWeight = 1.;
// determine qcd contribution
TH1F *qcdContrib;
TH1F *ssData = MakeHistoFromBranch(&input, "emuTree_data", "mass", SS, eRegion, "", 0., 0., binning, 0x100);
TH1F *ssBg = MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "genMTtbar", 0., 700., binning, 0x1DF);
totMcWeight = 1. / (1 / mcWeight->GetVal() + 1 / mcWeight700to1000->GetVal());
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "genMTtbar", 700., 1000., binning, 0x19F), totMcWeight);
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar700to1000", "mass", SS, eRegion, "genMTtbar", 700., 1000., binning, 0x19F), totMcWeight);
totMcWeight = 1. / (1 / mcWeight->GetVal() + 1 / mcWeight1000up->GetVal());
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "genMTtbar", 1000., 1000000000., binning, 0x19F), totMcWeight);
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ttbar1000up", "mass", SS, eRegion, "genMTtbar", 1000., 1000000000., binning, 0x19F), totMcWeight);
//TH1F *ssBg = MakeHistoFromBranch(&input, "emuTree_ttbar", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF);
//TH1F *ssBg = MakeHistoFromBranch(&input, "emuTree_ttbarto2l", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF);
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ztautau", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_ww", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_wz", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_zz", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_tw", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_zmumu", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_zee", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
ssBg->Add(MakeHistoFromBranch(&input, "emuTree_wjets", "mass", SS, eRegion, "", 0., 0., binning, 0x1DF));
qcdContrib = (TH1F *)ssData->Clone("qcdContrib_SS");
qcdContrib->Add(ssBg, -1);
for (int i = 0; i < qcdContrib->GetNbinsX() + 2; ++i) {
if (qcdContrib->GetBinContent(i) < 0) qcdContrib->SetBinContent(i, 0.);
}
cout << "expected SS QCD events: " << ssData->Integral() - ssBg->Integral() << endl;
cout << "derived SS QCD events: " << qcdContrib->Integral() << endl;
cout << "scale factor: " << (ssData->Integral() - ssBg->Integral()) / qcdContrib->Integral()<< endl;
qcdContrib->Scale((ssData->Integral() - ssBg->Integral()) / qcdContrib->Integral());
// loop over full spectrum, SS and OS
for (int k = 0; k < 3; ++k) {
// loop to get normal and cumulated spectrum
for (unsigned int j = 0; j < 2; ++j) {
input.cd();
bool normToBin = true;
if (j > 0) normToBin = false;
if (k == 2) k = -1;
// make the histograms
emuMass_wjets.push_back(MakeHistoFromBranch(&input, "emuTree_wjets", "mass", k, eRegion, "", 0., 0., binning, 0x1DF, normToBin));
if (k == -1) k = 2;
emuMass_wjets.back()->SetName("emuMass_" + histoSign[k] + "wjets" + nameSuffix[j]);
// qcd contribution
if (k == 2) k = -1;
emuMass_qcdFromFake.push_back((TH1F *)MakeHistoFromBranch(&input, "frEmuTree_data", "mass", k, eRegion, "", 0., 0., binning, 0x300));
emuMass_qcd.push_back((TH1F *)qcdContrib->Clone("emuMass_" + histoSign[k] + "qcd"));
if (k == ALL) emuMass_qcd.back()->Scale(2.);
// normalize to bin width
if (j < 1) {
for (int i = 1; i < emuMass_qcd.back()->GetNbinsX() + 1; ++i) {
emuMass_qcd.back()->SetBinContent(i, emuMass_qcd.back()->GetBinContent(i) / emuMass_qcd.back()->GetBinWidth(i));
emuMass_qcd.back()->SetBinError(i, emuMass_qcd.back()->GetBinError(i) / emuMass_qcd.back()->GetBinWidth(i));
emuMass_qcdFromFake.back()->SetBinContent(i, emuMass_qcdFromFake.back()->GetBinContent(i) / emuMass_qcdFromFake.back()->GetBinWidth(i));
emuMass_qcdFromFake.back()->SetBinError(i, emuMass_qcdFromFake.back()->GetBinError(i) / emuMass_qcdFromFake.back()->GetBinWidth(i));
}
}
if (k == -1) k = 2;
// add overflow in last bin
if (j == 0 && overflowBin) {
emuMass_wjets.back()->SetBinContent(emuMass_wjets.back()->GetNbinsX(), emuMass_wjets.back()->GetBinContent(emuMass_wjets.back()->GetNbinsX()) + emuMass_wjets.back()->GetBinContent(emuMass_wjets.back()->GetNbinsX() + 1));
emuMass_qcd.back()->SetBinContent(emuMass_qcd.back()->GetNbinsX(), emuMass_qcd.back()->GetBinContent(emuMass_qcd.back()->GetNbinsX()) + emuMass_qcd.back()->GetBinContent(emuMass_qcd.back()->GetNbinsX() + 1));
emuMass_qcdFromFake.back()->SetBinContent(emuMass_qcdFromFake.back()->GetNbinsX(), emuMass_qcdFromFake.back()->GetBinContent(emuMass_qcdFromFake.back()->GetNbinsX()) + emuMass_qcdFromFake.back()->GetBinContent(emuMass_qcdFromFake.back()->GetNbinsX() + 1));
}
// integrate from the right side
if (j == 1) {
// loop over bins
double error;
for (int i = 1; i < nBins + 1; ++i) {
emuMass_wjets.back()->SetBinContent(i, emuMass_wjets.back()->IntegralAndError(i, nBins, error));
emuMass_wjets.back()->SetBinError(i, error);
emuMass_qcd.back()->SetBinContent(i, emuMass_qcd.back()->IntegralAndError(i, nBins, error));
emuMass_qcd.back()->SetBinError(i, error);
emuMass_qcdFromFake.back()->SetBinContent(i, emuMass_qcdFromFake.back()->IntegralAndError(i, nBins, error));
emuMass_qcdFromFake.back()->SetBinError(i, error);
}
}
if (!plotSign[k]) continue;
if (!plotType[j]) continue;
TCanvas *emuPlot;
TPad *specPad;
if (plotPullBelowSpec && j == 0) {
emuPlot = new TCanvas("emuPlot" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 100, 100, 900, 900);
specPad = new TPad("specPad" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 0., 0.33, 1., 1.);
specPad->SetBottomMargin(0.06);
} else {
emuPlot = new TCanvas("emuPlot" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 100, 100, 900, 600);
specPad = new TPad("specPad" + histoSign[k] + nameSuffix[j], "emu Spectrum" + titleSuffix[j], 0., 0., 1., 1.);
specPad->SetBottomMargin(0.12);
}
specPad->SetBorderMode(0);
specPad->SetBorderSize(2);
specPad->SetFrameBorderMode(0);
specPad->SetFillColor(0);
specPad->SetFrameFillColor(0);
if (logPlotX) specPad->SetLogx();
if (logPlotY) specPad->SetLogy();
specPad->SetLeftMargin(0.11);
specPad->SetRightMargin(0.09);
specPad->SetTopMargin(0.08);
specPad->SetTickx(1);
specPad->SetTicky(1);
specPad->Draw();
specPad->cd();
gStyle->SetTitleFont(font);
gStyle->SetLabelFont(font);
gStyle->SetLegendFont(font);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetTitleXOffset(1.);
gStyle->SetTitleYOffset(1.3);
gPad->SetTicks(1, 1);
// make a histogram stack with the bg
THStack *bgStack = new THStack("bgStack" + histoSign[k] + nameSuffix[j], "Invariant Mass" + titleSuffix[j]);
bgStack->Add(emuMass_qcd.back());
bgStack->Add(emuMass_wjets.back());
// plot spectrum
emuMass_wjets.back()->SetFillColor(wjetColour);
emuMass_wjets.back()->SetMarkerColor(wjetColour);
emuMass_wjets.back()->SetLineColor(kBlack);
emuMass_wjets.back()->SetLineWidth(2);
//emuMass_wjets.back()->Draw("HISTsames");
emuMass_qcd.back()->SetFillColor(jetBkgColour);
emuMass_qcd.back()->SetMarkerColor(jetBkgColour);
emuMass_qcd.back()->SetLineColor(kBlack);
emuMass_qcd.back()->SetLineWidth(2);
//emuMass_qcd.back()->Draw("HISTsames");
bgStack->Draw("hist");
emuMass_qcdFromFake.back()->SetLineColor(kRed);
emuMass_qcdFromFake.back()->SetLineWidth(2);
emuMass_qcdFromFake.back()->Draw("esame");
if (plotPullBelowSpec && j == 0) {
bgStack->GetXaxis()->SetTitle("");
} else {
bgStack->GetXaxis()->SetTitle(xAxisTitle[k] + " [GeV]");
}
bgStack->GetXaxis()->SetTitleFont(font);
bgStack->GetXaxis()->SetTitleSize(0.047);
bgStack->GetXaxis()->SetTitleOffset(0.9);
bgStack->GetXaxis()->SetLabelFont(font);
bgStack->GetXaxis()->SetLabelSize(0.05);
bgStack->GetXaxis()->SetMoreLogLabels();
bgStack->GetXaxis()->SetNoExponent();
//bgStack->GetXaxis()->SetRangeUser(xRangeMin, xRangeMax);
bgStack->GetXaxis()->SetLimits(xRangeMin, xRangeMax);
if (j == 1) bgStack->GetYaxis()->SetTitle("Events #geq " + xAxisTitle[k]);
else bgStack->GetYaxis()->SetTitle("Events / GeV");
bgStack->GetYaxis()->SetTitleFont(font);
bgStack->GetYaxis()->SetTitleSize(0.047);
bgStack->GetYaxis()->SetTitleOffset(1.1);
bgStack->GetYaxis()->SetLabelFont(font);
bgStack->GetYaxis()->SetLabelSize(0.05);
bgStack->SetMinimum(yRangeMin[k + j * 3]);
bgStack->SetMaximum(yRangeMax[k + j * 3]);
// redraw axis
emuMass_qcd.back()->Draw("sameaxis");
// legend and labels
TLegend legend(0.710, 0.646, 0.901, 0.885);
legend.SetTextFont(font);
legend.SetTextSize(0.03);
legend.SetBorderSize(0);
legend.SetLineColor(1);
legend.SetLineStyle(1);
legend.SetLineWidth(1);
legend.SetFillColor(19);
legend.SetFillStyle(0);
legend.AddEntry(emuMass_wjets.back(), "W+jets (MC)" ,"F");
legend.AddEntry(emuMass_qcd.back(), "jets (SS data)" ,"F");
legend.AddEntry(emuMass_qcdFromFake.back(), "jets (Fake Rate)" ,"le");
legend.DrawClone("sames");
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextFont(font);
tex->SetLineWidth(2);
tex->SetTextSize(0.042);
if (prelim) tex->DrawLatex(0.325, 0.853, "CMS Preliminary, 8 TeV, 19.6 fb^{-1}");
else tex->DrawLatex(0.405, 0.853, "CMS, 8 TeV, 19.6 fb^{-1}");
if (eRegion == 0) tex->DrawLatex(0.325, 0.775, "e in barrel");
if (eRegion == 1) tex->DrawLatex(0.325, 0.775, "e in endcap");
// safe in various file formats
stringstream sStream;
if (!plotPullBelowSpec || j > 0) {
sStream << plotDir << "qcdClosureTestSpec";
if (k == 0) sStream << "_";
sStream << histoSign[k];
if (eRegion == 0) sStream << "EB_";
if (eRegion == 1) sStream << "EE_";
sStream << fileNameExtra << nameSuffix[j];
if (j > 0) sStream << "_";
if (groupedPlot) sStream << "grouped_";
if (!logPlotY) sStream << "lin_";
sStream << lumi->GetVal() << "pb-1";
TString saveFileName = sStream.str();
if ((j == 0 && saveSpec) || (j > 0 && saveCumSpec)) {
if (saveAsPdf) emuPlot->Print(saveFileName + ".pdf", "pdf");
if (saveAsPng) emuPlot->Print(saveFileName + ".png", "png");
if (saveAsRoot) emuPlot->Print(saveFileName + ".root", "root");
}
}
} // end loop over normal or cumulated
} // end loop over full, SS and OS
// generate one object containing everything
vector<vector<TH1F *> > emuMasses;
emuMasses.push_back(emuMass_wjets);
emuMasses.push_back(emuMass_qcd);
// // define groups of MC samples
// vector<bool> ttLikeSamples(6, true);
// vector<bool> contamSamples(6, false);
// contamSamples.push_back(true); // Zmm
// contamSamples.push_back(true); // Zee
// contamSamples.push_back(true); // WJets or QCD
// vector<bool> contamSamplesNoQcd(contamSamples);
// vector<bool> allSamples(9, true);
// vector<bool> onlyQCD(emuMasses.size() - 1, false);
// if (qcdEst > 0) {
// onlyQCD.back() = true;
// if (qcdEst != 2) {
// allSamples.push_back(true);
// contamSamples.push_back(true);
// contamSamplesNoQcd.push_back(false);
// systErrMC.push_back(0.); // QCD error will be calculated later
// } else {
// contamSamplesNoQcd.back() = false;
// }
// }
// vector<bool> allSamplesNoQcd(allSamples);
// if (qcdEst > 0) allSamplesNoQcd.back() = false;
// unsigned int qcdInd = onlyQCD.size();
// unsigned int qcdErrInd = qcdInd - 1;
//
// // calculate rate of syst errors
// float systErrLuEff = sqrt(systErrLumi*systErrLumi + systErrEff*systErrEff);
// vector<float> systErrMCLuEff;
// for (unsigned int it = 0; it < systErrMC.size(); ++it)
// systErrMCLuEff.push_back(sqrt(systErrMC[it]*systErrMC[it] + systErrLuEff*systErrLuEff));
//
// bool calcQcdErr = false;
// if (qcdEst == 1) calcQcdErr = true;
//
// //cout << "qcdInd " << qcdInd << ", emuMasses.size() " << emuMasses.size() << ", systErrMC.size() " << systErrMC.size()
// // << ", systErrMCLuEff.size() " << systErrMCLuEff.size() << ", allSamples.size() " << allSamples.size()
// // << ", allSamplesNoQcd.size() " << allSamplesNoQcd.size() << ", contamSamplesNoQcd.size() " << contamSamplesNoQcd.size()
// // << ", contamSamples.size() " << contamSamples.size() << ", onlyQCD.size() " << onlyQCD.size() << endl;
// //for (unsigned int sIt = 0; sIt < emuMasses.size() - 1; ++sIt) {
// // cout << "allSamples " << allSamples[sIt] << ", allSamplesNoQcd " << allSamplesNoQcd[sIt]
// // << ", contamSamples " << contamSamples[sIt] << ", contamSamplesNoQcd " << contamSamplesNoQcd[sIt]
// // << ", onlyQCD " << onlyQCD[sIt] << ", systErrMC " << systErrMC[sIt] << ", systErrMCLuEff " << systErrMCLuEff[sIt] << endl;
// //}
//
// // define special bins corresponding to specific masses
// int bin60 = emuMass_data.at(ALL)->FindBin(60.);
// int bin120 = emuMass_data.at(ALL)->FindBin(120.);
// int bin200 = emuMass_data.at(ALL)->FindBin(200.);
// int bin400 = emuMass_data.at(ALL)->FindBin(400.);
// int bin500 = emuMass_data.at(ALL)->FindBin(500.);
//
// vector<const char *> sampleNames;
// sampleNames.push_back("data ");
// sampleNames.push_back("ttbar ");
// sampleNames.push_back("Ztautau");
// sampleNames.push_back("WW ");
// sampleNames.push_back("WZ ");
// sampleNames.push_back("ZZ ");
// sampleNames.push_back("tW ");
// sampleNames.push_back("Zmumu ");
// sampleNames.push_back("Zee ");
// if (qcdEst != 2) sampleNames.push_back("WJets ");
// if (qcdEst > 0) sampleNames.push_back("QCD ");
//
// // write numbers
// cout << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// cout << "HEEP - TIGHT MU Lumi = " << lumi->GetVal() << "pb-1" << endl;
// //cout << " e pT EB > " << bar_et << "GeV/c" << endl;
// //cout << " e pT EE > " << end_et << "GeV/c" << endl;
// //cout << " mu pT > " << muon_et << "GeV/c" << endl;
// //cout << " mu |eta| < " << muon_etaMax << endl;
// cout << endl;
// cout << "Systematic errors" << endl;
// cout << " Luminosity: " << systErrLumi * 100 << "%" << endl;
// cout << " Efficiency: " << systErrEff * 100 << "%" << endl;
// cout << " ttbar: " << systErrMC[TTBAR-1] * 100 << "%" << endl;
// cout << " Z->tautau: " << systErrMC[ZTT-1] * 100 << "%" << endl;
// cout << " WW: " << systErrMC[WW-1] * 100 << "%" << endl;
// cout << " WZ: " << systErrMC[WZ-1] * 100 << "%" << endl;
// cout << " ZZ: " << systErrMC[ZZ-1] * 100 << "%" << endl;
// cout << " tW, tbarW: " << systErrMC[TW-1] * 100 << "%" << endl;
// cout << " Z->mumu: " << systErrMC[ZMM-1] * 100 << "%" << endl;
// cout << " Z->ee: " << systErrMC[ZEE-1] * 100 << "%" << endl;
// if (qcdEst != 2) cout << " W+Jets: " << systErrMC[WJET-1] * 100 << "%" << endl;
// else cout << " QCD: " << systErrMC.back() * 100 << "%" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// if (signIt == 3) cout << "-SS--------------------------------------------------------------------------------------------------------" << endl;
// if (signIt == 5) cout << "-OS--------------------------------------------------------------------------------------------------------" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | > 60GeV/c^2 | > 120GeV/c^2 | > 200GeV/c^2 | > 400GeV/c^2 |" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------" << endl;
//
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMass_data.at(signIt)->GetBinContent(bin60), sqrt(emuMass_data.at(signIt)->GetBinContent(bin60)),
// emuMass_data.at(signIt)->GetBinContent(bin120), sqrt(emuMass_data.at(signIt)->GetBinContent(bin120)),
// emuMass_data.at(signIt)->GetBinContent(bin200), sqrt(emuMass_data.at(signIt)->GetBinContent(bin200)),
// emuMass_data.at(signIt)->GetBinContent(bin400), sqrt(emuMass_data.at(signIt)->GetBinContent(bin400)));
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int sampleIt = 1; sampleIt < sampleNames.size(); ++sampleIt) {
// if (sampleIt == 7) cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
// if (qcdEst == 1 && sampleIt == sampleNames.size() - 1) {
// printf("nb %7s | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n", sampleNames[sampleIt],
// emuMass_qcd.at(signIt)->GetBinContent(bin60), emuMass_qcd.at(signIt)->GetBinContent(bin60) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin60),
// emuMass_qcd.at(signIt)->GetBinContent(bin120), emuMass_qcd.at(signIt)->GetBinContent(bin120) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin120),
// emuMass_qcd.at(signIt)->GetBinContent(bin200), emuMass_qcd.at(signIt)->GetBinContent(bin200) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin200),
// emuMass_qcd.at(signIt)->GetBinContent(bin400), emuMass_qcd.at(signIt)->GetBinContent(bin400) * CalcSSQcdErr(emuMasses, systErrMCLuEff, bin400));
// } else {
// printf("nb %7s | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n", sampleNames[sampleIt],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin60), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin60) * systErrMCLuEff[sampleIt-1],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin120), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin120) * systErrMCLuEff[sampleIt-1],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin200), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin200) * systErrMCLuEff[sampleIt-1],
// emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin400), emuMasses.at(sampleIt).at(signIt)->GetBinContent(bin400) * systErrMCLuEff[sampleIt-1]);
// }
// }
// cout << endl;
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("TOT ttlike | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin60), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin60),
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin120), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin120),
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin200), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin200),
// CalcBgSum(emuMasses, ttLikeSamples, signIt, bin400), CalcSystErr(emuMasses, systErrMCLuEff, ttLikeSamples, signIt, bin400));
// printf("TOT contam | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, contamSamples, signIt, bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin60, -1, calcQcdErr),
// CalcBgSum(emuMasses, contamSamples, signIt, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin120, -1, calcQcdErr),
// CalcBgSum(emuMasses, contamSamples, signIt, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin200, -1, calcQcdErr),
// CalcBgSum(emuMasses, contamSamples, signIt, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, contamSamples, signIt, bin400, -1, calcQcdErr));
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
//
// printf("TOT Bkg | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamples, signIt, bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin60, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin120, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin200, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin400, -1, calcQcdErr));
// cout << "----------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << endl << endl;
// }
// cout << endl;
//
// cout << "--Without adding QCD contribution:--------------------------------------------------------------------------------------------------------" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | > 60GeV/c^2 | > 120GeV/c^2 | > 200GeV/c^2 | > 400GeV/c^2 |" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// if (signIt == 3) cout << "-SS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// if (signIt == 5) cout << "-OS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin60), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin60)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin120), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin120)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin200), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin200)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin400), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin400)));
// printf("nb MC | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin60), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin60),
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin120), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin120),
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin200), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin200),
// CalcBgSum(emuMasses, allSamplesNoQcd, signIt, bin400), CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, signIt, bin400));
// }
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//
// if (qcdEst == 1) {
// //systErrMC.back() = 2 * sqrt(emuMasses.at(DATA).at(SS)->Integral() + pow(CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, SS, 1), 2)) / emuMasses.at(qcdInd).at(ALL)->Integral();
// //systErrMC.back() = CalcSystErr(emuMasses, systErrMCLuEff, allSamplesNoQcd, SSCUM, 1) / emuMass_qcd.at(SSCUM)->GetBinContent(1);
// //systErrMCLuEff.back() = systErrMC[qcdErrInd];
//
// cout << endl;
// cout << "---QCD events from SS spectrum:----------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("nb QCD SS+OS | %9.3f +- %8.3f (%.1f%%) (syst) | %9.3f +- %8.3f (%.1f%%) (syst) | %9.3f +- %8.3f (%.1f%%) (syst) | %9.3f +- %8.3f (%.1f%%) (syst) |\n",
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin60, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin60, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin60),
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin120, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin120, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin120),
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin200, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin200, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin200),
// emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin400, -1, calcQcdErr),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin400, -1, calcQcdErr) / emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin400));
// printf("%% of total MC | %7.3f%% +- %7.3f%% (syst) | %7.3f%% +- %7.3f%% (syst) | %7.3f%% +- %7.3f%% (syst) | %7.3f%% +- %7.3f%% (syst) |\n",
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin60) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin60),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin60, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin60),
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin120) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin120),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin120, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin120),
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin200) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin200),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin200, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin200),
// 100 * emuMasses.at(qcdInd).at(ALLCUM)->GetBinContent(bin400) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin400),
// 100 * CalcSystErrWithQCD(emuMasses, systErrMCLuEff, onlyQCD, ALLCUM, bin400, -1, calcQcdErr) / CalcBgSum(emuMasses, allSamplesNoQcd, ALLCUM, bin400));
// cout << "-----------------------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// }
//
// // top up bg contribution with qcd
// if (qcdEst > 0) {
// cout << endl;
// cout << "--After adding QCD contribution:----------------------------------------------------------------------------------------------------------" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | > 60GeV/c^2 | > 120GeV/c^2 | > 200GeV/c^2 | > 400GeV/c^2 |" << endl;
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// if (signIt == 3) cout << "-SS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// if (signIt == 5) cout << "-OS-------------------------------------------------------------------------------------------------------------------------------------" << endl;
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin60), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin60)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin120), sqrt((emuMasses.at(DATA).at(signIt))->GetBinContent(bin120)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin200), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin200)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin400), sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin400)));
// printf("nb MC | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamples, signIt, bin60), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin60, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin120, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin200, -1, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin400, -1, calcQcdErr));
// }
// cout << "------------------------------------------------------------------------------------------------------------------------------------------" << endl;
// }
//
// cout << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// cout << "M_emu | 60 - 120GeV/c^2 | 120 - 200GeV/c^2 | 200 - 400GeV/c^2 |" << endl;
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// for (unsigned int signIt = 1; signIt < 6; signIt += 2) {
// printf("nb data | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) | %5.0f +- %-.3f (stat) |\n",
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin60) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin120),
// sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin60) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin120)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin120) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin200),
// sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin120) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin200)),
// emuMasses.at(DATA).at(signIt)->GetBinContent(bin200) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin400),
// sqrt(emuMasses.at(DATA).at(signIt)->GetBinContent(bin200) - emuMasses.at(DATA).at(signIt)->GetBinContent(bin400)));
// printf("nb MC | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) | %9.3f +- %8.3f (syst) |\n",
// CalcBgSum(emuMasses, allSamples, signIt, bin60, bin120), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin60, bin120, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin120, bin200), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin120, bin200, calcQcdErr),
// CalcBgSum(emuMasses, allSamples, signIt, bin200, bin400), CalcSystErrWithQCD(emuMasses, systErrMCLuEff, allSamples, signIt, bin200, bin400, calcQcdErr));
// cout << "-----------------------------------------------------------------------------------------------------------" << endl;
// }
}
