void showHistogram2d(TH2* histogram,
const std::string& xAxisTitle, const std::string& yAxisTitle,
int zAxisNormOption, double zMin, double zMax,
Float_t* genX, Float_t* genY,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", 900, 800);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetTopMargin(0.10);
canvas->SetLeftMargin(0.12);
canvas->SetRightMargin(0.14);
canvas->SetBottomMargin(0.12);
histogram->SetTitle("");
histogram->SetStats(false);
int numBinsX = histogram->GetNbinsX();
int numBinsY = histogram->GetNbinsY();
if ( zAxisNormOption == kNormByQuantiles ) {
std::vector<double> binContents;
for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) {
for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) {
binContents.push_back(histogram->GetBinContent(iBinX, iBinY));
}
}
std::sort(binContents.begin(), binContents.end());
histogram->SetMinimum(binContents[TMath::Nint(0.05*binContents.size())]);
histogram->SetMaximum(binContents[TMath::Nint(0.95*binContents.size())]);
} else if ( zAxisNormOption == kNormByNegLogMax ) {
double maxBinContent = 0.;
for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) {
for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) {
double binContent = histogram->GetBinContent(iBinX, iBinY);
if ( binContent > maxBinContent ) {
std::cout << "binX = " << iBinX << " (x = " << histogram->GetXaxis()->GetBinCenter(iBinX) << "),"
<< " binY = " << iBinY << " (y = " << histogram->GetYaxis()->GetBinCenter(iBinY) << "): maxBinContent = " << maxBinContent << std::endl;
maxBinContent = binContent;
}
}
}
double logMaxBinContent = TMath::Log(maxBinContent);
for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) {
for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) {
double binContent = histogram->GetBinContent(iBinX, iBinY);
if ( binContent > 0. ) {
histogram->SetBinContent(iBinX, iBinY, -TMath::Log(binContent) + logMaxBinContent);
} else {
histogram->SetBinContent(iBinX, iBinY, -1.);
}
}
}
histogram->SetMinimum(0.);
histogram->SetMaximum(zMax);
} else if ( zAxisNormOption == kNormByValue ) {
histogram->SetMinimum(zMin);
histogram->SetMaximum(zMax);
} else assert(0);
TAxis* xAxis = histogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(1.15);
TAxis* yAxis = histogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(1.30);
gStyle->SetPalette(1,0);
histogram->Draw("COLZ");
TMarker* genMarker = 0;
if ( genX && genY ) {
genMarker = new TMarker(*genX, *genY, 34);
genMarker->SetMarkerColor(1);
genMarker->SetMarkerSize(2);
genMarker->Draw();
}
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas->Print(std::string(outputFileName_plot).append(".root").data());
delete genMarker;
delete canvas;
}
void Plot::FitSignal(int mode, int fitMode) {
const int nPar = 6;
TRandom ran;
if(mode==0) {
gStyle->SetOptLogy(1);
} else {
gStyle->SetOptLogy(0);
}
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
const float limitBinSize = 2.0; // **** bin size here
TCanvas* c = NewCanvas();
c->Divide(1,2);
gROOT->cd();
TH1F* cc = new TH1F("CCSignal","CC Signal",500,0.0,1000.0);
TH1F* ccBg = new TH1F("CCBgFit","CC Bg Fit",500,0.0,1000.0);
TH1F* ccBgErr = new TH1F("CCBgErr","CC Bg Err",500,0.0,1000.0);
TH1F* ccBgP = new TH1F("CCBgPlus","CC Bg Plus",500,0.0,1000.0);
TH1F* ccBgM = new TH1F("CCBgMinus","CC Bg Minus",500,0.0,1000.0);
TH1F* cp = new TH1F("CPSignal","CP Signal",500,0.0,1000.0);
TH1F* cpBg = new TH1F("CPBgFit","CP Bg Fit",500,0.0,1000.0);
TH1F* cpBgErr = new TH1F("CPBgErr","CP Bg Err",500,0.0,1000.0);
TH1F* cpBgP = new TH1F("CPBgPlus","CP Bg Plus",500,0.0,1000.0);
TH1F* cpBgM = new TH1F("CPBgMinus","CP Bg Minus",500,0.0,1000.0);
TMatrixD matrix(nPar,nPar);
fd->cd();
TH1F* hInt,*hBgInt;
char fitname[100];
for(int ind=0; ind<2; ind++) {
if(debug) printf("starting ind %i\n",ind);
c->cd(ind+1);
gStyle->SetOptLogy(1);
printf("Starting %i ######################################\n",ind);
TH1F* h;
//char cind[20];
//char handle[100];
//sprintf(handle,"side_1exp_%02i_%02i_%02i",ind,mode,fitMode);
TF1* fits[4];
//TF1* dpx[4];
if(debug) printf("looking for h %i\n",int(fd));
if(ind==0) {
h = (TH1F*)fd->FindObjectAny("pair_mass_2GeV1");
} else if(ind==1) {
h = (TH1F*)fd->FindObjectAny("pair_mass_2GeV3");
}
if(debug) printf("new h %i\n",int(h));
if(debug) printf("new fit\n");
sprintf(fitname,"hfit_%1i",ind);
fits[ind] = new TF1(fitname,"([0]*pow((x-30.0),[1])+[3]*pow((x-30.0),0.2))*([2]*exp(-[2]*(x-30.0))+[4]*[5]*exp(-[5]*(x-30.0)))",30.0,500.0);
//fits[ind] = new TF1(fitname,"([0]*((1-[3])*pow((x-30.0),[1])+[3]*pow((x-30.0),0.2)))*(exp(-[2]*(x-30.0))+[4]*exp(-[5]*(x-30.0)))",30.0,500.0);
fits[ind]->SetParameter(0,0.0004);
fits[ind]->SetParameter(1,2);
fits[ind]->SetParameter(2,0.02);
fits[ind]->SetParameter(3,0.005);
//fits[ind]->SetParameter(3,0.5);
fits[ind]->SetParameter(4,1.005);
fits[ind]->SetParameter(5,0.05);
float llim = 30.0;
h->Fit(fits[ind],"LN","",llim,1000.0);
double par[20],parMin[20],fval,fvalMin;
for(int i=0; i<nPar; i++) parMin[i] = fits[ind]->GetParameter(i);
gMinuit->Eval(nPar,0,fvalMin,parMin,0);
//printf("got back %10.5f\n",fvalMin);
// save the fit results in a histogram, for limit program
for(int ibin=16; ibin<250; ibin++) {
float xx = h->GetBinCenter(ibin);
float yy = fits[ind]->Eval(xx);
if(ind==0) {
cc->SetBinContent(ibin,h->GetBinContent(ibin));
ccBg->SetBinContent(ibin,yy);
ccBgErr->SetBinContent(ibin,0.0);
ccBgP->SetBinContent(ibin,0.0);
ccBgM->SetBinContent(ibin,99999.0);
} else {
cp->SetBinContent(ibin,h->GetBinContent(ibin));
cpBg->SetBinContent(ibin,yy);
cpBgErr->SetBinContent(ibin,0.0);
cpBgP->SetBinContent(ibin,0.0);
cpBgM->SetBinContent(ibin,99999.0);
}
}
//vary the parameters to find an error envelope
double par2[20],fval2=1e10;
int pslim = (ind==0?25000:150000);
for(int ips=0; ips<pslim; ips++) {
if(ips%10000==0) printf("Processing %d\n",ips);
for(int i=0; i<nPar; i++) {
par[i] = parMin[i];
}
for(int i=0; i<nPar; i++) {
//int i = (ips%2==0?0:3);
par[i] = parMin[i]+(2.0*(ran.Uniform()-0.5))*fits[ind]->GetParError(i);
}
fval = 0.0;
gMinuit->Eval(nPar,0,fval,par,0);
if((fval-fvalMin)<1.0) {
printf("Found nearby min %10.5f\n",fval-fvalMin);
float eOld,eNew;
for(int ibin=16; ibin<250; ibin++) {
float xx = h->GetBinCenter(ibin);
for(int i=0; i<nPar; i++) fits[ind]->SetParameter(i,par[i]);
float yy = fits[ind]->Eval(xx);
for(int i=0; i<nPar; i++) fits[ind]->SetParameter(i,parMin[i]);
float yyMin = fits[ind]->Eval(xx);
TH1F *hBgErr,*hBgP,*hBgM;
if(ind==0) {
hBgErr = ccBgErr; hBgP = ccBgP; hBgM = ccBgM;
} else {
hBgErr = cpBgErr; hBgP = cpBgP; hBgM = cpBgM;
}
eOld = hBgErr->GetBinContent(ibin);
eNew = yy - yyMin;
if(eOld>fabs(eNew)) hBgErr->SetBinContent(ibin,fabs(eNew));
eOld = hBgP->GetBinContent(ibin);
if(yy>eOld) hBgP->SetBinContent(ibin,yy);
eOld = hBgM->GetBinContent(ibin);
if(yy<eOld) hBgM->SetBinContent(ibin,yy);
}
} // end if near maximum
/*
if(fval<fval2) {
for(int i=0; i<nPar; i++) par2[i] = par[i];
fval2 = fval;
}
*/
}
/*
printf("forcing new fit..\n");
for(int i=0; i<nPar; i++) {
printf("old,new = %10.5f %10.5f\n",parMin[i],par2[i]);
fits[ind]->SetParameter(i,par2[i]);
}
*/
// restore original fit
fval = 0.0;
gMinuit->Eval(nPar,0,fval,parMin,0);
for(int i=0; i<nPar; i++) fits[ind]->SetParameter(i,parMin[i]);
//extract fit error matrix
gMinuit->mnemat(matrix.GetMatrixArray(),nPar);
matrix.Print();
for(int i=0; i<nPar; i++) {
for(int j=0; j<nPar; j++) {
printf("%10.5f",matrix(i,j)/sqrt(matrix(i,i)*matrix(j,j)));
}
printf("\n");
}
//matrix.Draw("text");
float hm = h->GetMaximum();
if(mode==0) {
//TAxis* ax = h->GetXaxis();
//ax->SetRangeUser(24.1,199.9);
h->SetMaximum(1.2*hm);
//h->SetMinimum(0.0);
} else if(mode==1) {
TAxis* ax = h->GetXaxis();
ax->SetRangeUser(20.0,500.0);
h->SetMaximum(1.15*hm);
h->SetMinimum(0.0);
}
h->Draw();
fits[ind]->SetLineColor(1);
fits[ind]->SetLineWidth(2.0);
fits[ind]->Draw("SAME");
// find chi2's and KS's
//AnaChiKs(h,fits[ind]);
TAxis* ax,*ay;
ax = h->GetXaxis();
ay = h->GetYaxis();
ax->SetTitle("m(#gamma#gamma) (GeV/c^{2})");
ay->SetTitle("Entries/2 GeV/c^{2}");
ax->CenterTitle(); ay->CenterTitle();
ax->SetTitleOffset(0.9);
ay->SetTitleOffset(1.0);
ax->SetTitleSize(0.08);
ay->SetTitleSize(0.07);
ax->SetLabelSize(0.07);
ay->SetLabelSize(0.07);
gPad->SetLeftMargin(0.16);
gPad->SetBottomMargin(0.16);
TText* text;
text = new TLatex(0.5,0.8,"Diphoton Data");
text->SetNDC(true);
text->SetTextSize(0.06);
text->Draw();
if(ind==0) text = new TLatex(0.5,0.72,"Central-Central");
else if(ind==1) text = new TLatex(0.5,0.72,"Central-Plug");
text->SetNDC(true);
text->SetTextSize(0.06);
text->Draw();
if(ind==0) {
text = new TLatex(0.15,0.92,"W/Z H#rightarrow X(#gamma#gamma)");
text->SetNDC(true);
text->SetTextSize(0.08);
text->Draw();
text = new TLatex(0.5,0.92,"CDF Run II Preliminary, 2.0 fb^{-1}");
text->SetNDC(true);
text->SetTextSize(0.06);
text->Draw();
}
/*
if(debug) printf("start loop\n");
int ibin;
for(ibin=16; ibin<=250; ibin++) {
if(debug) printf("start bin %i\n",ibin);
float xx = (ibin-0.5)*2.0; // *** bin width here
if(debug) printf("-1 test ibin %i\n",ibin);
float yy = fits[ind]->Eval(xx);
//printf("%f yy= %f \n",xx,yy);
// the derivative of this yield wrt parameters
if(debug) printf("0 test ibin %i\n",ibin);
double y0 = yy;
if(debug) printf("1 test ibin %i\n",ibin);
TMatrixD vv(nPar,1);
float dirSize = 0.5;
for(int i=0; i<nPar; i++){
int ipar = i;
double par = fits[ind]->GetParameter(ipar);
double spar = fits[ind]->GetParError(ipar);
double parp = par + dirSize*spar;
fits[ind]->SetParameter(ipar,parp);
double yp = fits[ind]->Eval(xx);
vv(i,0) = limitBinSize*(yp-y0)/(dirSize*spar);
fits[ind]->SetParameter(ipar,par);
//printf("%f %f %f\n",yp,y0,spar);
}
//vv.Print();
if(debug) printf("start matrix %i\n",ibin);
TMatrixD tempM(matrix, TMatrixDBase::kMult, vv);
//matrix.Print();
TMatrixD tempN(vv, TMatrixDBase::kTransposeMult, tempM);
//tempN.Print();
float bgSig = 0.0;
if(tempN(0,0)>0.0) bgSig = sqrt(tempN(0,0));
// ****** hack temp **********
bgSig = 0.3*y0;
// file hists to be saved
if(debug) printf("start fill %i\n",ibin);
if(ind==0) {
//printf("filling cc %i %f\n",ibin,h->GetBinContent(ibin));
cc->SetBinContent(ibin,h->GetBinContent(ibin));
//printf("getting cc %i %f\n",ibin,cc->GetBinContent(ibin));
ccBg->SetBinContent(ibin,yy);
ccBgErr->SetBinContent(ibin,bgSig);
ccBgP->SetBinContent(ibin,yy+bgSig);
ccBgM->SetBinContent(ibin,TMath::Max(yy-bgSig,float(0.0)));
//if(ibin==27) {
//printf("bg %f %f \n",yy,bgSig);
//}
} else {
cp->SetBinContent(ibin,h->GetBinContent(ibin));
cpBg->SetBinContent(ibin,yy);
cpBgErr->SetBinContent(ibin,bgSig);
cpBgP->SetBinContent(ibin,yy+bgSig);
cpBgM->SetBinContent(ibin,TMath::Max(yy-bgSig,float(0.0)));
}
if(debug) printf("end fill %i\n",ibin);
}
*/
}
printf("cc plus BG=%f\n",ccBgP->GetSum());
printf("cc minus BG=%f\n",ccBgM->GetSum());
printf("cp plus BG=%f\n",cpBgP->GetSum());
printf("cp minus BG=%f\n",cpBgM->GetSum());
char fn[100];
if(mode==0) {
sprintf(fn,"FitSignal_%d",fitMode);
savePlot(c,fn);
} else if(mode==1) {
sprintf(fn,"FitSignalLin_%d",fitMode);
savePlot(c,fn);
}
//if(mode!=0) return;
// plot of fit results
gStyle->SetOptLogy(0);
c = NewCanvas();
c->Divide(1,2);
c->cd(1);
cc->Draw();
ccBg->Draw("SAME");
c->cd(2);
ccBgErr->SetMinimum(0.0); ccBgErr->SetMaximum(4.0);
ccBgErr->Draw();
ccBgP->SetLineStyle(2); ccBgP->Draw("SAME");
ccBgM->SetLineStyle(2); ccBgM->Draw("SAME");
savePlot(c,"FitSignalResultsCC");
c = NewCanvas();
c->Divide(1,2);
c->cd(1);
cp->Draw();
cpBg->Draw("SAME");
c->cd(2);
cpBgErr->SetMinimum(0.0); cpBgErr->SetMaximum(4.0);
cpBgErr->Draw();
cpBgP->SetLineStyle(2); cpBgP->Draw("SAME");
cpBgM->SetLineStyle(2); cpBgM->Draw("SAME");
savePlot(c,"FitSignalResultsCP");
char title[100];
if(name) {
sprintf(title,"TPeaksHiggs_FitSignalHist_%s.root",name);
TFile* ff = new TFile(title,"RECREATE");
gROOT->GetList()->Write();
ff->Close();
}
}
void showFunctions1d(std::vector<TF1*>& functions, const std::vector<std::string>& legendEntries,
const TString& xAxisTitle, double yMin, double yMax, const TString& yAxisTitle,
const std::string& outputFileName)
{
assert(functions.size() == legendEntries.size());
TCanvas* canvas = new TCanvas("canvas", "canvas", 800, 600);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.12);
canvas->SetBottomMargin(0.12);
assert(functions.size() > 0);
TF1* refFunction = functions[0];
TH1* dummyHistogram = new TH1F("dummyHistogram", "dummyHistogram", 10, refFunction->GetXmin(), refFunction->GetXmax());
dummyHistogram->SetStats(false);
dummyHistogram->SetTitle("");
dummyHistogram->SetMinimum(-TMath::Log(yMax));
dummyHistogram->SetMaximum(-TMath::Log(yMax) + 5.);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.Data());
xAxis->SetTitleOffset(1.15);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle(Form("-log(%s)", yAxisTitle.Data()));
yAxis->SetTitleOffset(1.30);
dummyHistogram->Draw("axis");
int colors[] = { 1, 2, 3, 4, 5, 6, 7, 15 };
int numFunctions = functions.size();
if ( numFunctions > 8 ) {
std::cerr << "<showFunctions1d>:" << std::endl;
std::cerr << "Number of functions must not exceed 8 !!" << std::endl;
assert(0);
}
for ( int iFunction = 0; iFunction < numFunctions; ++iFunction ) {
TF1* function = functions[iFunction];
function->SetLineColor(colors[iFunction]);
function->SetLineWidth(2);
function->Draw("same");
}
TLegend* legend = new TLegend(0.68, 0.89 - (0.03 + 0.040*numFunctions), 0.89, 0.89, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
legend->SetTextSize(0.035);
for ( int iFunction = 0; iFunction < numFunctions; ++iFunction ) {
TF1* function = functions[iFunction];
const std::string& legendEntry = legendEntries[iFunction];
legend->AddEntry(function, legendEntry.data(), "l");
}
legend->Draw();
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete dummyHistogram;
delete legend;
delete canvas;
}
/*
* Main Function
*/
void ratio() {
gStyle->SetFrameLineWidth(1);
//Number of Measurements
const int NUM = 2;
//Measurements and uncertainties
// mean, -stat, +stat, -syst, +syst
double m[NUM][5] = {
0.98, 0.10, 0.10, 0.14, 0.14,
//1.33, 0.32, 0.32, 0.22, 0.22
1.26, 0.37, 0.37, 0.46, 0.46
};
//Theory and uncertainties
// mean, -uncert, +uncert
double t[NUM][3] = {
1.0, 0.114, 0.114,
1.0, 0.111, 0.111
};
// label text, sub-label text
// Note: TString does not work, b/c one cannot pass an array of TStrings
// as an argument to a function
char label[NUM][2][100] = {
"Z#gamma#gamma", "",
//"W#gamma#gamma", ""
"W#gamma#gamma (#mu)", ""
};
// format:
// # color, bgColor, fontSytle, linewidth, markerStyle
int aux[NUM][5] = {
1, 10, 42, 2, 20,
1, 10, 42, 2, 20
};
// determning the x size of the plot
double lowX = LOW_X;
double uppX = UPP_X;
TH2F* lft = new TH2F("lft", "", 50, lowX, uppX, 1, 0.0, 1.0);
// height = NUM*unitHeight + 2*spacers + 1*bottomMargin + 0.5*topMargin
const double unitHeight = 50.0; // even number
const double height = (double(NUM)+2.0)*unitHeight+100.0+30.0;
// how much to step each time to cover the vertical range of the histo in
// exactly NUM+2 steps
const double vstep = unitHeight/(height-100.0-30.0);
const double width = 800.0;
printf("Canvas: width=%d, height=%d\n",
TMath::Nint(width), TMath::Nint(height));
printf("Y-step = %6.4f\n", vstep);
// Set canvas and margins
TCanvas* canvas = new TCanvas("canvas", "canvas", 200, 0,
TMath::Nint(width), TMath::Nint(height));
canvas->SetFillColor(10);
canvas->SetRightMargin(20.0/width);
canvas->SetLeftMargin(20.0/width);
canvas->SetBottomMargin(56.0/height);
canvas->SetTopMargin(30.0/height);
canvas->Draw();
canvas->cd();
//printf("TopMargin : %6.4f\n", canvas->GetTopMargin());
//printf("BottomMargin: %6.4f\n", canvas->GetBottomMargin());
TAxis* xaxis = lft->GetXaxis();
TAxis* yaxis = lft->GetYaxis();
xaxis->CenterTitle(kTRUE);
xaxis->SetTitleSize(0.07);
xaxis->SetTitleFont(62);
xaxis->SetTitleOffset(1.1);
xaxis->SetNdivisions(6,5,0);
xaxis->SetLabelOffset(0.01);
xaxis->SetLabelSize(0.05);
xaxis->SetLabelFont(42);
yaxis->SetLabelSize(0.0);
yaxis->SetNdivisions(-1);
lft->SetXTitle("Cross Section Ratio #sigma_{Exp} / #sigma_{Theory}");
lft->SetYTitle("");
lft->SetStats(kFALSE);
lft->SetTitle("");
lft->Draw();
// Draw Theory Bands
for (int i=0; i!=NUM; ++i) {
drawTheory(i, t[i][0], t[i][1], t[i][2], vstep);
}
canvas->RedrawAxis();
gPad->RedrawAxis();
// Draw Measurements
for (int i=0; i!=NUM; ++i) {
drawMeasurement(i, m[i], label[i], aux[i], vstep, lft, canvas);
}
//Set CMS Preliminary marker
int iPeriod=2; // 8 TeV
int iPos = 0; //
CMS_lumi( canvas, iPeriod, iPos );
// Print
//canvas->Print("Ratio_CrossSec_Exp_Theory.pdf");
canvas->Draw();
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// drawFigure7
//
// parameter = "dg0"
// parameter = "lam0"
// parameter = "dk0"
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void drawFigure7(TString parameter = "dk0")
{
gInterpreter->ExecuteMacro("WZPaperStyle.C");
gSystem->mkdir("pdf", kTRUE);
gSystem->mkdir("png", kTRUE);
// Individual settings
//----------------------------------------------------------------------------
if (parameter.Contains("dg0"))
{
xtitle = "#Delta#kappa^{Z}";
ytitle = "#lambda";
xmin = -0.5;
xmax = 0.5;
ymin = -0.039;
ymax = 0.053;
}
else if (parameter.Contains("lam0"))
{
xtitle = "#Delta#kappa^{Z}";
ytitle = "#Deltag^{Z}_{1}";
xmin = -0.53;
xmax = 0.53;
ymin = -0.05;
ymax = 0.09;
}
else if (parameter.Contains("dk0"))
{
xtitle = "#Deltag^{Z}_{1}";
ytitle = "#lambda";
xmin = -0.059;
xmax = 0.059;
ymin = -0.037;
ymax = 0.052;
}
// Read the input file
//----------------------------------------------------------------------------
TFile* file = new TFile("rootfiles/contours_" + parameter + "_2Dpol2.root", "read");
TGraph* cont_exp_68 = (TGraph*)file->Get("cont_exp_68");
TGraph* cont_exp_95 = (TGraph*)file->Get("cont_exp_95");
TGraph* cont_exp_99 = (TGraph*)file->Get("cont_exp_99");
TGraph* cont_obs_95 = (TGraph*)file->Get("cont_obs_95");
TGraph* bestFit = (TGraph*)file->Get("bestFit");
bestFit->SetMarkerSize(1.5);
bestFit->SetMarkerStyle(34);
TGraph* g_large = new TGraph(2);
g_large->SetPoint(0, -1.0, 1.0);
g_large->SetPoint(1, 1.0, 1.0);
// Draw
//----------------------------------------------------------------------------
TCanvas* canvas = new TCanvas("canvas", "canvas");
TMultiGraph* mg = new TMultiGraph();
mg->Add(cont_exp_68);
mg->Add(cont_exp_95);
mg->Add(cont_exp_99);
mg->Add(cont_obs_95);
mg->Add(bestFit, "p");
mg->Add(g_large);
mg->Draw("ac");
mg->SetMinimum(ymin);
mg->SetMaximum(ymax);
// Axis labels
//----------------------------------------------------------------------------
TAxis* xaxis = mg->GetXaxis();
TAxis* yaxis = mg->GetYaxis();
xaxis->SetLabelFont ( 42);
xaxis->SetLabelOffset( 0.01);
xaxis->SetLabelSize ( 0.05);
xaxis->SetNdivisions ( 505);
xaxis->SetTitle (xtitle);
xaxis->SetTitleFont ( 42);
xaxis->SetTitleOffset( 1.2);
xaxis->SetTitleSize ( 0.05);
xaxis->SetLimits(xmin, xmax);
yaxis->SetLabelFont ( 42);
yaxis->SetLabelOffset( 0.01);
yaxis->SetLabelSize ( 0.05);
yaxis->SetNdivisions ( 505);
yaxis->SetTitle (ytitle);
yaxis->SetTitleFont ( 42);
yaxis->SetTitleOffset( 1.6);
yaxis->SetTitleSize ( 0.05);
canvas->Modified();
// Legend
//----------------------------------------------------------------------------
Double_t x0 = 0.580;
Double_t y0 = 0.755;
DrawTLegend(x0 - 0.36, y0 + 2.*(_yoffset+0.001), (TH1F*)cont_exp_68, " Expected 68% CL", "l");
DrawTLegend(x0 - 0.36, y0 + 1.*(_yoffset+0.001), (TH1F*)cont_exp_95, " Expected 95% CL", "l");
DrawTLegend(x0, y0 + 2.*(_yoffset+0.001), (TH1F*)cont_exp_99, " Expected 99% CL", "l");
DrawTLegend(x0, y0 + 1.*(_yoffset+0.001), (TH1F*)cont_obs_95, " Observed 95% CL", "l");
DrawTLegend(x0, y0, (TH1F*)bestFit, " Best fit", "p");
// Finish it
//----------------------------------------------------------------------------
DrawTLatex(_cmsTextFont, 0.190, 0.94, 0.055, 11, "CMS");
// DrawTLatex(_extraTextFont, 0.315, 0.94, 0.030, 11, "Preliminary");
DrawTLatex(_lumiTextFont, 0.940, 0.94, 0.040, 31, "19.6 fb^{-1} (8 TeV)");
canvas->SaveAs("pdf/lZ_dkg_2dlimit_" + parameter + "_2Dpol2_deltaNLL.pdf");
canvas->SaveAs("png/lZ_dkg_2dlimit_" + parameter + "_2Dpol2_deltaNLL.png");
}
void showGraphs(double canvasSizeX, double canvasSizeY,
TGraph* graph1, const std::string& legendEntry1,
TGraph* graph2, const std::string& legendEntry2,
TGraph* graph3, const std::string& legendEntry3,
TGraph* graph4, const std::string& legendEntry4,
TGraph* graph5, const std::string& legendEntry5,
TGraph* graph6, const std::string& legendEntry6,
int colors[], int markerStyles[],
double legendTextSize, double legendPosX, double legendPosY, double legendSizeX, double legendSizeY,
std::vector<std::string>& labelTextLines, double labelTextSize,
double labelPosX, double labelPosY, double labelSizeX, double labelSizeY,
double xMin, double xMax, const std::string& xAxisTitle, double xAxisOffset,
double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.14);
canvas->SetBottomMargin(0.12);
TH1* dummyHistogram = new TH1D("dummyHistogram", "dummyHistogram", 100, xMin, xMax);
dummyHistogram->SetTitle("");
dummyHistogram->SetStats(false);
dummyHistogram->SetMinimum(yMin);
dummyHistogram->SetMaximum(yMax);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleSize(0.045);
xAxis->SetTitleOffset(xAxisOffset);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleSize(0.045);
yAxis->SetTitleOffset(yAxisOffset);
dummyHistogram->Draw("axis");
graph1->SetLineColor(colors[0]);
graph1->SetLineWidth(2);
graph1->SetMarkerColor(colors[0]);
graph1->SetMarkerStyle(markerStyles[0]);
graph1->SetMarkerSize(2);
graph1->Draw("p");
if ( graph2 ) {
graph2->SetLineColor(colors[1]);
graph2->SetLineWidth(2);
graph2->SetMarkerColor(colors[1]);
graph2->SetMarkerStyle(markerStyles[1]);
graph2->SetMarkerSize(2);
graph2->Draw("p");
}
if ( graph3 ) {
graph3->SetLineColor(colors[2]);
graph3->SetLineWidth(2);
graph3->SetMarkerColor(colors[2]);
graph3->SetMarkerStyle(markerStyles[2]);
graph3->SetMarkerSize(2);
graph3->Draw("p");
}
if ( graph4 ) {
graph4->SetLineColor(colors[3]);
graph4->SetLineWidth(2);
graph4->SetMarkerColor(colors[3]);
graph4->SetMarkerStyle(markerStyles[3]);
graph4->SetMarkerSize(2);
graph4->Draw("p");
}
if ( graph5 ) {
graph5->SetLineColor(colors[4]);
graph5->SetLineWidth(2);
graph5->SetMarkerColor(colors[4]);
graph5->SetMarkerStyle(markerStyles[4]);
graph5->SetMarkerSize(2);
graph5->Draw("p");
}
if ( graph6 ) {
graph6->SetLineColor(colors[5]);
graph6->SetLineWidth(2);
graph6->SetMarkerColor(colors[5]);
graph6->SetMarkerStyle(markerStyles[5]);
graph6->SetMarkerSize(2);
graph6->Draw("p");
}
TLegend* legend = new TLegend(legendPosX, legendPosY, legendPosX + legendSizeX, legendPosY + legendSizeY, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
legend->SetTextSize(legendTextSize);
legend->AddEntry(graph1, legendEntry1.data(), "p");
if ( graph2 ) legend->AddEntry(graph2, legendEntry2.data(), "p");
if ( graph3 ) legend->AddEntry(graph3, legendEntry3.data(), "p");
if ( graph4 ) legend->AddEntry(graph4, legendEntry4.data(), "p");
if ( graph5 ) legend->AddEntry(graph5, legendEntry5.data(), "p");
if ( graph6 ) legend->AddEntry(graph6, legendEntry6.data(), "p");
legend->Draw();
TPaveText* label = 0;
if ( labelTextLines.size() > 0 ) {
label = new TPaveText(labelPosX, labelPosY, labelPosX + labelSizeX, labelPosY + labelSizeY, "brNDC");
for ( std::vector<std::string>::const_iterator labelTextLine = labelTextLines.begin();
labelTextLine != labelTextLines.end(); ++labelTextLine ) {
label->AddText(labelTextLine->data());
}
label->SetFillColor(10);
label->SetBorderSize(0);
label->SetTextColor(1);
label->SetTextAlign(12);
label->SetTextSize(labelTextSize);
label->Draw();
}
canvas->Update();
std::string outputFileName_plot = "plots/";
size_t idx = outputFileName.find_last_of('.');
outputFileName_plot.append(std::string(outputFileName, 0, idx));
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete dummyHistogram;
delete label;
delete legend;
delete canvas;
}
//-------------------------------------------------------------------------------
void showDistribution(const TString& title, double canvasSizeX, double canvasSizeY,
TH1* histogram1, const std::string& legendEntry1,
TH1* histogram2, const std::string& legendEntry2,
TH1* histogram3, const std::string& legendEntry3,
TH1* histogram4, const std::string& legendEntry4,
const std::string& xAxisTitle, double xAxisOffset,
bool useLogScale, double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
double legendX0, double legendY0,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.12);
canvas->SetBottomMargin(0.12);
canvas->SetLogy(useLogScale);
int colors[6] = { 1, 2, 3, 4, 6, 7 };
int markerStyles[6] = { 22, 32, 20, 24, 21, 25 };
int numHistograms = 1;
if ( histogram2 ) ++numHistograms;
if ( histogram3 ) ++numHistograms;
if ( histogram4 ) ++numHistograms;
TLegend* legend = new TLegend(legendX0, legendY0, legendX0 + 0.44, legendY0 + 0.05*numHistograms, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
histogram1->SetTitle("");
histogram1->SetStats(false);
histogram1->SetMinimum(yMin);
histogram1->SetMaximum(yMax);
histogram1->SetLineColor(colors[0]);
histogram1->SetLineWidth(2);
histogram1->SetMarkerColor(colors[0]);
histogram1->SetMarkerStyle(markerStyles[0]);
histogram1->Draw("e1p");
legend->AddEntry(histogram1, legendEntry1.data(), "p");
TAxis* xAxis = histogram1->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(xAxisOffset);
TAxis* yAxis = histogram1->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(yAxisOffset);
if ( histogram2 ) {
histogram2->SetLineColor(colors[1]);
histogram2->SetLineWidth(2);
histogram2->SetMarkerColor(colors[1]);
histogram2->SetMarkerStyle(markerStyles[1]);
histogram2->Draw("e1psame");
legend->AddEntry(histogram2, legendEntry2.data(), "p");
}
if ( histogram3 ) {
histogram3->SetLineColor(colors[2]);
histogram3->SetLineWidth(2);
histogram3->SetMarkerColor(colors[2]);
histogram3->SetMarkerStyle(markerStyles[2]);
histogram3->Draw("e1psame");
legend->AddEntry(histogram3, legendEntry3.data(), "p");
}
if ( histogram4 ) {
histogram4->SetLineColor(colors[3]);
histogram4->SetLineWidth(2);
histogram4->SetMarkerColor(colors[3]);
histogram4->SetMarkerStyle(markerStyles[3]);
histogram4->Draw("e1psame");
legend->AddEntry(histogram4, legendEntry4.data(), "p");
}
legend->Draw();
TPaveText* label = 0;
if ( title.Length() > 0 ) {
label = new TPaveText(0.175, 0.925, 0.48, 0.98, "NDC");
label->AddText(title.Data());
label->SetTextAlign(13);
label->SetTextSize(0.045);
label->SetFillStyle(0);
label->SetBorderSize(0);
label->Draw();
}
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete legend;
delete label;
delete canvas;
}
void makeNeuralMtautauPerformancePlots()
{
std::string inputFileName = "../test/testNeuralMtautau.root";
TFile* inputFile = TFile::Open(inputFileName.data());
std::string histogramName = "histogramRecVsGenMass";
TH2* histogram2d = dynamic_cast<TH2*>(getHistogram(inputFile, "", histogramName.data()));
const int numGenMassBins = 17;
double genMassBins[] = { 0., 50., 60., 70., 80., 90., 100., 110., 120., 130., 140., 160., 200., 250., 300., 350., 400., 500. };
int genMassBin_index = 0;
TH1* histogram1dTruncatedSum = 0;
TGraphErrors* graph_mean = new TGraphErrors(numGenMassBins);
TGraphErrors* graph_rms = new TGraphErrors(numGenMassBins);
int numBins2dX = histogram2d->GetNbinsX();
for ( int iBin2dX = 1; iBin2dX <= numBins2dX; ++iBin2dX ) {
std::string histogram1dName = std::string(histogram2d->GetName()).append(Form("BinX%i", iBin2dX));
TH1* histogram1d = histogram2d->ProjectionX(histogram1dName.data(), iBin2dX, iBin2dX);
std::string histogram1dTruncatedName = std::string(histogram2d->GetName()).append(Form("BinX%i_truncated", iBin2dX));
TH1* histogram1dTruncated = new TH1D(histogram1dTruncatedName.data(), histogram1dTruncatedName.data(), 200, 0., 2.);
double mTauTau_gen = histogram2d->GetXaxis()->GetBinCenter(iBin2dX);
//if ( mTauTau_gen > 100. ) continue;
//std::cout << "iBin2dX = " << iBin2dX << ": mTauTau(gen) = " << mTauTau_gen << std::endl;
//std::cout << "histogram1d: mean = " << histogram1d->GetMean() << ","
// << " rms = " << histogram1d->GetRMS() << std::endl;
int numBins1d = histogram1d->GetNbinsX();
for ( int iBin1d = 1; iBin1d <= numBins1d; ++iBin1d ) {
double mTauTau_rec = histogram1d->GetBinCenter(iBin1d);
//std::cout << "iBin1d = " << iBin1d << ": mTauTau(rec) = " << mTauTau_rec << std::endl;
double ratio = mTauTau_rec/mTauTau_gen;
//std::cout << "ratio = " << ratio << std::endl;
double binContent = histogram1d->GetBinContent(iBin1d);
if ( binContent > 1.e-2 ) histogram1dTruncated->Fill(ratio, binContent);
}
//std::cout << "histogram1dTruncated: mean = " << histogram1dTruncated->GetMean() << ","
// << " rms = " << histogram1dTruncated->GetRMS() << std::endl;
delete histogram1d;
if ( mTauTau_gen > genMassBins[genMassBin_index + 1] && mTauTau_gen < genMassBins[numGenMassBins - 1] ) {
double x = 0.5*(genMassBins[genMassBin_index] + genMassBins[genMassBin_index + 1]);
double xErr = 0.5*(genMassBins[genMassBin_index + 1] - genMassBins[genMassBin_index]);
double y_mean = histogram1dTruncatedSum->GetMean();
double yErr_mean = histogram1dTruncatedSum->GetMeanError();
double y_rms = histogram1dTruncatedSum->GetRMS();
double yErr_rms = histogram1dTruncatedSum->GetRMSError();
//std::cout << "mTauTau(gen) = " << x << ": mean = " << y_mean << " +/- " << yErr_mean << ","
// << " rms = " << y_rms << " +/- " << yErr_rms << std::endl;
graph_mean->SetPoint(genMassBin_index, x, y_mean);
graph_mean->SetPointError(genMassBin_index, xErr, yErr_mean);
graph_rms->SetPoint(genMassBin_index, x, y_rms);
graph_rms->SetPointError(genMassBin_index, xErr, yErr_rms);
delete histogram1dTruncatedSum;
histogram1dTruncatedSum = 0;
++genMassBin_index;
}
if ( !histogram1dTruncatedSum ) {
histogram1dTruncatedSum = histogram1dTruncated;
} else {
histogram1dTruncatedSum->Add(histogram1dTruncated);
delete histogram1dTruncated;
}
}
delete histogram1dTruncatedSum;
TCanvas* canvas = new TCanvas("canvas", "canvas", 800, 600);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.12);
canvas->SetBottomMargin(0.12);
canvas->SetLogy();
TH1* dummyHistogram = new TH1F("dummyHistogram", "dummyHistogram", 50, 0., 500.);
dummyHistogram->SetStats(false);
dummyHistogram->SetTitle("");
dummyHistogram->SetMinimum(1.e-2);
dummyHistogram->SetMaximum(1.e+1);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle("M_{#tau#tau}^{gen} / GeV");
xAxis->SetTitleOffset(1.15);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle("M_{#tau#tau}^{rec} / GeV");
yAxis->SetTitleOffset(1.30);
dummyHistogram->Draw("axis");
graph_mean->SetMarkerStyle(20);
graph_mean->SetMarkerColor(1);
graph_mean->Draw("P");
graph_rms->SetMarkerStyle(20);
graph_rms->SetMarkerColor(2);
graph_rms->Draw("P");
TLegend* legend = new TLegend(0.64, 0.69, 0.88, 0.87, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
legend->AddEntry(graph_mean, "<M_{#tau#tau}^{rec}/M_{#tau#tau}^{gen}>", "p");
legend->AddEntry(graph_rms, "#sigma(M_{#tau#tau}^{rec}/M_{#tau#tau}^{gen})", "p");
legend->Draw();
canvas->Update();
std::string outputFileName = "neuralMtautauPerformancePlot.eps";
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete graph_mean;
delete graph_rms;
delete dummyHistogram;
delete legend;
delete canvas;
}
void makePlot(const std::string& inputFilePath, const std::string& canvasName, const std::string& histogram, const std::string& channel, const std::string& xAxisTitle, const std::string& yAxisTitle,
const std::string& inputFileName, const std::string& outputFilePath, const std::string& outputFileName)
{
std::string inputFileName_full = Form("%s%s", inputFilePath.data(), inputFileName.data());
TFile* inputFile = new TFile(inputFileName_full.data());
if ( !inputFile ) {
std::cerr << "Failed to open input file = " << inputFileName_full << " !!" << std::endl;
assert(0);
}
inputFile->ls();
TCanvas* canvas = dynamic_cast<TCanvas*>(inputFile->Get(canvasName.data()));
if ( !canvas ) {
std::cerr << "Failed to load canvas = " << canvasName << " !!" << std::endl;
assert(0);
}
int idxPad = -1;
if ( histogram == "mVis" ) idxPad = 1;
if ( histogram == "mTauTau" ) idxPad = 2;
if ( !(idxPad >= 1 && idxPad <= 2) ) {
std::cerr << "Invalid histogram = " << histogram << " !!" << std::endl;
assert(0);
}
TVirtualPad* pad = canvas->GetPad(idxPad);
std::cout << "pad = " << pad << ": ClassName = " << pad->ClassName() << std::endl;
TCanvas* canvas_new = new TCanvas("canvas_new", "canvas_new", 900, 850);
canvas_new->SetFillColor(10);
canvas_new->SetBorderSize(2);
canvas_new->SetTopMargin(0.065);
canvas_new->SetLeftMargin(0.17);
canvas_new->SetBottomMargin(0.155);
canvas_new->SetRightMargin(0.045);
canvas_new->SetLogx(false);
canvas_new->SetLogy(false);
canvas_new->Draw();
canvas_new->cd();
//TList* pad_primitives = canvas->GetListOfPrimitives();
TList* pad_primitives = pad->GetListOfPrimitives();
TH1* histogramDYJets = 0;
TH1* histogramHiggs125 = 0;
TH1* histogramHiggs200 = 0;
TH1* histogramHiggs300 = 0;
TIter pad_nextObj(pad_primitives);
while ( TObject* obj = pad_nextObj() ) {
std::string objName = "";
if ( dynamic_cast<TNamed*>(obj) ) objName = (dynamic_cast<TNamed*>(obj))->GetName();
std::cout << "obj = " << obj << ": name = " << objName << ", type = " << obj->ClassName() << std::endl;
TH1* tmpHistogram = dynamic_cast<TH1*>(obj);
if ( tmpHistogram ) {
std::cout << "tmpHistogram:"
<< " fillColor = " << tmpHistogram->GetFillColor() << ", fillStyle = " << tmpHistogram->GetFillStyle() << ","
<< " lineColor = " << tmpHistogram->GetLineColor() << ", lineStyle = " << tmpHistogram->GetLineStyle() << ", lineWidth = " << tmpHistogram->GetLineWidth() << ","
<< " markerColor = " << tmpHistogram->GetMarkerColor() << ", markerStyle = " << tmpHistogram->GetMarkerStyle() << ", markerSize = " << tmpHistogram->GetMarkerSize() << ","
<< " integral = " << tmpHistogram->Integral() << std::endl;
if ( tmpHistogram->GetFillColor() == 0 ) histogramDYJets = tmpHistogram;
if ( tmpHistogram->GetFillColor() == 632 ) histogramHiggs125 = tmpHistogram;
if ( tmpHistogram->GetFillColor() == 616 ) histogramHiggs200 = tmpHistogram;
if ( tmpHistogram->GetFillColor() == 600 ) histogramHiggs300 = tmpHistogram;
}
}
if ( !(histogramDYJets && histogramHiggs125 && histogramHiggs200 && histogramHiggs300) ) {
std::cerr << "Failed to load histograms !!" << std::endl;
assert(0);
}
int lineColors[4] = { 1, 2, 6, 4 };
int lineStyles[4] = { 1, 1, 1, 1 };
int lineWidths[4] = { 2, 2, 2, 2 };
int fillColors[4] = { 10, 2, 6, 4 };
int fillStyles[4] = { 0, 3002, 3004, 3005 };
histogramDYJets->SetFillColor(fillColors[0]);
histogramDYJets->SetFillStyle(fillStyles[0]);
histogramDYJets->SetLineColor(lineColors[0]);
histogramDYJets->SetLineStyle(lineStyles[0]);
histogramDYJets->SetLineWidth(lineWidths[0]);
histogramHiggs125->SetFillColor(fillColors[1]);
histogramHiggs125->SetFillStyle(fillStyles[1]);
histogramHiggs125->SetLineColor(lineColors[1]);
histogramHiggs125->SetLineStyle(lineStyles[1]);
histogramHiggs125->SetLineWidth(lineWidths[1]);
histogramHiggs200->SetFillColor(fillColors[2]);
histogramHiggs200->SetFillStyle(fillStyles[2]);
histogramHiggs200->SetLineColor(lineColors[2]);
histogramHiggs200->SetLineStyle(lineStyles[2]);
histogramHiggs200->SetLineWidth(lineWidths[2]);
histogramHiggs300->SetFillColor(fillColors[3]);
histogramHiggs300->SetFillStyle(fillStyles[3]);
histogramHiggs300->SetLineColor(lineColors[3]);
histogramHiggs300->SetLineStyle(lineStyles[3]);
histogramHiggs300->SetLineWidth(lineWidths[3]);
TAxis* xAxis = histogramHiggs300->GetXaxis();
if ( histogram == "mVis" ) xAxis->SetRangeUser(0,350);
else xAxis->SetRangeUser(0,450);
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(1.00);
xAxis->SetTitleSize(0.070);
xAxis->SetTitleFont(42);
xAxis->SetLabelOffset(0.010);
xAxis->SetLabelSize(0.050);
xAxis->SetLabelFont(42);
xAxis->SetTickLength(0.040);
xAxis->SetNdivisions(505);
//double xMin = 20.;
//double xMax = xAxis->GetXmax();
//xAxis->SetRangeUser(xMin, xMax);
TAxis* yAxis = histogramHiggs300->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(1.20);
yAxis->SetTitleSize(0.070);
yAxis->SetTitleFont(42);
yAxis->SetLabelOffset(0.010);
yAxis->SetLabelSize(0.055);
yAxis->SetLabelFont(42);
yAxis->SetTickLength(0.040);
yAxis->SetNdivisions(505);
histogramHiggs300->SetTitle("");
histogramHiggs300->SetStats(false);
histogramHiggs300->SetMaximum(1.2*histogramDYJets->GetMaximum());
histogramHiggs300->SetMinimum(0.);
histogramHiggs300->Draw("hist");
histogramHiggs200->Draw("histsame");
histogramHiggs125->Draw("histsame");
histogramDYJets->Draw("histsame");
histogramHiggs300->Draw("axissame");
TLegend* legend_new = new TLegend(0.50, 0.62, 0.87, 0.92, NULL, "brNDC");
legend_new->SetFillColor(10);
legend_new->SetFillStyle(0);
legend_new->SetBorderSize(0);
legend_new->SetTextFont(42);
legend_new->SetTextSize(0.055);
legend_new->SetTextColor(1);
legend_new->SetMargin(0.20);
legend_new->AddEntry(histogramDYJets, "Z/#gamma* #rightarrow #tau#tau", "f");
legend_new->AddEntry(histogramHiggs125, "H(125 GeV) #rightarrow #tau#tau", "f");
legend_new->AddEntry(histogramHiggs200, "H(200 GeV) #rightarrow #tau#tau", "f");
legend_new->AddEntry(histogramHiggs300, "H(300 GeV) #rightarrow #tau#tau", "f");
legend_new->Draw();
double label_channel_y0;
if ( channel == "e#mu" ) label_channel_y0 = 0.9275;
else if ( channel == "#mu#tau_{h}" ) label_channel_y0 = 0.9400;
else if ( channel == "#tau_{h}#tau_{h}" ) label_channel_y0 = 0.9350;
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
TPaveText* label_channel = new TPaveText(0.855, label_channel_y0, 0.945, label_channel_y0 + 0.055, "NDC");
label_channel->SetFillStyle(0);
label_channel->SetBorderSize(0);
label_channel->AddText(channel.data());
label_channel->SetTextFont(62);
label_channel->SetTextSize(0.055);
label_channel->SetTextColor(1);
label_channel->SetTextAlign(31);
label_channel->Draw();
canvas_new->Update();
std::string outputFileName_full = Form("%s%s", outputFilePath.data(), outputFileName.data());
size_t idx = outputFileName_full.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName_full, 0, idx);
canvas_new->Print(std::string(outputFileName_plot).append(".pdf").data());
//canvas_new->Print(std::string(outputFileName_plot).append(".root").data());
delete legend_new;
delete label_channel;
delete canvas_new;
delete inputFile;
}
void plotFit(TString filename = "fp-d", TString pltmd = "tph") {
// CHECK FOR RIGHT INPUT ////////////////////////////////////////////////
string strpltmd = pltmd;
if( strpltmd.compare("tph") != 0 &&
strpltmd.compare("s2b") != 0 &&
strpltmd.compare("mmp") != 0 ) {error(4);};
// OPEN THE ROOT FILE //////////////////////////////////////////////////
gROOT->Reset();
gROOT->SetStyle("Plain");
gStyle->SetTitleBorderSize(0);
gStyle->SetPalette(1);
TCanvas *MyC = new TCanvas("MyC","Plot of the GAPP fit",200,10,700,500);
// Still to do: Automate the frame boundaries.
string strfile = filename, rootname = strfile + ".root";
TFile *rootfile = TFile::Open(rootname.c_str());
if(rootfile == NULL) error(1);
TTree *tree = (TTree*)rootfile->Get(strfile.c_str());
if(tree == NULL) error(2);
TBranch *fits2bbranch = (TBranch*)tree->GetBranch("fits2b");
TBranch *fittphbranch = (TBranch*)tree->GetBranch("fittph");
TBranch *fitxbranch = (TBranch*)tree->GetBranch("fitx");
if( (fits2bbranch == NULL) || (fittphbranch == NULL) || (fitxbranch == NULL) ) error(3);
Float_t fits2b, fittph, fitx;
tree->SetBranchAddress("fits2b",&fits2b);
tree->SetBranchAddress("fittph",&fittph);
tree->SetBranchAddress("fitx", &fitx);
// GET GRID /////////////////////////////////////////////////////////////
Int_t Npoints = (Int_t)tree->GetEntries();
Int_t point, zSteps = 0, ySteps = 0;
Float_t fitxMin = 100000, fitxMax = -1.0, s2bMin = 100000, tphMin = 100000;
Float_t s2bMax = -1.0, tphMax = -1.0;
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
if( fits2b > s2bMax ) {zSteps++; s2bMax = fits2b;}
if( fittph > tphMax ) {ySteps++; tphMax = fittph;}
};
const int s2bSteps = zSteps, tphSteps = ySteps, mmpSteps = Npoints;
Float_t s2bValues[s2bSteps], tphValues[tphSteps];
s2bMax = -1.0, tphMax = -1.0;
int s2bStep = 0, tphStep = 0;
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
if( fits2b > s2bMax ) {s2bValues[s2bStep] = fits2b; s2bStep++; s2bMax = fits2b;}
if( fittph > tphMax ) {tphValues[tphStep] = fittph; tphStep++; tphMax = fittph;}
};
// PREPARE PLOT /////////////////////////////////////////////////////////
string plottitle = "Model: " + strfile + " | Plot: ";
if( strpltmd.compare("tph") == 0 ) {
plottitle += "tan^{2}(#phi) over x for fixed sin^{2}(2#beta)";
}
if( strpltmd.compare("s2b") == 0 ) {
plottitle += "sin^{2}(2#beta) over x for fixed tan^{2}(#phi)";
}
if( strpltmd.compare("mmp") == 0 ) {
plottitle += "Masses of the new heavy gauge bosons";
}
// PLOT DATA ///////////////////////////////////////////////////////////
if (strpltmd.compare("tph") == 0) {
tphMax = -1.0;
// TGraph *tphplots[s2bSteps];
TGraph *tphplots[s2bSteps-30];
// for(s2bStep=0; s2bStep<s2bSteps; s2bStep++) {
for(s2bStep=0; s2bStep<s2bSteps-30; s2bStep++) {
Float_t tphArray[tphSteps], fitxArray[tphSteps];
tphStep = 0;
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
if(fits2b == s2bValues[s2bStep]) {
// tphArray[tphStep] = fittph;
tphArray[tphStep] = sqrt(1.0/(1.0+fittph));
if (fittph < tphMin) tphMin = fittph;
if (fittph > tphMax) tphMax = fittph;
fitxArray[tphStep] = fitx;
if (fitx < fitxMin) fitxMin = fitx;
if (fitx > fitxMax) fitxMax = fitx;
tphStep++;
TMarker *m = new TMarker(fitxArray[tphStep],tphArray[tphStep],20);
m->SetMarkerSize(2);
m->SetMarkerColor(31+tphStep);
m->Draw();
}
}
if (s2bStep == 0) {
TH1F* frame = MyC->DrawFrame(0.0,0.0,1.1*fitxMax,1.1);
// TH1F* frame = MyC->DrawFrame(0.7*fitxMin,0.7*tphMin,1.1*fitxMax,1.1*tphMax);
TAxis *xaxis = frame->GetXaxis();
TAxis *yaxis = frame->GetYaxis();
xaxis->SetTitle("x = u^{2}/v^{2}");
xaxis->CenterTitle();
xaxis->SetTitleOffset(1.);
xaxis->SetDecimals();
xaxis->SetLabelSize(0.03);
xaxis->SetLabelOffset(0.01);
yaxis->SetTitle("tan^{2}(#phi)");
yaxis->CenterTitle();
yaxis->SetTitleOffset(1.);
yaxis->SetDecimals();
yaxis->SetLabelSize(0.03);
yaxis->SetLabelOffset(0.01);
frame->SetTitle(plottitle.c_str());
}
tphplots[s2bStep] = new TGraph(tphSteps,fitxArray,tphArray);
tphplots[s2bStep]->SetMarkerStyle(20);
tphplots[s2bStep]->SetMarkerSize(0.4);
tphplots[s2bStep]->Draw("CP");
}
}
else if (strpltmd.compare("s2b") == 0) {
s2bMax = -1.0;
TGraph *s2bplots[tphSteps-100];
for(tphStep=0; tphStep<tphSteps-100; tphStep++) {
Float_t s2bArray[s2bSteps], fitxArray[s2bSteps];
s2bStep = 0;
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
if(fittph == tphValues[tphStep+20]) {
s2bArray[s2bStep] = fits2b;
if (fits2b < s2bMin) s2bMin = fits2b;
if (fits2b > s2bMax) s2bMax = fits2b;
fitxArray[s2bStep] = fitx;
if (fitx < fitxMin) fitxMin = fitx;
if (fitx > fitxMax) fitxMax = fitx;
s2bStep++;
}
}
if (tphStep == 0) {
TH1F* frame = MyC->DrawFrame(0.8*fitxMin,0.95*s2bMin,1.2*fitxMax,1.05*s2bMax);
TAxis *xaxis = frame->GetXaxis();
TAxis *yaxis = frame->GetYaxis();
xaxis->SetTitle("x = u^{2}/v^{2}");
xaxis->CenterTitle();
xaxis->SetTitleOffset(1.);
xaxis->SetDecimals();
xaxis->SetLabelSize(0.03);
xaxis->SetLabelOffset(0.01);
yaxis->SetTitle("sin^{2}(2#beta)");
yaxis->CenterTitle();
yaxis->SetTitleOffset(1.25);
yaxis->SetDecimals();
yaxis->SetLabelSize(0.03);
yaxis->SetLabelOffset(0.01);
frame->SetTitle(plottitle.c_str());
}
s2bplots[tphStep] = new TGraph(s2bSteps,fitxArray,s2bArray);
s2bplots[tphStep]->SetMarkerStyle(20);
s2bplots[tphStep]->SetMarkerSize(0.4);
s2bplots[tphStep]->Draw("C");
}
}
else if (strpltmd.compare("mmp") == 0) {
Float_t mzpArray[mmpSteps], mwpArray[mmpSteps];
Float_t mzpMin = 100000, mzpMax = -1.0, mwpMin = 100000, mwpMax = -1.0;
Float_t fitsph, fitcph;
Float_t Cz1, Cz2, Cz3, Cw1, Cw2, Cw3, Cw4, C1, C2;
string mdl(strfile,0,2);
if ( (mdl.compare("lr") == 0) ||
(mdl.compare("lp") == 0) ||
(mdl.compare("hp") == 0) ||
(mdl.compare("fp") == 0) ) {
string Higgs(strfile,3,1);
if (Higgs.compare("d") == 0) {
Cz1 = 11.95349795785275;
Cz2 = 30.63269990028513;
Cz3 = 42.58619785813789;
Cw1 = 21.29309892906894;
Cw2 = 9.339600971216193;
Cw3 = 30.63269990028513;
Cw4 = 42.58619785813789;
}
else if (Higgs.compare("t") == 0) {
Cz1 = 5.976748978926375;
Cz2 = 30.63269990028513;
Cz3 = 85.17239571627579;
Cw1 = 15.05649464522066;
Cw2 = 3.302047590161717;
Cw3 = 21.66058982554409;
Cw4 = 60.22597858088265;
} else {error(6);}
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
fitsph = fittph / (1.0 + fittph);
fitcph = 1.0 - fitsph;
if (fitsph != 0.0) {
mzpArray[point] = (0.001/sqrt(fitsph*fitcph*fitx)) * (Cz1*fitcph*fitcph + Cz2*fits2b + Cz3*fitx);
if (mzpArray[point] < mzpMin) mzpMin = mzpArray[point];
if (mzpArray[point] > mzpMax) mzpMax = mzpArray[point];
mwpArray[point] = (0.001/sqrt(fitsph*fitx)) * (Cw1 - Cw2*fitcph*fitcph + Cw3*fits2b + Cw4*fitx);
if (mwpArray[point] < mwpMin) mwpMin = mwpArray[point];
if (mwpArray[point] > mwpMax) mwpMax = mwpArray[point];
} else {
mzpArray[point] = 0.0;
mwpArray[point] = 0.0;
}
}
}
else if ( (mdl.compare("uu") == 0) ||
(mdl.compare("nu") == 0) ) {
C1 = 94.0397928463607
C2 = 77.1253849720165
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
fitsph = fittph / (1.0+fittph);
fitcph = 1.0 - fitsph;
if (fitsph != 0.0) {
mzpArray[point] = (0.001/sqrt(fitsph*fitcph*fitx)) * (C1*fitsph*fitsph + C2*fitx);
if (mzpArray[point] < mzpMin) mzpMin = mzpArray[point];
if (mzpArray[point] > mzpMax) mzpMax = mzpArray[point];
mwpArray[point] = (0.001/sqrt(fitsph*fitcph*fitx)) * (C1*fitsph*fitsph + C2*fitx);
if (mwpArray[point] < mwpMin) mwpMin = mwpArray[point];
if (mwpArray[point] > mwpMax) mwpMax = mwpArray[point];
} else {
mzpArray[point] = 0.0;
mwpArray[point] = 0.0;
}
}
}
//------------------------------------------------------------------------------
// DrawZPeak
//------------------------------------------------------------------------------
void DrawZPeak(TString energy)
{
if (energy.Contains("7TeV"))
{
_lumiText = "4.9 fb^{-1} (7 TeV)";
}
else
{
_lumiText = "19.6 fb^{-1} (8 TeV)";
}
// Read the input file
//----------------------------------------------------------------------------
TString name = "invMass2Lep_";
TFile* file = new TFile("rootfiles/" + name + energy + ".root", "read");
TH1F* data;
TH1F* WZ;
TH1F* fakes;
TH1F* ZZ;
TH1F* Zgamma;
TH1F* WV;
TH1F* VVV;
TH1F* allmc;
if (energy.Contains("7TeV"))
{
data = (TH1F*)file->Get("hZMass_Sel_datahist_COMB");
WZ = (TH1F*)file->Get("hZMass_Sel_wz_COMB");
fakes = (TH1F*)file->Get("hZMass_Sel_datadriven_COMB");
ZZ = (TH1F*)file->Get("hZMass_Sel_zz_COMB");
Zgamma = (TH1F*)file->Get("hZMass_Sel_zg_COMB");
WV = (TH1F*)file->Get("hZMass_Sel_wz_COMB");
VVV = (TH1F*)file->Get("hZMass_Sel_wz_COMB");
allmc = (TH1F*)file->Get("all_estimates_with_error_COMB");
}
else if (energy.Contains("8TeV"))
{
data = (TH1F*)file->Get("h_data");
WZ = (TH1F*)file->Get("h_WZ");
fakes = (TH1F*)file->Get("h_Fakes");
ZZ = (TH1F*)file->Get("h_ZZ");
Zgamma = (TH1F*)file->Get("h_ZGamma");
WV = (TH1F*)file->Get("h_WV");
VVV = (TH1F*)file->Get("h_VVV");
allmc = (TH1F*)file->Get("h_All");
}
WZ->SetFillColor(kOrange-2);
WZ->SetLineColor(kOrange-2);
Zgamma->SetFillColor(kRed+1); // kRed+2
Zgamma->SetLineColor(kRed+1); // kRed+2
ZZ->SetFillColor(kRed+1);
ZZ->SetLineColor(kRed+1);
fakes->SetFillColor(kGray+1);
fakes->SetLineColor(kGray+1);
data->SetMarkerStyle(kFullCircle);
allmc->SetFillColor (kBlack);
allmc->SetFillStyle (3345);
allmc->SetLineColor (kWhite);
allmc->SetLineWidth (0);
allmc->SetMarkerColor(kOrange-2);
allmc->SetMarkerSize (0);
THStack* hs = new THStack();
if (energy.Contains("8TeV"))
{
WV->SetFillColor(kRed+1); // kAzure
WV->SetLineColor(kRed+1); // kAzure
VVV->SetFillColor(kRed+1); // kBlack
VVV->SetLineColor(kRed+1); // kBlack
hs->Add(VVV);
hs->Add(WV);
}
hs->Add(Zgamma);
hs->Add(ZZ);
hs->Add(fakes);
hs->Add(WZ);
// Draw
//----------------------------------------------------------------------------
TCanvas* canvas = new TCanvas(energy, energy);
data->Draw("ep");
// Axis labels
//----------------------------------------------------------------------------
TAxis* xaxis = data->GetXaxis();
TAxis* yaxis = data->GetYaxis();
xaxis->SetLabelFont ( 42);
xaxis->SetLabelOffset(0.01);
xaxis->SetLabelSize (0.05);
xaxis->SetNdivisions ( 505);
xaxis->SetTitleFont ( 42);
xaxis->SetTitleOffset( 1.3);
xaxis->SetTitleSize (0.05);
yaxis->SetLabelFont ( 42);
yaxis->SetLabelOffset(0.01);
yaxis->SetLabelSize (0.05);
yaxis->SetNdivisions ( 505);
yaxis->SetTitleFont ( 42);
yaxis->SetTitleOffset( 1.6);
yaxis->SetTitleSize (0.05);
xaxis->SetRangeUser(68, 112);
xaxis->SetTitle("m_{#font[12]{ll}} (GeV)");
yaxis->SetTitle(Form("Events / %.0f GeV", data->GetBinWidth(0)));
// Adjust scale
//----------------------------------------------------------------------------
Float_t theMax = GetMaximumIncludingErrors(data);
Float_t theMaxMC = GetMaximumIncludingErrors(allmc);
if (theMaxMC > theMax) theMax = theMaxMC;
data->SetMaximum(1.15 * theMax);
// Legend
//----------------------------------------------------------------------------
Double_t x0 = 0.635;
Double_t y0 = 0.770;
DrawTLegend(x0, y0 + 2.*(_yoffset+0.001), data, " Data", "ep");
DrawTLegend(x0, y0 + 1.*(_yoffset+0.001), WZ, " WZ", "f");
DrawTLegend(x0, y0, fakes, " Non-prompt leptons", "f");
DrawTLegend(x0, y0 - 1.*(_yoffset+0.001), ZZ, " MC background", "f");
DrawTLegend(x0, y0 - 2.*(_yoffset+0.001), allmc, " stat. #oplus syst.", "f");
// Finish it
//----------------------------------------------------------------------------
data->SetTitle("");
DrawTLatex(_cmsTextFont, 0.215, 0.880, 0.055, 13, "CMS");
// DrawTLatex(_extraTextFont, 0.215, 0.826, 0.030, 13, "Preliminary");
DrawTLatex(_lumiTextFont, 0.940, 0.940, 0.040, 31, _lumiText);
hs ->Draw("hist,same");
allmc->Draw("e2,same");
data ->Draw("ep,same");
canvas->GetFrame()->DrawClone();
canvas->RedrawAxis();
canvas->Update();
canvas->SaveAs("pdf/" + name + energy + ".pdf");
canvas->SaveAs("png/" + name + energy + ".png");
}
//------------------------------------------------------------------------------
// DrawHistogram
//------------------------------------------------------------------------------
void DrawHistogram(TString hname,
TString xtitle,
Int_t ngroup = -1,
Int_t precision = 1,
TString units = "NULL",
Double_t xmin = -999,
Double_t xmax = 999,
Bool_t moveOverflow = true)
{
//TCanvas* canvas = new TCanvas(hname, hname, 550, 720);
TCanvas* canvas = new TCanvas(hname, hname, 800, 800);
TPad* pad1 = new TPad("pad1", "pad1", 0, 0.3, 1, 1.0);
TPad* pad2 = new TPad("pad2", "pad2", 0, 0.0, 1, 0.3);
pad1->SetTopMargin (0.08);
pad1->SetBottomMargin(0.02);
pad1->Draw();
pad2->SetTopMargin (0.08);
pad2->SetBottomMargin(0.35);
pad2->Draw();
//----------------------------------------------------------------------------
// pad1
//----------------------------------------------------------------------------
pad1->cd();
pad1->SetLogy(_setLogy);
THStack* hstack = new THStack(hname, hname);
TH1F* hist[nProcesses];
TH1F* hist_0[nProcesses]; // 0-jet
TH1F* hist_1[nProcesses]; // 1-jet
for (UInt_t ip=0; ip<nProcesses; ip++) {
if( _njet == 10 ){
hist_0[ip] = (TH1F*)input_0[ip]->Get(hname);
hist_1[ip] = (TH1F*)input_1[ip]->Get(hname);
}else{
//hist[ip] = (TH1F*)input[ip]->Get(hname);
//hist[ip]->SetName(hname + process[ip]);
}
if (moveOverflow){
if(_njet ==10){
MoveOverflowBins (hist_0[ip], xmin, xmax);
MoveOverflowBins (hist_1[ip], xmin, xmax);
}else{
//MoveOverflowBins (hist[ip], xmin, xmax);
}
}else{
if(_njet == 10){
ZeroOutOfRangeBins(hist_0[ip], xmin, xmax);
ZeroOutOfRangeBins(hist_1[ip], xmin, xmax);
}else{
//ZeroOutOfRangeBins(hist[ip], xmin, xmax);
}
}
if (ngroup > 0){
if(_njet == 10){
hist_0[ip]->Rebin(ngroup);
hist_1[ip]->Rebin(ngroup);
}else{
//hist[ip]->Rebin(ngroup);
}
}
// Add 0, 1 jet
if (ip == iData) {
if(_njet == 10 ){
hist[ip] = (TH1F*)hist_0[ip]->Clone(hname+process[ip]);
hist[ip]->Add(hist_1[ip]);
hist[ip]->SetMarkerStyle(kFullCircle);
}else{
//hist[ip]->SetMarkerStyle(kFullCircle);
}
}
else {
if(_njet == 10){
if (_dataDriven && ip == itt) hist_0[ip]->Scale(ttScale[0]);
if (_dataDriven && ip == itW) hist_0[ip]->Scale(tWScale[0]);
if (_dataDriven && ip == iWW) hist_0[ip]->Scale(WWScale[0]);
if (_dataDriven && ip == iDY) hist_0[ip]->Scale(ZjScale[0]);
if (_dataDriven && ip == iDYtau) hist_0[ip]->Scale(ZjScale[0]);
if (_dataDriven && ip == itt) hist_1[ip]->Scale(ttScale[1]);
if (_dataDriven && ip == itW) hist_1[ip]->Scale(tWScale[1]);
if (_dataDriven && ip == iWW) hist_1[ip]->Scale(WWScale[1]);
if (_dataDriven && ip == iDY) hist_1[ip]->Scale(ZjScale[1]);
if (_dataDriven && ip == iDYtau) hist_1[ip]->Scale(ZjScale[1]);
hist[ip] = (TH1F*)hist_0[ip]->Clone(hname+process[ip]);
hist[ip]->Add(hist_1[ip]);
hist[ip]->SetFillColor(color[ip]);
hist[ip]->SetFillStyle(1001);
hist[ip]->SetLineColor(color[ip]);
}else{
//hist[ip]->SetFillColor(color[ip]);
//hist[ip]->SetFillStyle(1001);
//hist[ip]->SetLineColor(color[ip]);
//if (_dataDriven && ip == itt) hist[ip]->Scale(ttScale[_njet]);
//if (_dataDriven && ip == itW) hist[ip]->Scale(tWScale[_njet]);
//if (_dataDriven && ip == iWW) hist[ip]->Scale(WWScale[_njet]);
//if (_dataDriven && ip == iDY) hist[ip]->Scale(ZjScale[_njet]);
//if (_dataDriven && ip == iDYtau) hist[ip]->Scale(ZjScale[_njet]);
}
hstack->Add(hist[ip]);
}
}
//=========================================================
//Save histograms to root file to draw paper style plots
//=========================================================
//TFile* outfile;
//TString fname = Form("files/%s_%djet.root", hname.Data(),_njet);
//TString fname = "files/0jet_"+hname+".root";
//if(_njet==1) fname = "files/1jet_"+hname+".root";
//if(_njet==10) fname = "files/10jet_"+hname+".root";
//outfile = new TFile(fname, "create");
//if(ip == iData) TH1F* data = (TH1F*)hist[iData]->Clone("Data"); //data -> Sumw2();
//if(ip == itt) TH1F* top = (TH1F*)hist[itt]->Clone("top"); //top -> Sumw2();
//if(ip == itW) TH1F* tW = (TH1F*)hist[itW]->Clone("tW"); //tW -> Sumw2();
//if(ip == iWW) TH1F* WW = (TH1F*)hist[iWW]->Clone("WW"); //WW -> Sumw2();
//if(ip == iWZ) TH1F* VVandVVV = (TH1F*)hist[iWZ]->Clone("VVandVVV"); //VV -> Sumw2();
//if(ip == iZZ) TH1F* ZZ = (TH1F*)hist[iZZ]->Clone("ZZ"); //ZZ -> Sumw2();
//if(ip == iWg) TH1F* Wg = (TH1F*)hist[iWg]->Clone("Wg"); //Wg -> Sumw2();
//if(ip == iWj) TH1F* Wjets = (TH1F*)hist[iWj]->Clone("W+jets"); //Wjets -> Sumw2();
//if(ip == iDY) TH1F* Zjets = (TH1F*)hist[iDY]->Clone("Z+jets"); //Zjets -> Sumw2();
//if(ip == iDYtau) TH1F* DYtau = (TH1F*)hist[iDYtau]->Clone("DYtau"); //DYtau -> Sumw2();
//if(ip == iZgamma) TH1F* Zgamma = (TH1F*)hist[iZgamma]->Clone("Zgamma"); //Zgamma -> Sumw2();
//if(ip == iH125) TH1F* ggH = (TH1F*)hist[iH125]->Clone("ggH"); //ggH -> Sumw2();
//
//top -> Add(tW);
//VVandVVV -> Add(ZZ);
//VVandVVV -> Add(Wg);
//Zjets -> Add(DYtau);
//Zjets -> Add(Zgamma);
//
//data -> Write();
//top -> Write();
//WW -> Write();
//VVandVVV -> Write();
//Wjets -> Write();
//Zjets -> Write();
//ggH -> Write();
//
//outfile -> Close();
//
//=========================================================
//Draw paper style plots
//=========================================================
//Use LatinoPlotTools.
//As input root file, use above saved root file "outfile"
//Run the following executable file:
//https://github.com/latinos/LatinoPlotTools/blob/master/WWRunI/scripts/doHWidth_Top_control.sh
// All MC
//----------------------------------------------------------------------------
TH1F* allmc = (TH1F*)hist[iData]->Clone("allmc");
allmc->SetFillColor (kGray+2);
allmc->SetFillStyle ( 3345);
allmc->SetLineColor (kGray+2);
allmc->SetMarkerColor(kGray+2);
allmc->SetMarkerSize ( 0);
for (UInt_t ibin=1; ibin<=allmc->GetNbinsX(); ibin++) {
Double_t binValue = 0;
Double_t binError = 0;
for (UInt_t ip=0; ip<nProcesses; ip++) {
if (ip == iData) continue;
Double_t binContent = hist[ip]->GetBinContent(ibin);
binValue += binContent;
binError += (hist[ip]->GetBinError(ibin) * hist[ip]->GetBinError(ibin));
//We need to calculate systematic uncertainty for ggH case
// if (_dataDriven)
// binError += (systError[ip]*binContent * systError[ip]*binContent);
}
binError = sqrt(binError);
allmc->SetBinContent(ibin, binValue);
allmc->SetBinError (ibin, binError);
}
// Axis labels
//----------------------------------------------------------------------------
TAxis* xaxis = hist[iData]->GetXaxis();
TAxis* yaxis = hist[iData]->GetYaxis();
TString ytitle = Form("entries / %s.%df", "%", precision);
xaxis->SetTitle(xtitle);
yaxis->SetTitle(Form(ytitle.Data(), hist[iData]->GetBinWidth(0)));
yaxis->SetTitleOffset(1.6);
if (!units.Contains("NULL")) {
xaxis->SetTitle(Form("%s [%s]", xaxis->GetTitle(), units.Data()));
yaxis->SetTitle(Form("%s %s", yaxis->GetTitle(), units.Data()));
}
// Draw
//----------------------------------------------------------------------------
xaxis->SetRangeUser(xmin, xmax);
hist[iData]->Draw("ep");
hstack ->Draw("hist,same");
allmc ->Draw("e2,same");
hist[iData]->Draw("ep,same");
// Adjust scale
//----------------------------------------------------------------------------
Float_t theMax = GetMaximumIncludingErrors(hist[iData], xmin, xmax);
Float_t theMaxMC = GetMaximumIncludingErrors(allmc, xmin, xmax);
if (theMaxMC > theMax) theMax = theMaxMC;
if (pad1->GetLogy()) {
theMax = TMath::Power(10, TMath::Log10(theMax) + 2.7);
hist[iData]->SetMinimum(0.05);
}
else theMax *= 1.55;
hist[iData]->SetMaximum(theMax);
// Legend
//----------------------------------------------------------------------------
Double_t x0 = 0.720;
Double_t y0 = 0.834;
Double_t yoffset = 0.048;
Double_t delta = yoffset + 0.001;
Double_t ndelta = 0;
Double_t YieldTop = Yield(hist[itt]) + Yield(hist[itW]);
Double_t YieldVV = Yield(hist[iWZ]) + Yield(hist[iZZ]) + Yield(hist[iWg]);
//Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]);
Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]) + Yield(hist[iZgamma]);
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iData], Form(" data (%.0f)", Yield(hist[iData])), "lp", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, allmc, Form(" all (%.0f)", Yield(allmc)), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWW], Form(" WW (%.0f)", Yield(hist[iWW])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWZ], Form(" VV (%.0f)", YieldVV), "f", 0.03, 0.2, yoffset); ndelta += delta;
ndelta = 0;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDY], Form(" Z+jets (%.0f)", YieldZJets), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iWj], Form(" W+jets (%.0f)", Yield(hist[iWj])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[itt], Form(" top (%.0f)", YieldTop), "f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" Higgs (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" ggH (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta;
// Additional titles
//----------------------------------------------------------------------------
//TString channelLabel = "ee/#mu#mu/e#mu/#mue";
TString channelLabel = "";
//if (_channel == "EE") channelLabel = "ee";
//if (_channel == "MuMu") channelLabel = "#mu#mu";
//if (_channel == "EMu") channelLabel = "e#mu";
//if (_channel == "MuE") channelLabel = "#mue";
//if (_channel == "SF") channelLabel = "ee/#mu#mu";
//if (_channel == "OF") channelLabel = "e#mu/#mue";
if( _njet != 10)
channelLabel += Form(" %d", _njet);
if (_njet == 0) channelLabel += "-jets";
if (_njet == 1) channelLabel += "-jet";
if (_njet >= 2 && _njet!= 10) channelLabel += "-jets";
if ( _njet== 10) channelLabel += "SS 0+1 jets";
DrawTLatex(0.185, 0.975, 0.05, 13, channelLabel.Data());
DrawTLatex(0.940, 0.983, 0.05, 33, Form("L = %.1f fb^{-1}", _luminosity/1e3));
//----------------------------------------------------------------------------
// pad2
//----------------------------------------------------------------------------
pad2->cd();
TH1F* ratio = hist[iData]->Clone("ratio");
TH1F* uncertainty = allmc->Clone("uncertainty");
for (UInt_t ibin=1; ibin<=ratio->GetNbinsX(); ibin++) {
Double_t mcValue = allmc->GetBinContent(ibin);
Double_t mcError = allmc->GetBinError (ibin);
Double_t dtValue = ratio->GetBinContent(ibin);
Double_t dtError = ratio->GetBinError (ibin);
Double_t ratioValue = (mcValue > 0) ? dtValue/mcValue : 0.0;
Double_t ratioError = (mcValue > 0) ? dtError/mcValue : 0.0;
Double_t uncertaintyError = (mcValue > 0) ? mcError/mcValue : 0.0;
ratio->SetBinContent(ibin, ratioValue);
ratio->SetBinError (ibin, ratioError);
uncertainty->SetBinContent(ibin, 1.0);
uncertainty->SetBinError (ibin, uncertaintyError);
}
TAxis* uaxis = (TAxis*)uncertainty->GetXaxis();
uaxis->SetRangeUser(xmin, xmax);
uncertainty->Draw("e2");
ratio ->Draw("ep,same");
uncertainty->GetYaxis()->SetRangeUser(0, 2.5);
// Save
//----------------------------------------------------------------------------
pad2->cd(); SetAxis(uncertainty, hist[iData]->GetXaxis()->GetTitle(), "data / prediction", 0.10, 0.8);
pad1->cd(); SetAxis(hist[iData], "", hist[iData]->GetYaxis()->GetTitle(), 0.05, 1.6);
canvas->cd();
TString suffixLogy = (_setLogy) ? "_Log" : "_Lin";
canvas->SaveAs(Form("%s/%s%s.%s",
_output.Data(),
hname.Data(),
suffixLogy.Data(),
_format.Data()));
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// drawFigure6
//
// logy = 0
// logy = 1
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void drawFigure6(Int_t logy = 0)
{
gInterpreter->ExecuteMacro("WZPaperStyle.C");
gSystem->mkdir("pdf", kTRUE);
gSystem->mkdir("png", kTRUE);
// Read the input file
//----------------------------------------------------------------------------
TString name = "WZ_PtZ_plot_allCh_largeATGC";
TFile* file = new TFile("rootfiles/" + name + ".root", "read");
TCanvas* c1 = (TCanvas*)file->Get("c1_allCh");
TH1F* data = (TH1F*)c1->FindObject("histo_data_3e");
TH1F* aTGC_dk = (TH1F*)c1->FindObject("histo_aTGC_dk_3e");
TH1F* aTGC_lam = (TH1F*)c1->FindObject("histo_aTGC_lam_3e");
TH1F* aTGC_dg = (TH1F*)c1->FindObject("histo_aTGC_dg_3e");
TH1F* WZ = (TH1F*)c1->FindObject("histo_SM_3e");
TH1F* fakes = (TH1F*)c1->FindObject("fake_0");
TH1F* ZZ = (TH1F*)c1->FindObject("total_bkg_rebined_ZZ_0");
TH1F* Zgamma = (TH1F*)c1->FindObject("total_bkg_rebined_Zgamma_0");
TH1F* WV = (TH1F*)c1->FindObject("total_bkg_rebined_WV_0");
TH1F* VVV = (TH1F*)c1->FindObject("total_bkg_rebined_VVV_0");
WZ->SetFillColor(kOrange-2);
WZ->SetLineColor(kOrange-2);
Zgamma->SetFillColor(kRed+1);
Zgamma->SetLineColor(kRed+1);
ZZ->SetFillColor(kRed+1);
ZZ->SetLineColor(kRed+1);
fakes->SetFillColor(kGray+1);
fakes->SetLineColor(kGray+1);
WV->SetFillColor(kRed+1);
WV->SetLineColor(kRed+1);
VVV->SetFillColor(kRed+1);
VVV->SetLineColor(kRed+1);
// Draw
//----------------------------------------------------------------------------
TCanvas* canvas = new TCanvas("canvas", "canvas");
canvas->SetLogy(logy);
data->Draw("ep");
// Axis labels
//----------------------------------------------------------------------------
TAxis* xaxis = data->GetXaxis();
TAxis* yaxis = data->GetYaxis();
xaxis->SetLabelFont ( 42);
xaxis->SetLabelOffset(0.01);
xaxis->SetLabelSize (0.05);
xaxis->SetNdivisions ( 505);
xaxis->SetTitleFont ( 42);
xaxis->SetTitleOffset( 1.2);
xaxis->SetTitleSize (0.05);
yaxis->SetLabelFont ( 42);
yaxis->SetLabelOffset(0.01);
yaxis->SetLabelSize (0.05);
yaxis->SetNdivisions ( 505);
yaxis->SetTitleFont ( 42);
yaxis->SetTitleOffset( 1.6);
yaxis->SetTitleSize (0.05);
xaxis->SetTitle("p_{T}^{Z} (GeV)");
yaxis->SetTitle(Form("Events / %.0f GeV", data->GetBinWidth(0)));
// Adjust scale
//----------------------------------------------------------------------------
Float_t theMax = GetMaximumIncludingErrors(data);
Float_t theMaxMC = GetMaximumIncludingErrors(aTGC_dk);
if (theMaxMC > theMax) theMax = theMaxMC;
if (canvas->GetLogy()) {
data->SetMaximum(15 * theMax);
data->SetMinimum(1);
} else {
data->SetMaximum(1.2 * theMax);
}
// Legend
//----------------------------------------------------------------------------
Double_t x0;
Double_t y0;
if (logy)
{
x0 = 0.630;
y0 = 0.765;
DrawTLegend(x0 - 0.37, y0 + 2.*(_yoffset+0.001), data, " Data", "ep");
DrawTLegend(x0 - 0.37, y0 + 1.*(_yoffset+0.001), aTGC_dk, " WZ aTGC (#Delta#kappa^{Z} = 0.6)", "l");
DrawTLegend(x0 - 0.37, y0, aTGC_dg, " WZ aTGC (#Deltag^{Z}_{1} = -0.06)", "l");
DrawTLegend(x0 - 0.37, y0 - 1.*(_yoffset+0.001), aTGC_lam, " WZ aTGC (#lambda = 0.04)", "l");
DrawTLegend(x0, y0 + 2.*(_yoffset+0.001), WZ, " WZ", "f");
DrawTLegend(x0, y0 + 1.*(_yoffset+0.001), fakes, " Non-prompt leptons", "f");
DrawTLegend(x0, y0, ZZ, " MC background", "f");
}
else
{
x0 = 0.570;
y0 = 0.755;
DrawTLegend(x0, y0 + 2.*(_yoffset+0.001), data, " Data", "ep");
DrawTLegend(x0, y0 + 1.*(_yoffset+0.001), aTGC_dk, " WZ aTGC (#Delta#kappa^{Z} = 0.6)", "l");
DrawTLegend(x0, y0, aTGC_dg, " WZ aTGC (#Deltag^{Z}_{1} = -0.06)", "l");
DrawTLegend(x0, y0 - 1.*(_yoffset+0.001), aTGC_lam, " WZ aTGC (#lambda = 0.04)", "l");
DrawTLegend(x0, y0 - 2.*(_yoffset+0.001), WZ, " WZ", "f");
DrawTLegend(x0, y0 - 3.*(_yoffset+0.001), fakes, " Non-prompt leptons", "f");
DrawTLegend(x0, y0 - 4.*(_yoffset+0.001), ZZ, " MC background", "f");
}
// Finish it
//----------------------------------------------------------------------------
data->SetTitle("");
if (logy)
{
DrawTLatex(_cmsTextFont, 0.190, 0.94, 0.055, 11, "CMS");
// DrawTLatex(_extraTextFont, 0.315, 0.94, 0.030, 11, "Preliminary");
}
else
{
DrawTLatex(_cmsTextFont, 0.215, 0.891, 0.055, 13, "CMS");
// DrawTLatex(_extraTextFont, 0.215, 0.837, 0.030, 13, "Preliminary");
}
DrawTLatex(_lumiTextFont, 0.940, 0.94, 0.040, 31, "19.6 fb^{-1} (8 TeV)");
WZ ->Draw("hist,same");
aTGC_dk ->Draw("hist,same");
aTGC_lam->Draw("hist,same");
aTGC_dg ->Draw("hist,same");
fakes ->Draw("hist,same");
ZZ ->Draw("hist,same");
Zgamma ->Draw("hist,same");
WV ->Draw("hist,same");
VVV ->Draw("hist,same");
data ->Draw("ep,same");
canvas->GetFrame()->DrawClone();
canvas->RedrawAxis();
canvas->Update();
TString cname = name;
if (logy) cname += "_log_range";
canvas->SaveAs("pdf/" + cname + ".pdf");
canvas->SaveAs("png/" + cname + ".png");
}
void showGraphs(double canvasSizeX, double canvasSizeY,
const std::vector<std::string>& entriesToPlot,
std::map<std::string, TGraph*>& graphs,
std::map<std::string, std::string>& legendEntries,
int colors[], int lineWidths[], int lineStyles[],
double legendTextSize, double legendPosX, double legendPosY, double legendSizeX, double legendSizeY,
double xMin, double xMax, const std::string& xAxisTitle, double xAxisOffset,
double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.14);
canvas->SetBottomMargin(0.12);
TH1* dummyHistogram = new TH1D("dummyHistogram", "dummyHistogram", 100, xMin, xMax);
dummyHistogram->SetTitle("");
dummyHistogram->SetStats(false);
dummyHistogram->SetMinimum(yMin);
dummyHistogram->SetMaximum(yMax);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleSize(0.045);
xAxis->SetTitleOffset(xAxisOffset);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleSize(0.045);
yAxis->SetTitleOffset(yAxisOffset);
dummyHistogram->Draw("axis");
TLegend* legend = new TLegend(legendPosX, legendPosY, legendPosX + legendSizeX, legendPosY + legendSizeY, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
legend->SetTextSize(legendTextSize);
size_t numEntriesToPlot = entriesToPlot.size();
for ( size_t iEntryToPlot = 0; iEntryToPlot < numEntriesToPlot; ++iEntryToPlot ) {
const std::string& entryToPlot = entriesToPlot[iEntryToPlot];
TGraph* graph = graphs[entryToPlot];
assert(graph);
graph->SetLineColor(colors[iEntryToPlot]);
graph->SetLineWidth(lineWidths[iEntryToPlot]);
graph->SetLineStyle(lineStyles[iEntryToPlot]);
graph->SetMarkerColor(colors[iEntryToPlot]);
graph->Draw("L");
legend->AddEntry(graph, legendEntries[entryToPlot].data(), "l");
}
legend->Draw();
canvas->Update();
std::string outputFileName_plot = "plots/";
size_t idx = outputFileName.find_last_of('.');
outputFileName_plot.append(std::string(outputFileName, 0, idx));
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete dummyHistogram;
delete legend;
delete canvas;
}
void plot_ZJetBalance(int JetAlgo) {
Float_t pt[NGenPtBins];
TString ptBin[NGenPtBins];
for(int i=0; i<NGenPtBins; i++) {
pt[i] = 0.5*( GenPt[i] + GenPt[i+1] );
ptBin[i] = Form("%d_%d", (int) GenPt[i], (int) GenPt[i+1] );
}
Float_t errpt[NGenPtBins];
Float_t genMean[NGenPtBins];
Float_t genSigma[NGenPtBins];
Float_t recoMean[NGenPtBins];
Float_t recoSigma[NGenPtBins];
TString algoSt;
if(JetAlgo==0) algoSt = "_ic5";
if(JetAlgo==1) algoSt = "_ic7";
if(JetAlgo==2) algoSt = "_mp5";
if(JetAlgo==3) algoSt = "_mp7";
if(JetAlgo==4) algoSt = "_kt6";
TString textFilename = "ZjetPtBalance" + algoSt + TString(".txt");
TString JetResponseFilename
= "Histograms_ZjetResponse" + algoSt + TString(".root");
FILE *file = fopen(textFilename,"w+");
fprintf( file ,"%s %s %s %s %s \n", "pT bin",
"genMean", "genSigma", "recoMean", "recoSigma");
TH1F* responseHistGen;
TH1F* responseHistReco;
TH1F* genJetpt;
TH1F* caloJetpt;
TH1F* Zpt;
if(storeResponsHistogramsInRootFile == true) {
TFile respHistFile(JetResponseFilename,"RECREATE");
}
for(int i=0; i<NGenPtBins; i++) {
responseHistGen = new TH1F("responseHistGen_"+ptBin[i],"", 40, 0.0, 2.0);
responseHistGen->Sumw2();
TAxis* responseHistGenx = responseHistGen->GetXaxis();
TAxis* responseHistGeny = responseHistGen->GetYaxis();
responseHistGenx->SetTitle("p_{T,Jet} / p_{T,Z} ");
responseHistGeny->SetTitle("Events / 0.05 ");
responseHistGeny->SetTitleOffset(1.2);
responseHistReco = new TH1F("responseHistReco_"+ptBin[i],"", 40, 0.0, 2.0);
responseHistReco->Sumw2();
responseHistReco->SetLineColor(2);
responseHistReco->SetMarkerColor(2);
genJetpt = new TH1F("genJetpt_"+ptBin[i],"", NGenPtBins-1, GenPt);
genJetpt->Sumw2();
caloJetpt = new TH1F("caloJetpt_"+ptBin[i],"", NGenPtBins-1, GenPt);
caloJetpt->Sumw2();
recoZpt = new TH1F("recoZpt_"+ptBin[i],"", NGenPtBins-1, GenPt);
recoZpt->Sumw2();
errpt[i] = 0.0;
genMean[i] = 0.0;
genSigma[i] = 0.0;
recoMean[i] = 0.0;
recoSigma[i] = 0.0;
plot_ZJetBalance( JetAlgo, i, *responseHistGen, *responseHistReco,
*genJetpt, *caloJetpt, *recoZpt);
genMean[i] = (Float_t) responseHistGen->GetMean(1);
genSigma[i] = (Float_t) responseHistGen->GetMean(11);
recoMean[i] = (Float_t) responseHistReco->GetMean(1);
recoSigma[i] = (Float_t) responseHistReco->GetMean(11);
if(storeResponseInTextFile == true) {
fprintf( file ,"%5.1f %5.4f %5.4f %5.4f %5.4f \n", pt[i],
genMean[i], genSigma[i], recoMean[i], recoSigma[i] );
}
if(storeResponsHistogramsInRootFile == true) {
respHistFile.cd();
responseHistGen->Write();
responseHistReco->Write();
genJetpt->Write();
caloJetpt->Write();
recoZpt->Write();
}
delete responseHistGen;
delete responseHistReco;
delete genJetpt;
delete caloJetpt;
delete recoZpt;
}
fclose(file);
respHistFile.Close();
if(makeplot_Response == true) {
// plot full spectrum
TGraphErrors *ptbalanceGen = new TGraphErrors(NGenPtBins, pt, genMean,
errpt, genSigma);
TGraphErrors *ptbalanceReco = new TGraphErrors(NGenPtBins, pt, recoMean,
errpt, recoSigma);
// plot Zmumu values
Float_t ptmm[9] = { 40.0, 60.0, 100.0, 140.0, 200.0, 250.0,
330.0, 400.0, 520.0 };
Float_t balancemm[9] = { 0.496, 0.568, 0.66, 0.71, 0.75, 0.765,
0.775, 0.79, 0.81 };
TGraph *ptbalancemm = new TGraph( 9, ptmm, balancemm);
ptbalanceGen->GetXaxis()->SetTitle("p_{T}^{Z} [GeV/c] ");
ptbalanceGen->GetYaxis()->SetTitle("p_{T}^{Jet} / p_{T}^{Z} ");
ptbalanceGen->SetMarkerStyle(22);
ptbalanceGen->SetMarkerSize(1.2);
ptbalanceGen->SetTitle("");
ptbalanceGen->SetMinimum(0.2);
ptbalanceReco->SetMarkerColor(2);
ptbalanceReco->SetLineColor(2);
ptbalanceReco->SetMarkerStyle(22);
ptbalanceReco->SetMarkerSize(1.2);
ptbalanceReco->SetMinimum(0.2);
ptbalancemm->SetMarkerStyle(24);
ptbalancemm->SetMarkerSize(1.2);
ptbalancemm->SetMinimum(0.2);
ptbalancemm->SetMarkerColor(4);
ptbalancemm->SetLineColor(4);
TCanvas c1("c1","",800,600);
c1.SetGrid();
ptbalanceGen->Draw("APL");
ptbalanceReco->Draw("PL");
ptbalancemm->Draw("PL");
leg_hist = new TLegend(0.6,0.35,0.85,0.55);
leg_hist->AddEntry( ptbalanceGen, "Generator level", "l");
leg_hist->AddEntry( ptbalanceReco,"Calorimeter level","l");
leg_hist->AddEntry( ptbalancemm,"Z#rightarrow#mu#mu","l");
leg_hist->SetFillColor(0);
leg_hist->Draw();
c1.SaveAs("PtBalanceVsPt.eps");
c1.SaveAs("PtBalanceVsPt.gif");
c1.SaveAs("PtBalanceVsPt.root");
c1.Close();
delete leg_hist;
delete ptbalanceGen;
delete ptbalanceReco;
delete ptbalancemm;
}
}
void plotVariable(string variable = "Elec_Fbrem",
const TString& category = "TauNoGammas",
const TString& xAxisTitle = "Fbrem",
const TString& yAxisTitle = "a.u.",
float xMin = -0.2,
float xMax = 1,
int nBins = 100,
int numPVMin = 0,
int numPVMax = 50,
float PtMin = 10,
float PtMax = 60,
const TString& Region = "Endcap"
)
{
string discriminator = "";
// string discriminator = "-AntiEMed";
float AbsEtaMin = 0;
float AbsEtaMax = 3.0;
if(Region == "Barrel"){
AbsEtaMin = 0;
AbsEtaMax = 1.479;
}
if(Region == "Endcap"){
AbsEtaMin = 1.479;
AbsEtaMax = 3.0;
}
TCanvas *c1 = new TCanvas("c1","",5,30,650,600);
c1->SetGrid(0,0);
c1->SetFillStyle(4000);
c1->SetFillColor(10);
c1->SetTicky();
c1->SetObjectStat(0);
gStyle->SetOptStat(0);
gStyle->SetTitleFillColor(0);
gStyle->SetCanvasBorderMode(0);
gStyle->SetCanvasColor(0);
gStyle->SetPadBorderMode(0);
gStyle->SetPadColor(0);
gStyle->SetTitleFillColor(0);
gStyle->SetTitleBorderSize(0);
gStyle->SetTitleH(0.07);
gStyle->SetTitleFontSize(0.1);
gStyle->SetTitleStyle(0);
gStyle->SetTitleOffset(1.3,"y");
TLegend* leg = new TLegend(0.6,0.75,0.8,0.88,NULL,"brNDC");
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->SetFillColor(10);
leg->SetTextSize(0.03);
//leg->SetHeader("#splitline{CMS Preliminary}{ #sqrt{s}=7 TeV}");
// std::string inputFileName = "/data_CMS/cms/ivo/AntiEMVA/Trees/AntiEMVA_Fall11DYJetsToLL-iter4.root";
// std::string inputFileName = "/data_CMS/cms/ivo/AntiEMVA/Trees/Trees_ForV4/AntiEMVA_AntiEMVATrees-DYJetsToLL-madgraph-PUS6.root";
std::string inputFileName = "/data_CMS/cms/ivo/AntiEMVA/Trees/Trees_ForV4/AntiEMVA_V4.root";
TFile* inputFile = new TFile (inputFileName.data(),"READ");
if(inputFile->IsZombie()){
cout << "No such file!" << endl;
return;
}
TTree* inputTree = (TTree*)inputFile->Get("AntiEMVAAnalyzer2/tree");
// TTree* inputTree = (TTree*)inputFile->Get("AntiEMVAAnalyzer/tree");
std::vector<TH1*> histograms;
std::vector<std::string> matchings ;
matchings.push_back("GenHadMatch");
matchings.push_back("GenEleMatch");
for ( std::vector<std::string>::const_iterator matching = matchings.begin();
matching != matchings.end(); ++matching ) {
TCut PUSelection(Form("NumPV>%i && NumPV<%i",numPVMin,numPVMax));
TCut ElecPtSelection (Form("Elec_Pt>%0f && Elec_Pt<%0f",PtMin,PtMax));
TCut TauPtSelection (Form("Tau_Pt>%0f && Tau_Pt<%0f",PtMin,PtMax));
TCut ElecAbsEtaSelection (Form("Elec_AbsEta>%0f && Elec_AbsEta<%0f",AbsEtaMin,AbsEtaMax));
TCut TauAbsEtaSelection = "";
if(Region == "Barrel"){
TauAbsEtaSelection = "Tau_Eta>-1.479 && Tau_Eta<1.479";
}
if(Region == "Endcap"){
TauAbsEtaSelection = "(Tau_Eta>1.479 && Tau_Eta<3.0) || (Tau_Eta>-3.0 && Tau_Eta<-1.479)";
}
// TCut TauAbsEtaSelection (Form("Tau_AbsEta>%0f && Tau_AbsEta<%0f",AbsEtaMin,AbsEtaMax));
TCut ElecMatchSelection (Form("Elec_%s == 1",matching->data()));
// TCut ElecMatchSelection (Form("Elec_PFTauMatch && Elec_%s",matching->data()));
TCut TauMatchSelection (Form("Tau_%s",matching->data()));
TCut CategorySelection = "";
if(discriminator == ""){
if (category == "NoEleMatch") CategorySelection = "Tau_GsfEleMatch<0.5";
if (category == "woG") CategorySelection = "Tau_NumGammaCands<0.5";
if (category == "wGwoGSF") CategorySelection = "Tau_NumGammaCands>0.5 && Tau_HasGsf<0.5";
if (category == "wGwGSFwoPFMVA")CategorySelection = "Tau_NumGammaCands>0.5 && Tau_HasGsf>0.5 && Elec_PFMvaOutput<-0.1";
if (category == "wGwGSFwPFMVA")CategorySelection = "Tau_NumGammaCands>0.5 && Tau_HasGsf>0.5 && Elec_PFMvaOutput>-0.1";
}
if(discriminator == "-AntiEMed"){
if (category == "NoEleMatch") CategorySelection = "Tau_GsfEleMatch<0.5";
if (category == "woG") CategorySelection = "Tau_NumGammaCands<0.5";
if (category == "wGwoGSF") CategorySelection = "Tau_NumGammaCands>0.5 && (Tau_HasGsf<0.5 || (Tau_HasGsf>0.5 && Elec_PFMvaOutput>-0.1))";
if (category == "wGwGSFwoPFMVA")CategorySelection = "Tau_NumGammaCands>0.5 && Tau_HasGsf>0.5 && Elec_PFMvaOutput<-0.1";
}
TCut ElecSelection = CategorySelection && PUSelection && ElecPtSelection && ElecAbsEtaSelection && ElecMatchSelection ;
TCut TauSelection = CategorySelection && PUSelection && TauPtSelection && TauAbsEtaSelection && TauMatchSelection ;
TCut Selection;
if (variable.find("Elec")!=std::string::npos)Selection = ElecSelection;
if (variable.find("Tau")!=std::string::npos)Selection = TauSelection;
TH1F* hVariable = new TH1F( "hVariable" ,"" , nBins ,xMin, xMax);
hVariable->SetXTitle(Form("%s",variable.data()));
if (matching->find("EleMatch")!=std::string::npos){
// hVariable->SetFillColor(kRed);
// hVariable->SetFillStyle(3345);
hVariable->SetLineColor(kRed);
hVariable->SetLineWidth(2);
}
if (matching->find("HadMatch")!=std::string::npos){
// hVariable->SetFillColor(kBlue);
// hVariable->SetFillStyle(3354);
hVariable->SetLineColor(kBlue);
hVariable->SetLineWidth(2);
}
inputTree->Draw(Form("%s>>hVariable",variable.data()));
cout<<"Variable plotted : "<<variable<<endl;
cout<<"Matching applied : "<<matching->data()<<endl;
cout<<" Total number of Candidates : "<<hVariable->GetEntries()<<endl;
inputTree->Draw(Form("%s>>hVariable",variable.data()),Selection);
cout<<" Number of Cantidates after selection: "<<hVariable->GetEntries()<<endl;
hVariable->Scale(1./hVariable->Integral());
leg->AddEntry(hVariable,Form("%s",matching->data()));
histograms.push_back(hVariable);
c1->Clear();
}
// double yMin = +1.e+6;
// double yMax = -1.e+6;
TH1* refHistogram = histograms.front();
refHistogram->SetStats(false);
refHistogram->SetTitle("");
// refHistogram->SetMinimum(yMin);
// refHistogram->SetMaximum(yMax);
if (xAxisTitle == "HoHplusE" ) {
refHistogram->SetMaximum(1.0);
refHistogram->SetMinimum(0.01);
c1->SetLogy();
}
if(xAxisTitle == "E_{#gamma}/(P_{in}-P_{out})" ){
refHistogram->SetMaximum(0.03);
refHistogram->SetMinimum(0.0);
}
if(xAxisTitle == "HadrMva(#tau)" ){
refHistogram->SetMaximum(0.25);
refHistogram->SetMinimum(0.0);
}
TAxis* xAxis = refHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.Data());
xAxis->SetTitleOffset(1.15);
//if(variable.find("AbsEta")!=std::string::npos)xAxis->SetLimits(AbsEtaMin, AbsEtaMax);
TAxis* yAxis = refHistogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.Data());
yAxis->SetTitleOffset(1.30);
int numHistograms = histograms.size();
float YMax = 0;
for ( int iHistogram = 0; iHistogram < numHistograms; ++iHistogram ) {
TH1* histogram = histograms[iHistogram];
if(histogram->GetMaximum()>YMax) YMax = histogram->GetMaximum();
}
for ( int iHistogram = 0; iHistogram < numHistograms; ++iHistogram ) {
TH1* histogram = histograms[iHistogram];
yAxis->SetRangeUser(0.,YMax+0.10*YMax);
std::string drawOption = "hist";
if ( iHistogram > 0 ) drawOption.append("same");
histogram->Draw(drawOption.data());
leg->Draw();
}//loop matchings
string outputName = Form("plots/plotVariablesAntiEMVA/%s/plotVariablesAntiEMVA_v4_%s_%s_%s",category.Data(),category.Data(),variable.data(),Region.Data());
c1->Print(std::string(outputName).append(".png").data());
c1->Print(std::string(outputName).append(".pdf").data());
}
void showHistograms(double canvasSizeX, double canvasSizeY,
TH1* histogram1, const std::string& legendEntry1,
TH1* histogram2, const std::string& legendEntry2,
TH1* histogram3, const std::string& legendEntry3,
TH1* histogram4, const std::string& legendEntry4,
double legendTextSize, double legendPosX, double legendPosY, double legendSizeX, double legendSizeY,
std::vector<std::string>& labelTextLines, double labelTextSize,
double labelPosX, double labelPosY, double labelSizeX, double labelSizeY,
double xMin, double xMax, const std::string& xAxisTitle, double xAxisOffset,
bool useLogScale, double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
const std::string& outputFileName)
{
const unsigned numBinsMin_rebinned = 20;
TH1* histogram1_rebinned = rebinHistogram(histogram1, numBinsMin_rebinned, xMin, xMax);
TH1* histogram2_rebinned = rebinHistogram(histogram2, numBinsMin_rebinned, xMin, xMax);
TH1* histogram3_rebinned = rebinHistogram(histogram3, numBinsMin_rebinned, xMin, xMax);
TH1* histogram4_rebinned = rebinHistogram(histogram4, numBinsMin_rebinned, xMin, xMax);
TCanvas* canvas = new TCanvas("canvas", "canvas", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.14);
canvas->SetBottomMargin(0.12);
canvas->SetLogy(useLogScale);
histogram1_rebinned->SetTitle("");
histogram1_rebinned->SetStats(false);
histogram1_rebinned->SetMinimum(yMin);
histogram1_rebinned->SetMaximum(yMax);
TAxis* xAxis = histogram1_rebinned->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleSize(0.045);
xAxis->SetTitleOffset(xAxisOffset);
if ( xMax > xMin ) {
std::cout << "limiting x-axis range to " << xMin << ".." << xMax << std::endl;
xAxis->SetRangeUser(xMin, xMax);
}
TAxis* yAxis = histogram1_rebinned->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleSize(0.045);
yAxis->SetTitleOffset(yAxisOffset);
int colors[4] = { 1, 2, 3, 4 };
int lineStyles[4] = { 1, 7, 4, 3 };
histogram1_rebinned->SetLineColor(colors[0]);
histogram1_rebinned->SetLineWidth(2);
histogram1_rebinned->SetLineStyle(lineStyles[0]);
histogram1_rebinned->Draw("hist");
if ( histogram2_rebinned ) {
histogram2_rebinned->SetLineColor(colors[1]);
histogram2_rebinned->SetLineWidth(2);
histogram2_rebinned->SetLineStyle(lineStyles[1]);
histogram2_rebinned->Draw("histsame");
}
if ( histogram3_rebinned ) {
histogram3_rebinned->SetLineColor(colors[2]);
histogram3_rebinned->SetLineWidth(2);
histogram3_rebinned->SetLineStyle(lineStyles[2]);
histogram3_rebinned->Draw("histsame");
}
if ( histogram4_rebinned ) {
histogram4_rebinned->SetLineColor(colors[3]);
histogram4_rebinned->SetLineWidth(2);
histogram4_rebinned->SetLineStyle(lineStyles[3]);
histogram4_rebinned->Draw("histsame");
}
TLegend* legend = new TLegend(legendPosX, legendPosY, legendPosX + legendSizeX, legendPosY + legendSizeY, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
legend->SetTextSize(legendTextSize);
legend->AddEntry(histogram1_rebinned, legendEntry1.data(), "l");
if ( histogram2_rebinned ) legend->AddEntry(histogram2_rebinned, legendEntry2.data(), "l");
if ( histogram3_rebinned ) legend->AddEntry(histogram3_rebinned, legendEntry3.data(), "l");
if ( histogram4_rebinned ) legend->AddEntry(histogram4_rebinned, legendEntry4.data(), "l");
legend->Draw();
TPaveText* label = 0;
if ( labelTextLines.size() > 0 ) {
label = new TPaveText(labelPosX, labelPosY, labelPosX + labelSizeX, labelPosY + labelSizeY, "brNDC");
for ( std::vector<std::string>::const_iterator labelTextLine = labelTextLines.begin();
labelTextLine != labelTextLines.end(); ++labelTextLine ) {
label->AddText(labelTextLine->data());
}
label->SetFillColor(10);
label->SetBorderSize(0);
label->SetTextColor(1);
label->SetTextAlign(12);
label->SetTextSize(labelTextSize);
label->Draw();
}
canvas->Update();
std::string outputFileName_plot = "plots/";
size_t idx = outputFileName.find_last_of('.');
outputFileName_plot.append(std::string(outputFileName, 0, idx));
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete label;
delete legend;
delete canvas;
delete histogram1_rebinned;
delete histogram2_rebinned;
delete histogram3_rebinned;
delete histogram4_rebinned;
}
//------------------------------------------------------------------------------
// DrawHistogram
//------------------------------------------------------------------------------
void DrawHistogram(TString hname,
TString xtitle,
Int_t ngroup = -1,
Int_t precision = 1,
TString units = "NULL",
Double_t xmin = -999,
Double_t xmax = 999,
Bool_t moveOverflow = true)
{
//TCanvas* canvas = new TCanvas(hname, hname, 550, 720);
TCanvas* canvas = new TCanvas(hname, hname, 800, 800);
TPad* pad1 = new TPad("pad1", "pad1", 0, 0.3, 1, 1.0);
TPad* pad2 = new TPad("pad2", "pad2", 0, 0.0, 1, 0.3);
pad1->SetTopMargin (0.08);
pad1->SetBottomMargin(0.02);
pad1->Draw();
pad2->SetTopMargin (0.08);
pad2->SetBottomMargin(0.35);
pad2->Draw();
//----------------------------------------------------------------------------
// pad1
//----------------------------------------------------------------------------
pad1->cd();
pad1->SetLogy(_setLogy);
THStack* hstack = new THStack(hname, hname);
TH1F* hist[nProcesses];
//Save histograms to root file
TFile* outfile;
//TString fname = Form("files/%s_%djet.root", hname.Data(),_njet);
TString fname = "files/0jet_"+hname+".root";
if(_njet==1) fname = "files/1jet_"+hname+".root";
outfile = new TFile(fname, "create");
TH1F* data;
TH1F* top;
TH1F* tW;
TH1F* WW;
TH1F* WZ;
TH1F* ZZ;
TH1F* Wg;
TH1F* WgSMu;
TH1F* WgSEl;
TH1F* Wjets;
TH1F* Zjets;
TH1F* DYtau;
TH1F* Zgamma;
TH1F* ggH;
for (UInt_t ip=0; ip<nProcesses; ip++) {
hist[ip] = (TH1F*)input[ip]->Get(hname);
hist[ip]->SetName(hname + process[ip]);
hist[ip]->SetTitle("");
if(ip == iData) data = (TH1F*)hist[iData]->Clone("Data"); //data -> Sumw2();
if(ip == itt) top = (TH1F*)hist[itt]->Clone("top"); //top -> Sumw2();
if(ip == itW) tW = (TH1F*)hist[itW]->Clone("tW"); //tW -> Sumw2();
if(ip == iWW) WW = (TH1F*)hist[iWW]->Clone("WW"); //WW -> Sumw2();
if(ip == iWZ) WZ = (TH1F*)hist[iWZ]->Clone("WZ"); //VV -> Sumw2();
if(ip == iZZ) ZZ = (TH1F*)hist[iZZ]->Clone("ZZ"); //ZZ -> Sumw2();
if(ip == iWg) Wg = (TH1F*)hist[iWg]->Clone("Wg"); //Wg -> Sumw2();
if(ip == iWgSMu){
WgSMu = (TH1F*)hist[iWgSMu]->Clone("WgSMu"); //WgSMu -> Sumw2();
hist[iWgSMu]->Scale(1.5);
}
if(ip == iWgSEl){
WgSEl = (TH1F*)hist[iWgSEl]->Clone("WgSEl"); //WgSel -> Sumw2();
hist[iWgSEl]->Scale(1.5); //WgSel -> Sumw2();
}
if(ip == iWj) Wjets = (TH1F*)hist[iWj]->Clone("W+jets"); //Wjets -> Sumw2();
if(ip == iDY) Zjets = (TH1F*)hist[iDY]->Clone("Z+jets"); //Zjets -> Sumw2();
if(ip == iDYtau) DYtau = (TH1F*)hist[iDYtau]->Clone("DYtau"); //DYtau -> Sumw2();
if(ip == iZgamma) Zgamma = (TH1F*)hist[iZgamma]->Clone("Zgamma"); //Zgamma -> Sumw2();
if(ip == iH125) ggH = (TH1F*)hist[iH125]->Clone("ggH"); //ggH -> Sumw2();
if (moveOverflow) MoveOverflowBins (hist[ip], xmin, xmax);
else ZeroOutOfRangeBins(hist[ip], xmin, xmax);
if (ngroup > 0) hist[ip]->Rebin(ngroup);
if (ip == iWg) {
//hist[ip]->Scale(0.01);
}
if (ip == iData) {
hist[ip]->SetMarkerStyle(kFullCircle);
}
else {
hist[ip]->SetFillColor(color[ip]);
hist[ip]->SetFillStyle(1001);
hist[ip]->SetLineColor(color[ip]);
if (_dataDriven && ip == itt) hist[ip]->Scale(ttScale[_njet]);
if (_dataDriven && ip == itW) hist[ip]->Scale(tWScale[_njet]);
if (_dataDriven && ip == iWW) hist[ip]->Scale(WWScale[_njet]);
if (_dataDriven && ip == iDY) hist[ip]->Scale(ZjScale[_njet]);
if (_dataDriven && ip == iDYtau) hist[ip]->Scale(ZjScale[_njet]);
if( ip != iZZ ) hstack->Add(hist[ip]);//TODO something wrong with ZZ
}
}
if (_dataDriven)
{
top->Scale(ttScale[_njet]);
tW->Scale(tWScale[_njet]);
WW->Scale(WWScale[_njet]);
Zjets->Scale(ZjScale[_njet]);
DYtau->Scale(ZjScale[_njet]);
}
top ->Add(tW);
//VV ->Add(ZZ);
//VV ->Add(Wg);
//Zjets->Add(DYtau);
//Zjets->Add(Zgamma);
data -> Write();
top -> Write();
WW -> Write();
//VV -> Write();
//Wjets -> Write();
//Zjets -> Write();
ggH -> Write();
outfile->Close();
// All MC
//----------------------------------------------------------------------------
TH1F* allmc = (TH1F*)hist[iData]->Clone("allmc");
allmc->SetFillColor (kGray+2);
allmc->SetFillStyle ( 3345);
allmc->SetLineColor (kGray+2);
allmc->SetMarkerColor(kGray+2);
allmc->SetMarkerSize ( 0);
for (UInt_t ibin=1; ibin<=allmc->GetNbinsX(); ibin++) {
Double_t binValue = 0;
Double_t binError = 0;
for (UInt_t ip=0; ip<nProcesses; ip++) {
if (ip == iData) continue;
if (ip == iZZ) continue;
Double_t binContent = hist[ip]->GetBinContent(ibin);
binValue += binContent;
binError += (hist[ip]->GetBinError(ibin) * hist[ip]->GetBinError(ibin));
//We need to calculate systematic uncertainty for ggH case
// if (_dataDriven)
// binError += (systError[ip]*binContent * systError[ip]*binContent);
}
binError = sqrt(binError);
allmc->SetBinContent(ibin, binValue);
allmc->SetBinError (ibin, binError);
}
// Axis labels
//------------------------------------------------------------------
TAxis* xaxis = hist[iData]->GetXaxis();
TAxis* yaxis = hist[iData]->GetYaxis();
TString ytitle = Form("entries / %s.%df", "%", precision);
xaxis->SetTitle(xtitle);
yaxis->SetTitle(Form(ytitle.Data(), hist[iData]->GetBinWidth(0)));
yaxis->SetTitleOffset(1.6);
if (!units.Contains("NULL")) {
xaxis->SetTitle(Form("%s [%s]", xaxis->GetTitle(), units.Data()));
yaxis->SetTitle(Form("%s %s", yaxis->GetTitle(), units.Data()));
}
// Draw
//--------------------------------------------------------------------
xaxis->SetRangeUser(xmin, xmax);
hist[iData]->Draw("ep");
hstack ->Draw("hist,same");
allmc ->Draw("e2,same");
hist[iData]->Draw("ep,same");
// Adjust scale
//----------------------------------------------------------------------------
Float_t theMax = GetMaximumIncludingErrors(hist[iData], xmin, xmax);
Float_t theMaxMC = GetMaximumIncludingErrors(allmc, xmin, xmax);
if (theMaxMC > theMax) theMax = theMaxMC;
if (pad1->GetLogy()) {
theMax = TMath::Power(10, TMath::Log10(theMax) + 2.7);
hist[iData]->SetMinimum(0.05);
}
else theMax *= 1.55;
hist[iData]->SetMaximum(theMax);
// Legend
//----------------------------------------------------------------------
Double_t x0 = 0.720;
Double_t y0 = 0.834;
Double_t yoffset = 0.048;
Double_t delta = yoffset + 0.001;
Double_t ndelta = 0;
Double_t YieldTop = Yield(hist[itt]) + Yield(hist[itW]);
Double_t YieldWZ = Yield(hist[iWZ]);
Double_t YieldVV = Yield(hist[iWZ]) + Yield(hist[iZZ]) + Yield(hist[iWg]);
//Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]);
Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]) + Yield(hist[iZgamma]);
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iData], Form(" data (%.0f)", Yield(hist[iData])), "lp", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[itt], Form(" tt (%.0f)", Yield(hist[itt])), "f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[itW], Form(" tW (%.0f)", Yield(hist[itW])), "f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.49, y0 - ndelta, allmc, Form(" all (%.0f)", Yield(allmc)), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWW], Form(" WW (%.0f)", Yield(hist[iWW])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWZ], Form(" WZ (%.0f)", Yield(hist[iWZ])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWg], Form(" Wg (%.0f)", Yield(hist[iWg])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWgSMu], Form(" Wg*Mu (%.0f)", Yield(hist[iWgSMu])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWgSEl], Form(" Wg*El (%.0f)", Yield(hist[iWgSEl])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWj], Form(" W+jets (%.0f)",Yield(hist[iWj])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iZZ], Form(" ZZ (%.0f)", Yield(hist[iZZ])), "f", 0.03, 0.2, yoffset); ndelta += delta;
ndelta = 0;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDY], Form(" DY (%.0f)", Yield(hist[iDY])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDYtau], Form(" DYtau (%.0f)", Yield(hist[iDYtau])),"f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iZgamma],Form(" Zg (%.0f)", Yield(hist[iZgamma])),"f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDY], Form(" Z+jets (%.0f)", YieldZJets), "f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" Higgs (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" ggH (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[itt], Form(" tt (%.0f)", Yield(hist[itt])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[itW], Form(" tW (%.0f)", Yield(hist[itW])), "f", 0.03, 0.2, yoffset); ndelta += delta;
// Additional titles
//----------------------------------------------------------------------------
//TString channelLabel = "ee/#mu#mu/e#mu/#mue";
TString channelLabel = "";
//if (_channel == "EE") channelLabel = "ee";
//if (_channel == "MuMu") channelLabel = "#mu#mu";
//if (_channel == "EMu") channelLabel = "e#mu";
//if (_channel == "MuE") channelLabel = "#mue";
//if (_channel == "SF") channelLabel = "ee/#mu#mu";
//if (_channel == "OF") channelLabel = "e#mu/#mue";
channelLabel += Form(" %d", _njet);
if (_njet == 0) channelLabel += "-jets";
if (_njet == 1) channelLabel += "-jet";
if (_njet >= 2) channelLabel += "-jets";
double nBin;
double binWidth;
nBin = allmc->GetSize();
nBin -=2;
binWidth = allmc->GetBinWidth(2);
int Z1bin=70/binWidth;
int Z2bin=110/binWidth;
cout<<"number of bin: "<<nBin<<endl;
cout<<"Z bin1: "<<Z1bin<<" Z bin2: "<<Z2bin<<endl;
double nMcZ, nDataZ;
nMcZ = allmc->Integral(Z1bin,Z2bin);
nDataZ = hist[iData]->Integral(Z1bin,Z2bin);
double effiCorr;
effiCorr=nDataZ/nMcZ;
cout<<"efficiency correction factor: "<<effiCorr<<endl;
double nMcGstar, nDataGstar, nMcGamma;
nMcGstar = hist[iWgSMu]->Integral(1,2);
nMcGamma = hist[iWg]->Integral(1,2);
//nMcGstar = allmc->Integral(1,2);
nMcGstar *= effiCorr;
nMcGamma *= effiCorr;
nDataGstar = hist[iData]->Integral(1,2);
double Kfactor;
double KfactorErr;
nDataGstar -= nMcGamma;
Kfactor = nDataGstar/nMcGstar;
KfactorErr =Kfactor* TMath::Sqrt(nDataGstar/nDataGstar/nDataGstar + nMcGstar/nMcGstar/nMcGstar);
KfactorErr += 0.1;
cout<<"Kfactor: "<<Kfactor<<"+"<<KfactorErr<<endl;
//DrawTLatex(0.185, 0.975, 0.05, 13, channelLabel.Data(),"");
DrawTLatex(0.940, 0.983, 0.05, 33, Form("L = %.1f fb^{-1}", _luminosity/1e3),"");
DrawTLatex(0.45, 0.48, 0.04, 13, Form("K factor (Data/Wg*) = %.2f #pm %.2f", Kfactor, KfactorErr ),"");
DrawTLatex(0.45, 0.43, 0.04, 13, Form("0< InvM(#mu^{+}#mu^{-}) <4 GeV"),"");
//----------------------------------------------------------------------------
// pad2
//----------------------------------------------------------------------------
pad2->cd();
TH1F* ratio = (TH1F*)hist[iData]->Clone("ratio");
TH1F* uncertainty = (TH1F*)allmc->Clone("uncertainty");
for (UInt_t ibin=1; ibin<=ratio->GetNbinsX(); ibin++) {
Double_t mcValue = allmc->GetBinContent(ibin);
Double_t mcError = allmc->GetBinError (ibin);
Double_t dtValue = ratio->GetBinContent(ibin);
Double_t dtError = ratio->GetBinError (ibin);
Double_t ratioValue = (mcValue > 0) ? dtValue/mcValue : 0.0;
Double_t ratioError = (mcValue > 0) ? dtError/mcValue : 0.0;
Double_t uncertaintyError = (mcValue > 0) ? mcError/mcValue : 0.0;
ratio->SetBinContent(ibin, ratioValue);
ratio->SetBinError (ibin, ratioError);
uncertainty->SetBinContent(ibin, 1.0);
uncertainty->SetBinError (ibin, uncertaintyError);
}
TAxis* uaxis = (TAxis*)uncertainty->GetXaxis();
uaxis->SetRangeUser(xmin, xmax);
uncertainty->Draw("e2");
ratio ->Draw("ep,same");
uncertainty->GetYaxis()->SetRangeUser(0, 2.5);
// Save
//----------------------------------------------------------------------
pad2->cd(); SetAxis(uncertainty, hist[iData]->GetXaxis()->GetTitle(), "data / prediction", 0.10, 0.8);
pad1->cd(); SetAxis(hist[iData], "", hist[iData]->GetYaxis()->GetTitle(), 0.05, 1.6);
canvas->cd();
TString suffixLogy = (_setLogy) ? "_Log" : "_Lin";
canvas->SaveAs(Form("%s/%s%s.%s",
_output.Data(),
hname.Data(),
suffixLogy.Data(),
_format.Data()));
}
void showEfficiency(const TString& title, double canvasSizeX, double canvasSizeY,
const TH1* histogram1_numerator, const TH1* histogram1_denominator, const std::string& legendEntry1,
const TH1* histogram2_numerator, const TH1* histogram2_denominator, const std::string& legendEntry2,
const TH1* histogram3_numerator, const TH1* histogram3_denominator, const std::string& legendEntry3,
const TH1* histogram4_numerator, const TH1* histogram4_denominator, const std::string& legendEntry4,
const TH1* histogram5_numerator, const TH1* histogram5_denominator, const std::string& legendEntry5,
const TH1* histogram6_numerator, const TH1* histogram6_denominator, const std::string& legendEntry6,
const std::string& xAxisTitle, double xAxisOffset,
bool useLogScale, double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
double legendX0, double legendY0,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.12);
canvas->SetBottomMargin(0.12);
canvas->SetLogy(useLogScale);
canvas->SetGridx();
canvas->SetGridy();
TH1* dummyHistogram = new TH1D("dummyHistogram_top", "dummyHistogram_top", 10, histogram1_numerator->GetXaxis()->GetXmin(), histogram1_numerator->GetXaxis()->GetXmax());
dummyHistogram->SetTitle("");
dummyHistogram->SetStats(false);
dummyHistogram->SetMaximum(yMax);
dummyHistogram->SetMinimum(yMin);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(xAxisOffset);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(yAxisOffset);
dummyHistogram->Draw();
int colors[6] = { 1, 2, 3, 4, 6, 7 };
int markerStyles[6] = { 22, 32, 20, 24, 21, 25 };
int numGraphs = 1;
if ( histogram2_numerator && histogram2_denominator ) ++numGraphs;
if ( histogram3_numerator && histogram3_denominator ) ++numGraphs;
if ( histogram4_numerator && histogram4_denominator ) ++numGraphs;
if ( histogram5_numerator && histogram5_denominator ) ++numGraphs;
if ( histogram6_numerator && histogram6_denominator ) ++numGraphs;
TLegend* legend = new TLegend(legendX0, legendY0, legendX0 + 0.18, legendY0 + 0.05*numGraphs, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
TGraphAsymmErrors* graph1 = getEfficiency(histogram1_numerator, histogram1_denominator);
graph1->SetLineColor(colors[0]);
graph1->SetMarkerColor(colors[0]);
graph1->SetMarkerStyle(markerStyles[0]);
graph1->Draw("p");
legend->AddEntry(graph1, legendEntry1.data(), "p");
TGraphAsymmErrors* graph2 = 0;
if ( histogram2_numerator && histogram2_denominator ) {
graph2 = getEfficiency(histogram2_numerator, histogram2_denominator);
graph2->SetLineColor(colors[1]);
graph2->SetMarkerColor(colors[1]);
graph2->SetMarkerStyle(markerStyles[1]);
graph2->Draw("p");
legend->AddEntry(graph2, legendEntry2.data(), "p");
}
TGraphAsymmErrors* graph3 = 0;
if ( histogram3_numerator && histogram3_denominator ) {
graph3 = getEfficiency(histogram3_numerator, histogram3_denominator);
graph3->SetLineColor(colors[2]);
graph3->SetMarkerColor(colors[2]);
graph3->SetMarkerStyle(markerStyles[2]);
graph3->Draw("p");
legend->AddEntry(graph3, legendEntry3.data(), "p");
}
TGraphAsymmErrors* graph4 = 0;
if ( histogram4_numerator && histogram4_denominator ) {
graph4 = getEfficiency(histogram4_numerator, histogram4_denominator);
graph4->SetLineColor(colors[3]);
graph4->SetMarkerColor(colors[3]);
graph4->SetMarkerStyle(markerStyles[3]);
graph4->Draw("p");
legend->AddEntry(graph4, legendEntry4.data(), "p");
}
TGraphAsymmErrors* graph5 = 0;
if ( histogram5_numerator && histogram5_denominator ) {
graph5 = getEfficiency(histogram5_numerator, histogram5_denominator);
graph5->SetLineColor(colors[4]);
graph5->SetMarkerColor(colors[4]);
graph5->SetMarkerStyle(markerStyles[4]);
graph5->Draw("p");
legend->AddEntry(graph5, legendEntry5.data(), "p");
}
TGraphAsymmErrors* graph6 = 0;
if ( histogram6_numerator && histogram6_denominator ) {
graph6 = getEfficiency(histogram6_numerator, histogram6_denominator);
graph6->SetLineColor(colors[5]);
graph6->SetMarkerColor(colors[5]);
graph6->SetMarkerStyle(markerStyles[5]);
graph6->Draw("p");
legend->AddEntry(graph6, legendEntry6.data(), "p");
}
legend->Draw();
TPaveText* label = 0;
if ( title.Length() > 0 ) {
label = new TPaveText(0.175, 0.925, 0.48, 0.98, "NDC");
label->AddText(title.Data());
label->SetTextAlign(13);
label->SetTextSize(0.045);
label->SetFillStyle(0);
label->SetBorderSize(0);
label->Draw();
}
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete legend;
delete label;
delete dummyHistogram;
delete canvas;
}
//------------------------------------------------------------------------------
//Subtraction
//------------------------------------------------------------------------------
void Subtraction(TString hname,
TString xtitle,
Int_t ngroup = -1,
Int_t precision = 1,
TString units = "NULL",
Double_t xmin = -999,
Double_t xmax = 999,
Bool_t moveOverflow = true)
{
TCanvas* canvas = new TCanvas(hname, hname, 800, 800);
TPad* pad1 = new TPad("pad1", "pad1", 0, 0.0, 1, 1.0);
pad1->SetTopMargin (0.08);
//pad1->SetBottomMargin(0.02);
pad1->Draw();
//----------------------------------------------------------------------------
// pad1
//----------------------------------------------------------------------------
pad1->cd();
pad1->SetLogy(_setLogy);
TH1F* hist[nProcesses];
for (UInt_t ip=0; ip<nProcesses; ip++) {
hist[ip] = (TH1F*)input[ip]->Get(hname);
hist[ip]->SetName(hname + process[ip]);
if (moveOverflow) MoveOverflowBins (hist[ip], xmin, xmax);
else ZeroOutOfRangeBins(hist[ip], xmin, xmax);
if (ngroup > 0) hist[ip]->Rebin(ngroup);
if (_dataDriven && ip == iWW) hist[ip]->Scale(WWScale[_njet]);
if (_dataDriven && ip == iDY) hist[ip]->Scale(ZjScale[_njet]);
if (_dataDriven && ip == iDYtau) hist[ip]->Scale(ZjScale[_njet]);
}
// Data subtraction for Top background estimation
//----------------------------------------------------------------------------
TH1F* subData = (TH1F*)hist[iData]->Clone("subData");
for (UInt_t ip=0; ip<nProcesses; ip++) {
if (ip == itt) continue;
if (ip == itW) continue;
if (ip == iData ) continue;
subData->Add(hist[ip],-1);
}
subData->SetLineColor(kRed+1);
Double_t subData_Yield = subData->Integral();
//subData->SetLineColor();
// Top background
//----------------------------------------------------------------------------
TH1F* Top = (TH1F*)hist[itt]->Clone("Top");
Top->Add(hist[itW]);
Top->SetLineColor(kBlue+1);
Double_t Top_Yield = Top->Integral();
// Axis labels
//----------------------------------------------------------------------------
TAxis* xaxis = subData->GetXaxis();
TAxis* yaxis = subData->GetYaxis();
TString ytitle = Form("entries / %s.%df", "%", precision);
xaxis->SetTitle(xtitle);
yaxis->SetTitle(Form(ytitle.Data(), subData->GetBinWidth(0)));
yaxis->SetTitleOffset(1.6);
if (!units.Contains("NULL")) {
xaxis->SetTitle(Form("%s [%s]", xaxis->GetTitle(), units.Data()));
yaxis->SetTitle(Form("%s %s", yaxis->GetTitle(), units.Data()));
}
// Draw
//----------------------------------------------------------------------------
xaxis->SetRangeUser(xmin, xmax);
subData->Draw("hist");
Top->Draw("hist same");
// Adjust scale
//----------------------------------------------------------------------------
subData->SetMinimum(0.0);
Float_t theMax = GetMaximumIncludingErrors(subData, xmin, xmax);
Float_t theMaxMC = GetMaximumIncludingErrors(Top, xmin, xmax);
if (theMaxMC > theMax) theMax = theMaxMC;
if (pad1->GetLogy()) {
theMax = TMath::Power(10, TMath::Log10(theMax) + 2.7);
subData->SetMinimum(0.05);
}
else theMax *= 1.55;
subData->SetMaximum(theMax);
// Legend
//----------------------------------------------------------------------------
Double_t x0 = 0.720;
Double_t y0 = 0.834;
Double_t yoffset = 0.048;
Double_t delta = yoffset + 0.001;
Double_t ndelta = 0;
DrawLegend(x0 - 0.49, y0 - ndelta, subData, Form(" Data Subtraction (MC without Top) (%.0f)", Yield(subData)), "l", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, Top, Form(" Top (%.0f)", Yield(Top)), "l", 0.03, 0.2, yoffset); ndelta += delta;
// Additional titles
//----------------------------------------------------------------------------
//TString channelLabel = "ee/#mu#mu/e#mu/#mue";
TString channelLabel = "";
//if (_channel == "EE") channelLabel = "ee";
//if (_channel == "MuMu") channelLabel = "#mu#mu";
//if (_channel == "EMu") channelLabel = "e#mu";
//if (_channel == "MuE") channelLabel = "#mue";
//if (_channel == "SF") channelLabel = "ee/#mu#mu";
//if (_channel == "OF") channelLabel = "e#mu/#mue";
channelLabel += Form(" %d", _njet);
if (_njet == 0) channelLabel += "-jets";
if (_njet == 1) channelLabel += "-jet";
if (_njet >= 2) channelLabel += "-jets";
DrawTLatex(0.185, 0.975, 0.05, 13, channelLabel.Data(),"");
DrawTLatex(0.940, 0.983, 0.05, 33, Form("L = %.1f fb^{-1}", _luminosity/1e3),"");
if (Top_Yield!=0){
cout << "subData_Yield = "<<subData_Yield<<", Top_Yield = "<<Top_Yield<<", Ratio = "<< subData_Yield/Top_Yield <<endl;
TLatex *tex3 = new TLatex(0.250, 0.75, "Scale Factor");
tex3->SetNDC();
tex3->SetTextSize(0.035);
tex3->Draw();
TLatex *tex4 = new TLatex(0.250, 0.7, Form("%.0f / %.0f = %3.3f",subData_Yield ,Top_Yield ,subData_Yield/Top_Yield));
tex4->SetNDC();
tex4->SetTextSize(0.035);
tex4->Draw();
}
// Save
//----------------------------------------------------------------------------
pad1->cd();
//SetAxis(subData, "", subData->GetYaxis()->GetTitle(), 0.05, 1.6);
canvas->cd();
TString suffixLogy = (_setLogy) ? "_Log" : "_Lin";
canvas->SaveAs(Form("%s/%s%s_sub.%s",
_output.Data(),
hname.Data(),
suffixLogy.Data(),
_format.Data()));
}
void showGraphs(const TString& title, double canvasSizeX, double canvasSizeY,
TGraph* graph1, const std::string& legendEntry1,
TGraph* graph2, const std::string& legendEntry2,
TGraph* graph3, const std::string& legendEntry3,
TGraph* graph4, const std::string& legendEntry4,
TGraph* graph5, const std::string& legendEntry5,
TGraph* graph6, const std::string& legendEntry6,
double xMin, double xMax, unsigned numBinsX, const std::string& xAxisTitle, double xAxisOffset,
double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
double legendX0, double legendY0,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.12);
canvas->SetBottomMargin(0.12);
int colors[6] = { 1, 2, 3, 4, 6, 7 };
int markerStyles[6] = { 22, 32, 20, 24, 21, 25 };
TLegend* legend = new TLegend(legendX0, legendY0, legendX0 + 0.44, legendY0 + 0.20, "", "brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
TH1* dummyHistogram = new TH1D("dummyHistogram", "dummyHistogram", numBinsX, xMin, xMax);
dummyHistogram->SetTitle("");
dummyHistogram->SetStats(false);
dummyHistogram->SetMinimum(yMin);
dummyHistogram->SetMaximum(yMax);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(xAxisOffset);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(yAxisOffset);
dummyHistogram->Draw("axis");
graph1->SetLineColor(colors[0]);
graph1->SetLineWidth(2);
graph1->Draw("L");
legend->AddEntry(graph1, legendEntry1.data(), "l");
if ( graph2 ) {
graph2->SetLineColor(colors[1]);
graph2->SetLineWidth(2);
graph2->Draw("L");
legend->AddEntry(graph2, legendEntry2.data(), "l");
}
if ( graph3 ) {
graph3->SetLineColor(colors[2]);
graph3->SetLineWidth(2);
graph3->Draw("L");
legend->AddEntry(graph3, legendEntry3.data(), "l");
}
if ( graph4 ) {
graph4->SetLineColor(colors[3]);
graph4->SetLineWidth(2);
graph4->Draw("L");
legend->AddEntry(graph4, legendEntry4.data(), "l");
}
if ( graph5 ) {
graph5->SetLineColor(colors[4]);
graph5->SetLineWidth(2);
graph5->Draw("L");
legend->AddEntry(graph5, legendEntry5.data(), "l");
}
if ( graph6 ) {
graph6->SetLineColor(colors[5]);
graph6->SetLineWidth(2);
graph6->Draw("L");
legend->AddEntry(graph6, legendEntry6.data(), "l");
}
legend->Draw();
TPaveText* label = 0;
if ( title.Length() > 0 ) {
label = new TPaveText(0.175, 0.925, 0.48, 0.98, "NDC");
label->AddText(title.Data());
label->SetTextAlign(13);
label->SetTextSize(0.045);
label->SetFillStyle(0);
label->SetBorderSize(0);
label->Draw();
}
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
delete legend;
delete label;
delete dummyHistogram;
delete canvas;
}
void plot_ZJetBalance( int index, std::string JetResponseFilename,
Float_t genMean[], Float_t genSigma[],
Float_t recoMean[], Float_t recoSigma[]) {
////////////// Defining the L3JetCorrector ///////////////////////
double p[6];
p[0] = 10.0;
p[1] = 800.0;
// // with MEAN response
// p[2] = 0.953124;
// p[3] = 4.87151;
// p[4] = 2.83723;
// p[5] = 2.91468;
// // with MPV response
// p[2] = 0.978755;
// p[3] = 2.1759;
// p[4] = 2.25031;
// p[5] = 0.0;
// // with TruncMEAN 2 sigma response
// p[2] = 1.00299;
// p[3] = 3.83695;
// p[4] = 2.87351;
// p[5] = 1.6071;
// // with TruncMEAN 1.5 sigma response
p[2] = 1.00299;
p[3] = 3.83695;
p[4] = 2.87351;
p[5] = 1.6071;
// // with TruncMEAN 1.5 sigma iterative 3 times
// p[2] = 1.16793;
// p[3] = 8.8575;
// p[4] = 5.01816;
// p[5] = 5.03132;
// // with TruncMEAN 1.5 sigma iterative n times
// p[2] = 1.23392;
// p[3] = 9.33578;
// p[4] = 5.60468;
// p[5] = 5.52937;
// // with TruncMEAN 1 sigma response
// p[2] = 0.690152;
// p[3] = 2.97111;
// p[4] = 1.70586;
// p[5] = 0.72181;
// // with MPV: when p[5] is allowed to go negative
// p[2] = 0.893141;
// p[3] = 0.00355417;
// p[4] = 0.0123656;
// p[5] = -1.00176;
// // from dijet MC truth
// p[2] = 0.996998;
// p[3] = 4.39412;
// p[4] = 2.96134;
// p[5] = 1.69966;
if(storeResponsHistogramsInRootFile == true) {
TFile respHistFile(JetResponseFilename.c_str(),"RECREATE");
}
TH1F* responseHistGen[nZPtBins];
TH1F* responseHistReco[nZPtBins];
TH1F* genJetpt[nZPtBins];
TH1F* recoZpt[nZPtBins];
TH1F* caloJetpt[nZPtBins];
TH1F* Zpt[nZPtBins];
for(int i=0; i<nZPtBins; i++) {
responseHistGen[i] = new TH1F(TString("responseHistGen_")+ptBin[i],
"",40, 0.0, 2.0);
TAxis* responseHistGenx = responseHistGen[i]->GetXaxis();
TAxis* responseHistGeny = responseHistGen[i]->GetYaxis();
responseHistGenx->SetTitle("p_{T}^{jet} / p_{T}^{Z} ");
responseHistGeny->SetTitle("Events / 0.05");
responseHistGeny->SetTitleOffset(1.4);
responseHistGenx->SetNdivisions(505);
responseHistGeny->SetNdivisions(505);
responseHistReco[i] = new TH1F(TString("responseHistReco_")+ptBin[i],
"",40,0.0,2.0);
responseHistReco[i]->SetLineColor(2);
responseHistReco[i]->SetMarkerColor(2);
genJetpt[i] = new TH1F(TString("genJetpt_")+ptBin[i],
"", 140, 0, 800);
caloJetpt[i] = new TH1F(TString("caloJetpt_")+ptBin[i],
"", 140, 0, 800);
recoZpt[i] = new TH1F(TString("recoZpt_")+ptBin[i],
"", 140, 0, 800);
responseHistReco[i]->Sumw2();
responseHistGen[i]->Sumw2();
genJetpt[i]->Sumw2();
caloJetpt[i]->Sumw2();
recoZpt[i]->Sumw2();
}
for (Long64_t entry =0; entry < mychain->GetEntries(); entry++) {
mychain->GetEntry(entry);
if(entry%100000==0) std::cout<<"**** Event # "<< entry <<std::endl;
// Fill generator level quantities
int leadGenIndex=-1, secondGenIndex=-1;
FindLeadIndex(JetGenPt[index], JetGenEta[index], JetGenPhi[index],
eMinusEtaGen, eMinusPhiGen,
ePlusEtaGen, ePlusPhiGen, leadGenIndex, secondGenIndex);
if(leadGenIndex !=-1 && secondGenIndex !=-1 &&
(ePlusPtGen>20.0) && (eMinusPtGen>20.0) &&
((fabs(ePlusEtaGen)<1.4442) ||
(fabs(ePlusEtaGen)>1.560 && fabs(ePlusEtaGen)<2.5)) &&
((fabs(eMinusEtaGen)<1.4442) ||
(fabs(eMinusEtaGen)>1.560 && fabs(eMinusEtaGen)<2.5)) &&
(fabs(JetGenEta[index][leadGenIndex])<1.3) ) {
float leadGenJetPt = JetGenPt[index][leadGenIndex];
float secondGenJetPt = JetGenPt[index][secondGenIndex];
double wt = GetWeight( mychain->GetFile()->GetName() );
double ptRatioGen = (double) leadGenJetPt/ (double) Z_PtGen;
if((double) secondGenJetPt/(double) Z_PtGen < 0.1) {
for(int bin=0; bin<nZPtBins; bin++) { //begin Z pT bin loop
if( (Z_PtGen > theZPt[bin]) && (Z_PtGen < theZPt[bin+1]) ) {
responseHistGen[bin]->Fill( ptRatioGen, wt );
genJetpt[bin]->Fill(leadGenJetPt, wt );
} // end if loop
} // end Z pT loop
}
}
// Fill reco level quantities
int leadRecoIndex=-1, secondRecoIndex=-1;
FindLeadIndex(JetRecoPt[index], JetRecoEta[index], JetRecoPhi[index],
eMinusEta, eMinusPhi,
ePlusEta, ePlusPhi, leadRecoIndex, secondRecoIndex);
if(leadRecoIndex !=-1 && secondRecoIndex !=-1) {
float leadRecoJetPt;
float secondRecoJetPt;
float leadRecoJetEta;
double dPhiReco;
double L3scale = 1.0;
double apt = JetRecoPt[index][leadRecoIndex];
if( apt< p[0] ) apt = p[0];
if( apt> p[1] ) apt = p[1];
double log10pt = log10(apt);
double result = p[2]+p[3]/(pow(log10pt,p[4])+p[5]);
if(usingCorrectedCaloJetPt) L3scale = result;
leadRecoJetPt = L3scale * JetRecoPt[index][leadRecoIndex];
secondRecoJetPt = JetRecoPt[index][secondRecoIndex];
leadRecoJetEta = JetRecoEta[index][leadRecoIndex];
dPhiReco = dPhi(JetRecoPhi[index][leadRecoIndex], Z_Phi);
bool pass = BoolCutResult( Z_Pt, mZee, eMinusPt, eMinusEta, ePlusPt,
ePlusEta, eMinus_trackiso, ePlus_trackiso,
eMinus_ecaliso, ePlus_ecaliso,
eMinus_hcaliso, ePlus_hcaliso,
iseMinusLoose, isePlusLoose,
leadRecoJetPt, leadRecoJetEta,
secondRecoJetPt, dPhiReco);
if( ! pass ) continue;
double wt = GetWeight( mychain->GetFile()->GetName() );
double ptRatioReco = (double) leadRecoJetPt/ (double) Z_Pt;
for(int bin=0; bin<nZPtBins; bin++) { //begin Z pT bin loop
if( (Z_Pt > theZPt[bin]) && (Z_Pt < theZPt[bin+1]) ) {
responseHistReco[bin]->Fill( ptRatioReco, wt );
caloJetpt[bin]->Fill(leadRecoJetPt, wt );
recoZpt[bin]->Fill( Z_Pt, wt );
} // end if loop
} // end Z pT loop
}
} // end TTree loop
// Fill the mean and error vectors
for(int i=0; i<nZPtBins; i++) {
if(ScaleToLuminosity) {
for(int j=0; j<40; j++) {
double err = sqrt( responseHistReco[i]->GetBinContent(j));
responseHistReco[i]->SetBinError(j, err);
err = sqrt( responseHistGen[i]->GetBinContent(j));
responseHistGen[i]->SetBinError(j, err);
}
}
genMean[i] = (Float_t) responseHistGen[i]->GetMean(1);
genSigma[i] = (Float_t) responseHistGen[i]->GetMean(11);
recoMean[i] = (Float_t) responseHistReco[i]->GetMean(1);
recoSigma[i] = (Float_t) responseHistReco[i]->GetMean(11);
}
// plot the pT balance response histograms
if(makeplot_ZptBalance==true) {
for(int i=0; i<nZPtBins; i++) {
TString plotname = Form("ptBalance-allCuts_%d_%d", (int) theZPt[i],
(int) theZPt[i+1] );
PlotOnCanvas( *responseHistGen[i], *responseHistReco[i], plotname);
}
}
// Now write all the histograms in a ROOT file
if(storeResponsHistogramsInRootFile == true) {
respHistFile.cd();
for(int i=0; i<nZPtBins; i++) {
responseHistGen[i]->Write();
responseHistReco[i]->Write();
genJetpt[i]->Write();
caloJetpt[i]->Write();
recoZpt[i]->Write();
}
respHistFile.Close();
}
// clean up the memory
delete [] responseHistGen;
delete [] responseHistReco;
delete [] genJetpt;
delete [] caloJetpt;
delete [] recoZpt;
}
void makeTable( int num )
{
// TString rootfilename;
// if(num<9) rootfilename = Form("root_electroneff_%d_eta_et.root", num);
// else if(num<17) rootfilename = Form("root_electroneff_10%d_eta_et.root", num-8);
// else if(num<25) rootfilename = Form("root_electroneff_20%d_eta_et.root", num-16);
// else if(num<33) rootfilename = Form("root_electroneff_30%d_eta_et.root", num-24);
// else rootfilename = Form("root_electroneff_40%d_eta_et.root", num-32);
TString rootfilename;
if(num==0) rootfilename = "root_electroneff_WenuOff_eta_et.root";
if(num==1) rootfilename = "root_electroneff_WenuOn_eta_et.root";
if(num==2) rootfilename = "root_electroneff_ZeeOff_eta_et.root";
if(num==3) rootfilename = "root_electroneff_ZeeOn_eta_et.root";
TString pname = "";
if(num==0) pname = "WenuOff-";
if(num==1) pname = "WenuOn-";
if(num==2) pname = "ZeeOff-";
if(num==3) pname = "ZeeOn-";
// if(num==1) pname = "WenuSelection-A1";
// if(num==2) pname = "WenuSelection-A2";
// if(num==3) pname = "WenuSelection-A3";
// if(num==4) pname = "WenuSelection-B1";
// if(num==5) pname = "WenuSelection-B2";
// if(num==6) pname = "WenuSelection-B3";
// if(num==7) pname = "ZeeSelection-A";
// if(num==8) pname = "ZeeSelection-B";
// if(num==9) pname = "WenuSelection-A1-noId-";
// if(num==10) pname = "WenuSelection-A2-noId-";
// if(num==11) pname = "WenuSelection-A3-noId-";
// if(num==12) pname = "WenuSelection-B1-noId-";
// if(num==13) pname = "WenuSelection-B2-noId-";
// if(num==14) pname = "WenuSelection-B3-noId-";
// if(num==15) pname = "ZeeSelection-A-noId-";
// if(num==16) pname = "ZeeSelection-B-noId-";
// if(num==17) pname = "WenuSelection-A1-noTrackIso-";
// if(num==18) pname = "WenuSelection-A2-noTrackIso-";
// if(num==19) pname = "WenuSelection-A3-noTrackIso-";
// if(num==20) pname = "WenuSelection-B1-noTrackIso-";
// if(num==21) pname = "WenuSelection-B2-noTrackIso-";
// if(num==22) pname = "WenuSelection-B3-noTrackIso-";
// if(num==23) pname = "ZeeSelection-A-noTrackIso-";
// if(num==24) pname = "ZeeSelection-B-noTrackIso-";
// if(num==25) pname = "WenuSelection-A1-noIso-";
// if(num==26) pname = "WenuSelection-A2-noIso-";
// if(num==27) pname = "WenuSelection-A3-noIso-";
// if(num==28) pname = "WenuSelection-B1-noIso-";
// if(num==29) pname = "WenuSelection-B2-noIso-";
// if(num==30) pname = "WenuSelection-B3-noIso-";
// if(num==31) pname = "ZeeSelection-A-noIso-";
// if(num==32) pname = "ZeeSelection-B-noIso-";
// if(num==33) pname = "WenuSelection-A1-noSigmaEtaEta-";
// if(num==34) pname = "WenuSelection-A2-noSigmaEtaEta-";
// if(num==35) pname = "WenuSelection-A3-noSigmaEtaEta-";
// if(num==36) pname = "WenuSelection-B1-noSigmaEtaEta-";
// if(num==37) pname = "WenuSelection-B2-noSigmaEtaEta-";
// if(num==38) pname = "WenuSelection-B3-noSigmaEtaEta-";
// if(num==39) pname = "ZeeSelection-A-noSigmaEtaEta-";
// if(num==40) pname = "ZeeSelection-B-noSigmaEtaEta-";
TString label = TString("electroneff-") + pname;
gROOT->ProcessLine(".L tdrstyleNew.C");
setTDRStyle();
tdrStyle->SetPadLeftMargin(0.16);
tdrStyle->SetPadRightMargin(0.1);
tdrStyle->SetPadTopMargin(0.08);
tdrStyle->SetLegendBorderSize(0);
TFile* myhistos = new TFile(rootfilename);
TH1F* h0 = (TH1F*) myhistos->Get("sbs_eff_EtDet");
TH1F* h1 = (TH1F*) myhistos->Get("sbs_eff_EtaDet");
TH2F* h2 = (TH2F*) myhistos->Get("sbs_eff_EtDet_EtaDet");
// TH1F *base = (TH1F*)f.Get("base");
// TH1F *destination = (TH1F*)f.Get("destination");
// TGraphAsymmErrors *g1 = new TGraphAsymmErrors();
// g1->BayesDivide(destination, base, "");
// g1->GetYaxis()->SetRangeUser(0.5, 1.05);
h0->SetMarkerStyle(20);
h1->SetMarkerStyle(20);
ScaleTo10pb( *h0 );
ScaleTo10pb( *h1 );
// TH1F* h01 = (TH1F*) myhistos->Get("fit_eff_Et");
// TH1F* h11 = (TH1F*) myhistos->Get("fit_eff_Eta");
// h01->SetMarkerColor(4);
// h01->SetLineColor(4);
// h11->SetMarkerColor(4);
// h11->SetLineColor(4);
// ScaleTo10pb( *h01 );
// ScaleTo10pb( *h11 );
TH1F* h02 = (TH1F*) myhistos->Get("truth_eff_EtDet");
TH1F* h12 = (TH1F*) myhistos->Get("truth_eff_EtaDet");
h02->SetMarkerColor(2);
h02->SetLineColor(2);
h02->SetMarkerStyle(24);
h12->SetMarkerColor(2);
h12->SetLineColor(2);
h12->SetMarkerStyle(24);
ScaleTo10pb( *h02 );
ScaleTo10pb( *h12 );
TAxis* xaxis = h0->GetXaxis();
TAxis* yaxis = h0->GetYaxis();
xaxis->SetTitle("E_{T} (GeV)");
xaxis->SetTitleSize(0.04);
xaxis->SetTitleOffset(1.3);
xaxis->SetNdivisions(505);
yaxis->SetTitle("Efficiency ");
yaxis->SetTitleSize(0.04);
yaxis->SetTitleOffset(1.6);
h0->SetMinimum(0.5);
h0->SetMaximum(1.1);
TAxis* xaxis = h1->GetXaxis();
TAxis* yaxis = h1->GetYaxis();
xaxis->SetTitle("#eta");
xaxis->SetTitleSize(0.04);
xaxis->SetTitleOffset(1.3);
xaxis->SetNdivisions(505);
yaxis->SetTitle("Efficiency ");
yaxis->SetTitleSize(0.04);
yaxis->SetTitleOffset(1.6);
h1->SetMinimum(0.5);
h1->SetMaximum(1.1);
TAxis* xaxis = h2->GetXaxis();
TAxis* yaxis = h2->GetYaxis();
xaxis->SetTitle("E_{T} (GeV)");
xaxis->SetTitleSize(0.04);
xaxis->SetTitleOffset(1.3);
xaxis->SetNdivisions(505);
yaxis->SetTitle("#eta ");
yaxis->SetTitleSize(0.04);
yaxis->SetTitleOffset(1.7);
double l1 = 0.2, l2 =0.3;
double p1 = 0.5;
if(num==0) p1 = 0.82;
if(num==2) p1 = 0.4;
TCanvas* can0 = new TCanvas("can0", "", 500, 500);
gStyle->SetOptStat(0);
h0->Draw("e");
// h01->Draw("esame");
h02->Draw("esame");
leg_hist = new TLegend(0.3, l1, 0.8, l2);
leg_hist->AddEntry( h0,"Sideband subtracted","P");
// leg_hist->AddEntry( h01,"fit","le");
leg_hist->AddEntry( h02,"Monte Carlo truth","P");
leg_hist->SetFillColor(0);
leg_hist->SetMargin(0.15);
leg_hist->Draw();
TLatex* CMS = new TLatex();
CMS->SetTextAlign(12);
CMS->SetTextSize(0.04);
CMS->SetNDC();
CMS->DrawLatex(0.25, p1, "CMS Preliminary, #intLdt = 10 pb^{-1}");
can0->Update();
can0->SaveAs( label+TString("et.eps") );
can0->SaveAs( label+TString("et.gif") );
can0->SaveAs( label+TString("et.root") );
can0->SaveAs( label+TString("et.pdf") );
p1 = 0.5;
if(num==0 || num==2) p1 = 0.82;
TCanvas* can1 = new TCanvas("can1", "", 500, 500);
gStyle->SetOptStat(0);
h1->Draw("e");
// h11->Draw("esame");
h12->Draw("esame");
leg_hist = new TLegend(0.3,l1,0.8,l2);
leg_hist->AddEntry( h1,"Sideband subtracted","P");
// leg_hist->AddEntry( h11,"fit","le");
leg_hist->AddEntry( h12,"Monte Carlo truth","P");
leg_hist->SetFillColor(0);
leg_hist->SetMargin(0.15);
leg_hist->Draw();
TLatex* CMS2 = new TLatex();
CMS2->SetTextAlign(12);
CMS2->SetTextSize(0.04);
CMS2->SetNDC();
CMS2->DrawLatex(0.25,p1,"CMS Preliminary, #intLdt = 10 pb^{-1}");
can1->Update();
can1->SaveAs( label+TString("eta.eps") );
can1->SaveAs( label+TString("eta.gif") );
can1->SaveAs( label+TString("eta.root") );
can1->SaveAs( label+TString("eta.pdf") );
tdrStyle->SetPadRightMargin(0.2);
TCanvas* can2 = new TCanvas("can2", "", 500, 500);
gStyle->SetOptStat(0);
h2->Draw("colz");
can2->SaveAs( label+TString("et_eta.eps") );
can2->SaveAs( label+TString("et_eta.gif") );
can2->SaveAs( label+TString("et_eta.root") );
can2->SaveAs( label+TString("et_eta.pdf") );
delete can0;
delete can1;
delete can2;
delete myhistos;
}
void draw() {
gROOT->Reset();
// first make a canvas and a 2D histogram for the axes
TCanvas* canvas = new TCanvas("canvas", "canvas", 10, 10, 500, 500);
canvas->SetFillColor(0);
canvas->SetBorderMode(0);
canvas->SetFrameBorderMode(0); // need this to turn off red hist frame!
gROOT->SetStyle("Plain");
canvas->UseCurrentStyle();
gPad->SetLeftMargin(0.15);
gPad->SetRightMargin(0.05);
gPad->SetTopMargin(0.07);
gPad->SetBottomMargin(0.17);
gStyle->SetOptStat(0);
gStyle->SetTitleBorderSize(0);
gStyle->SetTitleSize(0.04);
gStyle->SetTextFont(42);
gStyle->SetTextSize(0.04);
gStyle->SetTitleFont(42, "hxy"); // for histogram and axis title
gStyle->SetLabelFont(42, "xyz"); // for axis labels (values)
gStyle->SetTitleOffset(0.8, "h"); // what does this do?
gStyle->SetTitleX(0.15);
gStyle->SetTitleY(0.99);
gROOT->ForceStyle();
// can make histogram or alternatively use the histograms automatically
// connected to the TF1 or TGraph objects
double xMin = 0.1;
double xMax = 100.;
// double yMin = 0.1;
// double yMax = 10.;
double yMin = 0.;
double yMax = 8.;
TH2F* axhist = new TH2F("axhist", "title", 10, xMin, xMax, 10, yMin, yMax);
axhist->SetTitle("");
axhist->SetXTitle("b");
axhist->SetYTitle("med[Z|s]");
gPad->SetLogx(1);
gPad->SetLogy(0);
double u[20];
double x[20][500];
// Read in data from file and insert in TTree
TString fileName;
// cout << "Enter file name: ";
// cin >> fileName;
fileName = "medsig_s5_rel_bi.txt";
ifstream inFile;
inFile.open(fileName);
if (inFile.fail()) {
cout << "Couldn't open file!" << endl;
exit(1);
}
bool readLine = true;
int lineNum = 0;
int ncol;
while ( readLine ){
TString line;
stringstream ss;
line.ReadLine(inFile);
readLine = inFile.good();
if ( readLine ) {
TString firstChar = line(0,1);
bool useLine = firstChar != "#";
if ( useLine ){
int i = 0;
stringstream ss;
ss << line; // put whole line into ss
TString token;
bool getToken = true;
while ( getToken ) {
ss >> token; // extracts one token
if ( token.Length() > 0 ) {
u[i] = token.Atof();
i++;
}
else {
getToken = false;
}
} // getToken
ncol = i;
for (int i=0; i<ncol; i++){
x[i][lineNum] = u[i];
}
lineNum++;
} // useLine
} // readLine
} // readLine
int n = lineNum;
inFile.close();
// for (int i=0; i<n; i++){
// cout << i << " " << x[0][i] << " " << x[3][i] << " "
// << x[4][i] << endl;
// }
TGraph* tg1 = new TGraph(n, x[0], x[1]);
TGraph* tg2 = new TGraph(n, x[0], x[2]);
TGraph* tg3 = new TGraph(n, x[0], x[3]);
TGraph* tg4 = new TGraph(n, x[0], x[4]);
TGraph* tg5 = new TGraph(n, x[0], x[5]);
TGraph* tg6 = new TGraph(n, x[0], x[6]);
TGraph* tg7 = new TGraph(n, x[0], x[7]);
TGraph* tg8 = new TGraph(n, x[0], x[8]);
TGraph* tg9 = new TGraph(n, x[0], x[9]);
TGraph* tg10 = new TGraph(n, x[0], x[10]);
TGraph* tg11 = new TGraph(n, x[0], x[11]);
TGraph* tg12 = new TGraph(n, x[0], x[12]);
TGraph* tg13 = new TGraph(n, x[0], x[13]);
TGraph* tg14 = new TGraph(n, x[0], x[14]);
TGraph* tg15 = new TGraph(n, x[0], x[15]);
TAxis* xa = axhist->GetXaxis();
TAxis* ya = axhist->GetYaxis();
xa->SetTitleOffset(1.2); // factor multiplies default offset
ya->SetTitleOffset(1.1);
xa->SetLabelOffset(0.005);
ya->SetLabelOffset(0.005);
xa->SetTickLength(0.015); // default = 0.03
ya->SetTickLength(0.015); // default = 0.03
xa->SetTitleSize(0.05);
ya->SetTitleSize(0.05);
// gPad->SetLogx(1);
// xa->SetLimits(90., 700.);
xa->SetNdivisions(-5); // negative value should force number of divisions?
ya->SetNdivisions(-4);
xa->SetLabelSize(0.05);
ya->SetLabelSize(0.05);
// Draw axes and then add stuff
// kDot=1, kPlus, kStar, kCircle=4, kMultiply=5,
// kFullDotSmall=6, kFullDotMedium=7, kFullDotLarge=8,
// kFullCircle=20, kFullSquare=21, kFullTriangleUp=22,
// kFullTriangleDown=23, kOpenCircle=24, kOpenSquare=25,
// kOpenTriangleUp=26, kOpenDiamond=27, kOpenCross=28,
// kFullStar=29, kOpenStar=30
axhist->Draw();
tg1->SetLineColor(kRed);
tg1->SetLineWidth(2);
tg1->SetLineStyle(2);
tg1->SetMarkerColor(kRed);
tg1->SetMarkerSize(0.8);
tg1->SetMarkerStyle(20);
tg1->Draw("L,same"); // or P for points
tg2->SetLineColor(kRed);
tg2->SetLineWidth(2);
tg2->SetLineStyle(2);
tg2->SetMarkerColor(kRed);
tg2->SetMarkerSize(0.8);
tg2->SetMarkerStyle(20);
tg2->Draw("L,same"); // or P for points
tg3->SetLineColor(kRed);
tg3->SetLineWidth(2);
tg3->SetLineStyle(2);
tg3->SetMarkerColor(kRed);
tg3->SetMarkerSize(0.8);
tg3->SetMarkerStyle(20);
// tg3->Draw("L,same"); // or P for points
tg4->SetLineColor(kBlue);
tg4->SetLineWidth(2);
tg4->SetLineStyle(1);
tg4->SetMarkerColor(kBlue);
tg4->SetMarkerSize(0.8);
tg4->SetMarkerStyle(20);
tg4->Draw("L,same"); // or P for points
tg5->SetLineColor(kBlue);
tg5->SetLineWidth(2);
tg5->SetLineStyle(1);
tg5->SetMarkerColor(kBlue);
tg5->SetMarkerSize(0.8);
tg5->SetMarkerStyle(20);
tg5->Draw("L,same"); // or P for points
tg6->SetLineColor(kBlue);
tg6->SetLineWidth(2);
tg6->SetLineStyle(1);
tg6->SetMarkerColor(kBlue);
tg6->SetMarkerSize(0.8);
tg6->SetMarkerStyle(20);
// tg6->Draw("L,same"); // or P for points
tg7->SetLineColor(kRed);
tg7->SetLineWidth(2);
tg7->SetLineStyle(1);
tg7->SetMarkerColor(kRed);
tg7->SetMarkerSize(0.8);
tg7->SetMarkerStyle(21);
// tg7->Draw("P,same"); // or P for points
tg8->SetLineColor(kRed);
tg8->SetLineWidth(2);
tg8->SetLineStyle(1);
tg8->SetMarkerColor(kRed);
tg8->SetMarkerSize(0.8);
tg8->SetMarkerStyle(21);
// tg8->Draw("P,same"); // or P for points
tg9->SetLineColor(kRed);
tg9->SetLineWidth(2);
tg9->SetLineStyle(2);
tg9->SetMarkerColor(kRed);
tg9->SetMarkerSize(0.8);
tg9->SetMarkerStyle(21);
// tg9->Draw("P,same"); // or P for points
tg10->SetLineColor(kBlack);
tg10->SetLineWidth(2);
tg10->SetLineStyle(2);
tg10->SetMarkerColor(kBlack);
tg10->SetMarkerSize(0.8);
tg10->SetMarkerStyle(20);
tg10->Draw("P,same"); // or P for points
tg11->SetLineColor(kBlack);
tg11->SetLineWidth(2);
tg11->SetLineStyle(2);
tg11->SetMarkerColor(kBlack);
tg11->SetMarkerSize(0.8);
tg11->SetMarkerStyle(20);
tg11->Draw("P,same"); // or P for points
tg12->SetLineColor(kBlack);
tg12->SetLineWidth(2);
tg12->SetLineStyle(2);
tg12->SetMarkerColor(kBlack);
tg12->SetMarkerSize(0.8);
tg12->SetMarkerStyle(20);
// tg12->Draw("P,same"); // or P for points
tg13->SetLineColor(kBlack);
tg13->SetLineWidth(2);
tg13->SetLineStyle(3);
tg13->SetMarkerColor(kBlack);
tg13->SetMarkerSize(0.8);
tg13->SetMarkerStyle(20);
// tg13->Draw("L,same"); // or P for points
tg14->SetLineColor(kBlack);
tg14->SetLineWidth(2);
tg14->SetLineStyle(3);
tg14->SetMarkerColor(kBlack);
tg14->SetMarkerSize(0.8);
tg14->SetMarkerStyle(20);
// tg14->Draw("L,same"); // or P for points
tg15->SetLineColor(kBlack);
tg15->SetLineWidth(2);
tg15->SetLineStyle(3);
tg15->SetMarkerColor(kBlack);
tg15->SetMarkerSize(0.8);
tg15->SetMarkerStyle(20);
// tg15->Draw("L,same"); // or P for points
TLegend* leg = new TLegend(0.53, 0.48, 0.95, .73); // x1, y1, x2, y2
leg->SetTextSize(0.05);
leg->SetTextFont(42);
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->AddEntry(tg1, " s / #sqrt{b + #sigma_{b}^{2}}", "l");
leg->AddEntry(tg4, " Z_{A}", "l");
// leg->AddEntry(tg7, " #sqrt{q0}, MC median", "p");
leg->AddEntry(tg10, " Monte Carlo", "p");
// leg->AddEntry(tg13, " Z_{bi}" , "l");
// leg->AddEntry(tg4, "s = 0.03", "l");
leg->Draw();
TLatex* tl = new TLatex();
tl->SetTextAlign(11);
tl->SetTextSize(0.05);
tl->SetTextFont(42);
tl->SetNDC();
// tl->DrawLatex(.76, 0.33, "s = 2");
// tl->DrawLatex(.76, 0.465, "s = 5");
// tl->DrawLatex(.76, 0.6, "s = 10");
// tl->DrawLatex(.76, 0.73, "s = 20");
// tl->DrawLatex(.5, .77, "#sigma_{b}/b = 0.2, 0.5, 1");
tl->DrawLatex(.5, .77, "#sigma_{b}/b = 0.2, 0.5");
tl->DrawLatex(.5, .85, "s = 5");
// Fix idiotic problem with frame
TLine* tli = new TLine();
tli->SetLineStyle(1);
tli->SetLineWidth(1);
tli->DrawLine(xMin, yMin, xMax, yMin);
tli->DrawLine(xMax, yMin, xMax, yMax);
tli->DrawLine(xMin, yMax, xMax, yMax);
tli->DrawLine(xMin, yMin, xMin, yMax);
TPostScript psfile("medsig_s5_rel_bi.eps", 113); // 113 makes eps
canvas->Draw();
psfile.Close();
// canvas->Print("plot.gif", "gif");
}
void plot3(TString infile = "fp-d", TString pltmd = "cos") {
// CHECK FOR RIGHT INPUT ////////////////////////////////////////////////
string strpltmd = pltmd, filename = infile, strfile = infile;
if( (strpltmd.compare("cos") != 0 ) &&
(strpltmd.compare("sin") != 0 ) &&
(strpltmd.compare("tan") != 0 ) &&
(strpltmd.compare("mmp") != 0 ) ) {error(4);};
// GLOBAL VARIABLES ////////////////////////////////////////////////////
Int_t file, point, color, style;
Float_t fits2b, fittph, tphold, fitsph, fitcph, fitx, fitxmin, fitxmax = -1.0;
Float_t xVal, yVal;
Float_t xMin = 100000, xMax = -1.0, yMin = 100000, yMax = -1.0;
Float_t MZ, MW, Mmin = 100000;
Float_t Cz1, Cz2, Cz3, Cw1, Cw2, Cw3, Cw4, C1, C2;
Float_t phiMin, phiMax, cphmin, cphmax, sphmin, sphmax;
// CUSTOMIZE PLOT ///////////////////////////////////////////////////////
gROOT->Reset();
gROOT->SetStyle("Plain");
gStyle->SetTitleBorderSize(0);
gStyle->SetPalette(1);
TCanvas *MyC = new TCanvas("MyC","Plot of the GAPP fit results",200,10,700,500);
Float_t mmlegxmin, mmlegxmax, mmlegymin, mmlegymax;
Float_t s2blegxmin, s2blegymin, s2blegxmax, s2blegymax;
Float_t lblxmin, lblxmax, lblymin, lblymax;
string plottitle = "Model: " + infile + " | Plot: ";
string xtitle, ytitle, NPleg, SMleg, display;
NPleg = "#font[52]{M_{H}^{(NP)}, #bar{m}_{t}^{(NP)}}";
SMleg = "#font[52]{M_{H}^{(SM)}, #bar{m}_{t}^{(SM)}}";
if (strpltmd.compare("tan") == 0) {
plottitle += "#font[42]{tan^{2}(#tilde{#phi}) over }#font[52]{#tilde{x}}#font[42]{.}";
xtitle = "#font[52]{#tilde{x}}";
ytitle = "#font[42]{tan^{2}(#tilde{#phi})}";
display = "C";
mmlegxmin = 0.15;
mmlegxmax = 0.30;
mmlegymin = 0.75;
mmlegymax = 0.85;
s2blegxmin = 0.15;
s2blegxmax = 0.40;
s2blegymin = 0.30;
s2blegymax = 0.50;
lblxmin = 0.88;
lblxmax = 0.88;
lblymin = 0.60;
lblymax = 0.65;
} else if (strpltmd.compare("cos") == 0) {
plottitle += "#font[42]{cos(#tilde{#phi}) over }#font[52]{#tilde{x}}#font[42]{.}";
xtitle = "#font[52]{#tilde{x}}";
ytitle = "#font[42]{cos(#tilde{#phi})}";
display = "C";
mmlegxmin = 0.70;
mmlegxmax = 0.85;
mmlegymin = 0.75;
mmlegymax = 0.85;
s2blegxmin = 0.15;
s2blegxmax = 0.40;
s2blegymin = 0.30;
s2blegymax = 0.50;
lblxmin = 0.65;
lblxmax = 0.80;
lblymin = 0.60;
lblymax = 0.65;
} else if (strpltmd.compare("sin") == 0) {
plottitle += "#font[42]{sin(#tilde{#phi}) over }#font[52]{#tilde{x}}#font[42]{.}";
xtitle = "#font[52]{#tilde{x}}";
ytitle = "#font[42]{sin(#tilde{#phi})}";
display = "C";
mmlegxmin = 0.15;
mmlegxmax = 0.30;
mmlegymin = 0.75;
mmlegymax = 0.85;
s2blegxmin = 0.60;
s2blegxmax = 0.85;
s2blegymin = 0.30;
s2blegymax = 0.50;
lblxmin = 0.65;
lblxmax = 0.80;
lblymin = 0.60;
lblymax = 0.65;
} else if (strpltmd.compare("mmp") == 0) {
plottitle += "#font[42]{Masses of the new heavy gauge bosons.}";
xtitle = "#font[52]{M_{Z'}}#font[42]{ (TeV)}";
ytitle = "#font[52]{M_{W'}}#font[42]{ (TeV)}";
display = "C";
mmlegxmin = 0.15;
mmlegxmax = 0.30;
mmlegymin = 0.75;
mmlegymax = 0.85;
s2blegxmin = 0.60;
s2blegxmax = 0.85;
s2blegymin = 0.45;
s2blegymax = 0.65;
lblxmin = 0.35;
lblxmax = 0.50;
lblymin = 0.45;
lblymax = 0.50;
};
// PREPARE BOSON MASSES AND PHI BOUNDS //////////////////////////////////
string mdl(filename,0,2);
if ( (mdl.compare("lr") == 0) ||
(mdl.compare("lp") == 0) ||
(mdl.compare("hp") == 0) ||
(mdl.compare("fp") == 0) ) {
phiMin = 5.600; phiMax = 84.400;
string Higgs(filename,3,1);
if (Higgs.compare("d") == 0) {
Cz1 = 11.95349795785275;
Cz2 = 30.63269990028513;
Cz3 = 42.58619785813789;
Cw1 = 21.29309892906894;
Cw2 = 9.339600971216193;
Cw3 = 30.63269990028513;
Cw4 = 42.58619785813789;
}
else if (Higgs.compare("t") == 0) {
Cz1 = 5.976748978926375;
Cz2 = 30.63269990028513;
Cz3 = 85.17239571627579;
Cw1 = 15.05649464522066;
Cw2 = 3.302047590161717;
Cw3 = 21.66058982554409;
Cw4 = 60.22597858088265;
}
}
else if ( (mdl.compare("uu") == 0) ||
(mdl.compare("nu") == 0) ) {
phiMin = 10.179, phiMax = 79.821;
C1 = 94.0397928463607;
C2 = 77.1253849720165;
} else {error(6);}
cphmin = cos(TMath::Pi()*phiMin/180.0)*cos(TMath::Pi()*phiMin/180.0);
cphmax = cos(TMath::Pi()*phiMax/180.0)*cos(TMath::Pi()*phiMax/180.0);
sphmin = sin(TMath::Pi()*phiMin/180.0)*sin(TMath::Pi()*phiMin/180.0);
sphmax = sin(TMath::Pi()*phiMax/180.0)*sin(TMath::Pi()*phiMax/180.0);
// LOOP OVER ROOT FILES ////////////////////////////////////////////////
for(file=0; file<=1; file++) {
if(file==0) string epsfile = filename + "_" + strpltmd + ".eps";
if(file==1) string filename = filename + "_sm";
string rootname = filename + ".root";
TFile *rootfile = TFile::Open(rootname.c_str());
if(rootfile == NULL) error(1);
TTree *tree = (TTree*)rootfile->Get(filename.c_str());
if(tree == NULL) error(2);
TBranch *fits2bbranch = (TBranch*)tree->GetBranch("fits2b");
TBranch *fittphbranch = (TBranch*)tree->GetBranch("fittph");
TBranch *fitxbranch = (TBranch*)tree->GetBranch("fitx");
if( (fits2bbranch == NULL) ||
(fittphbranch == NULL) ||
(fitxbranch == NULL) ) error(3);
tree->SetBranchAddress("fits2b",&fits2b);
tree->SetBranchAddress("fittph",&fittph);
tree->SetBranchAddress("fitx", &fitx);
// GET ARRAYS ///////////////////////////////////////////////////////////
Int_t Npoints = (Int_t)tree->GetEntries();
Int_t tphStep = 0;
Float_t tphMax = -1.0;
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
if( fittph > tphMax ) {tphStep++; tphMax = fittph;}
};
const int tphSteps = tphStep;
Float_t xArray[tphSteps], yArray[tphSteps], zArray[tphSteps];
tphStep = -1, tphold = -1.0, fitxmin = 100000;
for(point=0; point<Npoints; point++) {
tree->GetEntry(point);
if(fittph > tphold) {tphStep++; fitxmin = 100000;}
fitsph = fittph / (1.0 + fittph);
fitcph = 1.0 - fitsph;
if (strpltmd.compare("tan") == 0) {
xVal = fitx;
yVal = fittph;
} else if (strpltmd.compare("cos") == 0) {
xVal = fitx;
yVal = sqrt(fitcph);
} else if (strpltmd.compare("sin") == 0) {
xVal = fitx;
yVal = sqrt(fitsph);
} else if (strpltmd.compare("mmp") == 0) {
if (fitsph != 0.0) {
if ( (mdl.compare("lr") == 0) ||
(mdl.compare("lp") == 0) ||
(mdl.compare("hp") == 0) ||
(mdl.compare("fp") == 0) ) {
MMI(Cz1,Cz2,Cz3,Cw1,Cw2,Cw3,Cw4,fitx,fitsph,fitcph,fits2b,xVal,yVal);
} else if ( (mdl.compare("uu") == 0) ||
(mdl.compare("nu") == 0) ) {
MMII(C1,C2,fitx,fitsph,fitcph,xVal,yVal);
}
}
}
if( (strpltmd.compare("mmp") == 0) && (tphStep==1) ) {
xArray[0] = xArray[1];
yArray[0] = yArray[1];
zArray[0] = zArray[1];
}
if(fitx>fitxmax) fitxmax = fitx;
if(fitx<fitxmin) {
xArray[tphStep] = xVal;
yArray[tphStep] = yVal;
zArray[tphStep] = fits2b;
fitxmin = fitx;
}
tphold = fittph;
}
if(file==0) TGraph *NPplot = new TGraph(tphSteps,xArray,yArray);
if(file==1) TGraph *SMplot = new TGraph(tphSteps,xArray,yArray);
TMarker *NPmrk[tphSteps], *SMmrk[tphSteps];
for(tphStep=0; tphStep<tphSteps; tphStep++){
marker(zArray[tphStep],color,style);
if(file==0) { NPmrk[tphStep] = new TMarker(xArray[tphStep],yArray[tphStep],style);
NPmrk[tphStep]->SetMarkerSize(0.8);
NPmrk[tphStep]->SetMarkerColor(color);}
if(file==1) { SMmrk[tphStep] = new TMarker(xArray[tphStep],yArray[tphStep],style);
SMmrk[tphStep]->SetMarkerSize(0.8);
SMmrk[tphStep]->SetMarkerColor(color);}
if( (strpltmd.compare("mmp") != 0) || (tphStep !=0 )) {
if (xArray[tphStep] < xMin) xMin = xArray[tphStep];
if (xArray[tphStep] > xMax) xMax = xArray[tphStep];
if (yArray[tphStep] < yMin) yMin = yArray[tphStep];
if (yArray[tphStep] > yMax) yMax = yArray[tphStep];
}
if( ((strfile.compare("uu-d") == 0) || (strfile.compare("nu-d") == 0)) && (strpltmd.compare("sin") == 0) ) {
fitx = xArray[tphStep];
fitsph = yArray[tphStep]*yArray[tphStep];
fitcph = 1.0 - fitsph;
if( (sphmin < fitsph) && (fitsph<sphmax) ) {
MMII(C1,C2,fitx,fitsph,fitcph,MZ,MW);
if(MZ < Mmin) { Mmin = MZ; cout << MZ << "\t" << sqrt(fitsph) << endl;}
}
}
}
}
// CREATE PLOTS /////////////////////////////////////////////////////////
NPplot->SetLineStyle(2);
NPplot->SetMarkerStyle(20);
NPplot->SetMarkerSize(0.4);
SMplot->SetMarkerStyle(20);
SMplot->SetMarkerSize(0.4);
if(strpltmd.compare("cos") == 0) {yMin = 0.0; yMax = 1.0;}
if(strpltmd.compare("sin") == 0) {yMin = 0.0; yMax = 1.0;}
if(strpltmd.compare("mmp") == 0) {xMin = 0.0; xMax = 5.0; yMin = 0.0; yMax = 5;}
TH1F* frame = MyC->DrawFrame(0.9*xMin,0.9*yMin,1.1*xMax,1.0*yMax);
frame->SetTitle(plottitle.c_str());
TAxis *xaxis = frame->GetXaxis();
TAxis *yaxis = frame->GetYaxis();
xaxis->SetTitle(xtitle.c_str());
xaxis->CenterTitle();
xaxis->SetTitleOffset(1.);
xaxis->SetDecimals();
xaxis->SetLabelSize(0.03);
xaxis->SetLabelOffset(0.01);
yaxis->SetTitle(ytitle.c_str());
yaxis->CenterTitle();
yaxis->SetTitleOffset(1.2);
yaxis->SetDecimals();
yaxis->SetLabelSize(0.03);
yaxis->SetLabelOffset(0.01);
TLegend *mmleg = new TLegend(mmlegxmin,mmlegymin,mmlegxmax,mmlegymax);
mmleg->AddEntry(NPplot,NPleg.c_str(),"l");
mmleg->AddEntry(SMplot,SMleg.c_str(),"l");
mmleg->SetTextSize(0.025);
mmleg->SetFillStyle(0);
if( (strfile.compare("uu-d") != 0) && (strfile.compare("nu-d") != 0) ) {
for(tphStep=0; tphStep<tphSteps; tphStep++){NPmrk[tphStep]->Draw(); SMmrk[tphStep]->Draw();}
}
Float_t xdummy[1] = {0.0}, ydummy[1] = {0.0};
TGraph *circle = new TGraph(1,xdummy,ydummy);
circle->SetMarkerStyle(24);
circle->SetMarkerColor(kGreen+1);
circle->SetMarkerSize(0.8);
TGraph *square = new TGraph(1,xdummy,ydummy);
square->SetMarkerStyle(25);
square->SetMarkerColor(kCyan+1);
square->SetMarkerSize(0.8);
TGraph *triangle = new TGraph(1,xdummy,ydummy);
triangle->SetMarkerStyle(26);
triangle->SetMarkerColor(kBlue+1);
triangle->SetMarkerSize(0.8);
TGraph *diamond = new TGraph(1,xdummy,ydummy);
diamond->SetMarkerStyle(27);
diamond->SetMarkerColor(kMagenta+1);
diamond->SetMarkerSize(0.8);
TLegend *s2bleg = new TLegend(s2blegxmin,s2blegymin,s2blegxmax,s2blegymax);
s2bleg->AddEntry(circle,"#font[42]{0.00 < sin^{2}(2#tilde{#beta}) #leq 0.25}","p");
s2bleg->AddEntry(square,"#font[42]{0.25 < sin^{2}(2#tilde{#beta}) #leq 0.50}","p");
s2bleg->AddEntry(triangle,"#font[42]{0.50 < sin^{2}(2#tilde{#beta}) #leq 0.75}","p");
s2bleg->AddEntry(diamond,"#font[42]{0.75 < sin^{2}(2#tilde{#beta}) #leq 1.00}","p");
s2bleg->SetTextSize(0.025);
s2bleg->SetFillStyle(0);
NPplot->Draw(display.c_str());
SMplot->Draw(display.c_str());
mmleg->Draw();
if( (strfile.compare("uu-d") != 0) && (strfile.compare("nu-d") != 0) ) s2bleg->Draw();
// BOUNDS ON PHI //////////////////////////////////////////////////////
Int_t i;
const int iSteps = 100;
fitxmin = 1.0, fitxmax *= 1.5;
Float_t deltax = (fitxmax-fitxmin)/iSteps;
Float_t phixmin0[iSteps], phixmax0[iSteps], phixmin1[iSteps], phixmax1[iSteps];
Float_t phiymin0[iSteps], phiymax0[iSteps], phiymin1[iSteps], phiymax1[iSteps];
if ( (strpltmd.compare("tan") == 0) ||
(strpltmd.compare("cos") == 0) ||
(strpltmd.compare("sin") == 0) ) {
for(i=0; i<100; i++) {
fitx = fitxmin + i*deltax;
phixmin0[i] = fitx;
if (strpltmd.compare("tan") == 0) { phiymin0[i] = sphmin / cphmin; phiymax0[i] = sphmax / cphmax; }
if (strpltmd.compare("cos") == 0) { phiymin0[i] = sqrt(cphmin); phiymax0[i] = sqrt(cphmax); }
if (strpltmd.compare("sin") == 0) { phiymin0[i] = sqrt(sphmin); phiymax0[i] = sqrt(sphmax); }
}
TGraph *phiMin0 = new TGraph(iSteps,phixmin0,phiymin0);
TGraph *phiMax0 = new TGraph(iSteps,phixmin0,phiymax0);
} else if (strpltmd.compare("mmp") == 0) {
if ( (mdl.compare("lr") == 0) ||
(mdl.compare("lp") == 0) ||
(mdl.compare("hp") == 0) ||
(mdl.compare("fp") == 0) ) {
for(i=0; i<100; i++) {
fitx = fitxmin + i*deltax;
MMI(Cz1,Cz2,Cz3,Cw1,Cw2,Cw3,Cw4,fitx,sphmin,cphmin,0.0,phixmin0[i],phiymin0[i]);
MMI(Cz1,Cz2,Cz3,Cw1,Cw2,Cw3,Cw4,fitx,sphmin,cphmin,1.0,phixmin1[i],phiymin1[i]);
MMI(Cz1,Cz2,Cz3,Cw1,Cw2,Cw3,Cw4,fitx,sphmax,cphmax,0.0,phixmax0[i],phiymax0[i]);
MMI(Cz1,Cz2,Cz3,Cw1,Cw2,Cw3,Cw4,fitx,sphmax,cphmax,1.0,phixmax1[i],phiymax1[i]);
}
TGraph *phiMin0 = new TGraph(iSteps,phixmin0,phiymin0);
TGraph *phiMin1 = new TGraph(iSteps,phixmin1,phiymin1);
TGraph *phiMax0 = new TGraph(iSteps,phixmax0,phiymax0);
TGraph *phiMax1 = new TGraph(iSteps,phixmax1,phiymax1);
phiMin1->SetLineStyle(7);
phiMin1->SetMarkerStyle(22);
phiMin1->SetMarkerSize(1.0);
phiMax1->SetLineStyle(7);
phiMax1->SetMarkerStyle(22);
phiMax1->SetMarkerSize(1.0);
phiMin1->Draw("C");
phiMax1->Draw("C");
} else if ( (mdl.compare("uu") == 0) ||
(mdl.compare("nu") == 0) ) {
for(i=0; i<100; i++) {
fitx = fitxmin + i*deltax;
MMII(C1,C2,fitx,sphmin,cphmin,phixmin0[i],phiymin0[i]);
MMII(C1,C2,fitx,sphmax,cphmax,phixmax0[i],phiymax0[i]);
}
TGraph *phiMin0 = new TGraph(iSteps,phixmin0,phiymin0);
TGraph *phiMax0 = new TGraph(iSteps,phixmax0,phiymax0);
}
}
phiMin0->SetLineStyle(3);
phiMin0->SetMarkerStyle(20);
phiMin0->SetMarkerSize(0.4);
phiMax0->SetLineStyle(3);
phiMax0->SetMarkerStyle(20);
phiMax0->SetMarkerSize(0.4);
phiMin0->Draw("C");
phiMax0->Draw("C");
// LABEL ALLOWED REGION ///////////////////////////////////////////////
TPaveText *allowed = new TPaveText(lblxmin,lblymin,lblxmax,lblymax,"NDC");
TText *text = allowed->AddText("#font[42]{allowed (95% CL)}");
allowed->SetTextSize(0.04);
if (strpltmd.compare("tan") == 0) text->SetTextAngle(270);
allowed->SetFillStyle(0);
allowed->SetLineColor(0);
allowed->SetBorderSize(1);
allowed->Draw();
// SAVE GRAPHIC ///////////////////////////////////////////////////////
MyC->Print(epsfile.c_str());
}
void showGraph(TGraph* graph,
const std::string& xAxisTitle,
Float_t* genX,
double yMin, double yMax, const std::string& yAxisTitle,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", 800, 600);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetTopMargin(0.10);
canvas->SetLeftMargin(0.16);
canvas->SetRightMargin(0.14);
canvas->SetBottomMargin(0.12);
int numPoints = graph->GetN();
double xMin, xMax, yDummy;
graph->GetPoint(0, xMin, yDummy);
graph->GetPoint(numPoints - 1, xMax, yDummy);
TH1* dummyHistogram = new TH1D("dummyHistogram", "dummyHistogram", numPoints/100, xMin, xMax);
dummyHistogram->SetStats(false);
dummyHistogram->SetMinimum(yMin);
dummyHistogram->SetMaximum(yMax);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(1.15);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(1.15);
dummyHistogram->Draw("axis");
TGraph* genMarker = 0;
if ( genX ) {
genMarker = new TGraph(2);
genMarker->SetPoint(0, xMin, *genX);
genMarker->SetPoint(1, xMax, *genX);
genMarker->SetLineColor(8);
genMarker->SetLineWidth(1);
genMarker->SetMarkerColor(8);
genMarker->SetMarkerStyle(20);
genMarker->SetMarkerSize(1);
genMarker->Draw("L");
}
graph->SetLineColor(1);
graph->SetLineWidth(2);
graph->SetMarkerColor(1);
graph->SetMarkerStyle(20);
graph->SetMarkerSize(1);
graph->Draw("L");
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas->Print(std::string(outputFileName_plot).append(".root").data());
delete dummyHistogram;
delete genMarker;
delete canvas;
}
void makePlot(const std::string& inputFilePath, const std::string& canvasName, const std::string& sample, int massPoint, const std::string& channel, double k,
const std::string& inputFileName, const std::string& outputFilePath, const std::string& outputFileName)
{
std::string inputFileName_full = Form("%s%s", inputFilePath.data(), inputFileName.data());
TFile* inputFile = new TFile(inputFileName_full.data());
if ( !inputFile ) {
std::cerr << "Failed to open input file = " << inputFileName_full << " !!" << std::endl;
assert(0);
}
inputFile->ls();
TCanvas* canvas = dynamic_cast<TCanvas*>(inputFile->Get(canvasName.data()));
if ( !canvas ) {
std::cerr << "Failed to load canvas = " << canvasName << " !!" << std::endl;
assert(0);
}
int idxPad = -1;
if ( massPoint == 90 ) idxPad = 1;
if ( massPoint == 125 ) idxPad = 2;
if ( massPoint == 200 ) idxPad = 3;
if ( massPoint == 300 ) idxPad = 4;
if ( massPoint == 500 ) idxPad = 5;
if ( massPoint == 800 ) idxPad = 6;
if ( !(idxPad >= 1 && idxPad <= 6) ) {
std::cerr << "Invalid sample = " << sample << " !!" << std::endl;
assert(0);
}
TVirtualPad* pad = canvas->GetPad(idxPad);
std::cout << "pad = " << pad << ": ClassName = " << pad->ClassName() << std::endl;
TCanvas* canvas_new = new TCanvas("canvas_new", "canvas_new", 900, 800);
canvas_new->SetFillColor(10);
canvas_new->SetBorderSize(2);
canvas_new->SetTopMargin(0.065);
canvas_new->SetLeftMargin(0.17);
canvas_new->SetBottomMargin(0.165);
canvas_new->SetRightMargin(0.015);
canvas_new->SetLogx(true);
canvas_new->SetLogy(true);
canvas_new->Draw();
canvas_new->cd();
//TList* pad_primitives = canvas->GetListOfPrimitives();
TList* pad_primitives = pad->GetListOfPrimitives();
TH1* histogramCA = 0;
TH1* histogramSVfit = 0;
TH1* histogramSVfitMEMkEq0 = 0;
TH1* histogramSVfitMEMkNeq0 = 0;
TIter pad_nextObj(pad_primitives);
while ( TObject* obj = pad_nextObj() ) {
std::string objName = "";
if ( dynamic_cast<TNamed*>(obj) ) objName = (dynamic_cast<TNamed*>(obj))->GetName();
std::cout << "obj = " << obj << ": name = " << objName << ", type = " << obj->ClassName() << std::endl;
TH1* tmpHistogram = dynamic_cast<TH1*>(obj);
if ( tmpHistogram ) {
std::cout << "tmpHistogram:"
<< " fillColor = " << tmpHistogram->GetFillColor() << ", fillStyle = " << tmpHistogram->GetFillStyle() << ","
<< " lineColor = " << tmpHistogram->GetLineColor() << ", lineStyle = " << tmpHistogram->GetLineStyle() << ", lineWidth = " << tmpHistogram->GetLineWidth() << ","
<< " markerColor = " << tmpHistogram->GetMarkerColor() << ", markerStyle = " << tmpHistogram->GetMarkerStyle() << ", markerSize = " << tmpHistogram->GetMarkerSize() << ","
<< " integral = " << tmpHistogram->Integral() << std::endl;
std::cout << "(mean = " << tmpHistogram->GetMean() << ", rms = " << tmpHistogram->GetRMS() << ": rms/mean = " << (tmpHistogram->GetRMS()/tmpHistogram->GetMean()) << ")" << std::endl;
if ( tmpHistogram->GetLineColor() == 416 ) histogramCA = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 600 ) histogramSVfit = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 616 ) histogramSVfitMEMkEq0 = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 632 ) histogramSVfitMEMkNeq0 = tmpHistogram;
}
}
if ( !(histogramCA && histogramSVfit && histogramSVfitMEMkEq0 && histogramSVfitMEMkNeq0) ) {
std::cerr << "Failed to load histograms !!" << std::endl;
assert(0);
}
//gStyle->SetLineStyleString(2,"40 10 10 10 10 10 10 10");
//gStyle->SetLineStyleString(3,"25 15");
//gStyle->SetLineStyleString(4,"60 25");
//int colors[4] = { kBlack, kGreen - 6, kBlue - 7, kMagenta - 7 };
int colors[4] = { 28, kGreen - 6, kBlue - 7, kBlack };
//int lineStyles[4] = { 2, 3, 4, 1 };
int lineStyles[4] = { 7, 1, 1, 1 };
//int lineWidths[4] = { 3, 3, 4, 3 };
int lineWidths[4] = { 3, 3, 1, 1 };
int markerStyles[4] = { 20, 25, 21, 24 };
int markerSizes[4] = { 2, 2, 2, 2 };
histogramCA->SetFillColor(0);
histogramCA->SetFillStyle(0);
histogramCA->SetLineColor(colors[0]);
histogramCA->SetLineStyle(lineStyles[0]);
histogramCA->SetLineWidth(lineWidths[0]);
histogramCA->SetMarkerColor(colors[0]);
histogramCA->SetMarkerStyle(markerStyles[0]);
histogramCA->SetMarkerSize(markerSizes[0]);
histogramSVfit->SetFillColor(0);
histogramSVfit->SetFillStyle(0);
histogramSVfit->SetLineColor(colors[1]);
histogramSVfit->SetLineStyle(lineStyles[1]);
histogramSVfit->SetLineWidth(lineWidths[1]);
histogramSVfit->SetMarkerColor(colors[1]);
histogramSVfit->SetMarkerStyle(markerStyles[1]);
histogramSVfit->SetMarkerSize(markerSizes[1]);
histogramSVfitMEMkEq0->SetFillColor(0);
histogramSVfitMEMkEq0->SetFillStyle(0);
histogramSVfitMEMkEq0->SetLineColor(colors[2]);
histogramSVfitMEMkEq0->SetLineStyle(lineStyles[2]);
histogramSVfitMEMkEq0->SetLineWidth(lineWidths[2]);
histogramSVfitMEMkEq0->SetMarkerColor(colors[2]);
histogramSVfitMEMkEq0->SetMarkerStyle(markerStyles[2]);
histogramSVfitMEMkEq0->SetMarkerSize(markerSizes[2]);
// CV: fix pathological bins at high mass for which dN/dm increases
int numBins = histogramSVfitMEMkEq0->GetNbinsX();
for ( int idxBin = 1; idxBin <= numBins; ++idxBin ) {
double binCenter = histogramSVfitMEMkEq0->GetBinCenter(idxBin);
if ( (channel == "#tau_{h}#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#tau_{h}#tau_{h}" && massPoint == 800 && binCenter > 2000.) ||
(channel == "#mu#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#mu#tau_{h}" && massPoint == 800 && binCenter > 2500.) ) {
histogramSVfitMEMkEq0->SetBinContent(idxBin, 0.);
}
}
histogramSVfitMEMkNeq0->SetFillColor(0);
histogramSVfitMEMkNeq0->SetFillStyle(0);
histogramSVfitMEMkNeq0->SetLineColor(colors[3]);
histogramSVfitMEMkNeq0->SetLineStyle(lineStyles[3]);
histogramSVfitMEMkNeq0->SetLineWidth(lineWidths[3]);
histogramSVfitMEMkNeq0->SetMarkerColor(colors[3]);
histogramSVfitMEMkNeq0->SetMarkerStyle(markerStyles[3]);
histogramSVfitMEMkNeq0->SetMarkerSize(markerSizes[3]);
TAxis* xAxis = histogramCA->GetXaxis();
xAxis->SetTitle("m_{#tau#tau} [GeV]");
xAxis->SetTitleOffset(1.15);
xAxis->SetTitleSize(0.070);
xAxis->SetTitleFont(42);
xAxis->SetLabelOffset(0.010);
xAxis->SetLabelSize(0.055);
xAxis->SetLabelFont(42);
xAxis->SetTickLength(0.040);
xAxis->SetNdivisions(510);
//double xMin = 20.;
//double xMax = xAxis->GetXmax();
//xAxis->SetRangeUser(xMin, xMax);
TAxis* yAxis = histogramCA->GetYaxis();
yAxis->SetTitle("dN/dm_{#tau#tau} [1/GeV]");
yAxis->SetTitleOffset(1.20);
yAxis->SetTitleSize(0.070);
yAxis->SetTitleFont(42);
yAxis->SetLabelOffset(0.010);
yAxis->SetLabelSize(0.055);
yAxis->SetLabelFont(42);
yAxis->SetTickLength(0.040);
yAxis->SetNdivisions(505);
double massPoint_double = 0.;
if ( massPoint == 90 ) massPoint_double = 91.2;
else massPoint_double = massPoint;
double dLog = (TMath::Log(5.*massPoint_double) - TMath::Log(50.))/25.; // xMin = 50, xMax = 5*massPoint, numBins = 25
double binWidth = TMath::Exp(TMath::Log(massPoint_double) + 0.5*dLog) - TMath::Exp(TMath::Log(massPoint_double) - 0.5*dLog);
double sf_binWidth = 1./binWidth;
std::cout << "massPoint = " << massPoint << ": sf_binWidth = " << sf_binWidth << std::endl;
histogramCA->SetTitle("");
histogramCA->SetStats(false);
histogramCA->SetMaximum(sf_binWidth*0.79);
histogramCA->SetMinimum(sf_binWidth*1.1e-4);
histogramCA->Draw("hist");
histogramSVfit->Draw("histsame");
//histogramSVfitMEMkEq0->Draw("histsame");
histogramSVfitMEMkEq0->Draw("epsame");
//histogramSVfitMEMkNeq0->Draw("histsame");
histogramSVfitMEMkNeq0->Draw("epsame");
histogramCA->Draw("axissame");
//TPaveText* label_sample = new TPaveText(0.21, 0.86, 0.46, 0.94, "NDC");
TPaveText* label_sample = new TPaveText(0.1700, 0.9475, 0.4600, 1.0375, "NDC");
label_sample->SetFillStyle(0);
label_sample->SetBorderSize(0);
label_sample->AddText(sample.data());
label_sample->SetTextFont(42);
label_sample->SetTextSize(0.055);
label_sample->SetTextColor(1);
label_sample->SetTextAlign(13);
label_sample->Draw();
//TLegend* legend_new = new TLegend(0.225, 0.52, 0.41, 0.82, NULL, "brNDC");
TLegend* legend_new = new TLegend(0.30, 0.30, 0.80, 0.80, NULL, "brNDC");
legend_new->SetFillColor(10);
legend_new->SetFillStyle(0);
legend_new->SetBorderSize(0);
legend_new->SetTextFont(42);
legend_new->SetTextSize(0.055);
legend_new->SetTextColor(1);
legend_new->SetMargin(0.20);
legend_new->AddEntry(histogramCA, "CA", "l");
legend_new->AddEntry(histogramSVfit, "SVfit", "l");
//legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "l");
legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "p");
//legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM(k=%1.0f)", k), "l");
legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM (k=%1.0f)", k), "p");
//legend_new->Draw();
double label_channel_y0;
if ( channel == "e#mu" ) label_channel_y0 = 0.9275;
else if ( channel == "#mu#tau_{h}" ) label_channel_y0 = 0.9400;
else if ( channel == "#tau_{h}#tau_{h}" ) label_channel_y0 = 0.9350;
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
TPaveText* label_channel = new TPaveText(0.895, label_channel_y0, 0.975, label_channel_y0 + 0.055, "NDC");
label_channel->SetFillStyle(0);
label_channel->SetBorderSize(0);
label_channel->AddText(channel.data());
label_channel->SetTextFont(62);
label_channel->SetTextSize(0.055);
label_channel->SetTextColor(1);
label_channel->SetTextAlign(31);
label_channel->Draw();
canvas_new->Update();
std::string outputFileName_full = Form("%s%s", outputFilePath.data(), outputFileName.data());
size_t idx = outputFileName_full.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName_full, 0, idx);
canvas_new->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas_new->Print(std::string(outputFileName_plot).append(".root").data());
std::string channel_string;
if ( channel == "e#mu" ) channel_string = "emu";
else if ( channel == "#mu#tau_{h}" ) channel_string = "muhad";
else if ( channel == "#tau_{h}#tau_{h}" ) channel_string = "hadhad";
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
std::string outputFileName_legend = Form("makeSVfitMEM_PerformancePlots_legend_%s.pdf", channel_string.data());
makePlot_legend(legend_new, outputFilePath, outputFileName_legend);
delete label_sample;
delete legend_new;
delete label_channel;
delete canvas_new;
delete inputFile;
}
void finalSpectra(
const char* inCentral=
"links/P01hi.central.2000.hist/finish_cut88778999_iter3.hist.root",
const char* inMinbias=
"links/P01hi.minbias.2000.hist/finish_cut97778999_iter3.hist.root",
const char* inPeripheral=
"links/P01hi.minbias.2000.hist/finish_cut57778999_iter3.hist.root",
const char* psDir="psFinal"
)
{
gSystem->Clear();
TFile* rCentral=new TFile(inCentral);
TFile* rMinbias=new TFile(inMinbias);
TFile* rPeripheral=new TFile(inPeripheral);
int DOKLUDGE=1;
//
// get the graphs
//
char name[200],title[200],txt[500];
char* sign=0; // "Minus"
int bin=0;
setName(name,"gSpecCorrected",bin,sign);
TGraphAsymmErrors* gCentralX=(TGraphAsymmErrors*)rCentral->Get(name);
TGraphAsymmErrors* gMinbiasX=(TGraphAsymmErrors*)rMinbias->Get(name);
TGraphAsymmErrors* gPeripheralX=(TGraphAsymmErrors*)rPeripheral->Get(name);
//
// kludges
//
if(DOKLUDGE){
cout << ">>>>WARNING DOING KLUDGE" << endl;
cout << ">>>>WARNING DOING KLUDGE" << endl;
cout << ">>>>WARNING DOING KLUDGE" << endl;
kludgeBackground(gCentralX,0.08);
kludgeBackground(gMinbiasX,0.08);
kludgeBackground(gPeripheralX,0.05);
kludgeSystematics(gCentralX);
kludgeSystematics(gMinbiasX);
kludgeSystematics(gPeripheralX);
}
// low pt stuff
TGraphAsymmErrors* gCentralLowPt=makeHMinus(2);
TGraphAsymmErrors* gMinbiasLowPt=makeHMinus(0);
TGraphAsymmErrors* gPeripheralLowPt=makeHMinus(1);
// ua1
float sigmaUA1_200=42;
float ua1Scale200 = 2.*3.14159/sigmaUA1_200;
float sigmaUA1_130=40.5;
float ua1Scale130= 2.*3.14159/sigmaUA1_130;
TGraphErrors* gUA1Data200=ua1Data200();
scale(gUA1Data200,ua1Scale200);
TF1* fUA1Fit130 = ua1Fit130(ua1Scale130);
// remove some error bars
gCentralLowPt=removeXErrors(gCentralLowPt);
gMinbiasLowPt=removeXErrors(gMinbiasLowPt);
gPeripheralLowPt=removeXErrors(gPeripheralLowPt);
// gStyles
gStyle->SetOptStat(0); gStyle->SetOptTitle(0);
gStyle->SetPadTickX(1);
gStyle->SetPadTickY(1);
// follow manuel in the fonts
int font = 42;
gStyle->SetTextFont(font); gStyle->SetTitleFont(font);
gStyle->SetLabelFont(font,"x"); gStyle->SetLabelFont(font,"y");
// TLatex
TLatex* ltx=new TLatex;
TCanvas* c1=new TCanvas("c1","c1",400,500);
// draw the spectra
double xMin=0,xMax=6;
double yMin=1e-7,yMax=10000;
double textSize=0.03;
double titleSize=0.04;
double markerSize=1;
double labelSize=0.03;
double yTitleOffset=1.2;
double xTitleOffset=0.8;
double tickSize=9990;
TAxis* axis;
c1->cd(); gPad->SetLogy();
int centralMarker=29;
int minbiasMarker=8;
int peripheralMarker=22;
int hMinusMarker=21;
int ua1Marker=4;
// central
//
gCentral=removeXErrors(gCentralX);
gCentral->SetMinimum(yMin); gCentral->SetMaximum(yMax);
gCentral->SetMarkerStyle(centralMarker);
gCentral->SetMarkerSize(markerSize+.2);
gCentral->Draw("ap");
strcpy(txt,"1/p_{T} d^{2}N^{(h^{-}+h^{+})/2}/dp_{T}d#eta #cbar_{|#eta|<0.5}(GeV/c)^{-2}");
// yaxis
axis=gCentral->GetYaxis();
axis->SetTitle(txt);
axis->SetTitleSize(titleSize);
axis->SetTitleOffset(yTitleOffset);
axis->SetLabelSize(labelSize);
// xaxis
axis=gCentral->GetXaxis();
axis->SetTitle("p_{T} (GeV/c)");
axis->SetTitleSize(titleSize);
axis->SetTitleOffset(xTitleOffset);
axis->SetLabelOffset(0.003);
axis->SetLabelSize(labelSize);
axis->SetLimits(xMin,xMax);
// low pt central
gCentralLowPt->SetMarkerStyle(centralMarker);
gCentralLowPt->SetMarkerSize(markerSize);
gCentralLowPt->Draw("p");
// draw bin widths
// drawAxisBins(gCentralX,tickSize,yMax);
// TLine* line=new TLine;
// line->DrawLineNDC((2/6)*(1./.8)+.1,.8,2/6*(1./.8)+.1 ,.9);
// minbias
//
// remove x errors
gMinbias=removeXErrors(gMinbiasX);
gMinbias->SetMarkerStyle(minbiasMarker);
gMinbias->SetMarkerSize(markerSize);
gMinbias->Draw("p");
gMinbiasLowPt->SetMarkerStyle(minbiasMarker);
gMinbiasLowPt->SetMarkerSize(markerSize);
gMinbiasLowPt->Draw("p");
// peripheral
//
// remove x errors
gPeripheral=removeXErrors(gPeripheralX);
gPeripheral->SetMarkerStyle(peripheralMarker);
gPeripheral->SetMarkerSize(markerSize);
gPeripheral->Draw("p");
gPeripheralLowPt->SetMarkerStyle(peripheralMarker);
gPeripheralLowPt->SetMarkerSize(markerSize);
gPeripheralLowPt->Draw("p");
// ua1
//
gUA1Data200->SetMarkerStyle(ua1Marker);
gUA1Data200->SetMarkerSize(markerSize);
//fUA1Fit130->SetLineColor();
gUA1Data200->Draw("p");
fUA1Fit130->SetRange(.1,6);
fUA1Fit130->Draw("same");
//
// legend
//
TLegend* l=new TLegend(0.5,0.7,0.8,0.8);
l->SetTextSize(textSize);
l->SetBorderSize(0); l->SetFillColor(4000); // transparent
l->AddEntry(gCentral,"central 0-5%","p");
l->AddEntry(gPeripheral,"periperhal 60-80%","p");
l->AddEntry(gMinbias,"minimum bias","p");
l->AddEntry(gUA1Data200,"ua1 200 GeV data","p");
l->AddEntry(fUA1Fit130,"ua1 130 GeV fit","l");
l->Draw();
Print(c1,psDir,"spectra");
}
