TGraphErrors *ReadMWGraph(const char *name, Int_t flag)
{
Double_t xreject = 0.49;
TGraphErrors *g = new TGraphErrors(name);
if (g->IsZombie()) return 0;
while (g->GetX()[0] < xreject)
g->RemovePoint(0);
TGraphErrors *g2 = new TGraphErrors(name);
if (g2->IsZombie()) return 0;
while (g2->GetX()[0] < xreject)
g2->RemovePoint(0);
g2->SetMarkerStyle(4);
g2->SetMarkerSize(1.00);
g2->SetMarkerColor(kBlack);
g2->SetLineColor(kBlack);
TGraphErrors *gsys = new TGraphErrors(name, "%lg %lg %lg %*lg %lg");
if (gsys->IsZombie()) return 0;
while (gsys->GetX()[0] < xreject)
gsys->RemovePoint(0);
for (Int_t i = 0; i < gsys->GetN(); i++)
gsys->SetPointError(i, gsys->GetErrorX(i)*0.75, gsys->GetErrorY(i));
gsys->SetFillColor(kGray+2);
gsys->SetLineColor(kGray+2);
gsys->SetFillStyle(3000);
if (flag == 1 || flag == 3) {
TGraphErrors *gt = new TGraphErrors(Form("%s_%s", name, "trues"));
if (gt->IsZombie()) return 0;
while (gt->GetX()[0] < xreject)
gt->RemovePoint(0);
gt->SetMarkerStyle(20);
gt->SetMarkerSize(0.75);
gt->SetMarkerColor(kGreen+1);
gt->SetLineColor(kGreen+1);
TGraphErrors *gbw = new TGraphErrors(Form("%s_%s", name, "gen"));
if (gbw->IsZombie()) return 0;
while (gbw->GetX()[0] < xreject)
gbw->RemovePoint(0);
gbw->SetMarkerStyle(20);
gbw->SetMarkerSize(0.75);
gbw->SetMarkerColor(kBlue+1);
gbw->SetLineColor(kBlue+1);
for (Int_t i = 0; i < g->GetN(); i++) {
g->SetPointError(i, g->GetEX()[i], 0.);
gt->SetPointError(i, gt->GetEX()[i], 0.);
gbw->SetPointError(i, gbw->GetEX()[i], 0.);
}
for (Int_t i = 0; i < g2->GetN(); i++) {
g2->SetPoint(i, g2->GetX()[i], g2->GetY()[i] - gt->GetY()[i] + gbw->GetY()[i]);
g2->SetPointError(i, g2->GetEX()[i], TMath::Sqrt(g2->GetEY()[i]*g2->GetEY()[i] + gt->GetEY()[i]*gt->GetEY()[i] +
gbw->GetEY()[i]*gbw->GetEY()[i]));
// g2->SetPoint(i, g2->GetX()[i], g2->GetY()[i] - gt->GetY()[i] + 1.01947);
// g2->SetPointError(i, g2->GetEX()[i], TMath::Sqrt(g2->GetEY()[i]*g2->GetEY()[i] + gt->GetEY()[i]*gt->GetEY()[i] +
// 7.78680e-06*7.78680e-06));
gsys->SetPoint(i, gsys->GetX()[i], g2->GetY()[i]);
}
}
g->SetTitle();
g->SetName(name);
g->GetXaxis()->SetTitle("p_{T}, GeV/c");
g->SetMarkerStyle(20);
g->SetMarkerSize(0.95);
g->SetMarkerColor(kRed+1);
g->SetLineColor(kRed+1);
const Double_t mass = 1.019455;
const Double_t mass_delta = 0.000020;
const Double_t width = 0.00426;
const Double_t width_delta = 0.00004;
if (flag == 1) { // mass
g->GetYaxis()->SetTitleOffset(1.50);
g->GetYaxis()->SetTitle("mass, GeV/c^{2}");
g->SetMaximum(mass+0.0015);
g->SetMinimum(mass-0.0015);
TBox *box = new TBox(g->GetXaxis()->GetXmin(), mass - mass_delta, g->GetXaxis()->GetXmax(), mass + mass_delta);
box->SetFillColor(kGray+1);
box->SetFillStyle(3001);
g->GetListOfFunctions()->Add(box);
g->GetListOfFunctions()->Add(g2, "CP");
g->GetListOfFunctions()->Add(gt, "CP");
g->GetListOfFunctions()->Add(gbw, "CP");
}
else if (flag == 3) { // mass simple
g2->SetTitle();
g2->SetName(Form("%s_only", name));
g2->GetXaxis()->SetTitle("p_{T}, GeV/c");
g2->SetMarkerStyle(20);
g2->SetMarkerSize(0.75);
g2->SetMarkerColor(kBlack);
g2->SetLineColor(kBlack);
g2->GetYaxis()->SetTitleOffset(1.50);
g2->GetYaxis()->SetTitle("mass, GeV/c^{2}");
g2->SetMaximum(mass+0.0015);
g2->SetMinimum(mass-0.0015);
TBox *box = new TBox(g->GetXaxis()->GetXmin(), mass - mass_delta, g2->GetXaxis()->GetXmax(), mass + mass_delta);
box->SetFillColor(kGray+1);
box->SetFillStyle(3001);
g2->GetListOfFunctions()->Add(box);
g2->GetListOfFunctions()->Add(gsys, "E5");
return g2;
}
else if (flag == 2) { // width
g->SetTitle();
g->SetName(name);
g->GetXaxis()->SetTitle("p_{T}, GeV/c");
g->SetMarkerStyle(20);
g->SetMarkerSize(0.75);
g->SetMarkerColor(kBlack);
g->SetLineColor(kBlack);
g->GetYaxis()->SetTitleOffset(1.50);
g->GetYaxis()->SetTitle("width, GeV/c^{2}");
g->SetMaximum(0.01);
g->SetMinimum(0.0);
TBox *box = new TBox(g->GetXaxis()->GetXmin(), width - width_delta, g->GetXaxis()->GetXmax(), width + width_delta);
box->SetFillColor(kGray+1);
box->SetFillStyle(3001);
g->GetListOfFunctions()->Add(box);
g->GetListOfFunctions()->Add(gsys, "E5");
}
return g;
}
void disceff(TString filename) {
gROOT->SetStyle("Plain");
TString cmssw;
// 167
cmssw = "$3.1.0_pre9$";
TFile *f = TFile::Open(filename);
std::vector< TString > taggers;
taggers.push_back( "TC2" );
taggers.push_back( "TC3" );
taggers.push_back( "TP" );
taggers.push_back( "BTP" );
taggers.push_back( "SSV" );
taggers.push_back( "CSV" );
taggers.push_back( "MSV" );
taggers.push_back( "SMT" );
taggers.push_back( "SETbyIP3d" );
taggers.push_back( "SETbyPt" );
taggers.push_back( "SMTbyIP3d" );
taggers.push_back( "SMTbyPt" );
std::vector< TString > discriminators;
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
discriminators.push_back( "disc"+taggers[itagger]+"_udsg" );
}
// discriminators.push_back( "discTC3_udsg" );
// discriminators.push_back( "discTP_udsg" );
const int dim=taggers.size();
TCanvas *cv[dim];
TMultiGraph* mg[dim];
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
TString tag = "g"+taggers[itagger]+"_udsg";
TString tagb = "g"+taggers[itagger]+"_b";
TString tagc = "g"+taggers[itagger]+"_c";
cv[itagger] = new TCanvas("cv_"+taggers[itagger],"cv_"+taggers[itagger],700,700);
TLegend *legend0 = new TLegend(0.68,0.70,0.88,0.90);
TGraphErrors *agraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tag);
TGraphErrors *bgraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tagb);
TGraphErrors *cgraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tagc);
TGraph *dgraph = (TGraph*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+discriminators[itagger]);
TGraph *bvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),bgraph->GetY());
TGraph *cvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),cgraph->GetY());
TGraph *lvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),agraph->GetY());
TGraph *udsgvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),dgraph->GetX());
dgraph->Sort();
// udsgvsdgraph->Sort();
// udsgvsdgraph->SetLineColor(1);
// legend0 -> AddEntry(udsgvsdgraph,"control","l");
lvsdgraph->Sort();
lvsdgraph->SetLineColor(2);
legend0 -> AddEntry(lvsdgraph,tag,"l");
cvsdgraph->Sort();
cvsdgraph->SetLineColor(3);
legend0 -> AddEntry(cvsdgraph,tagc,"l");
bvsdgraph->Sort();
bvsdgraph->SetLineColor(4);
legend0 -> AddEntry(bvsdgraph,tagb,"l");
mg[itagger]= new TMultiGraph();
// mg[itagger]->Add(udsgvsdgraph);
mg[itagger]->Add(lvsdgraph);
mg[itagger]->Add(cvsdgraph);
mg[itagger]->Add(bvsdgraph);
// mg[itagger]->Add(dgraph);
cv[itagger]->cd(1);
mg[itagger]->Draw("ALP");
mg[itagger]->GetYaxis()->SetTitle("eff");
mg[itagger]->GetXaxis()->SetTitle("discriminant");
legend0 -> Draw();
cv[itagger]->Update();
cv[itagger]->cd(0);
cv[itagger]-> Print ("BTagPATeff_vs_disc"+taggers[itagger]+".eps");
cv[itagger]-> Print ("BTagPATeff_vs_disc"+taggers[itagger]+".ps");
TGraphErrors *g = new TGraphErrors(agraph->GetN(),agraph->GetY(),agraph->GetX(),agraph->GetEY(),agraph->GetEX());
g->Sort();
g->SetLineColor(itagger+1);
std::cout << " Tagger: " << tag << std::endl;
std::cout << " Loose(10%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.1) << " b-eff = " << g->Eval(0.1) << std::endl;
std::cout << " Medium(1%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.01) << " b-eff = " << g->Eval(0.01) << std::endl;
std::cout << " Tight(0.1%) = " << " cut > " << std::setprecision(4) << dgraph->Eval(0.001) << " b-eff = " << g->Eval(0.001) << std::endl;
}//end for
}
void AnalyzeClipping(TString inputWaveName = "sum trigger input ch5 960mV",
TString outputWaveName = "sum trigger output ch5 - 2V clip - 960mV input",
Double_t inputDelay = 1.1E-8, Double_t lowerCut = 16E-9, Double_t upperCut = 23E-9,
const char *inFile = "Data.root",const char *WaveformsFile = "Waveforms.root") {
//try to access data file and in case of failure return
if(gSystem->AccessPathName(inFile,kFileExists)) {
cout << "Error: file " << inFile << " does not exsist. Run .x DataParse.C to create it" << endl;
return;
}
TFile *f = TFile::Open(inFile);
TFolder *dataSet;
TString dataFolderS = "SumTriggerBoardData";
dataFolderS.Append(";1");
dataSet = (TFolder*)f->Get(dataFolderS);
cout << dataSet << endl;
cout << dataSet->GetName() << endl;
Int_t nScope = 150; // number of measurements done by the scope evey time
//try to access waveforms file and in case of failure return
if(gSystem->AccessPathName(WaveformsFile,kFileExists)) {
cout << "Error: file " << WaveformsFile << " does not exsist. Run .x WaveformsFileMaker.C to create it" << endl;
return;
}
TFile *f = TFile::Open(WaveformsFile);
TList *listOfKeys = f->GetListOfKeys();
Int_t numberOfKeys = listOfKeys->GetEntries();
TList *listOfGraphs = new TList();
// if the waveform file name begins with the string "comparator" it goes in this list
TList *listOfCompWaves = new TList();
// if the waveform file name begins with the string "sum output" it goes in this list
TList *listOfAdderWaves = new TList();
for(Int_t i = 0; i < numberOfKeys; i++) {
TString *keyName = new TString(listOfKeys->At(i)->GetName());
TTree *tree = (TTree*)f->Get(keyName->Data());
Float_t x = 0;
Float_t y = 0;
tree->SetBranchAddress("x",&x);
tree->SetBranchAddress("y",&y);
Int_t nentries = tree->GetEntries();
TString *gName = new TString(keyName->Data());
gName->Append(" graph");
TGraphErrors *gWave = new TGraphErrors(nentries);
gWave->SetName(gName->Data());
gWave->SetTitle(gName->Data());
gWave->GetXaxis()->SetTitle("Time");
gWave->GetYaxis()->SetTitle("Voltage");
for (Int_t j = 0; j < nentries; j++) {
tree->GetEntry(j);
gWave->SetPoint(j,x,y);
}
listOfGraphs->Add(gWave);
}
// Global variables
Double_t *xInput, *xOutput, *yInput, *yOutput;
// V input 960 mV
TString path = "Clipping/Output width analysis/Channel 5/V input 960mV/";
TGraphErrors *gClip960mV = TBGraphErrors(dataSet,path,"V clip","Output FWHM",1,nScope);
gClip960mV->SetMarkerStyle(20);
gClip960mV->SetMarkerSize(0.8);
gClip960mV->GetXaxis()->SetTitle("V clipping (mV)");
gClip960mV->GetYaxis()->SetTitle("Output FWHM (ns)");
TCanvas *cClip960mV = new TCanvas("cClip960mV","Output FWHM in function of V clipping",800,600);
gClip960mV->Draw("APEL");
// Expected output FWHM
TGraphErrors *gInput960mV = listOfGraphs->FindObject("sum trigger input ch5 960mV graph");
Double_t *xClip = gClip960mV->GetX();
Int_t nClip = gClip960mV->GetN();
cout << "nClip = " << nClip << endl;
Long64_t graphPoints = gInput960mV->GetN();
yInput = gInput960mV->GetY();
xInput = gInput960mV->GetX();
vector<double> xFirst(nClip);
vector<double> xLast(nClip);
Double_t half;
Int_t flag = 0;
vector<double> yConv(graphPoints);
for(Int_t i = 0; i < graphPoints; i++) {
yConv[i] = -(yInput[i]);
yConv[i] *= 1000;
if(xInput[i] + inputDelay < lowerCut || xInput[i] + inputDelay > upperCut)
yConv[i] = 0;
}
Double_t yInput960mVMax = TMath::MaxElement(graphPoints,&yConv[0]);
for(Int_t i = 0; i < nClip; i++) {
if(xClip[i] > yInput960mVMax) half = yInput960mVMax;
else half = xClip[i];
half /=2;
cout << half << endl;
flag = 0;
for(Int_t j = 0; j < graphPoints - 3; j++) {
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 0) {
xFirst[i] = xInput[j];
flag = 1;
cout << "found first point! " << xFirst[i] << endl;
continue;
}
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 1) {
xLast[i] = xInput[j];
cout << "found last point! " << xLast[i] << endl;
break;
}
}
}
vector<double> expectedFWHM960mV(nClip);
for(Int_t i = 0; i < expectedFWHM960mV.size(); i++) {
expectedFWHM960mV[i] = xLast[i] - xFirst[i];
// convert from seconds to nanoseconds
expectedFWHM960mV[i] *= 10E8;
cout << "expectedFWHM960mV[" << i << "] = " << expectedFWHM960mV[i] << endl;
}
// expected FWHM 960 mV graph
TGraphErrors *gExpClip960mV = new TGraphErrors(nClip,xClip,&expectedFWHM960mV[0],0,0);
gExpClip960mV->SetLineStyle(7);
gExpClip960mV->SetMarkerStyle(20);
gExpClip960mV->SetMarkerSize(0.8);
// V input 1.9 V
path = "Clipping/Output width analysis/Channel 5/V input 1.9V/";
TGraphErrors *gClip1Point9V = TBGraphErrors(dataSet,path,"V clip","Output FWHM",1,nScope);
gClip1Point9V->SetMarkerStyle(20);
gClip1Point9V->SetMarkerSize(0.8);
gClip1Point9V->SetLineColor(kRed);
gClip1Point9V->GetXaxis()->SetTitle("V clipping (mV)");
gClip1Point9V->GetYaxis()->SetTitle("Output FWHM (ns)");
TCanvas *cClip1Point9V = new TCanvas("cClip1Point9V","Output FWHM in function of V clipping",800,600);
gClip1Point9V->Draw("APEL");
// Expected output FWHM
TGraphErrors *gInput1Point9V = listOfGraphs->FindObject("sum trigger input ch5 1900mV graph");
xClip = gClip1Point9V->GetX();
nClip = gClip1Point9V->GetN();
cout << "nClip = " << nClip << endl;
graphPoints = gInput1Point9V->GetN();
yInput = gInput1Point9V->GetY();
xInput = gInput1Point9V->GetX();
vector<double> xFirst(nClip);
vector<double> xLast(nClip);
flag = 0;
vector<double> yConv(graphPoints);
for(Int_t i = 0; i < graphPoints; i++) {
yConv[i] = -(yInput[i]);
yConv[i] *= 1000;
if(xInput[i] + inputDelay < lowerCut || xInput[i] + inputDelay > upperCut) yConv[i] = 0;
}
Double_t yInput1Point9VMax = TMath::MaxElement(graphPoints,&yConv[0]);
for(Int_t i = 0; i < nClip; i++) {
if(xClip[i] > yInput1Point9VMax) half = yInput1Point9VMax;
else half = xClip[i];
half /= 2;
cout << half << endl;
flag = 0;
for(Int_t j = 0; j < graphPoints - 3; j++) {
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 0) {
xFirst[i] = xInput[j];
flag = 1;
cout << "found first point! " << xFirst[i] << endl;
continue;
}
if((yConv[j + 1] - half)*(yConv[j] - half) < 0 && flag == 1) {
xLast[i] = xInput[j];
cout << "found last point! " << xLast[i] << endl;
break;
}
}
}
vector<double> expectedFWHM1Point9V(nClip);
for(Int_t i = 0; i < expectedFWHM1Point9V.size(); i++) {
expectedFWHM1Point9V[i] = xLast[i] - xFirst[i];
// convert from seconds to nanoseconds
expectedFWHM1Point9V[i] *= 10E8;
cout << "expectedFWHM1Point9V[" << i << "] = " << expectedFWHM1Point9V[i] << endl;
}
// expected FWHM 960 mV graph
TGraphErrors *gExpClip1Point9V = new TGraphErrors(nClip,xClip,&expectedFWHM1Point9V[0],0,0);
gExpClip1Point9V->SetLineStyle(7);
gExpClip1Point9V->SetLineColor(kRed);
gExpClip1Point9V->SetMarkerStyle(20);
gExpClip1Point9V->SetMarkerSize(0.8);
// Collection of Output FWHM graphs, 2 amplitudes, serveral V clipping
TMultiGraph *mgClipOutputFWHM = new TMultiGraph();
mgClipOutputFWHM->SetTitle("Collection of Output FWHM graphs, 2 amplitudes, serveral V clipping");
mgClipOutputFWHM->Add(gClip1Point9V);
mgClipOutputFWHM->Add(gClip960mV);
mgClipOutputFWHM->Add(gExpClip960mV);
mgClipOutputFWHM->Add(gExpClip1Point9V);
TCanvas *cmgClipOutputFWHM = new TCanvas("cmgClipOutputFWHM","Collection of Output FWHM graphs, 2 amplitudes, serveral V clipping");
mgClipOutputFWHM->Draw("APEL");
cmgClipOutputFWHM->Modified();
mgClipOutputFWHM->GetXaxis()->SetTitle("V clipping (mV)");
mgClipOutputFWHM->GetYaxis()->SetTitle("Output FWHM (ns)");
cmgClipOutputFWHM->Update();
legend = new TLegend(0.6,0.67,0.89,0.86,"V input");
legend->AddEntry(gClip1Point9V, "1.9 V", "lp");
legend->AddEntry(gClip960mV, "960 mV", "lp");
legend->AddEntry(gExpClip960mV, "Exp 960 mV", "lp");
legend->AddEntry(gExpClip1Point9V, "Exp 1.9 V", "lp");
legend->SetTextSize(0.04);
legend->SetMargin(0.5);
legend->Draw();
// Hysteresis plot: V output (t) in function of V input (t) for several clipping values
// variables used in the analysis
Long64_t iInputMax, iOutputMax;
Float_t xInputMax, xOutputMax, xInputHalf, xOutputHalf;
Double_t InputMax, OutputMax, InputHalf, OutputHalf;
Long64_t firstIndex = 0;
Long64_t lastIndex = 0;
Long64_t inputGraphPoints = 0;
Long64_t outputGraphPoints = 0;
// hard coded values to cut the x axis of both waves
// Input wave
inputWaveName += " graph";
TGraphErrors *gInput = listOfGraphs->FindObject(inputWaveName);
gInput->SetLineColor(kRed);
gInput->SetLineWidth(2);
xInput = gInput->GetX();
yInput = gInput->GetY();
inputGraphPoints = gInput->GetN();
cout << inputGraphPoints << endl;
// Invert the input wave
for(Int_t i = 0; i < inputGraphPoints; i++) {
yInput[i] = -(yInput[i]);
}
// find the x at which the graph reaches the max value
iInputMax = TMath::LocMax(inputGraphPoints, yInput);
xInputMax = xInput[iInputMax];
cout << "iInputMax = " << iInputMax << endl;
cout << "xInputMax = " << xInputMax << endl;
InputMax = gInput->Eval(xInput[iInputMax]);
cout << "InputMax = " << InputMax << endl;
// Output wave
outputWaveName += " graph";
TGraphErrors *gOutput = listOfGraphs->FindObject(outputWaveName);
gOutput->SetLineWidth(2);
xOutput = gOutput->GetX();
yOutput = gOutput->GetY();
outputGraphPoints = gOutput->GetN();
// find the x at which the graph reaches the max value
iOutputMax = TMath::LocMax(outputGraphPoints, yOutput);
xOutputMax = xOutput[iOutputMax];
cout << "iOutputMax = " << iOutputMax << endl;
cout << "xOutputMax = " << xOutputMax << endl;
OutputMax = gOutput->Eval(xOutput[iOutputMax]);
cout << "OutputMax = " << OutputMax << endl;
// compute x delay between max points
Double_t delay = xOutputMax - xInputMax;
cout << "delay = " << delay << endl;
// Shift the x axis of the input graph and create a new graph with only a portion of the first graph
for(Int_t i = 0; i < inputGraphPoints; i++) {
xInput[i] += inputDelay;
if(xInput[i] >= lowerCut) {
if(firstIndex == 0) firstIndex = i;
}
if(xInput[i] <= upperCut)
lastIndex = i;
}
cout << "firstIndex = " << firstIndex << endl;
cout << "lastIndex = " << lastIndex << endl;
cout << "xInput[firstIndex] = " << xInput[firstIndex] << endl;
cout << lastIndex - firstIndex << endl;
Long64_t input2GraphPoints = lastIndex - firstIndex;
TGraphErrors *gInput2 = new TGraphErrors(input2GraphPoints);
gInput2->SetTitle(inputWaveName);
for(Int_t i = firstIndex; i <= lastIndex; i++) {
gInput2->SetPoint(i - firstIndex,xInput[i],yInput[i]);
}
TCanvas *cgInput2 = new TCanvas("cgInput2", "cgInput2", 1200,800);
gInput2->Draw("AL");
// create a new graph with only a portion of the first graph
firstIndex = 0;
lastIndex = 0;
for(Int_t i = 0; i < outputGraphPoints; i++) {
if(xOutput[i] >= lowerCut) {
if(firstIndex == 0) firstIndex = i;
}
if(xOutput[i] <= upperCut)
lastIndex = i;
}
cout << "firstIndex = " << firstIndex << endl;
cout << "lastIndex = " << lastIndex << endl;
cout << "xOutput[firstIndex] = " << xOutput[firstIndex] << endl;
cout << lastIndex - firstIndex << endl;
Long64_t output2GraphPoints = lastIndex - firstIndex;
TGraphErrors *gOutput2 = new TGraphErrors(output2GraphPoints);
gOutput2->SetTitle(outputWaveName);
for(Int_t i = firstIndex; i <= lastIndex; i++) {
gOutput2->SetPoint(i - firstIndex,xOutput[i],yOutput[i]);
}
TCanvas *cgOutput2 = new TCanvas("cgOutput2", "cgOutput2", 1200,800);
gOutput2->Draw("AL");
// first hysteresis plot
Double_t step;
Double_t *xInput2;
xInput2 = gInput2->GetX();
cout << "xInput2[input2GraphPoints - 1] = " << xInput2[input2GraphPoints - 1] << endl;
cout << "xInput2[0] = " << xInput2[0] << endl;
step = (xInput2[input2GraphPoints - 1] - xInput2[0])/output2GraphPoints;
cout << "step = " << step << endl;
// in case gInput2 and gOutput2 contain a different number of points create the hysteresis plot with gOutput2 points
// and modify the yInput2 to match the number of points of yOutput2
vector<double> yInput2;
for(Int_t i = 0; i < output2GraphPoints; i++) {
yInput2.push_back(gInput2->Eval(xInput2[0] + i*step));
}
Double_t *yOutput2;
yOutput2 = gOutput2->GetY();
TGraphErrors *gHyst = new TGraphErrors(output2GraphPoints, &yInput2.at(0),yOutput2);
gHyst->SetTitle("Hysteresis plot");
gHyst->GetXaxis()->SetTitle("Vin(t) [mV]");
gHyst->GetYaxis()->SetTitle("Vout(t) [mV]");
gHyst->GetYaxis()->SetTitleOffset(1.4);
TCanvas *cgHyst = new TCanvas("cgHyst", "cgHyst", 1200,800);
cgHyst->SetLeftMargin(0.12);
gHyst->Draw("AL");
// collection of graphs
TMultiGraph *mgInputOutput = new TMultiGraph();
mgInputOutput->Add(gInput);
mgInputOutput->Add(gOutput);
mgInputOutput->SetTitle("Input and output");
TCanvas *cmgInputOutput = new TCanvas("cmgInputOutput", "Input and output", 1200,800);
mgInputOutput->Draw("AL");
cmgInputOutput->Update();
legend = new TLegend(0.65,0.68,0.86,0.86);
legend->AddEntry(gInput, "Input", "lp");
legend->AddEntry(gOutput, "Output", "lp");
legend->SetMargin(0.4);
legend->SetTextSize(0.04);
legend->Draw();
cmgInputOutput->Modified();
}
void DrawCosmicResult(){
TFile* tf = new TFile("Cosmic3Out.root");
TTree* trin = (TTree*)tf->Get("trOut");
const int nCSI = 2716;
Int_t RunNumber;
Int_t EventNumber;
Double_t ScintiSignal = 0;
Double_t ScintiHHTime = -500.;
Double_t ScintiTime =-500.;
Int_t nCSIDigi = 0;
Double_t CSIDigiE[nCSI];//nCSIDigi
Double_t CSIDigiTime[nCSI];//nCSIDigi
Double_t CSIDigiHHTime[nCSI];//nCSIDigi
Int_t CSIDigiID[nCSI];//nCSIDigi
Double_t CSIDigiSignal[nCSI];//nCSIDigi
Double_t FitP0[2];
Double_t FitP1[2];
Double_t FitChisq[2];
Double_t CSIDigiDeltaT0[nCSI];//nCSIDigi
Double_t CSIDigiDeltaT1[nCSI];//nCSIDigi
Int_t CosmicTrigUp;
Int_t CosmicTrigDn;
Double_t Roh;
Double_t Theta;
trin->SetBranchAddress( "RunNumber" , &RunNumber );
trin->SetBranchAddress( "EventNumber" , &EventNumber );
trin->SetBranchAddress( "ScintiSignal" , &ScintiSignal );
trin->SetBranchAddress( "ScintiHHTimne" , &ScintiHHTime );
trin->SetBranchAddress( "ScintiTime" , &ScintiTime );
trin->SetBranchAddress( "nCSIDigi" , &nCSIDigi );
trin->SetBranchAddress( "CSIDigiE" , CSIDigiE );
trin->SetBranchAddress( "CSIDigiTime" , CSIDigiTime );
trin->SetBranchAddress( "CSIDigiHHTime" , CSIDigiHHTime );
trin->SetBranchAddress( "CSIDigiID" , CSIDigiID );
trin->SetBranchAddress( "CSIDigiSignal" , CSIDigiSignal );
trin->SetBranchAddress( "CSIDigiDeltaT0" , CSIDigiDeltaT0 );
trin->SetBranchAddress( "CSIDigiDeltaT1" , CSIDigiDeltaT1 );
trin->SetBranchAddress( "FitP0" , FitP0 );
trin->SetBranchAddress( "FitP1" , FitP1 );
trin->SetBranchAddress( "FitChisq" , FitChisq );
trin->SetBranchAddress( "CosmicTrigUp" , &CosmicTrigUp );
trin->SetBranchAddress( "CosmicTrigDn" , &CosmicTrigDn );
trin->SetBranchAddress( "Roh" , &Roh );
trin->SetBranchAddress( "Theta" , &Theta );
TFile* tfout = new TFile("CosmicOut_hist3.root", "recreate");
TH2D* hisDeltaChannel = new TH2D("hisDeltaChannel","hisDeltaChannel",2716,0,2716,100,-10,10);
TH1D* hisDelta[2716];
TGraphErrors* grDelta = new TGraphErrors();
TGraphErrors* grRES = new TGraphErrors();
TCanvas *can = new TCanvas("can","",800,800);
for( int i = 0; i< 2716; i++){
hisDelta[i] = new TH1D(Form("hisDelta%d",i ),Form("hisDelta%d",i),100,-10,10);
}
for( int ievent = 0; ievent < trin->GetEntries(); ievent++){
trin->GetEntry(ievent);
for( int idigi = 0; idigi < nCSIDigi ; idigi++){
hisDelta[ CSIDigiID[ idigi ] ]->Fill( CSIDigiDeltaT1[ idigi ] );
hisDeltaChannel->Fill( CSIDigiID[ idigi ] , CSIDigiDeltaT1[ idigi ] );
//std::cout << CSIDigiID[ idigi ] << std::endl;
}
}
for( int i = 0; i< 2716; i++){
//std::cout << hisDelta[i]->GetEntries() << std::endl;
if( hisDelta[i]->GetEntries() > 10){
int rst = hisDelta[i]->Fit("gaus","Q","",hisDelta[i]->GetBinCenter( hisDelta[i]->GetMaximumBin() ) - 3, hisDelta[i]->GetBinCenter( hisDelta[i]->GetMaximumBin() )+3);
TF1* func = NULL;
func = hisDelta[i]->GetFunction("gaus");
if( func != NULL ){
grDelta->SetPoint( grDelta->GetN(), i, func->GetParameter(1));
grDelta->SetPointError( grDelta->GetN()-1, 0, func->GetParError(2));
grRES->SetPoint( grRES->GetN() , i , func->GetParameter(2));
}
}
/*
hisDelta[i]->Draw();
can->Modified();
can->Update();
getchar();
*/
hisDelta[ i ] ->Write();
}
std::ofstream ofs("TimeResolutionCosmic3.dat");
int ID[2716];
double Delta[2716];
double Resolution[2716];
for( int i = 0; i< 2716; i++){
Resolution[i] = 0xFFFF;
Delta[i] = 0xFFFF;
}
for( int i = 0; i< grRES->GetN(); i++){
Delta[(int)(grDelta->GetX()[i])] = grDelta->GetY()[i];
Resolution[(int)(grRES->GetX()[i])] = grRES->GetY()[i] ;
}
for( int i = 0; i< 2716; i++){
ofs << i << "\t"
<< Delta[i] << "\t"
<< Resolution[i] << "\n";
}
grDelta->SetNameTitle("grDelta","grDelta");
grRES->SetNameTitle("grRES","grRES");
grDelta->Write();
grRES->Write();
hisDeltaChannel->Write();
tfout->Close();
ofs.close();
}
void Drawmethodcomp(){
const int nDil = 8;
const double centDil[nDil+1] = {1.0,0.7,0.6,0.5,0.4,0.3,0.2,0.1,0};
double centDilbin[nDil];
for(int i=0;i<nDil;i++)
centDilbin[i]=0.29+i+N-1-nDil;
const double NpartDil[nDil] = {8.75,30.51,53.30,86.23,130.06,187.35,261.49,355.45};
const double NpartDilerr[nDil] = {1.13,3.02,3.95,4.35,4.60,4.44,3.96,2.83};
const double NcollDil[nDil] = {8.01,38.86,86.85,175.76,326.06,563.21,926.79,1484.49};
const double NcollDilerr[nDil] = {1.41,6.41,12.48,21.13,34.27,52.66,81.37,120.0};
TGraphErrors *graphNpartDil = new TGraphErrors(nDil,centDilbin,NpartDil,0,NpartDilerr);
TGraphErrors *graphNcollDil = new TGraphErrors(nDil,centDilbin,NcollDil,0,NcollDilerr);
TCanvas *c1 = new TCanvas("c1","c1",1,1,550,460);
c1->SetLogy();
c1->SetFillColor(10);
c1->SetFrameFillColor(0);
c1->SetFrameBorderSize(0);
c1->SetFrameBorderMode(0);
c1->SetLeftMargin(0.15);
c1->SetBottomMargin(0.15);
c1->SetTopMargin(0.02);
c1->SetRightMargin(0.02);
gStyle->SetOptStat(0);
c1->SetTicks(-1);
N=N-1;
TString str="Ncoll";
TH1D* hist = new TH1D("","",N,0,N);
hist->GetXaxis()->SetNdivisions(502);
if(method==0)
hist->SetXTitle("Centrality");
else
hist->SetXTitle("HF #Sigma E_{T} |#eta|>3");
hist->SetYTitle(Form("<%s> and systematic errors",str.Data()));
hist->SetMinimum(1);
hist->SetMaximum(3999.99);
hist->GetXaxis()->CenterTitle(0);
hist->GetYaxis()->CenterTitle(1);
hist->GetYaxis()->SetTitleOffset(1.1);
hist->GetXaxis()->SetTitleOffset(1.1);
hist->GetXaxis()->SetTitleSize(0.056);
hist->GetYaxis()->SetTitleSize(0.056);
hist->GetXaxis()->SetLabelSize(0.05);
hist->GetYaxis()->SetLabelSize(0.05);
hist->GetXaxis()->SetLabelOffset(99);
hist->Draw();
TFile *f=TFile::Open(outG);
TGraphErrors* graph = (TGraphErrors*)f->Get(Form("std/%s_graph",str.Data()));
// TGraphErrors* Gri055_graph = (TGraphErrors*)f->Get(Form("Gri055/%s_graph",str.Data()));
// TGraphErrors* Gri101_graph = (TGraphErrors*)f->Get(Form("Gri101/%s_graph",str.Data()));
TVectorD *centbin = (TVectorD*)f->Get(Form("std/G0/centbin"));
TVectorD *kpoint = (TVectorD*)f->Get(Form("std/G0/kpoint"));
TFile *f1=TFile::Open(Form("../../OneComp/double_side/%s",outG.Data()));
TGraphErrors* graph1 = (TGraphErrors*)f1->Get(Form("std/%s_graph",str.Data()));
// TGraphErrors* Gri055_graph = (TGraphErrors*)f->Get(Form("Gri055/%s_graph",str.Data()));
// TGraphErrors* Gri101_graph = (TGraphErrors*)f->Get(Form("Gri101/%s_graph",str.Data()));
TVectorD *centbin1 = (TVectorD*)f1->Get(Form("std/G0/centbin"));
TVectorD *kpoint1 = (TVectorD*)f1->Get(Form("std/G0/kpoint"));
graph->SetTitle("g1");
graph->SetMarkerStyle(20);
graph->SetMarkerColor(1);
graph->SetLineColor(1);
graph->SetLineWidth(2);
graph->SetMarkerSize(1.2);
graph->Draw("Psameez");
graph1->SetMarkerStyle(24);
graph1->SetMarkerColor(4);
graph1->SetLineColor(4);
graph1->SetLineWidth(2);
graph1->SetMarkerSize(1.2);
graph1->Draw("Psameez");
/*
Gri055_graph->SetTitle("g2");
Gri055_graph->SetMarkerStyle(33);
Gri055_graph->SetMarkerColor(2);
Gri055_graph->SetLineColor(2);
Gri055_graph->SetLineWidth(2);
Gri055_graph->SetMarkerSize(1.2);
Gri055_graph->Draw("Psameez");
Gri101_graph->SetTitle("g3");
Gri101_graph->SetMarkerStyle(34);
Gri101_graph->SetMarkerColor(4);
Gri101_graph->SetLineColor(4);
Gri101_graph->SetLineWidth(2);
Gri101_graph->SetMarkerSize(1.2);
Gri101_graph->Draw("Psameez");
*/
graphNpartDil->SetMarkerSize(1.2);
graphNpartDil->SetLineColor(2);
graphNpartDil->SetLineWidth(2);
graphNpartDil->SetMarkerStyle(33);
graphNpartDil->SetMarkerColor(2);
graphNcollDil->SetMarkerSize(1.2);
graphNcollDil->SetLineColor(2);
graphNcollDil->SetLineWidth(2);
graphNcollDil->SetMarkerStyle(33);
graphNcollDil->SetMarkerColor(2);
if(str=="Npart") graphNpartDil->Draw("Psame");
if(str=="Ncoll") graphNcollDil->Draw("Psame");
std::vector<TString> label(N);
for(int i=0;i<N;i++)
if(method==0)label[i] = Form("%.2f-%.2f%%",(*centbin)[i]*100,(*centbin)[i+1]*100);
else label[i] = Form("%.2f-%.2f",(*kpoint)[i],(*kpoint)[i+1]);
TLatex *tex1= new TLatex(0.2,0.9,"CMS Preliminary PbPb #sqrt{s_{NN}} = 2.76 TeV");
tex1->SetNDC();
tex1->SetTextColor(1);
tex1->SetTextFont(42);
tex1->SetTextSize(0.05);
tex1->Draw();
double y = gPad->GetUymin();
// - 0.2*h->GetYaxis()->GetBinWidth(1);
TText t;
t.SetTextAngle(45);
t.SetTextSize(0.03);
t.SetTextAlign(33);
for (int i=0;i<N;i++) {
double x = hist->GetXaxis()->GetBinCenter(i+1);
t.DrawText(x,y,label[i]);
}
TLegend *leg0 = new TLegend(0.18,0.70,0.50,0.85);
leg0->SetFillColor(10);
leg0->SetBorderSize(0);
leg0->SetTextFont(42);
leg0->SetTextSize(0.047);
leg0->AddEntry(graph,"From Ancestor fitting","p");
leg0->AddEntry(graph1,"From One Comp fitting","p");
// leg0->AddEntry(Gri055_graph,"Gribov #Omega=0.55","p");
// leg0->AddEntry(Gri101_graph,"Gribov #Omega=1.01","p");
if(str=="Npart") leg0->AddEntry(graphNpartDil,"Npart from run I","p");
if(str=="Ncoll") leg0->AddEntry(graphNcollDil,"Ncoll from run I","p");
leg0->Draw();
c1->SaveAs(Form("%sGri.png",str.Data()));
c1->SaveAs(Form("%sGri.pdf",str.Data()));
TCanvas *c2 = new TCanvas("c2","c2",1,1,550,460);
c2->SetFillColor(10);
c2->SetFrameFillColor(0);
c2->SetFrameBorderSize(0);
c2->SetFrameBorderMode(0);
c2->SetLeftMargin(0.15);
c2->SetBottomMargin(0.15);
c2->SetTopMargin(0.02);
c2->SetRightMargin(0.02);
c2->SetTicks(-1);
c2->cd();
TGraphErrors* fdvf1 = (TGraphErrors*)graph->Clone("fdvf1");
TGraphErrors* f1dvDil = (TGraphErrors*)graph->Clone("f1dvDil");
TGraphErrors* fdvDil = (TGraphErrors*)graph->Clone("fdvDil");
TGraphErrors* Dilsys = (TGraphErrors*)graph->Clone("Dilsys");
TGraphErrors* Dilsys2 = (TGraphErrors*)graph->Clone("Dilsys2");
for(int ip = 0;ip<fdvf1->GetN();ip++){
double x = graph->GetX()[ip];
double ey = graph->GetEY()[ip];
double y = graph->GetY()[ip];
double ey1 = graph1->GetEY()[ip];
double y1 = graph1->GetY()[ip];
double eyNcoll = graphNcollDil->GetEY()[ip];
double yNcoll = graphNcollDil->GetY()[ip];
double eyNpart = graphNpartDil->GetEY()[ip];
double yNpart = graphNpartDil->GetY()[ip];
if(y1!=0 && y!=0){
fdvf1->SetPoint(ip,x,y/y1);
fdvf1->SetPointError(ip,0,y/y1*sqrt((ey/y)**2+(ey1/y1)**2));
if(str=="Ncoll"){
fdvDil->SetPoint(ip,x,y/yNcoll);
double yerr = y/yNcoll*sqrt((ey/y)**2+(eyNcoll/yNcoll)**2);
fdvDil->SetPointError(ip,0,0);
f1dvDil->SetPoint(ip,x,y1/yNcoll);
double y1err = y1/yNcoll*sqrt((ey1/y1)**2+(eyNcoll/yNcoll)**2);
f1dvDil->SetPointError(ip,0,0);
Dilsys->SetPoint(ip,x,1.);
Dilsys->SetPointError(ip,0,TMath::Max(fabs(y1/yNcoll-1),fabs(y/yNcoll-1)));
Dilsys2->SetPoint(ip,x,1.);
Dilsys2->SetPointError(ip,0,TMath::Max(yerr,y1err));
}
else if(str=="Npart"){
fdvDil->SetPoint(ip,x,y/yNpart);
double yerr = y/yNpart*sqrt((ey/y)**2+(eyNcoll/yNpart)**2);
fdvDil->SetPointError(ip,0,0);
f1dvDil->SetPoint(ip,x,y1/yNpart);
double y1err = y1/yNpart*sqrt((ey1/y1)**2+(eyNcoll/yNcoll)**2);
f1dvDil->SetPointError(ip,0,0);
Dilsys->SetPoint(ip,x,1.);
Dilsys->SetPointError(ip,0,TMath::Max(fabs(y1/yNpart-1),fabs(y/yNpart-1)));
Dilsys2->SetPoint(ip,x,1.);
Dilsys2->SetPointError(ip,0,TMath::Max(yerr,y1err));
}
}
}
hist->SetMinimum(0.5);
hist->SetMaximum(1.5);
hist->SetYTitle(Form("<%s> ratio",str.Data()));
hist->Draw();
fdvf1->SetMarkerStyle(20);
fdvf1->SetMarkerColor(1);
fdvf1->SetLineColor(1);
fdvf1->SetLineWidth(2);
fdvf1->SetMarkerSize(1.4);
//fdvf1->Draw("Psameez");
f1dvDil->SetMarkerStyle(24);
f1dvDil->SetMarkerColor(2);
f1dvDil->SetLineColor(2);
f1dvDil->SetLineWidth(2);
f1dvDil->SetMarkerSize(1.4);
fdvDil->SetMarkerStyle(20);
fdvDil->SetMarkerColor(4);
fdvDil->SetLineColor(4);
fdvDil->SetLineWidth(2);
fdvDil->SetMarkerSize(1.4);
Dilsys->SetFillColor(kYellow+2);
Dilsys2->SetFillColor(kYellow+1);
//Dilsys2->Draw("e3same");
Dilsys->Draw("e3same");
fdvDil->Draw("Psameez");
f1dvDil->Draw("Psameez");
tex1->Draw();
TLine *l = new TLine(0,1,N,1);
l->SetLineStyle(2);
l->SetLineWidth(3);
l->Draw("same");
TLegend *leg1 = new TLegend(0.38,0.72,0.75,0.86);
leg1->SetFillColor(10);
leg1->SetBorderSize(0);
leg1->SetTextFont(42);
leg1->SetTextSize(0.04);
//leg1->AddEntry(fdvf1,"Ancestor fitting/One Comp fitting","p");
leg1->AddEntry(f1dvDil,"One Component fitting/Run I fitting","p");
leg1->AddEntry(fdvDil,"Two Component fitting/Run I fitting","p");
leg1->AddEntry(Dilsys,"RunI fitting systematics","f");
// leg1->AddEntry(Dilsys2,"RunI fitting ratio systematics","f");
double y = gPad->GetUymin()+0.5;
for (int i=0;i<N;i++) {
double x = hist->GetXaxis()->GetBinCenter(i+1);
t.DrawText(x,y,label[i]);
}
leg1->Draw();
c2->SaveAs(Form("%sGriratio.png",str.Data()));
c2->SaveAs(Form("%sGriratio.pdf",str.Data()));
}
//------------------------------------------------------------------------------
//
// drawXS
//
//------------------------------------------------------------------------------
void drawXS(UInt_t theCharge = WInclusive)
{
gStyle->SetEndErrorSize(5);
// 7 TeV inclusive
//----------------------------------------------------------------------------
xs_value[WInclusive][EEE] = 23.00;
xs_value[WInclusive][EEM] = 19.67;
xs_value[WInclusive][MME] = 19.81;
xs_value[WInclusive][MMM] = 21.02;
xs_value[WInclusive][all] = 20.76;
xs_stat[WInclusive][EEE] = 3.10;
xs_stat[WInclusive][EEM] = 2.73;
xs_stat[WInclusive][MME] = 2.60;
xs_stat[WInclusive][MMM] = 2.30;
xs_stat[WInclusive][all] = 1.32;
xs_syst[WInclusive][EEE] = 1.39;
xs_syst[WInclusive][EEM] = 1.50;
xs_syst[WInclusive][MME] = 1.55;
xs_syst[WInclusive][MMM] = 1.47;
xs_syst[WInclusive][all] = 1.13;
xs_lumi[WInclusive][EEE] = 0.51;
xs_lumi[WInclusive][EEM] = 0.43;
xs_lumi[WInclusive][MME] = 0.44;
xs_lumi[WInclusive][MMM] = 0.46;
xs_lumi[WInclusive][all] = 0.46;
// 7 TeV W+
//----------------------------------------------------------------------------
xs_value[WPlus][EEE] = 13.39;
xs_value[WPlus][EEM] = 13.18;
xs_value[WPlus][MME] = 14.14;
xs_value[WPlus][MMM] = 11.43;
xs_value[WPlus][all] = 12.73;
xs_stat[WPlus][EEE] = 2.39;
xs_stat[WPlus][EEM] = 2.24;
xs_stat[WPlus][MME] = 2.19;
xs_stat[WPlus][MMM] = 1.71;
xs_stat[WPlus][all] = 1.04;
xs_syst[WPlus][EEE] = 0.75;
xs_syst[WPlus][EEM] = 0.64;
xs_syst[WPlus][MME] = 0.74;
xs_syst[WPlus][MMM] = 0.53;
xs_syst[WPlus][all] = 0.59;
xs_lumi[WPlus][EEE] = 0.29;
xs_lumi[WPlus][EEM] = 0.29;
xs_lumi[WPlus][MME] = 0.31;
xs_lumi[WPlus][MMM] = 0.25;
xs_lumi[WPlus][all] = 0.28;
// 7 TeV W-
//----------------------------------------------------------------------------
xs_value[WMinus][EEE] = 9.49;
xs_value[WMinus][EEM] = 6.51;
xs_value[WMinus][MME] = 5.73;
xs_value[WMinus][MMM] = 9.48;
xs_value[WMinus][all] = 7.46;
xs_stat[WMinus][EEE] = 1.95;
xs_stat[WMinus][EEM] = 1.58;
xs_stat[WMinus][MME] = 1.40;
xs_stat[WMinus][MMM] = 1.52;
xs_stat[WMinus][all] = 0.79;
xs_syst[WMinus][EEE] = 0.60;
xs_syst[WMinus][EEM] = 0.37;
xs_syst[WMinus][MME] = 0.37;
xs_syst[WMinus][MMM] = 0.50;
xs_syst[WMinus][all] = 0.40;
xs_lumi[WMinus][EEE] = 0.21;
xs_lumi[WMinus][EEM] = 0.14;
xs_lumi[WMinus][MME] = 0.13;
xs_lumi[WMinus][MMM] = 0.21;
xs_lumi[WMinus][all] = 0.16;
// Do the work
//----------------------------------------------------------------------------
TGraphErrors* gStat = new TGraphErrors(nChannel);
TGraphErrors* gSyst = new TGraphErrors(nChannel);
TGraphErrors* gLumi = new TGraphErrors(nChannel);
for (UInt_t i=0; i<nChannel; i++)
{
Double_t errorSquared = (xs_stat[theCharge][i] * xs_stat[theCharge][i]);
gStat->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0);
errorSquared += (xs_syst[theCharge][i] * xs_syst[theCharge][i]);
gSyst->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0);
errorSquared += (xs_lumi[theCharge][i] * xs_lumi[theCharge][i]);
gLumi->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0);
gStat->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1);
gSyst->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1);
gLumi->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1);
}
// Cosmetics
//----------------------------------------------------------------------------
gStat->SetLineWidth (2);
gStat->SetMarkerSize (1.3);
gStat->SetMarkerStyle(kFullCircle);
gSyst->SetLineColor (kRed);
gSyst->SetLineWidth (2);
gSyst->SetMarkerSize (1.3);
gSyst->SetMarkerStyle(kFullCircle);
gLumi->SetLineColor (kBlue);
gLumi->SetLineWidth (2);
gLumi->SetMarkerSize (1.3);
gLumi->SetMarkerStyle(kFullCircle);
// Draw
//----------------------------------------------------------------------------
TString suffix = "7TeV_" + sCharge[theCharge];
TCanvas* canvas = new TCanvas("ratioNLO_" + suffix, "ratioNLO_" + suffix);
canvas->SetLeftMargin(canvas->GetRightMargin());
Double_t xmin = 0.0;
Double_t xmax = 2.0;
Double_t ylegend = 1.2;
Double_t ymin = -0.6;
Double_t ymax = nChannel + ymin + ylegend;
TH2F* h2 = new TH2F("h2_" + suffix, "", 100, xmin, xmax, 100, ymin, ymax);
h2->Draw();
// NLO WZ cross-section
//----------------------------------------------------------------------------
TBox* nlo = new TBox(1. - xs_nlo_left [theCharge] / xs_nlo[theCharge], ymin,
1. + xs_nlo_right[theCharge] / xs_nlo[theCharge], ymax - ylegend);
nlo->SetLineColor(0);
nlo->SetFillColor(kGray);
nlo->SetFillStyle(1001);
nlo->Draw("e2,same");
TLine* line = new TLine(1., ymin, 1., ymax - ylegend);
line->SetLineColor(kGray+1);
line->SetLineWidth(2);
line->Draw("same");
// Cross sections
//----------------------------------------------------------------------------
gLumi->Draw("p,same");
gSyst->Draw("p,same");
gStat->Draw("p,same");
// Labels
//----------------------------------------------------------------------------
for (UInt_t i=0; i<nChannel; i++) {
Double_t x = gStat->GetX()[i];
Double_t y = gStat->GetY()[i];
Double_t gStatError = gStat->GetErrorX(i);
Double_t gSystError = gSyst->GetErrorX(i);
Double_t gLumiError = gLumi->GetErrorX(i);
DrawTLatex(42, xmin+0.06, y+0.15, 0.035, 12,
Form("%s %.2f #pm %.2f",
lChannel[i].Data(), x, gLumiError), 0);
gLumiError = sqrt(gLumiError*gLumiError - gSystError*gSystError);
gSystError = sqrt(gSystError*gSystError - gStatError*gStatError);
DrawTLatex(42, xmin+0.06, y-0.15, 0.025, 12,
Form("%.2f #pm %.2f #pm %.2f #pm %.2f",
x, gStatError, gSystError, gLumiError), 0);
}
DrawTLatex(42, 0.050, 0.975, _bigLabelSize, 13, "CMS Preliminary");
DrawTLatex(42, 0.940, 0.983, _bigLabelSize, 33,
Form("#sqrt{s} = 7 TeV, L = %.1f fb^{-1}", luminosity/1e3));
TString swz = "";
if (theCharge == WPlus) swz = "W^{+}Z";
else if (theCharge == WMinus) swz = "W^{-}Z";
else swz = "W^{#pm}Z";
h2->GetXaxis()->CenterTitle();
h2->GetXaxis()->SetTitleOffset(1.4);
h2->GetXaxis()->SetTitle(Form("#sigma_{%s}^{exp} / #sigma_{%s}^{theory}",
swz.Data(),
swz.Data()));
h2->GetYaxis()->SetTitle("");
// Remove y-axis labels
//----------------------------------------------------------------------------
TAxis* yaxis = h2->GetYaxis();
for (Int_t j=1; j<yaxis->GetNbins(); j++) yaxis->SetBinLabel(j, "");
// Additional legend
//----------------------------------------------------------------------------
DrawLegend(0.645, 0.840, gStat, " stat.", "lp");
DrawLegend(0.645, 0.795, nlo, " theory", "f");
DrawLegend(0.800, 0.840, gSyst, " syst.", "l");
DrawLegend(0.800, 0.795, gLumi, " lumi.", "l");
// Save
//----------------------------------------------------------------------------
canvas->Update();
canvas->GetFrame()->DrawClone();
canvas->RedrawAxis();
canvas->SaveAs(Form("pdf/ratioNLO_%s.pdf", suffix.Data()));
canvas->SaveAs(Form("png/ratioNLO_%s.png", suffix.Data()));
}
int postprocessingSysError(){
cout<<endl<<endl<<endl<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Postproccess all systematic uncertainties! %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<endl<<endl;
gErrorIgnoreLevel = 1001;
const TString method = "RMS99";
const TString type = "PFCHS";
const int nEta =4;
double eta_bins[5] = {0., 0.5, 1.1, 1.7, 2.3};
// For looking at different systematic uncertainties independently
const bool QCD = true;
const bool JEC = true;
const bool flavor = true;
const bool PU = true;
const bool MC = true;
TString etaString, filename;
TString rootFiles, AuxString;
TString JetType = "PFCHS";
TString Method = "RMS99";
double *ratioEtaBinnedX = new double[nEta];
double *ratioEtaBinnedY = new double[nEta];
double *ratioEtaBinnedEX = new double[nEta];
double *ratioEtaBinnedEY = new double[nEta];
double *ratioEtaBinnedQCDUpY = new double[nEta];
double *ratioEtaBinnedQCDDownY = new double[nEta];
TF1 *QCDuncertainty;
if(QCD){
rootFiles = (TString) "scripts/plotsQCD/FinalErrorsQCD_" + type + (TString) "_" + method + (TString) ".root";
TFile *_file = TFile::Open(rootFiles);
_file->GetObject("function",QCDuncertainty);
}
for(int eta = 0; eta < nEta; eta++){
//cout<< endl<<endl<<endl<<eta+1<<". eta Bin!!"<<endl;
// Read the MC and data results
rootFiles = (TString) "root_files_FINAL_data/Resolution_for_" + (long) (eta+1) + (TString) "_eta_bin_" + JetType + (TString) "_data_" + Method + (TString) ".root";
TGraphErrors* JERData = readTGraphErrors(rootFiles,"Graph;1","Graph");
rootFiles = (TString) "root_files_FINAL_mc/Resolution_for_" + (long) (eta+1) + (TString) "_eta_bin_" + JetType + (TString) "_mc_" + Method + (TString) ".root";
TGraphErrors* JERMC = readTGraphErrors(rootFiles,"Graph","Graph");
if(eta+1 == 1) etaString = Form("JER for |#eta| < %4.1f",etaBins[eta+1]);
else etaString = Form("JER for %4.1f <|#eta|< %4.1f",etaBins[eta+1],etaBins[eta+2]);
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 1.) Calculate the ratio w/o systematic Uncertainties
int nData = JERData->GetN();
double *dataX = JERData->GetX();
double *dataY = JERData->GetY();
double *dataEX = JERData->GetEX();
double *dataEY = JERData->GetEY();
double *mcX = new double[nData];
double *mcY = new double[nData];
double *mcEX = new double[nData];
double *mcEY = new double[nData];
double *ratioX = new double[nData];
double *ratioY = new double[nData];
double *ratioEX = new double[nData];
double *ratioEY = new double[nData];
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Initialize some stuff for QCD uncertainty
double *ratioQCDUpY = new double[nData];
double *ratioQCDDownY = new double[nData];
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
int idx = 0;
for(int i=0; i<nData; i++){
JERMC -> GetPoint(idx,mcX[i],mcY[i]);
mcEX[i] = JERMC -> GetErrorX(idx);
mcEY[i] = JERMC -> GetErrorY(idx);
idx += 1;
if(TMath::Abs(dataX[i]/mcX[i] - 1.) > 0.1){
i -= 1;
continue;
}
ratioX[i] = 1./2.*(dataX[i] + mcX[i]);
ratioY[i] = dataY[i]/mcY[i];
ratioEX[i] = 1./2.*TMath::Sqrt(TMath::Power(dataEX[i],2)+TMath::Power(mcEX[i],2));
ratioEY[i] = TMath::Sqrt(TMath::Power((1./mcY[i]),2)*TMath::Power(dataEY[i],2)+TMath::Power((dataY[i]/(TMath::Power(mcY[i],2))),2)*TMath::Power(mcEY[i],2));
if(QCD){
// For QCD
ratioQCDUpY[i] = ratioY[i]*(1. + QCDuncertainty->Eval(ratioX[i]));
ratioQCDDownY[i] = ratioY[i]*(1. - QCDuncertainty->Eval(ratioX[i]));
//cout<<"QCDuncertainty->Eval(ratioX[i]) = "<<QCDuncertainty->Eval(ratioX[i])<<endl;
}
}
TGraphErrors *Ratio = new TGraphErrors(nData,ratioX,ratioY,ratioEX,ratioEY);
// For QCD
TGraphErrors *QCDUp = new TGraphErrors(nData,ratioX,ratioQCDUpY,ratioEX,ratioEY);
TGraphErrors *QCDDown = new TGraphErrors(nData,ratioX,ratioQCDDownY,ratioEX,ratioEY);
if(eta+1 == 1 ) AuxString = Form("Ratio between Data and MC for |#eta| < %4.1f",etaBins[eta+1]);
else AuxString = Form("Ratio between Data and MC for %4.1f <|#eta|<%4.1f",etaBins[eta+1],etaBins[eta+2]);
Ratio -> SetTitle(AuxString);
Ratio -> GetXaxis() -> SetTitle("Photon pT");
Ratio -> GetXaxis() -> SetTitleOffset(1.1);
Ratio -> GetYaxis() -> SetTitle("Ratio of JER (DATA/MC)");
Ratio -> GetYaxis() -> SetTitleOffset(1.2);
Ratio -> GetXaxis() -> SetLimits(0,600);
TF1* f1 = new TF1("name","pol0",0,600);
Ratio -> Fit("name","QR");
TF1* fitQCDUp = new TF1("fitQCDUp","pol0",0,600);
TF1* fitQCDDown = new TF1("fitQCDDown","pol0",0,600);
if(QCD){
// For QCD
QCDUp -> Fit("fitQCDUp","QR");
QCDDown -> Fit("fitQCDDown","QR");
}
TLegend *legend = 0;
legend = new TLegend(0.55,0.8,0.9,0.9);
legend -> SetFillColor(0);
legend -> SetHeader(Form(" %4.3f #pm %4.3f", f1 -> GetParameter(0), f1->GetParError(0)));
TCanvas *c11 = new TCanvas("c11",AuxString,200,10,500,500);
c11 -> cd();
Ratio -> SetMinimum(0.5);
Ratio -> SetMaximum(2.0);
Ratio -> Draw("AP");
legend -> Draw("same");
TLatex* info = new TLatex();
info-> SetNDC();
info->SetTextSize(0.045);
info->DrawLatex(0.22,0.84,Form("#splitline{#chi^{2} = %4.2f}{dof = %i}",f1 -> GetChisquare(),f1 -> GetNDF()));
filename = (TString) "plots/Ratio_Resolution_for_" + (long) (eta+1) + (TString) "_eta_bin_" + type + (TString) "_data_comparison_" + method + (TString) ".pdf";
c11 -> SaveAs(filename);
delete c11;
ratioEtaBinnedX[eta] = (eta_bins[eta+1] + eta_bins[eta])/2.;
ratioEtaBinnedY[eta] = f1 -> GetParameter(0);
ratioEtaBinnedEX[0]=0.25;
ratioEtaBinnedEX[1]=0.3;
ratioEtaBinnedEX[2]=0.3;
ratioEtaBinnedEX[3]=0.3;
ratioEtaBinnedEY[eta] = f1->GetParError(0);
if(QCD){
ratioEtaBinnedQCDUpY[eta] = fitQCDUp -> GetParameter(0);
ratioEtaBinnedQCDDownY[eta]= fitQCDDown -> GetParameter(0);
// Some additional stuff for QCD uncertainty
TCanvas *plotsQCD = new TCanvas("plotsQCD","plotsQCD",200,10,500,500);
plotsQCD -> cd();
Ratio -> SetMarkerColor(1);
Ratio -> SetLineColor(1);
Ratio -> SetMarkerStyle(20);
Ratio -> GetFunction("name")->SetLineColor(1);
QCDUp -> SetMarkerColor(3);
QCDDown -> SetMarkerColor(3);
QCDUp -> SetLineColor(3);
QCDDown -> SetLineColor(3);
QCDUp -> SetMarkerStyle(20);
QCDDown -> SetMarkerStyle(20);
QCDUp -> SetMarkerSize(0.8);
QCDDown -> SetMarkerSize(0.8);
QCDUp -> GetFunction("fitQCDUp")->SetLineColor(3);
QCDDown -> GetFunction("fitQCDDown")->SetLineColor(3);
Ratio -> Draw("AP");
QCDUp -> Draw("sameP");
QCDDown -> Draw("sameP");
delete legend;
legend = new TLegend(0.4,0.8,0.9,0.9);
legend -> SetFillColor(0);
legend -> SetTextSize(0.045);
legend -> AddEntry(Ratio,"Central Value","l");
legend -> AddEntry(QCDUp,Form("Upward variation: + %4.3f",abs(ratioEtaBinnedQCDUpY[eta]/ratioEtaBinnedY[eta]-1.)),"l");
legend -> AddEntry(QCDDown,Form("Downward variation: - %4.3f",abs(ratioEtaBinnedQCDDownY[eta]/ratioEtaBinnedY[eta]-1.)),"l");
legend -> Draw("same");
filename = (TString) "plots/plotsQCD_for_" + (long) (eta+1) + (TString) "_bin_" + type + (TString) "_" + method + (TString) ".pdf";
plotsQCD -> SaveAs(filename);
delete plotsQCD;
}
}
TGraphErrors* ratioEtaBinned = new TGraphErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ratioEtaBinnedEX,ratioEtaBinnedEY);
filename = (TString) "plots/RatioEtaBinned_" + type + (TString) "_" + method + (TString) ".root";
TFile *f = new TFile(filename,"RECREATE");
f -> WriteTObject(ratioEtaBinned,"Graph");
f->Close();
delete f;
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 1.) Calculate sys Error from QCD contamination
//cout<<endl;
double deltaRatioUpQCD[nEta] = {0.};
double deltaRatioDownQCD[nEta] = {0.};
if(QCD){
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpQCD[eta] = abs(ratioEtaBinnedQCDUpY[eta]/ratioEtaBinnedY[eta]-1.);
deltaRatioDownQCD[eta] = abs(ratioEtaBinnedQCDDownY[eta]/ratioEtaBinnedY[eta]-1.);
//cout<<"ratioEtaBinnedQCDDownY[eta]"<<ratioEtaBinnedQCDDownY[eta]<<endl;
//cout<<"ratioEtaBinnedY[eta]"<<ratioEtaBinnedY[eta]<<endl;
//cout<<"deltaRatioUpQCD["<<eta<<"] = "<<deltaRatioUpQCD[eta]<<endl;
//cout<<"deltaRatioDownQCD["<<eta<<"] = "<<deltaRatioDownQCD[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 2.) Calculate sys Error from JEC uncertainty (percentage change of MC result)
//cout<<endl;
double deltaRatioUpJEC[nEta] = {0.};
double deltaRatioDownJEC[nEta] = {0.};
if(JEC){
rootFiles = (TString) "scripts/plotsJEC/FinalEtaBinnedErrorsJECUp_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *JECuncertaintyUp = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelJECUp = JECuncertaintyUp -> GetY();
rootFiles = (TString) "scripts/plotsJEC/FinalEtaBinnedErrorsJECLow_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *JECuncertaintyLow = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelJECLow = JECuncertaintyLow -> GetY();
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpJEC[eta] = sysRelJECUp[eta];
deltaRatioDownJEC[eta] = sysRelJECLow[eta];
//cout<<"deltaRatioUpJEC["<<eta<<"] = "<<deltaRatioUpJEC[eta]<<endl;
//cout<<"deltaRatioDownJEC["<<eta<<"] = "<<deltaRatioDownJEC[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 3.) Calculate sys Error from Flavor uncertainty (percentage change of MC result)
//cout<<endl;
// Multiply on mc (as symmetric Error)
// ratioUp = 1/(1 - delta) * ratio
// ratioLow = 1/(1 + delta) * ratio
double deltaRatioUpFlavor[nEta] = {0.};
double deltaRatioDownFlavor[nEta] = {0.};
if(flavor){
rootFiles = (TString) "scripts/plotsFlavor/FinalEtaBinnedErrorsFlavorUp_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *FlavoruncertaintyUp = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelFlavorUp = FlavoruncertaintyUp -> GetY();
rootFiles = (TString) "scripts/plotsFlavor/FinalEtaBinnedErrorsFlavorLow_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *FlavoruncertaintyLow = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelFlavorLow = FlavoruncertaintyLow -> GetY();
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpFlavor[eta] = sysRelFlavorUp[eta];
deltaRatioDownFlavor[eta] = sysRelFlavorLow[eta];
//cout<<"deltaRatioUpFlavor["<<eta<<"] = "<<deltaRatioUpFlavor[eta]<<endl;
//cout<<"deltaRatioDownFlavor["<<eta<<"] = "<<deltaRatioDownFlavor[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 4.) Calculate sys Error from PU uncertainty (percentage change of MC result)
//cout<<endl;
double deltaRatioUpPU[nEta] = {0.};
double deltaRatioDownPU[nEta] = {0.};
if(PU){
rootFiles = (TString) "scripts/plotsPU/FinalEtaBinnedErrorsPUUp_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *PUuncertaintyUp = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelPUUp = PUuncertaintyUp -> GetY();
rootFiles = (TString) "scripts/plotsPU/FinalEtaBinnedErrorsPULow_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *PUuncertaintyLow = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelPULow = PUuncertaintyLow -> GetY();
// Multiply on mc (as symmetric Error)
// ratioUp = 1/(1 - delta) * ratio
// ratioUp = 1/(1 + delta) * ratio
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpPU[eta] = sysRelPUUp[eta];
deltaRatioDownPU[eta] = sysRelPULow[eta];
//cout<<"deltaRatioUpPU["<<eta<<"] = "<<deltaRatioUpPU[eta]<<endl;
//cout<<"deltaRatioDownPU["<<eta<<"] = "<<deltaRatioDownPU[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 5.) Calculate sys Error from Out-of Cone showering simulation (percentage change of full ratio result)
//cout<<endl;
double deltaRatioUpMC[nEta] = {0.};
double deltaRatioDownMC[nEta] = {0.};
if(MC){
rootFiles = (TString) "scripts/plotsMC/FinalErrorsMC_" + type + (TString) "_" + method + (TString) ".root";
TGraphErrors *MCuncertainty = readTGraphErrors(rootFiles,"graph","Graph");
double *sysRelMC = MCuncertainty -> GetY();
// Percentage change is only in one direction, to take this into account keep deltaRatioDownMC = 0
for(int eta = 0; eta<nEta; eta++){
deltaRatioUpMC[eta] = sysRelMC[eta];
deltaRatioDownMC[eta] = sysRelMC[eta];
//cout<<"deltaRatioUpMC["<<eta<<"] = "<<deltaRatioUpMC[eta]<<endl;
//cout<<"deltaRatioDownMC["<<eta<<"] = "<<deltaRatioDownMC[eta]<<endl;
}
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Take all systematic Uncertainties together and plot
//cout<<endl;
double *deltaTotalSysUp = new double[nEta];
double *deltaTotalSysDown = new double[nEta];
double *DeltaTotalSysUp = new double[nEta];
double *DeltaTotalSysDown = new double[nEta];
double *DeltaTotalDown = new double[nEta];
double *DeltaTotalUp = new double[nEta];
for(int eta = 0; eta<nEta; eta++){
// Add all systematic Uncertainties in quadrature (delta is relative Uncertainty)
deltaTotalSysUp[eta] = sqrt(TMath::Power(deltaRatioUpJEC[eta],2) + TMath::Power(deltaRatioUpFlavor[eta],2) + TMath::Power(deltaRatioUpPU[eta],2) + TMath::Power(deltaRatioUpMC[eta],2) + TMath::Power(deltaRatioUpQCD[eta],2));
deltaTotalSysDown[eta] = sqrt(TMath::Power(deltaRatioDownJEC[eta],2) + TMath::Power(deltaRatioDownFlavor[eta],2) + TMath::Power(deltaRatioDownPU[eta],2) + TMath::Power(deltaRatioDownMC[eta],2) + TMath::Power(deltaRatioDownQCD[eta],2));
// Calculation of the absolute Uncertainty with Delta = ratio * delta
DeltaTotalSysUp[eta] = deltaTotalSysUp[eta] * ratioEtaBinnedY[eta];
DeltaTotalSysDown[eta] = deltaTotalSysDown[eta] * ratioEtaBinnedY[eta];
// Calculate Systematic plus staistical Uncertainty
DeltaTotalUp[eta] = sqrt(pow(DeltaTotalSysUp[eta],2) + pow(ratioEtaBinnedEY[eta],2));
DeltaTotalDown[eta] = sqrt(pow(DeltaTotalSysDown[eta],2) + pow(ratioEtaBinnedEY[eta],2));
cout<<endl<<"relative: deltaTotalSysUp["<<eta<<"] = "<<fixed<<setprecision(3)<<deltaTotalSysUp[eta]<<endl;
cout<<"relative: deltaTotalSysDown["<<eta<<"] = "<<deltaTotalSysDown[eta]<<endl;
cout<<endl<<"absolute: DeltaTotalSysUp["<<eta<<"] = "<<DeltaTotalSysUp[eta]<<endl;
cout<<"absolute: DeltaTotalSysDown["<<eta<<"] = "<<DeltaTotalSysDown[eta]<<endl;
}
double ex[nEta] ={0.25,0.3,0.3,0.3};
TGraphAsymmErrors* ratioEtaBinnedSys = new TGraphAsymmErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ex,ex,DeltaTotalSysDown,DeltaTotalSysUp);
double *TotalSysUp = new double[nEta];
double *TotalSysDown = new double[nEta];
for(int i=0; i<nEta; i++){
TotalSysUp[i] = ratioEtaBinnedY[i]+DeltaTotalSysUp[i];
TotalSysDown[i] = ratioEtaBinnedY[i]-DeltaTotalSysDown[i];
}
TGraph* ratioSysBorderUp = new TGraph(nEta, ratioEtaBinnedX, TotalSysUp);
TGraph* ratioSysBorderDown = new TGraph(nEta, ratioEtaBinnedX, TotalSysDown);
TGraph* ratioRelativeErrorsUp = new TGraph(nEta,ratioEtaBinnedX,deltaTotalSysUp);
TGraph* ratioRelativeErrorsDown = new TGraph(nEta,ratioEtaBinnedX,deltaTotalSysDown);
TGraphErrors* ratioEtaBinnedStat = new TGraphErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ratioEtaBinnedEX,ratioEtaBinnedEY);
TGraphAsymmErrors* ratioEtaBinnedStatPlusSys = new TGraphAsymmErrors(nEta,ratioEtaBinnedX,ratioEtaBinnedY,ex,ex,DeltaTotalDown,DeltaTotalUp);
TCanvas *cFinal = new TCanvas("cFinal","cFinal",200,10,500,500);
cFinal -> cd();
ratioEtaBinnedSys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedSys -> GetXaxis() -> SetTitle("|#eta|");
if(PU && flavor && JEC && MC && QCD) etaString = "All sys. Uncertainties";
else if(PU && !flavor && !JEC && !MC && !QCD) etaString = "Only PU uncert.";
else if(!PU && flavor && !JEC && !MC && !QCD) etaString = "Only flavor uncert.";
else if(!PU && !flavor && JEC && !MC && !QCD) etaString = "Only JEC uncert.";
else if(!PU && !flavor && !JEC && MC && !QCD) etaString = "Only Out-of-Cone sim. uncert.";
else if(!PU && !flavor && !JEC && MC && !QCD) etaString = "Only Out-of-Cone sim. uncert.";
else if(!PU && !flavor && !JEC && !MC && QCD) etaString = "Only QCD uncert.";
else if(PU && flavor && JEC && !MC && QCD) etaString = "All besides MC uncertainty.";
else etaString = "Strange set of systematic uncertainties.";
cout<<endl<<etaString<<endl<<endl;
ratioEtaBinnedSys -> SetMarkerStyle(20);
ratioEtaBinnedSys -> SetMarkerSize(1.4);
ratioEtaBinnedSys -> SetFillColor(kGray);
ratioEtaBinnedSys -> SetFillStyle(3001);
ratioEtaBinnedSys -> SetLineColor(kGray);
ratioEtaBinnedSys -> SetMinimum(0.8);
ratioEtaBinnedSys -> SetMaximum(1.5);
ratioEtaBinnedSys -> GetXaxis() -> SetLimits(0., 2.3);
ratioEtaBinnedSys -> GetXaxis() -> SetNdivisions(6,6,0, "X");
ratioEtaBinnedSys -> DrawClone("Ae3p");
//ratioEtaBinnedSys -> SetPointError(0, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(1, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(2, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(3, 0., 0., 0., 0.);
//ratioEtaBinnedSys -> SetPointError(4, 0., 0., 0., 0.);
ratioEtaBinnedStat -> SetMarkerStyle(20);
ratioEtaBinnedStat -> SetMarkerSize(1.4);
ratioEtaBinnedStat -> SetFillColor(kGray);
ratioEtaBinnedStat -> SetFillStyle(3001);
ratioEtaBinnedStat -> SetLineColor(1);
ratioEtaBinnedStat -> Draw("psame");
TLatex *infoFinal = new TLatex();
infoFinal -> SetTextFont(132);
infoFinal -> SetNDC();
infoFinal -> SetTextSize(0.045);
infoFinal -> DrawLatex(0.2,0.8,etaString);
filename = (TString) "plots/FinalErrorPlot_" + type + (TString) "_" + method + (TString) ".pdf";
cFinal -> Print(filename,"pdf");
filename = (TString) "plots/FinalErrorPlot_" + type + (TString) "_" + method + (TString) ".pdf";
cFinal -> SaveAs(filename,"pdf");
delete cFinal;
filename = (TString) "plots/FinalRelativeErrorsUp_" + type + (TString) "_" + method + (TString) ".root";
f = new TFile(filename,"RECREATE");
f -> WriteTObject(ratioRelativeErrorsUp,"graph");
f->Close();
delete f;
filename = (TString) "plots/FinalRelativeErrorsLow_" + type + (TString) "_" + method + (TString) ".root";
f = new TFile(filename,"RECREATE");
f -> WriteTObject(ratioRelativeErrorsDown,"graph");
f->Close();
delete f;
ofstream RelativeErrors;
RelativeErrors.open("plots/Errors.txt");
RelativeErrors<<"Relative Errors: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<fixed<<setprecision(3)<<(deltaTotalSysDown[i]*100)<<"% / +"<<(deltaTotalSysUp[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<"Absolute Errors: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(DeltaTotalSysDown[i])<<" / +"<<(DeltaTotalSysUp[i])<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors JEC: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownJEC[i]*100)<<"% / +"<<(deltaRatioUpJEC[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors Flavor: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownFlavor[i]*100)<<"% / +"<<(deltaRatioUpFlavor[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors Out-of-Cone showering simulation: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownMC[i]*100)<<"% / +"<<(deltaRatioUpMC[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors QCD: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownQCD[i]*100)<<"% / +"<<(deltaRatioUpQCD[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Relative Errors PU reweighing: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(deltaRatioDownPU[i]*100)<<"% / +"<<(deltaRatioUpPU[i]*100)<<"%"<<endl;
}
RelativeErrors<<endl<<endl<<"Central values and statistical Uncertainty: "<<endl;
for(int i=0; i<nEta; i++){
RelativeErrors<<i+1<<". Eta bin: "<<"-"<<(ratioEtaBinnedY[i])<<" +/- "<<ratioEtaBinnedEY[i]<<endl;
}
RelativeErrors.close();
// Write directly full latex table with systematic and statistical unceratinty
ofstream latexTable;
latexTable.open("plots/latexTable.txt");
latexTable<<"\\renewcommand{\\arraystretch}{2.0}"<<endl;
latexTable<<"\\begin{center}"<<endl;
latexTable<<"\\begin{tabular}{ | c | c c c| }"<<endl;
latexTable<<"$|\\eta^{\\text{Jet}}|$ & Ratio & stat. & sys. \\\\\\hline"<<endl;
for(int z=0;z<nEta;z++){
latexTable<<"$"<<fixed<<setprecision(1)<<etaBins[z]<<" - "<<etaBins[z+1]<<"$ &"<<fixed<<setprecision(3)<<ratioEtaBinnedY[z]<<" & $\\pm "<<ratioEtaBinnedEY[z]<<"$ & $^{+"<<DeltaTotalSysUp[z]<<"}_{-"<<DeltaTotalSysDown[z]<<"}$ \\\\"<<endl;
}
latexTable<<"\\hline"<<endl;
latexTable<<"\\end{tabular}"<<endl;
latexTable<<"\\end{center}"<<endl<<endl<<endl<<endl<<endl;
latexTable<<"\\begin{center}"<<endl;
latexTable<<"\\begin{tabular}{ l| c | c | c | c |}"<<endl;
latexTable<<"\\multicolumn{1}{c}{} & \\multicolumn{4}{c}{$|\\eta^{\\text{Jet}}|$}\\\\\\hline"<<endl<<fixed<<setprecision(1);
for(int z=0;z<nEta;z++) latexTable<<"& \\textbf{"<<etaBins[z]<<" - "<<etaBins[z+1]<<"}";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Multijet contamination}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpQCD[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $-"<<deltaRatioDownQCD[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Flavor uncertainty}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpFlavor[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $"<<deltaRatioDownFlavor[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{JEC uncertainty}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpJEC[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $"<<deltaRatioDownJEC[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Out-of-Cone showering simulation}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpMC[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $-"<<deltaRatioDownMC[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{PU uncertainty}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaRatioUpPU[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $"<<deltaRatioDownPU[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline\\hline"<<endl;
latexTable<<"\\multirow{2}{*}{\\textbf{Total}}";
for(int z=0;z<nEta;z++) latexTable<<"& $+"<<deltaTotalSysUp[z]*100<<" \\% $ ";
latexTable<<"\\\\"<<endl;
for(int z=0;z<nEta;z++) latexTable<<"& $-"<<deltaTotalSysDown[z]*100<<" \\% $ ";
latexTable<<"\\\\\\hline"<<endl;
latexTable<<"\\end{tabular}"<<endl;
latexTable<<"\\end{center}"<<endl;
latexTable.close();
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Comparison to 2011 Data
cout<<endl;
gROOT->LoadMacro("tdrstyle_mod14.C");
setTDRStyle();
gROOT->LoadMacro("CMS_lumi.C");
writeExtraText = true; // if extra text
extraText = "Preliminary"; // default extra text is "Preliminary"
lumi_8TeV = "19.7 fb^{-1}"; // default is "19.7 fb^{-1}"
lumi_7TeV = "4.9 fb^{-1}"; // default is "5.1 fb^{-1}"
int iPeriod = 2; // 1=7TeV, 2=8TeV, 3=7+8TeV, 7=7+8+13TeV
gStyle->SetHatchesLineWidth(1);
gStyle->SetHatchesSpacing(2.2);
//-----------------------------------------------------
TCanvas *cFinal2 = new TCanvas("cFinal2","cFinal2",200,10,1000,1000);
cFinal2 -> cd();
double x_2011[4];
x_2011[0]=0.25;
x_2011[1]=0.80;
x_2011[2]=1.40;
x_2011[3]=2.00;
double y_2011[4];
y_2011[0]=1.052;
y_2011[1]=1.057;
y_2011[2]=1.096;
y_2011[3]=1.134;
double yErrStat_2011[4];
yErrStat_2011[0]=0.012;
yErrStat_2011[1]=0.012;
yErrStat_2011[2]=0.017;
yErrStat_2011[3]=0.035;
double yErrSysHigh_2011[4];
yErrSysHigh_2011[0]=0.062;
yErrSysHigh_2011[1]=0.056;
yErrSysHigh_2011[2]=0.063;
yErrSysHigh_2011[3]=0.087;
double yErrSysLow_2011[4];
yErrSysLow_2011[0]=0.061;
yErrSysLow_2011[1]=0.055;
yErrSysLow_2011[2]=0.062;
yErrSysLow_2011[3]=0.085;
double xErrLow_2011[4];
xErrLow_2011[0]=0.25;
xErrLow_2011[1]=0.3;
xErrLow_2011[2]=0.3;
xErrLow_2011[3]=0.3;
double xErrHigh_2011[4];
xErrHigh_2011[0]=0.25;
xErrHigh_2011[1]=0.3;
xErrHigh_2011[2]=0.3;
xErrHigh_2011[3]=0.3;
double yErrTotalHigh_2011[4];
double yErrTotalLow_2011[4];
for(int i=0; i<4; i++){
yErrTotalHigh_2011[i]=sqrt(pow(yErrStat_2011[i],2) + pow(yErrSysHigh_2011[i],2));
yErrTotalLow_2011[i]=sqrt(pow(yErrStat_2011[i],2) + pow(yErrSysLow_2011[i],2));
}
TGraphAsymmErrors *Res_2011_stat = new TGraphAsymmErrors(4,x_2011,y_2011,xErrLow_2011,xErrHigh_2011,yErrStat_2011,yErrStat_2011);
Res_2011_stat->SetName("Res_2011_stat");
TGraphAsymmErrors *Res_2011_sys = new TGraphAsymmErrors(4,x_2011,y_2011,xErrLow_2011,xErrHigh_2011,yErrSysLow_2011,yErrSysHigh_2011);
Res_2011_sys->SetName("Res_2011_sys");
TGraphAsymmErrors *Res_2011_total = new TGraphAsymmErrors(4,x_2011,y_2011,xErrLow_2011,xErrHigh_2011,yErrTotalLow_2011,yErrTotalHigh_2011);
Res_2011_sys->SetName("Res_2011_total");
//-----------------------------------------------------
ratioEtaBinnedStatPlusSys -> GetXaxis() -> SetTitle("|#eta|");
ratioEtaBinnedStatPlusSys -> GetXaxis() -> SetRangeUser(0., 2.3);
ratioEtaBinnedStatPlusSys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedSys -> GetXaxis() -> SetTitle("|#eta|");
ratioEtaBinnedSys -> GetXaxis() -> SetRangeUser(0., 2.3);
ratioEtaBinnedSys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedStat -> GetXaxis() -> SetTitle("|#eta|");
ratioEtaBinnedStat -> GetXaxis() -> SetRangeUser(0., 2.3);
ratioEtaBinnedStat -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
ratioEtaBinnedStat -> GetYaxis() -> SetRangeUser(0.8, 1.6);
Res_2011_stat -> GetXaxis() -> SetTitle("|#eta|");
Res_2011_stat -> GetXaxis() -> SetLimits(0., 2.3);
Res_2011_stat -> GetXaxis() -> SetNdivisions(505, "X");
Res_2011_stat -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
Res_2011_sys -> GetXaxis() -> SetTitle("|#eta|");
Res_2011_sys -> GetXaxis() -> SetLimits(0., 2.3);
Res_2011_sys -> GetXaxis() -> SetNdivisions(505, "X");
Res_2011_sys -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
Res_2011_total -> GetXaxis() -> SetTitle("|#eta|");
Res_2011_total -> GetXaxis() -> SetLimits(0., 2.3);
Res_2011_total -> GetXaxis() -> SetNdivisions(505, "X");
Res_2011_total -> GetYaxis() -> SetTitle("Data/MC ratio for JER");
Res_2011_total -> GetYaxis() -> SetRangeUser(0.8, 1.5);
ratioEtaBinnedStatPlusSys -> SetMarkerStyle(20);
ratioEtaBinnedStatPlusSys -> SetMarkerSize(2.0);
ratioEtaBinnedStatPlusSys -> SetLineColor(kPink-8);
ratioEtaBinnedStatPlusSys -> SetLineWidth(2);
ratioEtaBinnedStatPlusSys -> SetMarkerColor(kPink-8);
ratioEtaBinnedStatPlusSys -> SetFillColor(kPink-8);
ratioEtaBinnedStatPlusSys -> SetName("statPlusSys_2012");
ratioEtaBinnedStat -> SetMarkerStyle(20);
ratioEtaBinnedStat -> SetMarkerSize(2.0);
ratioEtaBinnedStat -> SetLineColor(kPink-8);
ratioEtaBinnedStat -> SetLineWidth(2);
ratioEtaBinnedStat -> SetMarkerColor(kPink-8);
ratioEtaBinnedStat -> SetFillColor(kPink-8);
ratioEtaBinnedStat -> SetName("Stat_2012");
ratioEtaBinnedStatPlusSys -> SetFillStyle(3244);
ratioEtaBinnedStat -> SetFillStyle(3144);
Res_2011_stat->SetMarkerStyle(24);
Res_2011_stat->SetMarkerSize(2.0);
Res_2011_stat->SetLineColor(kGray+2);
Res_2011_stat->SetLineWidth(2);
Res_2011_stat->SetLineWidth(2);
Res_2011_stat->SetFillStyle(1001);
Res_2011_total->SetMarkerStyle(24);
Res_2011_total->SetMarkerSize(2.0);
Res_2011_total->SetLineColor(1);
Res_2011_total->SetLineWidth(2);
Res_2011_total->SetFillColor(kGray);
Res_2011_total->SetFillStyle(1001);
Res_2011_total->SetLineColor(kGray+2);
Res_2011_total->Draw("a2");
Res_2011_stat->Draw("esame");
ratioEtaBinnedStatPlusSys -> Draw("2same");
Res_2011_stat->Draw("pXsame");
Res_2011_stat->SetMarkerSize(1.9);
Res_2011_stat->Draw("pXsame");
Res_2011_stat->SetMarkerSize(1.7);
Res_2011_stat->Draw("pXsame");
ratioEtaBinnedStatPlusSys -> Draw("pXsame");
ratioEtaBinnedStat -> Draw("esame");
TLegend *leg = new TLegend(0.18, 0.60, 0.55, 0.75);
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextFont(42);
leg->SetTextSize(0.045);
leg->AddEntry(Res_2011_total,"5/fb (7 TeV)", "pfl");
leg->AddEntry(ratioEtaBinnedStatPlusSys,"20/fb (8 TeV)", "pfl");
leg->Draw("same");
TLatex *info = new TLatex();
info->SetNDC();
info->DrawLatex(0.67,0.83,"Anti-k_{T} R=0.5");
info->DrawLatex(0.67,0.77,"PF+CHS");
CMS_lumi( cFinal2, iPeriod, 11 );
cFinal2->Print("plots/resultsComparisonFINAL.pdf","pdf");
cFinal2->SaveAs("plots/resultsComparisonFINAL.C");
return 0;
}
// Soft radiation corrections for L3Res
void softrad(double etamin=0.0, double etamax=1.3, bool dodijet=false) {
setTDRStyle();
writeExtraText = false; // for JEC paper CWR
TDirectory *curdir = gDirectory;
// Open jecdata.root produced by reprocess.C
TFile *fin = new TFile("rootfiles/jecdata.root","UPDATE");
assert(fin && !fin->IsZombie());
const int ntypes = 3;
const char* types[ntypes] = {"data", "mc", "ratio"};
const int nmethods = 2;
const char* methods[nmethods] = {"mpfchs1", "ptchs"};
const int nsamples = (dodijet ? 4 : 3);
const char* samples[4] = {"gamjet", "zeejet", "zmmjet", "dijet"};
string sbin = Form("eta%02.0f-%02.0f",10*etamin,10*etamax);
const char* bin = sbin.c_str();
const int nalphas = 4;
const int alphas[nalphas] = {30, 20, 15, 10};
// Z+jet bins
const double ptbins1[] = {30, 40, 50, 60, 75, 95, 125, 180, 300, 1000};
const int npt1 = sizeof(ptbins1)/sizeof(ptbins1[0])-1;
TH1D *hpt1 = new TH1D("hpt1","",npt1,&ptbins1[0]);
TProfile *ppt1 = new TProfile("ppt1","",npt1,&ptbins1[0]);
// gamma+jet bins
const double ptbins2[] = {30, 40, 50, 60, 75, 100, 125, 155, 180,
210, 250, 300, 350, 400, 500, 600, 800};
const int npt2 = sizeof(ptbins2)/sizeof(ptbins2[0])-1;
TH1D *hpt2 = new TH1D("hpt2","",npt2,&ptbins2[0]);
TProfile *ppt2 = new TProfile("ppt2","",npt2,&ptbins2[0]);
// dijet bins
const double ptbins4[] = {20, 62, 107, 175, 242, 310, 379, 467,
628, 839, 1121, 1497, 2000};
const int npt4 = sizeof(ptbins4)/sizeof(ptbins4[0])-1;
TH1D *hpt4 = new TH1D("hpt4","",npt4,&ptbins4[0]);
TProfile *ppt4 = new TProfile("ppt4","",npt4,&ptbins4[0]);
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextSize(0.045);
map<string,const char*> texlabel;
texlabel["gamjet"] = "#gamma+jet";
texlabel["zeejet"] = "Z#rightarrowee+jet";
texlabel["zmmjet"] = "Z#rightarrow#mu#mu+jet";
texlabel["dijet"] = "Dijet";
texlabel["ptchs"] = "p_{T} balance (CHS)";
texlabel["mpfchs"] = "MPF raw (CHS)";
texlabel["mpfchs1"] = "MPF type-I (CHS)";
// overlay of various alpha values
TCanvas *c1 = new TCanvas("c1","c1",ntypes*400,nmethods*400);
c1->Divide(ntypes,nmethods);
TH1D *h1 = new TH1D("h1",";p_{T} (GeV);Response",1270,30,1300);
// extrapolation vs alpha for each pT bin
vector<TCanvas*> c2s(ntypes*nmethods);
for (unsigned int icanvas = 0; icanvas != c2s.size(); ++icanvas) {
TCanvas *c2 = new TCanvas(Form("c2_%d",icanvas),Form("c2_%d",icanvas),
1200,1200);
c2->Divide(3,3);
c2s[icanvas] = c2;
}
TH1D *h2 = new TH1D("h2",";#alpha;Response",10,0.,0.4);
h2->SetMaximum(1.08);
h2->SetMinimum(0.88);
// krad corrections
TCanvas *c3 = new TCanvas("c3","c3",ntypes*400,nmethods*400);
c3->Divide(ntypes,nmethods);
TH1D *h3 = new TH1D("h3",";p_{T,ref} (GeV);FSR sensitivity: -dR/d#alpha [%]",
1270,30,1300);
cout << "Reading in data" << endl << flush;
// Read in plots vs pT (and alpha)
map<string, map<string, map<string, map<int, TGraphErrors*> > > > gemap;
map<string, map<string, map<string, map<int, TGraphErrors*> > > > gamap;
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
for (int isample = 0; isample != nsamples; ++isample) {
for (int ialpha = 0; ialpha != nalphas; ++ialpha) {
fin->cd();
assert(gDirectory->cd(types[itype]));
assert(gDirectory->cd(bin));
TDirectory *d = gDirectory;
const char *ct = types[itype];
const char *cm = methods[imethod];
const char *cs = samples[isample];
const int a = alphas[ialpha];
// Get graph made vs pT
string s = Form("%s/%s/%s_%s_a%d",types[itype],bin,cm,cs,a);
TGraphErrors *g = (TGraphErrors*)fin->Get(s.c_str());
if (!g) cout << "Missing " << s << endl << flush;
assert(g);
// Clean out empty points
// as well as trigger-biased ones for dijets
// as well as weird gamma+jet high pT point
for (int i = g->GetN()-1; i != -1; --i) {
if (g->GetY()[i]==0 || g->GetEY()[i]==0 ||
(string(cs)=="dijet" && g->GetX()[i]<70.) ||
(string(cs)=="gamjet" && g->GetX()[i]>600. && etamin!=0))
g->RemovePoint(i);
}
gemap[ct][cm][cs][a] = g;
// Sort points into new graphs vs alpha
TH1D *hpt = (isample==0 ? hpt2 : hpt1);
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { hpt = hpt4; ppt = ppt4; } // pas-v6
for (int i = 0; i != g->GetN(); ++i) {
double pt = g->GetX()[i];
ppt->Fill(pt, pt);
int ipt = int(hpt->GetBinLowEdge(hpt->FindBin(pt))+0.5);
//int ipt = int(pt+0.5);
TGraphErrors *ga = gamap[ct][cm][cs][ipt];
if (!ga) {
ga = new TGraphErrors(0);
ga->SetMarkerStyle(g->GetMarkerStyle());
ga->SetMarkerColor(g->GetMarkerColor());
ga->SetLineColor(g->GetLineColor());
gamap[ct][cm][cs][ipt] = ga;
}
int n = ga->GetN();
ga->SetPoint(n, 0.01*a, g->GetY()[i]);
ga->SetPointError(n, 0, g->GetEY()[i]);
} // for i
} // for ialpha
} // for isample
} // for imethod
} // for itype
cout << "Drawing plots vs pT for each alpha" << endl << flush;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
const char *ct = types[itype];
const char *cm = methods[imethod];
int ipad = ntypes*imethod + itype + 1; assert(ipad<=6);
c1->cd(ipad);
gPad->SetLogx();
h1->SetMaximum(itype<2 ? 1.15 : 1.08);
h1->SetMinimum(itype<2 ? 0.85 : 0.93);
h1->SetYTitle(Form("Response (%s)",ct));
h1->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3, #alpha=0.1--0.3");
TLegend *leg = tdrLeg(0.60,0.75,0.90,0.90);
for (int isample = 0; isample != nsamples; ++isample) {
for (int ialpha = 0; ialpha != nalphas; ++ialpha) {
const char *cs = samples[isample];
const int a = alphas[ialpha];
TGraphErrors *g = gemap[ct][cm][cs][a]; assert(g);
// Clean out points with very large uncertainty for plot readability
for (int i = g->GetN()-1; i != -1; --i) {
if (g->GetEY()[i]>0.02) g->RemovePoint(i);
}
g->Draw("SAME Pz");
if (ialpha==0) leg->AddEntry(g,texlabel[cs],"P");
}
} // for isample
// Individual plots for JEC paper
if ( true ) { // paper
TH1D *h = new TH1D(Form("h_5%s_%s",ct,cm),
Form(";p_{T} (GeV);Response (%s)",ct),
1270,30,1300);
h->GetXaxis()->SetMoreLogLabels();
h->GetXaxis()->SetNoExponent();
h->SetMinimum(0.88);
h->SetMaximum(1.13);
writeExtraText = true;
extraText = (string(ct)=="mc" ? "Simulation" : "");
lumi_8TeV = (string(ct)=="mc" ? "" : "19.7 fb^{-1}");
TCanvas *c0 = tdrCanvas(Form("c0_%s_%s",cm,ct), h, 2, 11, true);
c0->SetLogx();
TLegend *leg = tdrLeg(0.55,0.68,0.85,0.83);
tex->DrawLatex(0.55,0.85,texlabel[cm]);
tex->DrawLatex(0.55,0.18,"|#eta| < 1.3, #alpha=0.3");
//tex->DrawLatex(0.55,0.18,"Anti-k_{T} R=0.5");
// Loop over Z+jet and gamma+jet (only, no dijet/multijet)
for (int isample = 0; isample != min(3,nsamples); ++isample) {
const char *cs = samples[isample];
TGraphErrors *g = gemap[ct][cm][cs][30]; assert(g);
g->Draw("SAME Pz");
leg->AddEntry(g,texlabel[cs],"P");
} // for isample
if (etamin==0) {
c0->SaveAs(Form("pdf/paper_softrad_%s_%s_vspt.pdf",ct,cm));
c0->SaveAs(Form("pdfC/paper_softrad_%s_%s_vspt.C",ct,cm));
}
else {
c0->SaveAs(Form("pdf/an_softrad_%s_%s_eta%1.0f-%1.0f_vspt.pdf",
ct,cm,10*etamin,10*etamax));
}
} // paper
} // for imethod
} // for itype
c1->cd(0);
//cmsPrel(_lumi, true);
CMS_lumi(c1, 2, 33);
c1->SaveAs("pdf/softrad_2x6_vspt.pdf");
cout << "Drawing plots vs alpha for each pT" << endl << flush;
cout << "...and fitting slope vs alpha" << endl << flush;
map<string, map<string, map<string, TGraphErrors* > > > gkmap;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
int icanvas = nmethods*imethod + itype; assert(icanvas<=6);
TCanvas *c2 = c2s[icanvas]; assert(c2);
const char *ct = types[itype];
const char *cm = methods[imethod];
const int npads = 9;
for (int ipad = 0; ipad != npads; ++ipad) {
c2->cd(ipad+1);
h2->SetYTitle(Form("Response (%s)",ct));
h2->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3");
tex->DrawLatex(0.20,0.75,Form("%1.0f < p_{T} < %1.0f GeV",
hpt1->GetBinLowEdge(ipad+1),
hpt1->GetBinLowEdge(ipad+2)));
TLegend *leg = tdrLeg(0.65,0.75,0.90,0.90);
leg->AddEntry(gemap[ct][cm]["gamjet"][30], texlabel["gamjet"], "P");
leg->AddEntry(gemap[ct][cm]["zeejet"][30], texlabel["zeejet"], "P");
leg->AddEntry(gemap[ct][cm]["zmmjet"][30], texlabel["zmmjet"], "P");
leg->AddEntry(gemap[ct][cm]["dijet"][30], texlabel["dijet"], "P");
}
for (int isample = 0; isample != nsamples; ++isample) {
const char *cs = samples[isample];
map<int, TGraphErrors*> &gam = gamap[ct][cm][cs];
map<int, TGraphErrors*>::iterator itpt;
for (itpt = gam.begin(); itpt != gam.end(); ++itpt) {
int ipt = itpt->first;
int jpt = hpt1->FindBin(ipt);
if (jpt>npads) continue;
assert(jpt<=npads);
c2->cd(jpt);
TGraphErrors *ga = itpt->second; assert(ga);
ga->Draw("SAME Pz");
// Fit slope
TF1 *f1 = new TF1(Form("f1_%s_%s_%s_%d",ct,cm,cs,ipt),
"(x<1)*([0]+[1]*x) + (x>1 && x<2)*[0] +"
"(x>2)*[1]",-1,1);
f1->SetLineColor(ga->GetLineColor());
f1->SetParameters(1,0);
const double minalpha = (isample==0 ? 10./ipt : 5./ipt);
// Constrain slope to within reasonable values
// in the absence of sufficient data using priors
if (true) { // use priors
int n = ga->GetN();
// For response, limit to 1+/-0.02 (we've corrected for L3Res
ga->SetPoint(n, 1.5, 1);
ga->SetPointError(n, 0, 0.02);
n = ga->GetN();
if (imethod==1) { // pT balance
// For pT balance, estimate slope of <vecpT2>/alpha from data
// => 7.5%/0.30 = 25%
// Approximate uncertainty on this to be
// 0.5%/0.30 ~ 1.5% for data, 0.5%/0.30 ~ 1.5% for Z+jet MC, and
// 2%/0.30 ~ 6% for gamma+jet MC (same as slope)
if (itype==0) ga->SetPoint(n, 2.5, -0.250); // DT
if (itype==1 && isample!=0) ga->SetPoint(n, 2.5, -0.250); // MC
if (itype==1 && isample==0) ga->SetPoint(n, 2.5, -0.190);
if (itype==2 && isample!=0) ga->SetPoint(n, 2.5, -0.000); // rt
if (itype==2 && isample==0) ga->SetPoint(n, 2.5, -0.060);
//
// BUG: found 2015-01-08 (no effect on ratio)
//if (itype==1) ga->SetPointError(n, 0, -0.015);
if (itype==0) ga->SetPointError(n, 0, -0.015); // DT
if (itype==1 && isample!=0) ga->SetPointError(n, 0, -0.015); // MC
if (itype==1 && isample==0) ga->SetPointError(n, 0, -0.060);
if (itype==2 && isample!=0) ga->SetPointError(n, 0, -0.015); // rt
if (itype==2 && isample==0) ga->SetPointError(n, 0, -0.060);
}
if (imethod==0) { // MPF
// For MPF, expectation is no slope
// Maximal slope would be approximately
// (<vecpT2>/alpha ~ 25% from pT balance) times
// (response difference between pT1 and vecpT2~10%)
// => 0.25*0.10 = 2.5%
// For data/MC, estimate uncertainty as half of this
// => 1.25%
ga->SetPoint(n, 2.5, 0.);
if (itype!=2) ga->SetPointError(n, 0, 0.025);
if (itype==2) ga->SetPointError(n, 0, 0.0125);
} // MPF
} // use priors
if (ga->GetN()>2) {
f1->SetRange(minalpha, 3.);
ga->Fit(f1,"QRN");
if (f1->GetNDF()>=0) {
f1->DrawClone("SAME");
f1->SetRange(0,0.4);
f1->SetLineStyle(kDashed);
f1->DrawClone("SAME");
// Store results
TGraphErrors *gk = gkmap[ct][cm][cs];
if (!gk) {
gk = new TGraphErrors(0);
gk->SetMarkerStyle(ga->GetMarkerStyle());
gk->SetMarkerColor(ga->GetMarkerColor());
gk->SetLineColor(ga->GetLineColor());
gkmap[ct][cm][cs] = gk;
}
int n = gk->GetN();
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { ppt = ppt4; } // pas-v6
double pt = ppt->GetBinContent(ppt->FindBin(ipt));
gk->SetPoint(n, pt, f1->GetParameter(1));
gk->SetPointError(n, 0, f1->GetParError(1));
} // f1->GetNDF()>=0
} // ga->GetN()>2
} // for itpt
} // for isample
c2->SaveAs(Form("pdf/softrad_3x3_%s_%s_vsalpha.pdf",ct,cm));
}
}
cout << "Drawing plots of kFSR vs pT" << endl;
// 2x6 plots
for (int itype = 0; itype != ntypes; ++itype) {
for (int imethod = 0; imethod != nmethods; ++imethod) {
const char *ct = types[itype];
const char *cm = methods[imethod];
TMultiGraph *mgk = new TMultiGraph();
int ipad = ntypes*imethod + itype + 1; assert(ipad<=6);
c3->cd(ipad);
gPad->SetLogx();
h3->SetMaximum(imethod==0 ? 0.05 : (itype!=2 ? 0.1 : 0.25));
h3->SetMinimum(imethod==0 ? -0.05 : (itype!=2 ? -0.4 : -0.25));
h3->SetYTitle(Form("k_{FSR} = dR/d#alpha (%s)",ct));
h3->DrawClone("AXIS");
tex->DrawLatex(0.20,0.85,texlabel[cm]);
tex->DrawLatex(0.20,0.80,"|#eta| < 1.3");
TLegend *leg = tdrLeg(0.60,0.75,0.90,0.90);
for (int isample = 0; isample != nsamples; ++isample) {
const char *cs = samples[isample];
TGraphErrors *gk = gkmap[ct][cm][cs]; assert(gk);
leg->AddEntry(gk,texlabel[cs],"P");
// Fit each sample separately for pT balance
if (true) {
TF1 *fk = new TF1(Form("fk_%s_%s_%s",ct,cm,cs),
"[0]+[1]*log(0.01*x)+[2]*pow(log(0.01*x),2)",
30,1300);
fk->SetParameters(-0.25,-0.5);
fk->SetLineColor(gk->GetLineColor());
gk->Fit(fk, "QRN");
tex->SetTextColor(fk->GetLineColor());
tex->DrawLatex(0.55,0.27-0.045*isample,
Form("#chi^{2}/NDF = %1.1f / %d",
fk->GetChisquare(), fk->GetNDF()));
tex->SetTextColor(kBlack);
// Error band
const int n = fk->GetNpar();
TMatrixD emat(n,n);
gMinuit->mnemat(emat.GetMatrixArray(), n);
TF1 *fke = new TF1(Form("fk_%s_%s_%s",ct,cm,cs),
sr_fitError, 30, 1300, 1);
_sr_fitError_func = fk;
_sr_fitError_emat = &emat;
fke->SetLineStyle(kSolid);
fke->SetLineColor(fk->GetLineColor()-10);
fke->SetParameter(0,-1);
fke->DrawClone("SAME");
fke->SetParameter(0,+1);
fke->DrawClone("SAME");
fk->DrawClone("SAME");
gk->DrawClone("SAME Pz");
// Store soft radiation corrections in fsr subdirectory
assert(fin->cd(ct));
assert(gDirectory->cd(bin));
if (!gDirectory->FindObject("fsr")) gDirectory->mkdir("fsr");
assert(gDirectory->cd("fsr"));
TH1D *hk = (TH1D*)(isample==0 ? hpt2->Clone() : hpt1->Clone());
hk->SetName(Form("hkfsr_%s_%s",cm,cs));
TProfile *ppt = (isample==0 ? ppt2 : ppt1);
if (isample==3) { ppt = ppt4; } // pas-v6
for (int i = 1; i != hk->GetNbinsX()+1; ++i) {
double pt = ppt->GetBinContent(i);
if (pt>30 && pt<1300) {
hk->SetBinContent(i, fk->Eval(pt));
hk->SetBinError(i, fabs(fke->Eval(pt)-fk->Eval(pt)));
}
else {
hk->SetBinContent(i, 0);
hk->SetBinError(i, 0);
}
}
hk->Write(hk->GetName(), TObject::kOverwrite);
// Factorize error matrix into eigenvectors
// Remember: A = Q*Lambda*Q^-1, where
// A is emat, Q is eigmat, and Lambda is a diagonal matrix with
// eigenvalues from eigvec on the diagonal. For eigenmatrix
// Q^-1 = Q^T, i.e. inverse matrix is the original transposed
TVectorD eigvec(n);
TMatrixD eigmat = emat.EigenVectors(eigvec);
// Eigenvectors are the columns and sum of eigenvectors squared
// equals original uncertainty. Calculate histograms from the
// eigenvectors and store them
TF1 *fkeig = (TF1*)fk->Clone(Form("%s_eig",fk->GetName()));
fkeig->SetLineStyle(kDotted);
for (int ieig = 0; ieig != n; ++ieig) {
// Eigenvector functions
for (int i = 0; i != n; ++i) {
fkeig->SetParameter(i, fk->GetParameter(i)
+ eigmat[i][ieig] * sqrt(eigvec[ieig]));
}
fkeig->DrawClone("SAMEL");
// Eigenvector histograms evaluated at bin mean pT
TH1D *hke = (TH1D*)hk->Clone(Form("%s_eig%d",hk->GetName(),ieig));
hke->Reset();
for (int i = 0; i != gk->GetN(); ++i) {
double pt = gk->GetX()[i];
int ipt = hke->FindBin(pt);
// Need to store central value as well, because
// uncertainty sources are signed
hke->SetBinContent(ipt, fkeig->Eval(pt)-fk->Eval(pt));
hke->SetBinError(ipt, fabs(fkeig->Eval(pt)-fk->Eval(pt)));
}
hke->Write(hke->GetName(), TObject::kOverwrite);
}
cout << "." << flush;
} // if tree
} // for isample
} // for imethod
} // for itype
c3->cd(0);
//cmsPrel(_lumi, true);
CMS_lumi(c3, 2, 33);
c3->SaveAs("pdf/softrad_2x6_kfsr.pdf");
fin->Close();
curdir->cd();
} // softrad
void plot(int mass) {
double myQCDRelUncert = 0.038;
double myEWKRelUncert = 0.131;
double myFakesRelUncert = 0.238;
double delta = 1.4;
double br = 0.05;
bool debug = false;
bool log = false;
double ymin = 0.001;
double ymax = 48;
static bool bMessage = false;
if (!bMessage) {
cout << "Values used as relative uncertainty (please check):" << endl;
cout << " QCD: " << myQCDRelUncert << endl;
cout << " EWK genuine tau: " << myEWKRelUncert << endl;
cout << " EWK fake tau: " << myFakesRelUncert << endl << endl;
bMessage = true;
}
cout << "Processing mass point: " << mass << " GeV/c2" << endl;
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetTitleFont(43, "xyz");
gStyle->SetTitleSize(33, "xyz");
gStyle->SetLabelFont(43, "xyz");
gStyle->SetLabelSize(27, "xyz");
//std::string infile = "EPS_data_nodeltaphi/hplus_100.root";
//std::string infile = "EPS_data_deltaphi160/hplus_100.root";
std::stringstream s;
s << "lands_histograms_hplushadronic_m" << mass << ".root";
std::string infile = s.str();
// Canvas
TCanvas *myCanvas = new TCanvas("myCanvas", "",0,0,600,600);
myCanvas->SetHighLightColor(2);
myCanvas->Range(0,0,1,1);
myCanvas->SetFillColor(0);
myCanvas->SetBorderMode(0);
myCanvas->SetBorderSize(2);
if (log)
myCanvas->SetLogy();
myCanvas->SetTickx(1);
myCanvas->SetTicky(1);
myCanvas->SetLeftMargin(0.16);
myCanvas->SetRightMargin(0.05);
myCanvas->SetTopMargin(0.05);
myCanvas->SetBottomMargin(0.08);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->cd();
Int_t ci;
TFile* f = TFile::Open(infile.c_str());
s.str("");
s << "HW" << mass << "_1";
TH1* hw = (TH1*)f->Get(s.str().c_str());
s.str("");
s << "HH" << mass << "_1";
TH1* hh = (TH1*)f->Get(s.str().c_str());
TH1* data = (TH1*)f->Get("data_obs");
data->SetLineWidth(2);
data->SetMarkerStyle(20);
data->SetMarkerSize(1.2);
TH1* ewktau = (TH1*)f->Get("EWK_Tau");
ci = TColor::GetColor("#993399");
ewktau->SetFillColor(ci);
ewktau->SetLineWidth(0);
TH1* ewkDY = (TH1*)f->Get("EWK_DYx");
TH1* ewkVV = (TH1*)f->Get("EWK_VVx");
ewktau->Add(ewkDY);
ewktau->Add(ewkVV);
//TH1* qcd = (TH1*)f->Get("QCDInv");
TH1* qcd = (TH1*)f->Get("QCD");
ci = TColor::GetColor("#ffcc33");
qcd->SetFillColor(ci);
qcd->SetLineWidth(0);
TH1* fakett = (TH1*)f->Get("fake_tt");
ci = TColor::GetColor("#669900");
fakett->SetFillColor(ci);
fakett->SetLineWidth(0);
TH1* fakeW = (TH1*)f->Get("fake_W");
ci = TColor::GetColor("#cc3300");
fakeW->SetFillColor(ci);
fakeW->SetLineWidth(0);
TH1* faket = (TH1*)f->Get("fake_t");
TH1F *hFrame = new TH1F("hFrame","",20,0,400);
hFrame->SetMinimum(ymin);
if (log)
hFrame->SetMaximum(ymax*1.5);
else
hFrame->SetMaximum(ymax);
hFrame->SetDirectory(0);
hFrame->SetStats(0);
hFrame->SetLineStyle(0);
hFrame->SetMarkerStyle(20);
hFrame->SetXTitle("Transverse mass (#tau jet, E_{T}^{miss}), (GeV/c^{2})");
if (paperStatus)
hFrame->SetXTitle("Transverse mass (#tau_{h}, E_{T}^{miss}), (GeV/c^{2})");
hFrame->SetYTitle("Events / 20 GeV/c^{2}");
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(27);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// signal
hh->Scale(br*br);
hw->Scale(2*br*(1.0-br));
TH1* signal = (TH1*)hh->Clone();
signal->Add(hw);
ci = TColor::GetColor("#ff3399");
signal->SetLineColor(ci);
signal->SetLineStyle(2);
signal->SetLineWidth(2);
// Fakes
TH1* fakes = (TH1*)(fakett->Clone());
fakes->Add(fakeW);
fakes->Add(faket);
// stacked backgrounds
THStack *exp = new THStack();
exp->SetName("exp");
exp->SetTitle("exp");
exp->Add(fakes);
exp->Add(ewktau);
exp->Add(qcd);
exp->Add(signal);
TH1* hExpBkg = (TH1*)fakes->Clone();
hExpBkg->Add(ewktau);
hExpBkg->Add(qcd);
// uncertainty
TH1* uncert = (TH1*)fakeW->Clone();
uncert->Add(fakett);
uncert->Add(ewktau);
uncert->Add(qcd);
uncert->SetFillColor(1);
uncert->SetFillStyle(3344);
uncert->SetLineColor(0);
uncert->SetLineStyle(0);
uncert->SetLineWidth(0);
TH1* hExpBkgTotalUncert = (TH1*)uncert->Clone();
hExpBkgTotalUncert->SetFillStyle(3354);
TH1* hAgreement = (TH1*)data->Clone();
hAgreement->Divide(hExpBkg);
TGraphErrors* hAgreementRelUncert = new TGraphErrors(hAgreement->GetNbinsX());
hAgreementRelUncert->SetLineWidth(2);
hAgreementRelUncert->SetLineColor(kBlack);
for (int i = 1; i <= hFrame->GetNbinsX(); ++i) {
double myQCDTotalUncert = TMath::Power(qcd->GetBinError(i), 2)
+ TMath::Power(qcd->GetBinContent(i)*myQCDRelUncert, 2);
double myEWKTotalUncert = TMath::Power(ewktau->GetBinError(i), 2)
+ TMath::Power(ewktau->GetBinContent(i)*myEWKRelUncert, 2);
double myFakesTotalUncert = TMath::Power(fakes->GetBinError(i), 2)
+ TMath::Power(fakes->GetBinContent(i)*myFakesRelUncert, 2);
hExpBkgTotalUncert->SetBinError(i, TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert));
if (hExpBkg->GetBinContent(i) > 0) {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), data->GetBinContent(i) / hExpBkg->GetBinContent(i));
double myUncertData = 0;
if (data->GetBinContent(i) > 0)
myUncertData = TMath::Power(data->GetBinError(i) / data->GetBinContent(i), 2);
double myUncertBkg = (myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / TMath::Power(hExpBkg->GetBinContent(i), 2);
hAgreementRelUncert->SetPointError(i-1, 0, data->GetBinContent(i) / hExpBkg->GetBinContent(i) * TMath::Sqrt(myUncertData + myUncertBkg));
} else {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), 0);
hAgreementRelUncert->SetPointError(i-1, 0, 0);
}
if (debug) {
cout << "Point: " << hAgreementRelUncert->GetX()[i-1]-10 << "-" << hAgreementRelUncert->GetX()[i-1]+10
<< " GeV/c2, agreement: " << hAgreementRelUncert->GetY()[i-1] << ", uncert: " << hAgreement->GetBinError(i) << ", " << hAgreementRelUncert->GetErrorY(i-1) << endl;
cout << " bkg. stat. uncert. " << hExpBkg->GetBinError(i) << " (i.e. " << hExpBkg->GetBinError(i) / hExpBkg->GetBinContent(i) * 100.0 << " %)"
<< ", stat+syst uncert. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert)
<< " (i.e. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / hExpBkg->GetBinContent(i) * 100.0 << " %)" << endl;
}
}
// Agreement pad
TPad* pad = new TPad("ratiopad","ratiopad",0.,0.,1.,.3);
pad->Draw();
pad->cd();
pad->Range(0,0,1,1);
pad->SetFillColor(0);
pad->SetFillStyle(4000);
pad->SetBorderMode(0);
pad->SetBorderSize(2);
pad->SetTickx(1);
pad->SetTicky(1);
pad->SetLeftMargin(0.16);
pad->SetRightMargin(0.05);
pad->SetTopMargin(0);
pad->SetBottomMargin(0.34);
pad->SetFrameFillStyle(0);
pad->SetFrameBorderMode(0);
// Plot here ratio
if (1.0-delta > 0)
hAgreement->SetMinimum(1.0-delta);
else
hAgreement->SetMinimum(0.);
hAgreement->SetMaximum(1.0+delta);
hAgreement->GetXaxis()->SetLabelOffset(0.007);
hAgreement->GetXaxis()->SetLabelFont(43);
hAgreement->GetXaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelFont(43);
hAgreement->GetYaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelOffset(0.007);
hAgreement->GetYaxis()->SetNdivisions(505);
hAgreement->GetXaxis()->SetTitleFont(43);
hAgreement->GetYaxis()->SetTitleFont(43);
hAgreement->GetXaxis()->SetTitleSize(33);
hAgreement->GetYaxis()->SetTitleSize(33);
hAgreement->SetTitleSize(27, "xyz");
hAgreement->GetXaxis()->SetTitleOffset(3.2);
hAgreement->GetYaxis()->SetTitleOffset(1.3);
hAgreement->SetXTitle(hFrame->GetXaxis()->GetTitle());
hAgreement->SetYTitle("Data/#Sigmabkg");
hAgreement->Draw("e2");
// Plot line at zero
TH1* hAgreementLine = dynamic_cast<TH1*>(hAgreement->Clone());
for (int i = 1; i <= hAgreementLine->GetNbinsX(); ++i) {
hAgreementLine->SetBinContent(i,1.0);
hAgreementLine->SetBinError(i,0.0);
}
hAgreementLine->SetLineColor(kRed);
hAgreementLine->SetLineWidth(2);
hAgreementLine->SetLineStyle(3);
hAgreementLine->Draw("hist same");
hAgreement->Draw("same");
hAgreementRelUncert->Draw("[]");
pad->RedrawAxis();
myCanvas->cd();
TPad* plotpad = new TPad("plotpad", "plotpad",0,0.3,1.,1.);
plotpad->Draw();
plotpad->cd();
plotpad->Range(0,0,1,1);
plotpad->SetFillColor(0);
plotpad->SetFillStyle(4000);
plotpad->SetBorderMode(0);
plotpad->SetBorderSize(2);
//if (logy)
// plotpad->SetLogy();
plotpad->SetTickx(1);
plotpad->SetTicky(1);
plotpad->SetLeftMargin(0.16);
plotpad->SetRightMargin(0.05);
plotpad->SetTopMargin(0.065);
plotpad->SetBottomMargin(0.0);
plotpad->SetFrameFillStyle(0);
plotpad->SetFrameBorderMode(0);
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(33);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// Draw objects
hFrame->Draw();
exp->Draw("hist same");
uncert->Draw("E2 same");
hExpBkgTotalUncert->Draw("E2 same");
// Data
data->Draw("same");
//signal->Draw("same");
TLegend *leg = new TLegend(0.53,0.6,0.87,0.91,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(18);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(kWhite);
//leg->SetFillStyle(4000); // enabling this will cause the plot to be erased from the pad
TLegendEntry* entry = leg->AddEntry(data, "Data", "P");
s.str("");
s << "with H^{#pm}#rightarrow#tau^{#pm}#nu";
entry = leg->AddEntry(signal, s.str().c_str(), "L");
entry = leg->AddEntry(qcd, "QCD (meas.)", "F");
entry = leg->AddEntry(ewktau, "EWK genuine #tau (meas.)", "F");
entry = leg->AddEntry(fakes, "EWK fake #tau (MC)", "F");
entry = leg->AddEntry(uncert, "stat. uncert.", "F");
entry = leg->AddEntry(hExpBkgTotalUncert, "stat. #oplus syst. uncert.", "F");
leg->Draw();
string myTitle = "CMS Preliminary";
if (paperStatus)
myTitle = "CMS";
TLatex *tex = new TLatex(0.62,0.945,myTitle.c_str());
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.2,0.945,"#sqrt{s} = 7 TeV");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.43,0.945,"2.2 fb^{-1}");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "m_{H^{#pm}} = " << mass << " GeV/c^{2}";
tex = new TLatex(0.28,0.865,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "BR(t#rightarrowbH^{#pm})=" << setprecision(2) << br;
tex = new TLatex(0.28,0.805,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
plotpad->RedrawAxis();
plotpad->Modified();
s.str("");
s << "mT_datadriven_m" << mass << ".png";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".C";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".eps";
myCanvas->Print(s.str().c_str());
}
// Determine sensitivity to tracker dynamic inefficiency
// by studying ratio of jet responses in Runs G and F (and BCD / F, E / F)
void drawAvsB() {
setTDRStyle();
string epocha = "BCD";//"BCD";//"H";//"F";//"BCD";//"F";//"E";//"BCD";//"F";
string epochb = "GH";//"G";//"BCD";//"G";//"E";//"E";//"F";//"G";
// Add the rest as well
string epocha2 = "";//"EF";
string epochb2 = "";//"G";
string type = "data";
vector<string> methods;
methods.push_back("mpfchs1");
methods.push_back("ptchs");
bool nozjptb = false;
bool nogjmpf = false;
bool nogjptb = true;
bool mjvsjes = false;
vector<string> samples;
samples.push_back("zeejet");
samples.push_back("zmmjet");
samples.push_back("gamjet");
//samples.push_back("multijet");
cout << "draw"<<epocha<<"vs"<<epochb<<endl;
const char *ct = type.c_str();
const char *pa = epocha.c_str();
const char *pb = epochb.c_str();
const char *pa2 = epocha2.c_str();
const char *pb2 = epochb2.c_str();
TFile *fg = new TFile(Form("rootfiles/jecdata%s.root",pb),"READ");
assert(fg && !fg->IsZombie());
TFile *ff = new TFile(Form("rootfiles/jecdata%s.root",pa),"READ");
assert(ff && !ff->IsZombie());
TFile *fg2(0), *ff2(0);
if (epochb2!="") fg2 = new TFile(Form("rootfiles/jecdata%s.root",pb2),"READ");
if (epocha2!="") ff2 = new TFile(Form("rootfiles/jecdata%s.root",pa2),"READ");
TH1D *h = new TH1D("h",
Form(";p_{T,ref} (GeV);%s ratio (%s / %s)",
(type=="ratio" ? "Data/MC" :
type=="data" ? "Data/data" : "MC/MC"),
(epocha + (epocha2!="" ? "+"+epocha2 : "")).c_str(),
(epochb + (epochb2!="" ? "+"+epochb2 : "")).c_str()),
3470,30,3500);
h->SetMinimum(0.90);
h->SetMaximum(1.15);
h->GetXaxis()->SetMoreLogLabels();
h->GetXaxis()->SetNoExponent();
if (epocha=="F" && epochb=="G")
lumi_13TeV = "Run2016F+G, 3.1+7.1 fb^{-1}";
if (epocha=="BCD" && epochb=="G")
lumi_13TeV = "Run2016BCD+H, 12.9+8.8 fb^{-1}";
if (epocha=="BCD" && epochb=="G")
lumi_13TeV = "Run2016BCD+FearlyGH, 12.9+16.8 fb^{-1}";
if (epocha=="BCD" && epochb=="F")
lumi_13TeV = "Run2016BCD+F, 13+3.1 fb^{-1}";
if (epocha=="BCD" && epochb=="E")
lumi_13TeV = "Run2016BCD+E, 13+4.0 fb^{-1}";
if (epocha=="E" && epochb=="F")
lumi_13TeV = "Run2016E+F, 4.0+3.1 fb^{-1}";
if (epocha=="F" && epochb=="E")
lumi_13TeV = "Run2016E+F, 4.0+3.1 fb^{-1}";
if ((epocha=="BCDEF" && epochb=="GH") ||
(epocha=="BCD" && epocha2=="EF" && epochb=="H" && epochb2=="G"))
lumi_13TeV = "Run2016BCDEF+GH, 19.7+16.8 fb^{-1}";
if (epocha=="EF" && epochb=="BCD")
lumi_13TeV = "Run2016BCD+EF, 12.9+6.8 fb^{-1}";
if (epocha=="H" && epochb=="G")
lumi_13TeV = "Run2016G+H, 8.0+8.8 fb^{-1}";
if ((epocha=="BCD" && epocha2=="EF" && epochb=="G" && epochb2=="H"))
lumi_13TeV = "Run2016BCDFearly+FlateGH, 19.7+16.8 fb^{-1}";
if ((epocha=="BCD" && epocha2=="" && ((epochb=="GH" && epochb2=="") ||
(epochb=="G" && epochb2=="H"))))
lumi_13TeV = "Run2016BCD+FlateGH, 12.9+16.8 fb^{-1}";
if ((epocha=="EF" && epocha2=="" && ((epochb=="GH" && epochb2=="") ||
(epochb=="G" && epochb2=="H"))))
lumi_13TeV = "Run2016EF+FlateGH, 6.8+16.8 fb^{-1}";
if ((epocha=="EF" && epocha2=="" && epochb=="G" && epochb2=="H"))
lumi_13TeV = "Run2016EFearly+FlateGH, 6.8+16.8 fb^{-1}";
TCanvas *c1 = tdrCanvas("c1",h,4,11,true);
c1->SetLogx();
TLatex *tex = new TLatex();
tex->SetNDC(); tex->SetTextSize(0.045);
TMultiGraph *mg = new TMultiGraph();
string s = "draw"+epocha+(epocha2!="" ? "p" + epocha2 : "")
+"vs"+epochb+(epochb2!="" ? "p" + epochb2 : "");
TGraphErrors *gmjb(0), *gmpf(0);
for (unsigned int im = 0; im != methods.size(); ++im) {
const char *cm = methods[im].c_str();
tex->DrawLatex(0.20,0.75-0.06*im,cm);
s += "_" + methods[im];
for (unsigned int is = 0; is != samples.size(); ++is) {
const char *cs = samples[is].c_str();
TGraphErrors *gg = (TGraphErrors*)fg->Get(Form("%s/eta00-13/%s_%s_a30",ct,cm,cs));
cout << cm << " " << cs << endl << flush;
assert(gg);
if (fg2) {
TGraphErrors *gg2 = (TGraphErrors*)fg2->Get(Form("%s/eta00-13/%s_%s_a30",ct,cm,cs));
assert(gg2);
gg = addGraph(gg,gg2);
}
TGraphErrors *gf = (TGraphErrors*)ff->Get(Form("%s/eta00-13/%s_%s_a30",ct,cm,cs));
assert(gf);
if (ff2) {
TGraphErrors *gf2 = (TGraphErrors*)ff2->Get(Form("%s/eta00-13/%s_%s_a30",ct,cm,cs));
assert(gf2);
gf = addGraph(gf,gf2);
}
if (!(gf->GetN()==gg->GetN())) {
// Remove highest pT point is that is the offender (BCD vs GH)
if (gg->GetN()>gf->GetN() &&
fabs(gg->GetX()[gg->GetN()-1]/gf->GetX()[gf->GetN()-1]-1)>0.1 &&
fabs(gg->GetX()[gg->GetN()-2]/gf->GetX()[gf->GetN()-1]-1)<0.1) {
cout << "Remove point B(N-1)" << endl;
gg->RemovePoint(gg->GetN()-1);
}
else {
cout << "sample " << samples[is] << " method " << methods[im]
<< " gf->N: " << gf->GetN() << " gg->N: " << gg->GetN() << endl;
cout << " x_gf(N-1)=" << gf->GetX()[gf->GetN()-1]
<< " x_gg(N-1)=" << gg->GetX()[gg->GetN()-1]
<< " x_gg(N-2)=" << gg->GetX()[gg->GetN()-2] << endl;
}
assert(gf->GetN()==gg->GetN());
}
TGraphErrors *g = (TGraphErrors*)gg->Clone(Form("ge_%s_%s",cm,cs));
for (int i = 0; i != g->GetN(); ++i) {
double yg = gg->GetY()[i];
double yf = gf->GetY()[i];
g->SetPoint(i, gg->GetX()[i], yf / yg);
double ex = gg->GetEX()[i];
double eg = gg->GetEY()[i];
double ef = gf->GetEY()[i];
g->SetPointError(i, ex, yf/yg*sqrt(pow(eg/yg,2)+pow(ef/yf,2)));
}
//g->Draw(is==0 ? "AP" : "SAMEP");
g->SetLineWidth(1+is);
g->Draw("SAMEPZ");
if (samples[is]=="gamjet" && methods[im]=="mpfchs1" && nogjmpf) {
tex->SetTextColor(kBlue);
tex->DrawLatex(0.20,0.63,"#gamma+jet MPF excl. from fit");
tex->SetTextColor(kBlack);
}
else if (samples[is]=="gamjet" && methods[im]=="ptchs" && nogjptb) {
tex->SetTextColor(kBlue);
tex->DrawLatex(0.20,0.63,"#gamma+jet p_{T}^{bal} excl. from fit");
tex->SetTextColor(kBlack);
}
else if ((samples[is]=="zmmjet" || samples[is]=="zeejet") &&
methods[im]=="ptchs" && nozjptb) {
tex->SetTextColor(kRed);
tex->DrawLatex(0.20,0.63,"Z+jet p_{T}^{bal} excl. from fit");
tex->SetTextColor(kBlack);
}
else if (samples[is]=="multijet") {
g->SetMarkerColor(kGray+1);
g->SetLineColor(kGray+1);
if (methods[im]=="ptchs") gmjb = g;
if (methods[im]=="mpfchs1") gmpf = g;
}
else
mg->Add(g);
} // for is
} // for im
if (nogjmpf) s += "_nogjmpf";
if (nogjptb) s += "_nogptb";
if (nozjptb) s += "_nozptb";
if (mjvsjes) {
s += "_mjvsjes";
tex->SetTextColor(kBlack);
tex->DrawLatex(0.20,0.58,"Multijet vs JES fit");
}
TF1 *fjes = new TF1("fjes",jesFit,30,2200,2);
fjes->SetParameters(0.99,0.05);
mg->Fit(fjes,"RN");
fjes->SetLineColor(kBlack);
fjes->SetLineStyle(kDashed);
fjes->SetLineWidth(2);
fjes->SetRange(10.,3500.);
fjes->Draw("SAME");
//TF1 *ft = new TF1("ft","1-[0]-[1]*pow(x,[2]) + ([3]+[4]*log(x))/x",30,2200);
//ft->SetParameters(0,0.05,-0.5,1,0.1);
//ft->FixParameter(3,0);
// Logarithmic sigmoid
//TF1 *ft = new TF1("ft","[0]+(1-[0])/(1. + exp(-(log(x)-log(abs([1])))"
// "/(log(abs([2])+abs([1]))-log(abs([1])))))", 30,2200);
//ft->SetParameters(0.98, 150, 50);
TF1 *ft = new TF1("ft","[0]+(1-[0])/(1. + exp(-(log(x)-[1])/[2]))",30,2200);
//ft->SetParameters(0.98,log(145),log(190)-log(145));
//ft->SetParameters(0.982,4.967,0.271);
//ft->SetParameters(0.976,5.040,0.370); // ENDCAP
//ft->SetParameters(0.985,5.0,0.3);
ft->SetParameters(0.985,5.025,0.3);
//ft->FixParameter(1,5.03); // semi-weighted average of BCD and EF
//ft->FixParameter(2,0.395); // combined fit to BCD+EF / G+H
// ( 12.9*5.055+6.8*5.000)/(12.9+6.8)
ft->FixParameter(1,5.036); // semi-weighted average of BCD/GH and EF/GH
// ( 12.9*0.344 + 6.8*0.455)/(12.9+6.8)
ft->FixParameter(2,0.391); // combined fit to BCD+EF / GH
// Log-sigmoid + powerlaw
//TF1 *ft = new TF1("ft","[0]+(1-[0])/(1. + exp(-(log(x)-[1])/[2]))"
// "*(1-[3]*pow(x,[4]))",30,2200);
//ft->SetParameters(0.982,4.967,0.271,0.1,-0.2);
// Double powerlaw
//TF1 *ft = new TF1("ft","[4]-[0]*pow(x,[1])-[2]*pow(x,[3])",30,2200);
//ft->SetParameters(0.05,-0.15,0.01,-0.3,1);
mg->Fit(ft,"RN");
ft->SetLineColor(kBlue);
ft->SetLineWidth(2);
ft->SetRange(10.,3500.);
ft->Draw("SAME");
// Map multijet with response ratio
if (gmpf) { // we have multijet available
TGraphErrors *gmpf2 = (TGraphErrors*)gmpf->Clone("gmpf2");
gmpf2->SetMarkerColor(kBlack);//kGray+1);
gmpf2->SetLineColor(kBlack);//kGray+1);
for (int i = 0; i != gmpf->GetN(); ++i) {
if (mjvsjes) {
gmpf2->SetPoint(i, 0.4*gmpf->GetX()[i],
fjes->Eval(gmpf->GetX()[i])/gmpf->GetY()[i]);
gmpf2->SetPointError(i, 0.4*gmpf->GetEX()[i],
gmpf->GetEY()[i]);
}
else {
gmpf2->SetPoint(i, 0.4*gmpf->GetX()[i],
ft->Eval(gmpf->GetX()[i])/gmpf->GetY()[i]);
gmpf2->SetPointError(i, 0.4*gmpf->GetEX()[i],
gmpf->GetEY()[i]);
}
}
gmpf2->Draw("SAMEPz");
} // multijet
tex->SetTextColor(kBlue);
tex->DrawLatex(0.50,0.85,Form("#chi^{2} / NDF = %1.1f / %d",
ft->GetChisquare(),
ft->GetNDF()));
tex->SetTextColor(kBlack);
tex->SetTextSize(0.040);
tex->DrawLatex(0.50,0.80,Form("(#chi^{2} / NDF = %1.1f / %d)",
fjes->GetChisquare(),
fjes->GetNDF()));
tex->SetTextColor(kBlue-9);
tex->SetTextSize(0.030);
tex->DrawLatex(0.20,0.25,ft->GetExpFormula());
tex->DrawLatex(0.20,0.20,
Form("p_{0}=%1.3f#pm%1.3f"
", p_{1}=%1.3f#pm%1.3f"
", p_{2}=%1.3f#pm%1.3f",
ft->GetParameter(0),ft->GetParError(0),
ft->GetParameter(1),ft->GetParError(1),
ft->GetParameter(2),ft->GetParError(2)));
if (ft->GetNpar()>3)
tex->DrawLatex(0.20,0.17,
Form("p_{3}=%1.3f#pm%1.3f"
", p_{4}=%1.3f#pm%1.3f",
ft->GetParameter(3),ft->GetParError(3),
ft->GetParameter(4),ft->GetParError(4)));
c1->SaveAs(Form("pdf/%s.pdf",s.c_str()));
for (int i = 0; i != ft->GetNpar(); ++i) {
cout << Form("%s%1.4g",i==0 ? "{" : ", ",ft->GetParameter(i));
}
cout << "}" << endl;
}
