//____________________________________________________________________________________
TGraphAsymmErrors *calcEfficiency(TH1* h1, TH1* h2)
{
TH1 *phUp = (TH1 *)h2->Clone("phUp");
TH1 *phDown = (TH1 *)h1->Clone("phDown");
phUp->SetDirectory(0);
phDown->SetDirectory(0);
TGraphAsymmErrors *pgEfficiency = new TGraphAsymmErrors();
pgEfficiency->BayesDivide(phUp,phDown,"");
return pgEfficiency;
}
TH1* GetHist(const string histname)
{
const float scaleTo = fDATA_LUMI; // pb
TH1 *hists[nBins] = {0,0,0,0,0,0,0};
TH1 *Hist = 0;
for (int i=0; i<nBins; ++i)
{
hists[i] = dynamic_cast<TH1*> (files[i]->Get(histname.c_str()));
if (hists[i] != 0)
{
hists[i]->Sumw2();
const float scale = scaleTo/ ( nEvents[i] / xSec[i] );
hists[i]->Scale(scale);
hists[i]->SetLineWidth(2);
hists[i]->SetLineColor(i);
if (i == 0)
{
Hist = dynamic_cast<TH1*> (hists[i]->Clone("hist0_copy"));
Hist->SetDirectory(0);
} else
{
Hist->Add(hists[i]);
}
} else {
cout << "hist " << histname << " not found in " << files[i]->GetName() << "!" << endl;
assert (false);
}
}
return Hist;
}
bool TrLikeDB::LoadPdfVer0(char* dirname) {
TFile* file = TFile::Open(Form("%s/v5.00/TrLikeDBver0/PDFDBv2.root",dirname),"read");
if (!file) return false;
int index = 0;
int irig = 1;
TH1* pdf = 0;
fZmax = 28;
for (int Z=1; Z<=fZmax; Z++) {
for (int icat=0; icat<2; icat++) {
// 2D Xi_{X} vs Xi_{Y}
index = CreateIndex(0,Z,icat,0,irig);
pdf = (TH1*) file->Get(Form("hLogXi2D_Z%d_Rig%d_Cat%d",Z,irig,icat+1));
if (!pdf) {
printf("TrLikeDB::LoadPdfVer0-E error in loading PDFs (hLogXi2D_Z%d_Rig%d_Cat%d). Tracker integer charge could have some problem!\n",Z,irig,icat+1);
file->Close();
break;
}
pdf->SetDirectory(0);
AddPdf(pdf,index);
for (int iside=0; iside<2; iside++) {
// 1D Xi
index = CreateIndex(1,Z,icat,iside,irig);
pdf = (TH1*) file->Get(Form("hLogXi1D_Z%d_Rig%d_Cat%d_Side%d",Z,irig,icat+1,iside));
if (!pdf) {
printf("TrLikeDB::LoadPdfVer0-E error in loading PDFs (hLogXi1D_Z%d_Rig%d_Cat%d_Side%d). Tracker integer charge could have some problem!\n",Z,irig,icat+1,iside);
file->Close();
break;
}
pdf->SetDirectory(0);
AddPdf(pdf,index);
// 1D Eta
index = CreateIndex(2,Z,icat,iside,irig);
pdf = (TH1*) file->Get(Form("hLogEtaS1D_Z%d_Rig%d_Cat%d_Side%d",Z,irig,icat+1,iside));
if (!pdf) {
printf("TrLikeDB::LoadPdfVer0-E error in loading PDFs (hLogEtaS1D_Z%d_Rig%d_Cat%d_Side%d). Tracker integer charge could have some problem!\n",Z,irig,icat+1,irig);
file->Close();
break;
}
pdf->SetDirectory(0);
AddPdf(pdf,index);
}
}
}
// create missing pdf here if needed ... not for now
file->Close();
return true;
}
//____________________________________________________________________
void Run(const char* newName, const char* oldName,
const char* newTitle="New", const char* oldTitle="Old")
{
TFile* newFile = TFile::Open(newName,"READ");
TFile* oldFile = TFile::Open(oldName,"READ");
if (!newFile || !oldFile) return;
TH1* newCent = GetH1(newFile, "realCent");
TH1* oldCent = GetH1(oldFile, "realCent");
if (!newCent || !oldCent) return;
TString t; t.Form("#it{R}=#frac{%s}{%s}", newTitle, oldTitle);
TCanvas* c = new TCanvas("c", t, 1200, 800);
c->SetTopMargin(0.01);
c->SetRightMargin(0.20);
fLegend = new TLegend(1-c->GetRightMargin(),
c->GetBottomMargin(),
1, 1-c->GetTopMargin(),
t);
fLegend->SetFillStyle(0);
fLegend->SetBorderSize(0);
THStack* stack = new THStack("ratios","");
fMin = +1e6;
fMax = -1e6;
TH1* one = 0;
for (Int_t i = newCent->GetNbinsX(); i--;) {
Double_t c1 = newCent->GetXaxis()->GetBinLowEdge(i+1);
Double_t c2 = newCent->GetXaxis()->GetBinUpEdge(i+1);
Info("", "c1=%f c2=%f", c1, c2);
TH1* r = One(newFile, oldFile, c1, c2);
if (!r) continue;
if (!one) {
one = static_cast<TH1*>(r->Clone("one"));
one->SetDirectory(0);
one->Reset();
for (Int_t j = 1; j <= one->GetNbinsX(); j++) {
one->SetBinContent(j,1);
one->SetBinError (j,0);
}
}
// r->Add(one, i-1);
// r->Scale(TMath::Power(10,i));
stack->Add(r);
}
stack->Draw("nostack");
stack->SetMinimum(0.95*fMin);
stack->SetMaximum(1.05*fMax);
stack->GetHistogram()->SetXTitle("#eta");
stack->GetHistogram()->SetYTitle("#it{R}");
fLegend->Draw();
c->Modified();
c->Update();
c->cd();
c->SaveAs(Form("%sover%s.png", newTitle, oldTitle));
}
void GetSumNom(){
TH1* htemp;
for(int i = 1; i < 12; i++){
TFile* inputfile = TFile::Open(pathsum + Form("Tree_TTbar_Powheg_%i.root", i))->GetObject("CountLHE",htemp);
h->Add(htemp);
htemp->SetDirectory(0);
//cout << "i = " << i << ", h->GetEntries() = " << h->GetEntries() << endl;
delete htemp; delete inputfile;
}
fac = h->GetBinContent(1002);
}
//#endif
void DrawInPad(TVirtualPad* p,
Int_t sub,
TH1* h,
Bool_t logy=false)
{
TVirtualPad* pp = p->cd(sub);
pp->SetRightMargin(0.02);
if (logy) pp->SetLogy();
TH1* copy = h->DrawCopy("hist");
copy->GetXaxis()->SetLabelSize(0.13);
copy->GetYaxis()->SetLabelSize(0.08);
copy->SetDirectory(0);
}
TH1* makeIntHist(const TH1* hist,bool intIsGreatThan)
{
TH1* cHist = (TH1*) hist->Clone("cHist");
cHist->SetDirectory(0);
cHist->SetName(hist->GetName());
int maxBin = hist->GetNbinsX()+1;
for(int binNr=0;binNr<=hist->GetNbinsX();binNr++){
//if(hist->GetBinContent(binNr) == 0) continue;
float nrEntries = intIsGreatThan ? hist->Integral(binNr,maxBin) : hist->Integral(0,binNr);
cHist->SetBinContent(binNr,nrEntries);
}
return cHist;
}
//____________________________________________________________________
TH1* One(TDirectory* newDir, TDirectory* oldDir, Double_t c1, Double_t c2)
{
TString name;
name.Form("cent%03dd%02d_%03dd%02d",
Int_t(c1), Int_t(c1*100)%100,
Int_t(c2), Int_t(c2*100)%100);
TDirectory* newSubDir = GetD(newDir, name);
TDirectory* oldSubDir = GetD(oldDir, name);
if (!newSubDir || !oldSubDir) return 0;
Int_t newDim = 0;
if (TString(newDir->GetName()).Contains("etaipz")) newDim = 3;
else if (TString(newDir->GetName()).Contains("eta")) newDim = 2;
else if (TString(newDir->GetName()).Contains("const")) newDim = 1;
Int_t oldDim = 0;
if (TString(oldDir->GetName()).Contains("etaipz")) oldDim = 3;
else if (TString(oldDir->GetName()).Contains("eta")) oldDim = 2;
else if (TString(oldDir->GetName()).Contains("const")) oldDim = 1;
TDirectory* newSubSubDir = GetD(newSubDir, Form("results%dd",newDim));
TDirectory* oldSubSubDir = GetD(oldSubDir, Form("results%dd",oldDim));
if (!newSubSubDir || !oldSubSubDir) return 0;
TH1* newRes = GetH1(newSubSubDir, "result");
TH1* oldRes = GetH1(oldSubSubDir, "result");
if (!newRes || !oldRes) return 0;
TH1* ratio = static_cast<TH1*>(newRes->Clone(name));
ratio->SetDirectory(0);
ratio->SetTitle(Form("%5.1f - %5.1f%%", c1, c2));
ratio->SetYTitle("New / Old");
ratio->Divide(oldRes);
fMin = TMath::Min(fMin, ratio->GetMinimum());
fMax = TMath::Max(fMax, ratio->GetMaximum());
Printf("Calculated %s/%s", newDir->GetName(), oldDir->GetName());
if (!fLegend) return ratio;
TLegendEntry* e =
fLegend->AddEntry("", Form("%3.0f - %3.0f%%", c1, c2), "f");
e->SetFillStyle(1001);
e->SetFillColor(ratio->GetMarkerColor());
return ratio;
}
void savehistos(const string& filewithlist,
const string& outputfilename,
const string& openmode="RECREATE")
{
FILE *fp = fopen(filewithlist.c_str(),"r");
if (!fp) {
cerr << "File not found, " << filewithlist << endl;
return;
}
TFile *rootfile = new TFile(outputfilename.c_str(),openmode.c_str());
if (rootfile->IsZombie()) {
cerr << "File failed to open, " << outputfilename << endl;
return;
}
string theline,newname;
vector<string> tokens;
while (getLine(fp,theline)) {
if (theline[0] == '#') continue; // "comments are welcome"
Tokenize(theline,tokens,"\t");
TH1 *h1 = getHisto(tokens[0]);
if (!h1) {
cerr << "Couldn't get histo " << tokens[0] << endl;
return;
}
TH1 *target = h1;
if( tokens.size() > 1 && tokens[1].length() ) {
newname = tokens[1];
cout<<"Writing histo "<<newname<<" to file "<<outputfilename<<endl;
target = (TH1 *)h1->Clone(newname.c_str());
} else
cout<<"Writing histo "<<h1->GetName()<<" to file "<<outputfilename<<endl;
target->SetDirectory(rootfile);
rootfile->cd();
target->Write();
}
rootfile->Close();
}
std::shared_ptr<TH1> getHistogram(const std::string& name, const std::vector<Input>& inputs, int type) {
TH1* h = nullptr;
for (const auto& input: inputs) {
if (input.type != type)
continue;
TH1* f = static_cast<TH1*>(input.file->Get(name.c_str()));
f->Scale(input.cross_section / (input.generated_events * input.top_pt_weight));
if (! h) {
h = static_cast<TH1*>(f->Clone());
h->SetDirectory(NULL);
} else
h->Add(f);
}
return std::shared_ptr<TH1>(h);
}
/**
* Add the bin histograms to our summary stacks
*
* @param bin Bin stack
* @param i Current off-set in the stacks
* @param measured All measured @f$ P(N_{ch})@f$
* @param truth All MC truth @f$ P(N_{ch})@f$
* @param accepted All MC accepted @f$ P(N_{ch})@f$
* @param unfolded All unfolded @f$ P(N_{ch})@f$
* @param corrected All corrected @f$ P(N_{ch})@f$
* @param result The result in this bin
*/
void Bin2Stack(const THStack* bin, Int_t i,
THStack* measured,
THStack* truth,
THStack* accepted,
THStack* unfolded,
THStack* corrected,
TH1*& result)
{
Int_t open, closed;
Double_t factor;
Float_t size;
BinAttributes(i, open, closed, size, factor);
TIter next(bin->GetHists());
TH1* h = 0;
while ((h = static_cast<TH1*>(next()))) {
THStack* tmp = 0;
Int_t col = h->GetMarkerColor();
Int_t sty = 0;
switch (col) {
case kColorMeasured: tmp = measured; sty = closed; break;
case kColorTruth: tmp = truth; sty = open; break;
case kColorAccepted: tmp = accepted; sty = open; break;
case kColorUnfolded: tmp = unfolded; sty = closed; break;
case kColorCorrected: tmp = corrected; sty = closed; break;
default: continue;
}
// Now clone, and add to the appropriate stack
TH1* cln = static_cast<TH1*>(h->Clone(h->GetName()));
cln->SetDirectory(0);
cln->SetMarkerStyle(sty);
cln->SetMarkerSize(size);
cln->Scale(factor); // Scale by 10^i
if (col == kColorCorrected) result = cln;
// Make sure we do not get the old legend
TObject* tst = cln->FindObject("legend");
if (tst) cln->GetListOfFunctions()->Remove(tst);
tmp->Add(cln, next.GetOption());
}
// Add entries to our stacks
TString txt = bin->GetTitle();
if (i == 0) txt.Append(" (#times1)");
else if (i == 1) txt.Append(" (#times10)");
else txt.Append(Form(" (#times10^{%d})", i));
THStack* stacks[] = { measured, truth, accepted, unfolded, corrected, 0 };
THStack** pstack = stacks;
while (*pstack) {
TLegend* leg = StackLegend(*pstack);
pstack++;
if (!leg) continue;
TObject* dummy = 0;
TLegendEntry* e = leg->AddEntry(dummy, txt, "p");
e->SetMarkerStyle(closed);
e->SetMarkerSize(1.2*size);
e->SetMarkerColor(kBlack);
e->SetFillColor(0);
e->SetFillStyle(0);
e->SetLineColor(kBlack);
}
}
/**
* Process a single eta bin
*
* @param measured Input collection of measured data
* @param corrections Input collection of correction data
* @param method Unfolding method to use
* @param regParam Regularisation parameter
* @param out Output directory.
*
* @return Stack of histograms or null
*/
THStack* ProcessBin(TCollection* measured,
TCollection* corrections,
UInt_t method,
Double_t regParam,
TDirectory* out)
{
Printf(" Processing %s ...", measured->GetName());
// Try to get the data
TH1* inRaw = GetH1(measured, "rawDist");
TH1* inTruth = GetH1(corrections, "truth");
TH1* inTruthA = GetH1(corrections, "truthAccepted");
TH1* inTrgVtx = GetH1(corrections, "triggerVertex");
TH2* inResp = GetH2(corrections, "response");
if (!inRaw || !inTruth || !inTruthA || !inTrgVtx || !inResp)
return 0;
// Make output directory
TDirectory* dir = out->mkdir(measured->GetName());
dir->cd();
// Copy the input to the output
TH1* outRaw = static_cast<TH1*>(inRaw ->Clone("measured"));
TH1* outTruth = static_cast<TH1*>(inTruth ->Clone("truth"));
TH1* outTruthA = static_cast<TH1*>(inTruthA ->Clone("truthAccepted"));
TH1* outTrgVtx = static_cast<TH1*>(inTrgVtx ->Clone("triggerVertex"));
TH2* outResp = static_cast<TH2*>(inResp ->Clone("response"));
// Make our response matrix
RooUnfoldResponse matrix(0, 0, inResp);
// Store regularization parameter
Double_t r = regParam;
RooUnfold::Algorithm algo = (RooUnfold::Algorithm)method;
RooUnfold* unfolder = RooUnfold::New(algo, &matrix, inRaw, r);
unfolder->SetVerbose(0);
// Do the unfolding and get the result
TH1* res = unfolder->Hreco();
res->SetDirectory(0);
// Make a copy to store on the output
TH1* outUnfold = static_cast<TH1*>(res->Clone("unfolded"));
TString tit(outUnfold->GetTitle());
tit.ReplaceAll("Unfold Reponse matrix", "Unfolded P(#it{N}_{ch})");
outUnfold->SetTitle(tit);
// Clone the unfolded results and divide by the trigger/vertex
// bias correction
TH1* outCorr = static_cast<TH1*>(outUnfold->Clone("corrected"));
outCorr->Divide(inTrgVtx);
tit.ReplaceAll("Unfolded", "Corrected");
outCorr->SetTitle(tit);
// Now normalize the output to integral=1
TH1* hists[] = { outRaw, outUnfold, outCorr, 0 };
TH1** phist = hists;
while (*phist) {
TH1* h = *phist;
if (h) {
Double_t intg = h->Integral(1, h->GetXaxis()->GetXmax());
h->Scale(1. / intg, "width");
}
phist++;
}
// And make ratios
TH1* ratioTrue = static_cast<TH1*>(outCorr->Clone("ratioCorrTruth"));
tit = ratioTrue->GetTitle();
tit.ReplaceAll("Corrected", "Corrected/MC 'truth'");
ratioTrue->SetTitle(tit);
ratioTrue->Divide(outTruth);
ratioTrue->SetYTitle("P_{corrected}(#it{N}_{ch})/P_{truth}(#it{N}_{ch})");
TH1* ratioAcc = static_cast<TH1*>(outUnfold->Clone("ratioUnfAcc"));
tit = ratioAcc->GetTitle();
tit.ReplaceAll("Unfolded", "Unfolded/MC selected");
ratioAcc->SetTitle(tit);
ratioAcc->Divide(outTruthA);
ratioAcc->SetYTitle("P_{unfolded}(#it{N}_{ch})/P_{MC}(#it{N}_{ch})");
// Make a stack
tit = measured->GetName();
tit.ReplaceAll("m", "-");
tit.ReplaceAll("p", "+");
tit.ReplaceAll("d", ".");
tit.ReplaceAll("_", "<#it{#eta}<");
THStack* stack = new THStack("all", tit);
stack->Add(outTruth, "E2");
stack->Add(outTruthA, "E2");
stack->Add(outRaw, "E1");
stack->Add(outUnfold, "E1");
stack->Add(outCorr, "E1");
dir->Add(stack);
// Rest of the function is devoted to making the output look nice
outRaw ->SetDirectory(dir);
outTruth ->SetDirectory(dir);
outTruthA->SetDirectory(dir);
outTrgVtx->SetDirectory(dir);
outResp ->SetDirectory(dir);
outUnfold->SetDirectory(dir);
outCorr ->SetDirectory(dir);
outRaw ->SetMarkerStyle(20); // Measured is closed
outTruth ->SetMarkerStyle(24); // MC is open
outTruthA->SetMarkerStyle(24); // MC is open
outTrgVtx->SetMarkerStyle(20); // Derived is closed
outUnfold->SetMarkerStyle(20); // Derived is closed
outCorr ->SetMarkerStyle(20); // Derived is closed
outRaw ->SetMarkerSize(0.9);
outTruth ->SetMarkerSize(1.6);
outTruthA->SetMarkerSize(1.4);
outTrgVtx->SetMarkerSize(1.0);
outUnfold->SetMarkerSize(0.9);
outCorr ->SetMarkerSize(1.0);
outRaw ->SetMarkerColor(kColorMeasured);
outTruth ->SetMarkerColor(kColorTruth);
outTruthA->SetMarkerColor(kColorAccepted);
outTrgVtx->SetMarkerColor(kColorTrgVtx);
outUnfold->SetMarkerColor(kColorUnfolded);
outCorr ->SetMarkerColor(kColorCorrected);
outRaw ->SetFillColor(kColorError);
outTruth ->SetFillColor(kColorError);
outTruthA->SetFillColor(kColorError);
outTrgVtx->SetFillColor(kColorError);
outUnfold->SetFillColor(kColorError);
outCorr ->SetFillColor(kColorError);
outRaw ->SetFillStyle(0);
outTruth ->SetFillStyle(1001);
outTruthA->SetFillStyle(1001);
outTrgVtx->SetFillStyle(0);
outUnfold->SetFillStyle(0);
outCorr ->SetFillStyle(0);
outRaw ->SetLineColor(kBlack);
outTruth ->SetLineColor(kBlack);
outTruthA->SetLineColor(kBlack);
outTrgVtx->SetLineColor(kBlack);
outUnfold->SetLineColor(kBlack);
outCorr ->SetLineColor(kBlack);
// Legend
TLegend* l = StackLegend(stack);
l->AddEntry(outRaw, "Raw", "lp");
l->AddEntry(outTruth, "MC 'truth'", "fp");
l->AddEntry(outTruthA, "MC 'truth' accepted", "fp");
l->AddEntry(outUnfold, "Unfolded", "lp");
l->AddEntry(outCorr, "Corrected", "lp");
return stack;
}
// Plot the closure test
void plotHadTau3(double scale = 1.,
const TString &fileName = "HadTau_WJetMC_PredGen.root") {
gROOT->ProcessLine(".L ../utils/StyleMatters.h+");
StyleMatters::init();
bool isMCPred = false;
if( fileName.Contains("MC") ) isMCPred = true;
bool isGenPred = false;
if( isMCPred && fileName.Contains("Gen") ) isGenPred = true;
// Get histograms from file
const unsigned int kNDists = 3;
TH1* hTrue[kNDists];
TH1* hPred[kNDists];
TH1* hMuonPt = 0;
TFile file(fileName,"READ");
for(unsigned int i = 0; i < kNDists; ++i) {
TString name = "";
if( i == 0 ) name = "TauJetPt";
else if( i == 1 ) name = "Ht";
else if( i == 2 ) name = "Mht";
file.GetObject("hPred"+name,hPred[i]);
if( !hPred[i] ) {
std::cerr << "ERROR: Histograms not found" << std::endl;
exit(-1);
}
hPred[i]->SetDirectory(0);
hPred[i]->UseCurrentStyle();
if( isMCPred ) {
file.GetObject("hTrue"+name,hTrue[i]);
if( !hTrue[i] ) {
std::cerr << "ERROR: Histograms not found" << std::endl;
exit(-1);
}
hTrue[i]->SetDirectory(0);
hTrue[i]->UseCurrentStyle();
}
}
file.GetObject("hMuonPt",hMuonPt);
if( !hMuonPt ) {
std::cerr << "ERROR: Histogram not found" << std::endl;
exit(-1);
}
hMuonPt->SetDirectory(0);
hMuonPt->UseCurrentStyle();
file.Close();
// Apply correction factors
for(unsigned int i = 0; i < kNDists; ++i) {
hPred[i]->Scale(scale);
}
// Set style
for(unsigned int i = 0; i < kNDists; ++i) {
TString xTitle = "";
if( i == 0 ) xTitle = "p_{T}(#tau) [GeV]";
else if( i == 1 ) xTitle = "H_{T} [GeV]";
else if( i == 2 ) xTitle = "#slash{H}_{T} [GeV]";
TString yTitle = "N(events) / ";
yTitle += static_cast<int>(hPred[i]->GetXaxis()->GetBinWidth(1));
yTitle += " GeV";
hPred[i]->GetXaxis()->SetTitle(xTitle);
hPred[i]->GetYaxis()->SetTitle(yTitle);
hPred[i]->SetMarkerStyle(20);
hPred[i]->SetMarkerColor(kRed);
hPred[i]->SetLineColor(hPred[i]->GetMarkerColor());
if( isMCPred ) {
hTrue[i]->GetXaxis()->SetTitle(xTitle);
hTrue[i]->GetYaxis()->SetTitle(yTitle);
hTrue[i]->SetLineColor(kBlue);
}
}
if( isGenPred ) hMuonPt->GetXaxis()->SetTitle("p_{T}(#mu^{gen}) [GeV]");
else hMuonPt->GetXaxis()->SetTitle("p_{T}(#mu) [GeV]");
hMuonPt->SetMarkerStyle(20);
hMuonPt->SetMarkerColor(kBlack);
hMuonPt->SetLineColor(hMuonPt->GetMarkerColor());
// Create legend
TLegend* leg = new TLegend(0.4,0.75,0.9,0.89);
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetTextFont(42);
leg->SetTextSize(0.05);
if( isMCPred ) {
leg->AddEntry(hTrue[0],"MC Expectation");
if( isGenPred ) leg->AddEntry(hPred[0],"Gen-Based Pred.");
else leg->AddEntry(hPred[0],"Data-Based Pred.");
}
// Draw
for(unsigned int i = 0; i < kNDists; ++i) {
TString name = "";
if( i == 0 ) name = "TauJetPt";
else if( i == 1 ) name = "HT";
else if( i == 2 ) name = "MHT";
TCanvas* can = new TCanvas(name,name,600,600);
can->cd();
if( isMCPred ) {
hTrue[i]->Draw("HISTE");
hPred[i]->Draw("PE1same");
leg->Draw("same");
if( isGenPred ) name = "hGenClosure"+name;
else name = "hRecoClosure"+name;
} else {
hPred[i]->Draw("PE1");
name = "hDataPred"+name;
}
gPad->SetLogy();
can->SaveAs(name+".eps","eps");
}
TCanvas* can = new TCanvas("can","muon pt",600,600);
can->cd();
hMuonPt->Draw("PE1");
gPad->SetLogy();
TString name = "MuonPt";
if( isMCPred ) {
if( isGenPred ) name = "hGenClosure"+name;
else name = "hRecoClosure"+name;
} else {
name = "hDataPred"+name;
}
can->SaveAs(name+".eps","eps");
}
void DrawTwoInPad(TVirtualPad* p,
Int_t sub,
TH1* h1,
TH1* h2,
Bool_t ratio,
Bool_t logy=false,
Bool_t legend=false)
{
TVirtualPad* pp = p->cd(sub);
pp->SetRightMargin(0.02);
pp->SetLeftMargin(0.10);
TVirtualPad* ppp = pp;
if (ratio) {
pp->Divide(1,2,0,0);
ppp = pp->cd(1);
ppp->SetRightMargin(0.02);
}
if (logy) ppp->SetLogy();
TH1* hs[] = { h1, h2, 0 };
if (h1->GetMaximum() < h2->GetMaximum()) {
hs[0] = h2;
hs[1] = h1;
}
TH1** ph = hs;
Double_t size = (ratio ? 0.1 : 0.05);
Double_t off = (ratio ? 0.6 : 0.5);
h1->SetFillStyle(3004);
h2->SetFillStyle(3005);
while (*ph) {
TString opt("hist");
if (ph != hs) opt.Append(" same");
TH1* copy = (*ph)->DrawCopy(opt);
copy->GetXaxis()->SetLabelSize(2*size);
copy->GetYaxis()->SetLabelSize(size);
copy->GetYaxis()->SetTitleSize(size);
copy->GetYaxis()->SetTitleOffset(off);
copy->SetYTitle(copy->GetTitle());
copy->SetTitle("");
copy->SetDirectory(0);
ph++;
}
TString s1 = h1->GetYaxis()->GetTitle();
TString s2 = h2->GetYaxis()->GetTitle();
if (legend) {
TLegend* l = new TLegend(0.6, 0.1, 0.9, 0.9);
l->SetBorderSize(0);
TLegendEntry* e = l->AddEntry("dummy", s1, "lf");
l->SetFillColor(kWhite);
e->SetFillColor(kBlack);
e->SetFillStyle(h1->GetFillStyle());
e = l->AddEntry("dummy", s2, "lf");
e->SetFillColor(kBlack);
e->SetFillStyle(h2->GetFillStyle());
l->Draw();
}
if (!ratio) return;
ppp = pp->cd(2);
ppp->SetRightMargin(0.02);
TH1* r = static_cast<TH1*>(h1->Clone(Form("ratio%s", h1->GetName())));
r->SetDirectory(0);
r->SetTitle("");
r->GetXaxis()->SetLabelSize(size);
r->GetYaxis()->SetLabelSize(size);
r->GetYaxis()->SetTitleSize(0.9*size);
r->GetYaxis()->SetTitleOffset(0.9*off);
r->SetMarkerStyle(20);
r->SetMarkerColor(h1->GetFillColor()+1);
r->SetFillStyle(3007);
r->SetYTitle(Form("#frac{%s}{%s}", s1.Data(), s2.Data()));
// r->Add(h2, -1);
// r->Divide(h1);
if (!r->IsA()->InheritsFrom(TProfile::Class())) {
r->GetSumw2()->Set(0); // r->Sumw2(false);
h2->GetSumw2()->Set(0); // h2->Sumw2(false);
}
r->Divide(h2);
Printf("%s", r->GetName());
for (UShort_t bin = 1; bin <= r->GetNbinsX(); bin++) {
Printf(" bin # %2d: Diff=%g+/-%g", bin, r->GetBinContent(bin),
r->GetBinError(bin));
r->SetBinError(bin, 0);
}
r->GetSumw2()->Set(0); //r->Sumw2(false);
r->SetMarkerSize(4);
r->SetMaximum(r->GetMaximum()*1.2);
r->SetMinimum(r->GetMinimum()*0.8);
r->Draw("hist text30");
p->Modified();
p->Update();
p->cd();
}
///////////////////////////////////////////////////////////////////
//////// Go4 GUI example script addhistos.C
// J.Adamczewski, gsi, May 2006
// JAM May 2015: added support for 2d histograms
// NOTE: to be run in Go4 GUI local command line only!
// NEVER call this script in remote analysis process!!!
/////// Functionality:
// adds histogram of name2 to histogram of name1
/////// Usage:
// histogram name2 will be scaled by factor.
// (e.g. if factor==-1, his2 is substracted from his1)
// The draw flag switches if the results are displayed each time this makro is called
// if display is switched off, the result histogram is just updated in browser and existing displays
///////
Bool_t addhistos(const char* name1, const char* name2, Double_t factor, Bool_t draw)
{
if(TGo4AbstractInterface::Instance()==0 || go4!=TGo4AbstractInterface::Instance()) {
std::cout <<"FATAL: Go4 gui macro executed outside Go4 GUI!! returning." << std::endl;
return kFALSE;
}
TString fullname1 = go4->FindItem(name1);
TObject* ob1=go4->GetObject(fullname1,1000); // 1000=timeout to get object from analysis in ms
TH1 *his1(0), *his2(0);
if(ob1 && ob1->InheritsFrom("TH1"))
his1 = (TH1*) ob1;
if(his1==0) {
std::cout <<"addhistos could not get histogram "<<fullname1 << std::endl;
return kFALSE;
}
TString fullname2 = go4->FindItem(name2);
TObject* ob2=go4->GetObject(fullname2,1000); // 1000=timeout to get object from analysis in ms
if(ob2 && ob2->InheritsFrom("TH1"))
his2 = (TH1*)ob2;
if(his2==0) {
std::cout <<"addhistos could not get histogram "<<fullname2 << std::endl;
return kFALSE;
}
if((his1->GetDimension()) != (his2->GetDimension()))
{
std::cout <<"addhistos could not add histograms of different dimensions "<< std::endl;
return kFALSE;
}
TH1* result = (TH1*) his1->Clone();
TString n1 = his1->GetName();
TString n2 = his2->GetName();
TString t1 = his1->GetTitle();
TString t2 = his2->GetTitle();
TString soper;
if(factor>0)
soper.Form(") + %4.1E * (",factor);
else
soper.Form(") - %4.1E * (",-1*factor);
TString finalname = TString("(")+n1+soper+n2+")";
TString finaltitle = TString("(")+t1+soper+t2+")";
result->SetName(finalname);
result->SetTitle(finaltitle);
result->Sumw2();
result->Add(his2,factor);
result->SetDirectory(0);
TString rname = go4->SaveToMemory("Sums", result, kTRUE);
std::cout<< "Saved result histogram to " << rname.Data() <<std::endl;
if(draw) {
ViewPanelHandle vpanel = go4->StartViewPanel();
if(result->GetDimension()>1)
{
// superimpose mode is not supported for 2d histograms
go4->DrawItem(rname, vpanel);
}
else
{
go4->SetSuperimpose(vpanel,kTRUE);
go4->DrawItem(fullname1, vpanel);
go4->DrawItem(fullname2, vpanel);
go4->DrawItem(rname, vpanel);
}
}
return kTRUE;
}
//void makeHist(const int sample, const int dataset=1)
void makeHist(const string title="")
{
vector<Hist> hist2print;
TPaveText *tx = new TPaveText(.05,.1,.95,.8);
// tx->AddText("Using Deafult JERs for all jets");
// tx->AddText("Using b-Jet JERs");
/* string title("QCD MG:");
//if (sample==1) title += "NJet(70/50/30>=2/4/5), #slash{E}_{T}>175, Triplet>1, 80<TopMass<270, TOP+0.5*BJET>500, MT2>300, #Delta#Phi(.5,.5,.3), BJets>=1";
if (sample==1) title += "All Stop cuts applied (use default JERs for all jets)";
else if (sample==2) title += "All Stop cuts applied + Inverted #Delta#Phi (use default JERs for all jets)";
else if (sample==3) title += "All Stop cuts applied (use b-Jet JERs)";
else if (sample==4) title += "All Stop cuts applied + Inverted #Delta#Phi (use b-Jet JERs)";
else if (sample==5) title += "No cuts applied";
*/
unsigned bitMaskArray[] = {0,1,2,3,129,130,131,195,257,258,269,323};
vector<unsigned> vBitMaskArray(bitMaskArray, bitMaskArray + sizeof(bitMaskArray) / sizeof(unsigned));
stringstream unclmet_title;
unclmet_title << title << "Unclutered MET";
hist2print.push_back(Hist("met",title,2,0.0, 400.0,1));
hist2print.push_back(Hist("unclmet",unclmet_title.str().c_str(),2,0.0, 100.0,1));
hist2print.push_back(Hist("mht",title,2,0.0, 400.0,1));
hist2print.push_back(Hist("ht",title,2,0,2000,1));
hist2print.push_back(Hist("njet30eta5p0",title,1,0,15,1));
hist2print.push_back(Hist("nbjets",title,1,0,10,1));
// hist2print.push_back(Hist("bjetPt",title,2));
hist2print.push_back(Hist("M123",title,2));
// hist2print.push_back(Hist("M23overM123",title));
hist2print.push_back(Hist("MT2",title,2));
hist2print.push_back(Hist("MTb",title,4));
hist2print.push_back(Hist("MTt",title,4));
hist2print.push_back(Hist("MTb_p_MTt",title,2,400,1000,1));
//hist2print.push_back(Hist("jet1_pt",title,2));
//hist2print.push_back("bjetPt");
// hist2print.push_back(Hist("bjetMass",title,2,0,200));
// hist2print.push_back(Hist("dphimin",title,4));
TFile *outRootFile = new TFile("Merged.root");
/*TPad *c1=0, *c2=0;
TCanvas *c = GetCanvas(c1, c2);
if (c ==NULL|| c1 == 0 ||c2 == 0)
{
cout << " A drawing pad is null !"<< endl;
cout << "c = " << c << endl;
cout << "c1 = " << c1 << endl;
cout << "c2 = " << c2 << endl;
assert(false);
}*/
TCanvas *c = new TCanvas("c1");
c->Range(0,0,1,1);
c->SetBorderSize(2);
c->SetFrameFillColor(0);
// ------------>Primitives in pad: c1_1
TPad *c1_1 = new TPad("c1_1", "c1_1",0.01,0.30,0.99,0.99);
c1_1->Draw();
c1_1->cd();
c1_1->SetBorderSize(2);
c1_1->SetTickx(1);
c1_1->SetTicky(1);
c1_1->SetTopMargin(0.1);
c1_1->SetBottomMargin(0.0);
//c1_1->SetFrameFillColor(3);
//c1_1->SetLogy();
c->cd();
// ------------>Primitives in pad: c1_2
TPad *c1_2 = new TPad("c1_2", "c1_2",0.01,0.01,0.99,0.30);
c1_2->Draw();
c1_2->cd();
c1_2->SetBorderSize(2);
c1_2->SetTickx(1);
c1_2->SetTicky(1);
c1_2->SetTopMargin(0.0);
c1_2->SetBottomMargin(0.24);
c1_2->SetFrameFillColor(0);
c1_2->SetGridx();
c1_2->SetGridy();
c->cd();
gStyle->SetOptStat(0);
gPad->Print("samples.eps[");
for (unsigned i=0;i<vBitMaskArray.size(); ++i)
{
unsigned mask = vBitMaskArray.at(i);
for (unsigned ihist=0; ihist < hist2print.size(); ++ihist)
{
stringstream path, reco_hist_name, gen_hist_name, smear_hist_name;
stringstream reco_hist, gen_hist, smear_hist;
stringstream folder;
folder << "Hist/Mask"<< mask << "HT0to8000MHT0to8000/";
//cout << "folder = " << folder.str() << endl;
/* if ((hist2print.at(ihist).Name()).find("Jet"))
{
reco_hist_name << folder.str() << "reco" << hist2print.at(ihist).Name() << "_copy";
reco_hist << folder.str() << "reco" << hist2print.at(ihist).Name();
smear_hist_name << folder.str() << "smeared" << hist2print.at(ihist).Name() << "_copy";
smear_hist << folder.str() << "smeared" << hist2print.at(ihist).Name();
gen_hist_name << folder.str() << "gen" << hist2print.at(ihist).Name() << "_copy";
gen_hist << folder.str() << "gen" << hist2print.at(ihist).Name();
} else
*/ {
reco_hist_name << folder.str() << "reco_" << hist2print.at(ihist).Name() << "_copy";
reco_hist << folder.str() << "reco_" << hist2print.at(ihist).Name();
smear_hist_name << folder.str() << "smeared_" << hist2print.at(ihist).Name() << "_copy";
smear_hist << folder.str() << "smeared_" << hist2print.at(ihist).Name();
gen_hist_name << folder.str() << "gen_" << hist2print.at(ihist).Name() << "_copy";
gen_hist << folder.str() << "gen_" << hist2print.at(ihist).Name();
}
TH1* hreco = (TH1*) (outRootFile->Get(reco_hist.str().c_str()));
if (hreco == NULL) { cout << "hreco = " << reco_hist.str() << " was not found!" << endl; assert(false); }
hreco->SetDirectory(0);
TH1* hsmear = (TH1*) (outRootFile->Get(smear_hist.str().c_str()));
if (hsmear == NULL) { cout << "hsmear = " << smear_hist.str() << " was not found!" << endl; assert(false); }
hsmear->SetDirectory(0);
TH1* hgen = (TH1*) (outRootFile->Get(gen_hist.str().c_str()));
//->Clone(gen_hist_name.str().c_str()));
if (hgen == NULL) { cout << "hgen = " << gen_hist.str() << " was not found!" << endl; assert(false); }
hgen->SetDirectory(0);
hreco->Sumw2();
hsmear->Sumw2();
hgen->Sumw2();
const int rebin = hist2print.at(ihist).Rebin();
const string title = hist2print.at(ihist).Title();
const double xmin = hist2print.at(ihist).Xmin();
const double xmax = hist2print.at(ihist).Xmax();
if (rebin>1)
{
hreco->Rebin(rebin);
hsmear->Rebin(rebin);
hgen->Rebin(rebin);
}
if (title.length()>0)
{
hreco->SetTitle(title.c_str());
hsmear->SetTitle(title.c_str());
hgen->SetTitle(title.c_str());
}
if (xmin != LargeNegNum || xmax != LargeNegNum)
{
hreco->GetXaxis()->SetRangeUser(xmin,xmax);
hsmear->GetXaxis()->SetRangeUser(xmin,xmax);
hgen->GetXaxis()->SetRangeUser(xmin,xmax);
}
const double reco_max_y = hreco->GetBinContent(hreco->GetMaximumBin());
const double smear_max_y = hsmear->GetBinContent(hsmear->GetMaximumBin());
const double y_max = max(reco_max_y, smear_max_y);
double y_min = 9999.0;
for (unsigned bin=1; bin<hreco->GetNbinsX(); ++bin)
{
const double v1 = hreco->GetBinContent(bin);
const double v2 = hsmear->GetBinContent(bin);
const double minv = min(v1,v2);
if (minv != 0 && minv < y_min) y_min = minv;
}
cout << hreco->GetName() << "->ymin/max = " << y_min << "(" << y_min/2.0 << ")/" << y_max << "(" << y_max*2.0 << ")" << endl;
hreco->GetYaxis()->SetRangeUser(y_min/2.0, y_max*2.0);
hsmear->GetYaxis()->SetRangeUser(y_min/2.0, y_max*2.0);
hgen->SetLineColor(kBlue);
hgen->SetMarkerColor(kBlue);
hgen->SetMarkerStyle(24);
hgen->SetLineWidth(2);
hsmear->SetLineColor(kRed);
hsmear->SetMarkerColor(kRed);
hsmear->SetMarkerStyle(24);
hsmear->SetLineWidth(2);
hreco->SetLineWidth(2);
hreco->SetMarkerStyle(kDot);
hreco->SetLineColor(kBlack);
hreco->SetMarkerColor(kBlack);
//hreco->GetXaxis()->SetRangeUser(0,300);
//hsmear->GetXaxis()->SetRangeUser(0,300);
hreco->GetYaxis()->CenterTitle(1);
hreco->SetLabelFont(42,"XYZ");
hreco->SetTitleFont(42,"XYZ");
hreco->GetYaxis()->SetTitleOffset(0.8);
hreco->SetLabelSize(0.05,"XYZ");
hreco->SetTitleSize(0.06,"XYZ");
TH1 *hsmeartoreco_ratio = (TH1*) (hsmear->Clone("hsmear_copy"));
hsmeartoreco_ratio->Divide(hreco);
hsmeartoreco_ratio->SetTitle("");
hsmeartoreco_ratio->GetYaxis()->SetTitle("Smear/Reco");
hsmeartoreco_ratio->GetYaxis()->SetRangeUser(0,2.);
hsmeartoreco_ratio->GetYaxis()->SetTitleOffset(0.4);
hsmeartoreco_ratio->GetXaxis()->SetTitleOffset(0.9);
hsmeartoreco_ratio->GetYaxis()->CenterTitle(1);
hsmeartoreco_ratio->GetXaxis()->CenterTitle(1);
hsmeartoreco_ratio->SetLabelSize(0.125,"XYZ");
hsmeartoreco_ratio->SetTitleSize(0.125,"XYZ");
// hsmeartoreco_ratio->SetLabelFont(labelfont,"XYZ");
// hsmeartoreco_ratio->SetTitleFont(titlefont,"XYZ");
hsmeartoreco_ratio->GetXaxis()->SetTickLength(0.07);
stringstream recoleg,smearleg, genleg;
const double sum_reco = hreco->Integral(1, hreco->GetNbinsX()+1);
const double sum_smear = hsmear->Integral(1, hsmear->GetNbinsX()+1);
const double sum_gen = hgen->Integral(1, hgen->GetNbinsX()+1);
const double err_reco = StatErr(hreco);
const double err_smear = StatErr(hsmear);
cout << setprecision(1) << fixed;
recoleg << "Reco (" << sum_reco << "#pm" << err_reco << ")";
smearleg << "Smear (" << sum_smear << "#pm" << err_smear << ")";
genleg << "Gen (" << sum_gen << ")";
cout << smear_hist_name.str() << "::reco/smear = " << sum_reco << "/" << sum_smear << endl;
TLegend *l2 = new TLegend(0.6,0.6,0.9,0.9);
l2->AddEntry(hreco, recoleg.str().c_str());
//l2->AddEntry(hgen, genleg.str().c_str());
l2->AddEntry(hsmear, smearleg.str().c_str());
c1_1->cd();
gPad->SetLogy(hist2print.at(ihist).LogY());
hreco->DrawCopy();
//hgen->DrawCopy("same");
hsmear->DrawCopy("same");
l2->Draw();
//tx->Draw();
c1_2->cd();
hsmeartoreco_ratio->DrawCopy();
c->cd();
gPad->Print("samples.eps");
}
}
gPad->Print("samples.eps]");
}
void exclusiongraph2()
{
TCanvas *c = new TCanvas("c",
"Charged Higgs L300 Contour",0,0,700,700);
c->SetTickx();
c->SetTicky();
c->SetGridx();
c->SetGridy();
TH1 *frame = new TH1F("frame","",1000,50,500);
frame->SetMinimum(1);
frame->SetMaximum(50);
frame->SetDirectory(0);
frame->SetStats(0);
frame->GetXaxis()->SetTitle("m_{A} (GeV)");
frame->GetXaxis()->SetTickLength(0.02);
frame->GetXaxis()->SetLabelSize(0.03);
frame->GetYaxis()->SetTitle("tan#beta");
frame->GetYaxis()->SetMoreLogLabels();
frame->GetYaxis()->SetLabelSize(0.03);
frame->Draw(" ");
c->SetLogy();
TGraph *gr1 = new TGraph(10);
gr1->SetFillColor(6);
gr1->SetFillStyle(3005);
gr1->SetLineColor(6);
gr1->SetLineWidth(603);
gr1->SetPoint(0,140,0.5);
gr1->SetPoint(1,130,2.9);
gr1->SetPoint(2,124.677,3.83726);
gr1->SetPoint(3,113.362,6.06903);
gr1->SetPoint(4,108.513,8.00221);
gr1->SetPoint(5,111.746,10.0272);
gr1->SetPoint(6,119.828,12.8419);
gr1->SetPoint(7,135.991,30.0872);
gr1->SetPoint(8,140,40);
gr1->SetPoint(9,135,60);
gr1->Draw("C");
TLatex *tex = new TLatex(140.841,37.9762,
"#leftarrow t #rightarrow bH^{+}, H^{+} #rightarrow #tau#nu");
tex->SetTextColor(6);
tex->Draw();
TGraph *gr2 = new TGraph(15);
gr2->SetName("Graph");
gr2->SetTitle("Graph");
gr2->SetFillColor(1);
gr2->SetFillStyle(3005);
gr2->SetLineWidth(3);
gr2->SetPoint(0,499.192,3.02622);
gr2->SetPoint(1,427.748,3.06233);
gr2->SetPoint(2,358.244,3.10722);
gr2->SetPoint(3,305.711,3.24589);
gr2->SetPoint(4,244.289,3.36617);
gr2->SetPoint(5,206.304,3.7544);
gr2->SetPoint(6,178.017,4.50347);
gr2->SetPoint(7,148.114,6.20297);
gr2->SetPoint(8,131.142,8.00221);
gr2->SetPoint(9,111.746,8.48188);
gr2->SetPoint(10,102.047,9.52921);
gr2->SetPoint(11,96.3901,13.2212);
gr2->SetPoint(12,92.3491,19.0232);
gr2->SetPoint(13,90.7328,26.3935);
gr2->SetPoint(14,93.1573,50.4385);
gr2->Draw("L");
tex = new TLatex(346.929,6.62281,"ATLAS");
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(328.341,5.24703,"#intLdt = 300 fb^{-1}");
tex->SetTextSize(0.0297619);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(340.463,4.1874,"Maximal mixing");
tex->SetTextSize(0.0297619);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(413.2,2.51608,"LEP 2000");
tex->SetTextSize(0.0297619);
tex->SetLineWidth(2);
tex->Draw();
TGraph *gr3 = new TGraph(10);
gr3->SetName("Graph");
gr3->SetTitle("Graph");
gr3->SetFillColor(2);
gr3->SetFillStyle(3004);
gr3->SetLineColor(2);
gr3->SetLineWidth(603);
gr3->SetPoint(0,176.84,10.7499);
gr3->SetPoint(1,190.575,11.9912);
gr3->SetPoint(2,211.58,12.7108);
gr3->SetPoint(3,243.088,12.3457);
gr3->SetPoint(4,279.443,12.6185);
gr3->SetPoint(5,302.065,12.9916);
gr3->SetPoint(6,331.957,13.7713);
gr3->SetPoint(7,369.928,14.2821);
gr3->SetPoint(8,425.673,16.1651);
gr3->SetPoint(9,499.192,18.1635);
gr3->Draw("C");
tex = new TLatex(188.151,9.36035,
"gb #rightarrow tH^{+}, H^{+} #rightarrow #tau#nu");
tex->SetTextColor(2);
tex->Draw();
TGraph *gr4 = new TGraph(10);
gr4->SetName("Graph");
gr4->SetTitle("Graph");
gr4->SetFillColor(4);
gr4->SetFillStyle(3004);
gr4->SetLineColor(4);
gr4->SetLineWidth(-603);
gr4->SetPoint(0,178.456,2.91797);
gr4->SetPoint(1,200.269,3.40033);
gr4->SetPoint(2,229.354,3.96243);
gr4->SetPoint(3,249.551,4.07959);
gr4->SetPoint(4,269.749,3.71097);
gr4->SetPoint(5,298.025,3.09308);
gr4->SetPoint(6,341.652,2.89679);
gr4->SetPoint(7,378.007,2.57808);
gr4->SetPoint(8,441.023,2.16454);
gr4->SetPoint(9,499.677,1.76145);
gr4->Draw("C");
tex = new TLatex(165.,1.15498,
"gb #rightarrow tH^{+}, H^{+} #rightarrow tb");
tex->SetTextColor(4);
tex->Draw();
TGraph *gr5 = new TGraph(10);
gr5->SetName("Graph");
gr5->SetTitle("Graph");
gr5->SetFillColor(4);
gr5->SetFillStyle(3004);
gr5->SetLineColor(4);
gr5->SetLineWidth(603);
gr5->SetPoint(0,152.603,23.0996);
gr5->SetPoint(1,188.151,18.8373);
gr5->SetPoint(2,239.048,15.2499);
gr5->SetPoint(3,264.901,15.8156);
gr5->SetPoint(4,299.641,18.8373);
gr5->SetPoint(5,334.381,20.7085);
gr5->SetPoint(6,360.233,22.4362);
gr5->SetPoint(7,396.589,24.4859);
gr5->SetPoint(8,433.752,25.7669);
gr5->SetPoint(9,499.192,27.3132);
gr5->Draw("C");
}
void
Example(Bool_t fit=true)
{
// Load the class - if not already done
if (!gROOT->GetClass("GraphSysErr"))
gROOT->LoadMacro("GraphSysErr.C+g");
// Adjust size along X of common errors
gStyle->SetErrorX(.2);
// Adjust size of hat, cap, ... - depends on canvas size!
gStyle->SetEndErrorSize(10);
// Make our object
GraphSysErr* gse = new GraphSysErr("foo", "Gaussian");
// Draw data with-out ticks
gse->SetDataOption(GraphSysErr::kNoTick);
gse->SetXTitle("X");
gse->SetYTitle("Y");
// Set some key/value pairs
gse->SetKey("laboratory", "The Center");
gse->SetKey("accelerator", "Mega Collider");
gse->SetKey("detector", "Huge Experiment");
gse->SetKey("author", "Christensen");
gse->SetKey("reference","Jour.All.Things A1,999");
gse->SetKey("doi","9999-9999-9999-9999");
gse->SetKey("abstract", "The data");
gse->SetKey("location", "In the paper");
gse->SetKey("reackey", "graviton -> tachyons");
gse->SetKey("obskey", "GUT");
// Adding qualifiers
gse->AddQualifier("question", "Life, universe, and everything");
// Two sources of common errors one relative, one absolue
UInt_t cm1 = gse->DefineCommon("Common 0.05", false, .05);
UInt_t cm2 = gse->DefineCommon("Common 10%", true, .1);
// Two sources of point-to-point errors, one relative, one absolute
UInt_t pp1 = gse->DeclarePoint2Point("Point-to-Point 0.1-0.2", true);
UInt_t pp2 = gse->DeclarePoint2Point("Point-to-Point 5-10%", false);
// Set options on summed errors (in case of option COMBINED)
gse->SetSumLineColor(kRed+2);
gse->SetSumLineWidth(2);
gse->SetSumTitle("All errors");
gse->SetSumOption(GraphSysErr::kHat);
// Set attributes of common errors
gse->SetSysFillColor(cm1, kRed+2);
gse->SetSysFillStyle(cm1, 3001);
gse->SetSysLineColor(cm1, kRed+2);
gse->SetSysFillColor(cm2, kCyan+2);
gse->SetSysFillStyle(cm2, 3001);
gse->SetSysOption(cm1, GraphSysErr::kBox);
gse->SetSysOption(cm2, GraphSysErr::kRect);
// Set attributes of other errors
gse->SetSysLineColor(pp1, kBlue+2);
gse->SetSysLineWidth(pp1, 2);
gse->SetSysLineColor(pp2, kGreen+2);
gse->SetSysLineWidth(pp2, 3);
gse->SetSysOption(pp1, GraphSysErr::kBar);
gse->SetSysOption(pp2, GraphSysErr::kHat);
// Fill a histogram with a Guassian random deviate
TH1* h = new TH1F("h", "h", 30, -3, 3);
h->Sumw2();
h->SetDirectory(0);
h->FillRandom("gaus",1000);
h->Scale(1./1000, "width");
// Fill in the data points
for (Int_t i = 0; i < h->GetNbinsX(); i++) {
Int_t bin = i+1;
Double_t x = h->GetXaxis()->GetBinCenter(bin);
Double_t y = h->GetBinContent(bin);
Double_t sta = h->GetBinError(bin);
Double_t w = h->GetXaxis()->GetBinWidth(bin);
// Set data
gse->SetPoint(i, x, y);
gse->SetPointError(i, w/2, w/2);
gse->SetStatError(i, sta);
// Set point-to-point errors
gse->SetSysError(pp1, i, 0., gRandom->Uniform(0.1, 0.2));
gse->SetSysError(pp2, i, 0., 0.,
gRandom->Uniform(0.05, 0.1),
gRandom->Uniform(0.05, 0.1));
}
// Remove temporary histogram
delete h;
// Build our canvas
TCanvas* c = new TCanvas("c","c", 1400, 1000);
c->SetFillColor(0);
c->SetFillStyle(0);
c->SetTopMargin(0.01);
c->SetRightMargin(0.01);
// Draw or fit (and draw) a Guassian to the data
const char* option = "STACK stat axis quad split max west";
if (!fit)
gse->Draw(option);
else
gse->Fit("gaus", "SQ", option, -3, 3);
// Make a legend
TLegend* l = c->BuildLegend(0.7,0.7,0.97,0.97);
l->SetFillColor(0);
l->SetFillStyle(0);
l->SetBorderSize(0);
// update the canvas and print
c->Modified();
c->Update();
c->cd();
c->Print("Example.png");
}
void stackPlotter::moveDirHistsToStacks(TDirectory* tdir, TString histname, int color){
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks" << std::endl;
// get metainfo from directory, else exit TODO
metaInfo tMI;
tMI.extractFrom(tdir);
if(debug) {
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo color=" << tMI.color << std::endl;
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo legendname=" << tMI.legendname<< std::endl;
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo legendorder=" << tMI.legendorder << std::endl;
}
TIter histIter(tdir->GetListOfKeys());
TObject* cHistObj;
TKey* cHistKey;
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || Iterating through histograms." << std::endl;
// loop through keys in the directory
while((cHistKey = (TKey*) histIter())) {
if(histname != cHistKey->GetName()) continue;
cHistObj=tdir->Get(cHistKey->GetName());
if(!cHistObj->InheritsFrom(TH1::Class())) continue;
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || Found histogram "
<< cHistKey->GetName() << std::endl;
// prepare the histogram to be added to the stack
TH1* cHist = (TH1*) cHistObj->Clone();
cHist->SetDirectory(0);
TString mapName = cHist->GetName();
std::pair<Int_t,TH1*> newEntry(tMI.legendorder,cHist);
// initialize the stack info if needed
if(!stacksLegEntries_.count(mapName)) {
std::vector<std::pair<Int_t,TH1*> > legInfo(0);
legInfo.push_back(newEntry);
stacksLegEntries_[mapName] = legInfo;
}
cHist->SetFillColor(color);
cHist->SetFillStyle(1001);
cHist->SetMarkerStyle(kNone);
cHist->SetMarkerColor(kBlack);
cHist->SetLineColor(kBlack);
cHist->SetTitle(mapName);
cHist->SetName(tMI.legendname);
std::vector<std::pair<Int_t,TH1*> > legEntries = stacksLegEntries_[mapName];
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || legEntries size is " << legEntries.size() << std::endl;
for(size_t i=0; i < legEntries.size(); i++) {
if(legEntries.at(i).second == cHist && legEntries.at(i).first == tMI.legendorder) break;
if(legEntries.at(i).first >= tMI.legendorder) {
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || i is " << i << std::endl;
stacksLegEntries_[mapName].insert(stacksLegEntries_[mapName].begin()+i,newEntry);
break;
}
if(i==legEntries.size()-1) {
stacksLegEntries_[mapName].push_back(newEntry);
break;
}
}
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || legEntries size is " << legEntries.size() << std::endl;
}
}
void MakeTree_2015(const char* inputOniaTree = "../All_v2.24_Histos_Runs_211739-211831_GlbGlb_woPileUpRej_allPV.root",
//miniUpsilon_Histos_Runs_210498-211631_HFvars_paapJune28.root",
// const char* runNumber = "211739-211831",
// const char* runNumber = "210498-211631",// whole pA run, with wrong alignment
// const char* runNumber = "gt210658-211631",
const char* runNumber = "HIN-15-001",
//const char* runNumber = "a",
float newVtxProbCut = 0.01,// default in the input tree is already 0.01
float ptcut = 0., // single muon cut pt
int nTriggerBit = 2,
// const char* dataSource= "upsiMiniTree_pp276tev_5p41_ptmu4_woPileup_june27",
// const char* dataSource= "upsiMiniTree_pA5tev_ptmu4_octb15_chunk1_runGT210658",
const char* dataSource= "upsiMiniTree_pp2p76tev_noIDVars_GlbGlb",
// const char* dataSource= "upsiMiniTree_pp7tev_dimu0v1_ptmu4",
// const char* dataSource= "upsiMiniTree_aa276tevC50100_ppofficial_trktrk_ptmu4",
bool isAArereco = false,// only for newly processed AA; old tree is with triger v1,v2 included
bool bAllTriggers = false,
bool addExtraCentrality = true,
bool excludeWrongAlign_pa = false
)
{
gROOT->Macro("setTDRStyle_modified.C+");
float mass_min = 7.0;
float mass_max = 14.0;
int nBins = 30;
TFile *f = TFile::Open(Form("%s",inputOniaTree));
TTree *t = (TTree*)f->Get("myTree");
Long64_t nentries = t->GetEntries();
cout<<"Got the tree!"<<endl;
cout << nentries << endl;
const int NMAX=1000000;
UInt_t eventNb;
UInt_t runNb;
Int_t Centrality;
Int_t HLTriggers;
Int_t Reco_QQ_size;
Int_t Reco_QQ_type[NMAX];
Int_t Reco_QQ_sign[NMAX];
Int_t Reco_QQ_NtrkDeltaR03[NMAX];
Int_t Reco_QQ_NtrkDeltaR04[NMAX];
Int_t Reco_QQ_NtrkDeltaR05[NMAX];
Int_t Reco_QQ_NtrkPt04[NMAX];
Int_t Reco_QQ_NtrkPt03[NMAX];
Int_t Reco_QQ_NtrkPt02[NMAX];
Float_t Reco_QQ_ctau[NMAX];
Float_t Reco_QQ_ctauErr[NMAX];
Float_t Reco_QQ_ctauTrue[NMAX];
Float_t Reco_QQ_VtxProb[NMAX];
float Reco_QQ_dca[NMAX]; // new float, unused in upsilon
Int_t Reco_QQ_trig[NMAX];
Float_t zVtx;
int Reco_QQ_mupl_nTrkHits[NMAX];
float Reco_QQ_mupl_normChi2_inner[NMAX];
float Reco_QQ_mupl_normChi2_global[NMAX];
float Reco_QQ_mupl_dxy[NMAX];
float Reco_QQ_mupl_dxyErr[NMAX];
float Reco_QQ_mupl_dz[NMAX];
float Reco_QQ_mupl_dzErr[NMAX];
Bool_t Reco_QQ_mupl_TrkMuArb[NMAX];
Bool_t Reco_QQ_mupl_TMOneStaTight[NMAX]; // new bool, unused in upsilon(?)
int Reco_QQ_mupl_nMuValHits[NMAX]; // new int, unused in upsilon
int Reco_QQ_mupl_nPixWMea[NMAX]; // new int, unused in upsilon
int Reco_QQ_mupl_nTrkWMea[NMAX]; // new int, unused in upsilon
int Reco_QQ_mupl_StationsMatched[NMAX]; // new int, unused in Upsilon
float Reco_QQ_mupl_pt_inner[NMAX]; // new float, unused.
float Reco_QQ_mupl_pt_global[NMAX]; //new float, unused.
float Reco_QQ_mupl_ptErr_inner[NMAX]; // new float, unused.
float Reco_QQ_mupl_ptErr_global[NMAX]; //new float, unused.
int Reco_QQ_mumi_nTrkHits[NMAX];
float Reco_QQ_mumi_normChi2_inner[NMAX];
float Reco_QQ_mumi_normChi2_global[NMAX];
float Reco_QQ_mumi_dxy[NMAX];
float Reco_QQ_mumi_dxyErr[NMAX];
float Reco_QQ_mumi_dz[NMAX];
float Reco_QQ_mumi_dzErr[NMAX];
Bool_t Reco_QQ_mumi_TrkMuArb[NMAX];
Bool_t Reco_QQ_mumi_TMOneStaTight[NMAX]; // new bool, unused in upsilon(?)
int Reco_QQ_mumi_nMuValHits[NMAX]; // new int, unused in upsilon
int Reco_QQ_mumi_nPixWMea[NMAX]; // new int, unused in upsilon
int Reco_QQ_mumi_nTrkWMea[NMAX]; // new int, unused in upsilon
int Reco_QQ_mumi_StationsMatched[NMAX]; // new int, unused in Upsilon
float Reco_QQ_mumi_pt_inner[NMAX]; // new float, unused.
float Reco_QQ_mumi_pt_global[NMAX]; //new float, unused.
float Reco_QQ_mumi_ptErr_inner[NMAX]; // new float, unused.
float Reco_QQ_mumi_ptErr_global[NMAX]; //new float, unused.
TClonesArray *Reco_QQ_vtx = 0;;
TClonesArray *Reco_QQ_4mom = 0;
TClonesArray *Reco_QQ_mupl_4mom = 0;
TClonesArray *Reco_QQ_mumi_4mom = 0;
TClonesArray *Reco_mu_4mom = 0;
Int_t Reco_mu_size;
Int_t Reco_mu_type[NMAX];
Int_t Reco_mu_charge[NMAX];
int nPlusMu;
int nMinusMu;
float muPt[NMAX];
float muEta[NMAX];
float muPhi[NMAX];
//Int_t nReco_QQ;
Float_t invariantMass;
Int_t QQtrig;
Int_t QQsign;
Int_t QQTrkDr03;
Int_t QQTrkDr04;
Int_t QQTrkDr05;
Int_t QQTrkPt04;
Int_t QQTrkPt03;
Int_t QQTrkPt02;
float weight;
float weight2;
Float_t upsPt;
Float_t upsEta;
Float_t upsPhi;
Float_t upsRapidity;
Float_t vProb;
Float_t muPlusPt;
Float_t muMinusPt;
Float_t muPlusEta;
Float_t muMinusEta;
Float_t muPlusPhi;
Float_t muMinusPhi;
Float_t RmuPlusPhi = 0;
Float_t RmuMinusPhi = 0;
// centrliaty extra stuff
Int_t Npix, NpixelTracks,Ntracks;
Float_t SumET_HF, SumET_HFplus, SumET_HFminus, SumET_HFplusEta4, SumET_HFminusEta4, SumET_EB, SumET_ET, SumET_EE, SumET_EEplus, SumET_EEminus, SumET_ZDC, SumET_ZDCplus, SumET_ZDCminus;
// track extra stuff
const int NTRKMAX=100000000;
int Reco_trk_size=0;
TClonesArray *Reco_trk_vtx = 0;
TClonesArray *Reco_trk_4mom = 0;
float trkPt[NTRKMAX];
float trkEta[NTRKMAX];
float trkPhi[NTRKMAX];
//---------------------------
TBranch *b_Centrality; //!
TBranch *b_eventNb; //!
TBranch *b_runNb; //!
TBranch *b_HLTriggers; //!
TBranch *b_Reco_QQ_size; //!
TBranch *b_Reco_QQ_trig; //!
TBranch *b_Reco_QQ_type; //!
TBranch *b_Reco_QQ_sign; //!
TBranch *b_Reco_QQ_VtxProb; //!
TBranch *b_Reco_QQ_dca; // new float, unused in upsilon
TBranch *b_Reco_QQ_ctau; //!
TBranch *b_Reco_QQ_ctauErr; //!
TBranch *b_Reco_QQ_ctauTrue; //!
TBranch *b_Reco_QQ_4mom; //!
TBranch *b_Reco_QQ_vtx; //!
TBranch *b_Reco_QQ_mupl_4mom;//!
TBranch *b_Reco_QQ_mumi_4mom;//!
TBranch *b_Reco_QQ_NtrkDeltaR03;//!
TBranch *b_Reco_QQ_NtrkDeltaR04;//!
TBranch *b_Reco_QQ_NtrkDeltaR05;//!
TBranch *b_Reco_QQ_NtrkPt04;//!
TBranch *b_Reco_QQ_NtrkPt03;//!
TBranch *b_Reco_QQ_NtrkPt02;//!
//------------------------------
TBranch *b_Reco_QQ_mupl_nTrkHits;
TBranch *b_Reco_QQ_mupl_normChi2_inner;
TBranch *b_Reco_QQ_mupl_normChi2_global;
TBranch *b_Reco_QQ_mupl_dxy;
TBranch *b_Reco_QQ_mupl_dxyErr;
TBranch *b_Reco_QQ_mupl_dz;
TBranch *b_Reco_QQ_mupl_dzErr;
TBranch *b_Reco_QQ_mupl_TrkMuArb;
TBranch *b_Reco_QQ_mupl_TMOneStaTight; // new bool, unused in upsilon(?)
TBranch *b_Reco_QQ_mupl_nMuValHits; // new int, unused in upsilon
TBranch *b_Reco_QQ_mupl_nPixWMea; // new int, unused in upsilon
TBranch *b_Reco_QQ_mupl_nTrkWMea; // new int, unused in upsilon
TBranch *b_Reco_QQ_mupl_StationsMatched; // new int, unused in Upsilon
TBranch *b_Reco_QQ_mupl_pt_inner; // new float, unused.
TBranch *b_Reco_QQ_mupl_pt_global; //new float, unused.
TBranch *b_Reco_QQ_mupl_ptErr_inner; // new float, unused.
TBranch *b_Reco_QQ_mupl_ptErr_global; //new float, unused.
TBranch *b_Reco_QQ_mumi_TMOneStaTight; // new bool, unused in upsilon(?)
TBranch *b_Reco_QQ_mumi_nMuValHits; // new int, unused in upsilon
TBranch *b_Reco_QQ_mumi_nPixWMea; // new int, unused in upsilon
TBranch *b_Reco_QQ_mumi_nTrkWMea; // new int, unused in upsilon
TBranch *b_Reco_QQ_mumi_StationsMatched; // new int, unused in Upsilon
TBranch *b_Reco_QQ_mumi_pt_inner; // new float, unused.
TBranch *b_Reco_QQ_mumi_pt_global; //new float, unused.
TBranch *b_Reco_QQ_mumi_ptErr_inner; // new float, unused.
TBranch *b_Reco_QQ_mumi_ptErr_global; //new float, unused.
TBranch *b_Reco_QQ_mumi_normChi2_inner;
TBranch *b_Reco_QQ_mumi_normChi2_global;
TBranch *b_Reco_QQ_mumi_dxy;
TBranch *b_Reco_QQ_mumi_dxyErr;
TBranch *b_Reco_QQ_mumi_dz;
TBranch *b_Reco_QQ_mumi_dzErr;
TBranch *b_Reco_QQ_mumi_TrkMuArb;
TBranch *b_Reco_QQ_mumi_nTrkHits;
//------------- //------------- //-------------
TBranch *b_Reco_mu_size; //!
TBranch *b_Reco_mu_type; //!
TBranch *b_Reco_mu_charge;//!
TBranch *b_Reco_mu_4mom; //!
//------------- //------------- //-------------
TBranch *b_zVtx; //!
TBranch *b_Npix; //!
TBranch *b_NpixelTracks; //!
TBranch *b_Ntracks; //!
TBranch *b_SumET_HF; //!
TBranch *b_SumET_HFplus; //!
TBranch *b_SumET_HFminus; //!
TBranch *b_SumET_HFplusEta4; //!
TBranch *b_SumET_HFminusEta4; //!
TBranch *b_SumET_ET; //!
TBranch *b_SumET_EE; //!
TBranch *b_SumET_EB; //!
TBranch *b_SumET_EEplus; //!
TBranch *b_SumET_EEminus; //!
TBranch *b_SumET_ZDC; //!
TBranch *b_SumET_ZDCplus; //!
TBranch *b_SumET_ZDCminus; //!
//------------------------------
TBranch *b_Reco_trk_size; //!
TBranch *b_Reco_trk_4mom; //!
TBranch *b_Reco_trk_vtx; //!
/// new tree variables
Int_t _mupl_nTrkHits;
Float_t _mupl_normChi2_inner;
Float_t _mupl_normChi2_global;
Float_t _mupl_dxy;
Float_t _mupl_dxyErr;
Float_t _mupl_dz;
Float_t _mupl_dzErr;
Bool_t _mupl_TrkMuArb;
Bool_t _mupl_TMOneStaTight; // new bool, unused in upsilon(?)
Int_t _mupl_nMuValHits; // new int, unused in upsilon
Int_t _mupl_nPixWMea; // new int, unused in upsilon
Int_t _mupl_nTrkWMea; // new int, unused in upsilon
Int_t _mupl_StationsMatched; // new int, unused in Upsilon
Float_t _mupl_pt_inner; // new float, unused.
Float_t _mupl_pt_global; //new float, unused.
Float_t _mupl_ptErr_inner; // new float, unused.
Float_t _mupl_ptErr_global; //new float, unused.
Bool_t _mumi_TMOneStaTight; // new bool, unused in upsilon(?)
Int_t _mumi_nMuValHits; // new int, unused in upsilon
Int_t _mumi_nPixWMea; // new int, unused in upsilon
Int_t _mumi_nTrkWMea; // new int, unused in upsilon
Int_t _mumi_StationsMatched; // new int, unused in Upsilon
Float_t _mumi_pt_inner; // new float, unused.
Float_t _mumi_pt_global; //new float, unused.
Float_t _mumi_ptErr_inner; // new float, unused.
Float_t _mumi_ptErr_global; //new float, unused.
Float_t _mumi_normChi2_inner;
Float_t _mumi_normChi2_global;
Float_t _mumi_dxy;
Float_t _mumi_dxyErr;
Float_t _mumi_dz;
Float_t _mumi_dzErr;
Bool_t _mumi_TrkMuArb;
Int_t _mumi_nTrkHits;
Float_t _dca;
float _ctau; // new float, unused in upsilon
float _ctauTrue; // new float, unused in upsilon
float _ctauErr; // new float, unused in upsilon
float _zVtx;
// ###### read input TTree
t->SetBranchAddress("Centrality", &Centrality, &b_Centrality);
t->SetBranchAddress("eventNb", &eventNb, &b_eventNb);
t->SetBranchAddress("runNb", &runNb, &b_runNb);
t->SetBranchAddress("HLTriggers", &HLTriggers, &b_HLTriggers);
t->SetBranchAddress("Reco_QQ_size", &Reco_QQ_size, &b_Reco_QQ_size);
t->SetBranchAddress("Reco_QQ_type", &Reco_QQ_type, &b_Reco_QQ_type);
t->SetBranchAddress("Reco_QQ_sign", &Reco_QQ_sign, &b_Reco_QQ_sign);
t->SetBranchAddress("Reco_QQ_4mom", &Reco_QQ_4mom, &b_Reco_QQ_4mom);
t->SetBranchAddress("Reco_QQ_vtx", &Reco_QQ_vtx, &b_Reco_QQ_vtx);
t->SetBranchAddress("Reco_QQ_mupl_4mom", &Reco_QQ_mupl_4mom, &b_Reco_QQ_mupl_4mom);
t->SetBranchAddress("Reco_QQ_mumi_4mom", &Reco_QQ_mumi_4mom, &b_Reco_QQ_mumi_4mom);
t->SetBranchAddress("Reco_mu_size", &Reco_mu_size, &b_Reco_mu_size);
t->SetBranchAddress("Reco_mu_type", &Reco_mu_type, &b_Reco_mu_type);
t->SetBranchAddress("Reco_mu_charge",&Reco_mu_charge, &b_Reco_mu_charge);
t->SetBranchAddress("Reco_mu_4mom", &Reco_mu_4mom, &b_Reco_mu_4mom);
t->SetBranchAddress("Reco_QQ_NtrkDeltaR03", &Reco_QQ_NtrkDeltaR03, &b_Reco_QQ_NtrkDeltaR03);
t->SetBranchAddress("Reco_QQ_NtrkDeltaR04", &Reco_QQ_NtrkDeltaR04, &b_Reco_QQ_NtrkDeltaR04);
t->SetBranchAddress("Reco_QQ_NtrkDeltaR05", &Reco_QQ_NtrkDeltaR05, &b_Reco_QQ_NtrkDeltaR05);
t->SetBranchAddress("Reco_QQ_NtrkPt04", &Reco_QQ_NtrkPt04, &b_Reco_QQ_NtrkPt04);
t->SetBranchAddress("Reco_QQ_NtrkPt03", &Reco_QQ_NtrkPt03, &b_Reco_QQ_NtrkPt03);
t->SetBranchAddress("Reco_QQ_NtrkPt02", &Reco_QQ_NtrkPt02, &b_Reco_QQ_NtrkPt02);
// additional selection
//id variables
t->SetBranchAddress("Reco_QQ_mupl_nTrkHits", &Reco_QQ_mupl_nTrkHits, &b_Reco_QQ_mupl_nTrkHits);
t->SetBranchAddress("Reco_QQ_mupl_normChi2_inner", &Reco_QQ_mupl_normChi2_inner, &b_Reco_QQ_mupl_normChi2_inner);
t->SetBranchAddress("Reco_QQ_mupl_normChi2_global", &Reco_QQ_mupl_normChi2_global, &b_Reco_QQ_mupl_normChi2_global);
t->SetBranchAddress("Reco_QQ_mupl_dxy", &Reco_QQ_mupl_dxy, &b_Reco_QQ_mupl_dxy);
t->SetBranchAddress("Reco_QQ_mupl_dz", &Reco_QQ_mupl_dz, &b_Reco_QQ_mupl_dz);
t->SetBranchAddress("Reco_QQ_mupl_dxyErr", &Reco_QQ_mupl_dxyErr, &b_Reco_QQ_mupl_dxyErr);
t->SetBranchAddress("Reco_QQ_mupl_dzErr", &Reco_QQ_mupl_dzErr, &b_Reco_QQ_mupl_dzErr);
t->SetBranchAddress("Reco_QQ_mupl_TrkMuArb", &Reco_QQ_mupl_TrkMuArb, &b_Reco_QQ_mupl_TrkMuArb);
t->SetBranchAddress("Reco_QQ_mupl_StationsMatched",&Reco_QQ_mupl_StationsMatched, &b_Reco_QQ_mupl_StationsMatched); // new int, unused in Upsilon
t->SetBranchAddress("Reco_QQ_mupl_TMOneStaTight", &Reco_QQ_mupl_TMOneStaTight, &b_Reco_QQ_mupl_TMOneStaTight); // new bool, unused in upsilon(?)
t->SetBranchAddress("Reco_QQ_mupl_nMuValHits", &Reco_QQ_mupl_nMuValHits, &b_Reco_QQ_mupl_nMuValHits); // new int, unused in upsilon
t->SetBranchAddress("Reco_QQ_mupl_nPixWMea",&Reco_QQ_mupl_nPixWMea,&b_Reco_QQ_mupl_nPixWMea); // new int, unused in upsilon
t->SetBranchAddress("Reco_QQ_mupl_nTrkWMea",&Reco_QQ_mupl_nTrkWMea,&b_Reco_QQ_mupl_nTrkWMea); // new int, unused in upsilon
t->SetBranchAddress("Reco_QQ_mupl_pt_inner",&Reco_QQ_mupl_pt_inner,&b_Reco_QQ_mupl_pt_inner); // new float, unused.
t->SetBranchAddress("Reco_QQ_mupl_pt_global",&Reco_QQ_mupl_pt_global,&b_Reco_QQ_mupl_pt_global);//new float, unused.
t->SetBranchAddress("Reco_QQ_mupl_ptErr_inner",&Reco_QQ_mupl_ptErr_inner,&b_Reco_QQ_mupl_ptErr_inner); // new float, unused.
t->SetBranchAddress("Reco_QQ_mupl_ptErr_global",&Reco_QQ_mupl_ptErr_global,&b_Reco_QQ_mupl_ptErr_global);//new float, unused.
//muminus
t->SetBranchAddress("Reco_QQ_mumi_nTrkHits", &Reco_QQ_mumi_nTrkHits, &b_Reco_QQ_mumi_nTrkHits);
t->SetBranchAddress("Reco_QQ_mumi_normChi2_inner", &Reco_QQ_mumi_normChi2_inner, &b_Reco_QQ_mumi_normChi2_inner);
t->SetBranchAddress("Reco_QQ_mumi_normChi2_global", &Reco_QQ_mumi_normChi2_global, &b_Reco_QQ_mumi_normChi2_global);
t->SetBranchAddress("Reco_QQ_mumi_dxy", &Reco_QQ_mumi_dxy, &b_Reco_QQ_mumi_dxy);
t->SetBranchAddress("Reco_QQ_mumi_dz", &Reco_QQ_mumi_dz, &b_Reco_QQ_mumi_dz);
t->SetBranchAddress("Reco_QQ_mumi_dxyErr", &Reco_QQ_mumi_dxyErr, &b_Reco_QQ_mumi_dxyErr);
t->SetBranchAddress("Reco_QQ_mumi_dzErr", &Reco_QQ_mumi_dzErr, &b_Reco_QQ_mumi_dzErr);
t->SetBranchAddress("Reco_QQ_mumi_TrkMuArb", &Reco_QQ_mumi_TrkMuArb, &b_Reco_QQ_mumi_TrkMuArb);
t->SetBranchAddress("Reco_QQ_mumi_TMOneStaTight", &Reco_QQ_mumi_TMOneStaTight, &b_Reco_QQ_mumi_TMOneStaTight); // new bool, unused in upsilon(?)
t->SetBranchAddress("Reco_QQ_mumi_nMuValHits", &Reco_QQ_mumi_nMuValHits, &b_Reco_QQ_mumi_nMuValHits); // new int, unused in upsilon
t->SetBranchAddress("Reco_QQ_mumi_nPixWMea",&Reco_QQ_mumi_nPixWMea,&b_Reco_QQ_mumi_nPixWMea); // new int, unused in upsilon
t->SetBranchAddress("Reco_QQ_mumi_nTrkWMea",&Reco_QQ_mumi_nTrkWMea,&b_Reco_QQ_mumi_nTrkWMea); // new int, unused in upsilon
t->SetBranchAddress("Reco_QQ_mumi_StationsMatched",&Reco_QQ_mumi_StationsMatched, &b_Reco_QQ_mumi_StationsMatched); // new int, unused in Upsilon
t->SetBranchAddress("Reco_QQ_mumi_pt_inner",&Reco_QQ_mumi_pt_inner,&b_Reco_QQ_mumi_pt_inner); // new float, unused.
t->SetBranchAddress("Reco_QQ_mumi_pt_global",&Reco_QQ_mumi_pt_global,&b_Reco_QQ_mumi_pt_global);//new float, unused.
t->SetBranchAddress("Reco_QQ_mumi_ptErr_inner",&Reco_QQ_mumi_ptErr_inner,&b_Reco_QQ_mumi_ptErr_inner); // new float, unused.
t->SetBranchAddress("Reco_QQ_mumi_ptErr_global",&Reco_QQ_mumi_ptErr_global,&b_Reco_QQ_mumi_ptErr_global);//new float, unused.
//dimuons
t->SetBranchAddress("Reco_QQ_dca", &Reco_QQ_dca, &b_Reco_QQ_dca);
t->SetBranchAddress("Reco_QQ_trig", &Reco_QQ_trig, &b_Reco_QQ_trig);
t->SetBranchAddress("Reco_QQ_VtxProb", &Reco_QQ_VtxProb, &b_Reco_QQ_VtxProb);
t->SetBranchAddress("Reco_QQ_ctau", &Reco_QQ_ctau, &b_Reco_QQ_ctau);
t->SetBranchAddress("Reco_QQ_ctauErr", &Reco_QQ_ctauErr, &b_Reco_QQ_ctauErr);
t->SetBranchAddress("Reco_QQ_ctauTrue", &Reco_QQ_ctauTrue, &b_Reco_QQ_ctauTrue);
t->SetBranchAddress("zVtx", &zVtx, &b_zVtx);
// extra centrality variables
t->SetBranchAddress("Npix", &Npix, &b_Npix);
t->SetBranchAddress("NpixelTracks", &NpixelTracks, &b_NpixelTracks);
t->SetBranchAddress("Ntracks", &Ntracks, &b_Ntracks);
t->SetBranchAddress("SumET_HF", &SumET_HF, &b_SumET_HF);
t->SetBranchAddress("SumET_HFplus", &SumET_HFplus, &b_SumET_HFplus);
t->SetBranchAddress("SumET_HFminus", &SumET_HFminus, &b_SumET_HFminus);
t->SetBranchAddress("SumET_HFplusEta4", &SumET_HFplusEta4, &b_SumET_HFplusEta4);
t->SetBranchAddress("SumET_HFminusEta4",&SumET_HFminusEta4, &b_SumET_HFminusEta4);
t->SetBranchAddress("SumET_ET", &SumET_ET, &b_SumET_ET);
t->SetBranchAddress("SumET_EE", &SumET_EE, &b_SumET_EE);
t->SetBranchAddress("SumET_EB", &SumET_EB, &b_SumET_EB);
t->SetBranchAddress("SumET_EEplus", &SumET_EEplus, &b_SumET_EEplus);
t->SetBranchAddress("SumET_EEminus", &SumET_EEminus, &b_SumET_EEminus);
t->SetBranchAddress("SumET_ZDC" , &SumET_ZDC, &b_SumET_ZDC);
t->SetBranchAddress("SumET_ZDCplus", &SumET_ZDCplus, &b_SumET_ZDCplus);
t->SetBranchAddress("SumET_ZDCminus", &SumET_ZDCminus, &b_SumET_ZDCminus);
// extra track variable
t->SetBranchAddress("Reco_trk_size", &Reco_trk_size, &b_Reco_trk_size);
t->SetBranchAddress("Reco_trk_4mom", &Reco_trk_4mom, &b_Reco_trk_4mom);
t->SetBranchAddress("Reco_trk_vtx", &Reco_trk_vtx, &b_Reco_trk_vtx);
// #### define control histograms
TH1F *h_QQ_mass = new TH1F("h_QQ_mass","",nBins, mass_min,mass_max); // all OS
TH1F *h_QQ_mass_1 = new TH1F("h_QQ_mass_1","",nBins, mass_min,mass_max);// OS in acceptance
TH1F *h_QQ_mass_2 = new TH1F("h_QQ_mass_2","",nBins, mass_min, mass_max);// SS
// ##### output file
TFile *f1 = new TFile(Form("../dimuonTree_%s_Run%s_trigBit%d_allTriggers%d.root",dataSource,runNumber,nTriggerBit,bAllTriggers),"RECREATE");
TTree *MuTree = new TTree("MuTree","MuTree");
TTree *UpsilonTree = new TTree("UpsilonTree","UpsilonTree");
TTree *UpsilonTree_allsign = new TTree("UpsilonTree_allsign","UpsilonTree_allsign");
TTree *UpsilonTree_trkRot = new TTree("UpsilonTree_trkRot","UpsilonTree_trkRot");
MuTree->Branch("Reco_mu_size", &Reco_mu_size, "Reco_mu_size/I");
MuTree->Branch("nPlusMu", &nPlusMu, "nPlusMu/I");
MuTree->Branch("nMinusMu", &nMinusMu, "nMinusMu/I");
MuTree->Branch("muPt", &muPt, "muPt[Reco_mu_size]/F");
MuTree->Branch("muEta", &muEta, "muEta[Reco_mu_size]/F");
MuTree->Branch("muPhi", &muPhi, "muPhi[Reco_mu_size]/F");
MuTree->Branch("Reco_mu_type", &Reco_mu_type, "Reco_mu_type[Reco_mu_size]/I");
MuTree->Branch("Reco_mu_charge", &Reco_mu_charge, "Reco_mu_charge[Reco_mu_size]/I" );
MuTree->Branch("eventNb", &eventNb, "eventNb/I");
MuTree->Branch("runNb", &runNb, "runNb/I");
//UpsilonTree->Branch("nReco_QQ", &nReco_QQ, "nReco_QQ/I");
UpsilonTree->Branch("Centrality", &Centrality, "Centrality/I");
UpsilonTree->Branch("HLTriggers", &HLTriggers, "HLTriggers/I");
UpsilonTree->Branch("QQsign", &QQsign, "QQsign/I");
UpsilonTree->Branch("QQTrkDr03", &QQTrkDr03, "QQTrkDr03/I");
UpsilonTree->Branch("QQTrkDr04", &QQTrkDr04, "QQTrkDr04/I");
UpsilonTree->Branch("QQTrkDr05", &QQTrkDr05, "QQTrkDr05/I");
UpsilonTree->Branch("QQTrkPt02", &QQTrkPt02, "QQTrkPt02/I");
UpsilonTree->Branch("QQTrkPt03", &QQTrkPt03, "QQTrkPt03/I");
UpsilonTree->Branch("QQTrkPt04", &QQTrkPt04, "QQTrkPt04/I");
UpsilonTree->Branch("eventNb", &eventNb, "eventNb/I");
UpsilonTree->Branch("runNb", &runNb, "runNb/I");
UpsilonTree->Branch("invariantMass", &invariantMass, "invariantMass/F");
UpsilonTree->Branch("upsPt", &upsPt, "upsPt/F");
UpsilonTree->Branch("upsEta", &upsEta, "upsEta/F");
UpsilonTree->Branch("upsPhi", &upsPhi, "upsPhi/F");
UpsilonTree->Branch("upsRapidity", &upsRapidity, "upsRapidity/F");
UpsilonTree->Branch("muPlusPt", &muPlusPt, "muPlusPt/F");
UpsilonTree->Branch("muMinusPt", &muMinusPt, "muMinusPt/F");
UpsilonTree->Branch("muPlusEta", &muPlusEta, "muPlusEta/F");
UpsilonTree->Branch("muMinusEta", &muMinusEta, "muMinusEta/F");
UpsilonTree->Branch("muPlusPhi", &muPlusPhi, "muPlusPhi/F");
UpsilonTree->Branch("muMinusPhi", &muMinusPhi, "muMinusPhi/F");
// additional selection
// id muplus
UpsilonTree->Branch("_mupl_TrkMuArb",&_mupl_TrkMuArb,"_mupl_TrkMuArb/O");
UpsilonTree->Branch("_mupl_TMOneStaTight",&_mupl_TMOneStaTight,"_mupl_TMOneStaTight/O"); // new bool, unused in upsilon(?)
UpsilonTree->Branch("_mupl_nMuValHits",&_mupl_nMuValHits,"_mupl_nMuValHits/I"); // new int, unused in upsilon
UpsilonTree->Branch("_mupl_nPixWMea",&_mupl_nPixWMea,"_mupl_nPixWMea/I"); // new int, unused in upsilon
UpsilonTree->Branch("_mupl_nTrkWMea",&_mupl_nTrkWMea,"_mupl_nTrkWMea/I"); // new int, unused in upsilon
UpsilonTree->Branch("_mupl_StationsMatched",&_mupl_StationsMatched,"_mupl_StationsMatched/I"); // new int, unused in Upsilon
UpsilonTree->Branch("_mupl_pt_inner",&_mupl_pt_inner,"_mupl_pt_inner/F"); // new float, unused.
UpsilonTree->Branch("_mupl_pt_global",&_mupl_pt_global,"_mupl_pt_global/F"); //new float, unused.
UpsilonTree->Branch("_mupl_ptErr_inner",&_mupl_ptErr_inner,"_mupl_ptErr_inner/F"); // new float, unused.
UpsilonTree->Branch("_mupl_ptErr_global",&_mupl_ptErr_global,"_mupl_ptErr_global/F"); //new float, unused.
UpsilonTree->Branch("_mupl_nTrkHits",&_mupl_nTrkHits," _mupl_nTrkHits/I");
UpsilonTree->Branch("_mupl_normChi2_inner", &_mupl_normChi2_inner," _mupl_normChi2_inner/F");
UpsilonTree->Branch("_mupl_normChi2_global",&_mupl_normChi2_global,"_mupl_normChi2_global/F");
UpsilonTree->Branch("_mupl_dxy",&_mupl_dxy,"_mupl_dxy/F");
UpsilonTree->Branch("_mupl_dxyErr",&_mupl_dxyErr,"_mupl_dxyErr/F");
UpsilonTree->Branch("_mupl_dz",&_mupl_dz,"_mupl_dz/F");
UpsilonTree->Branch("_mupl_dzErr",&_mupl_dzErr,"_mupl_dzErr/F");
//id muminus
UpsilonTree->Branch("_mumi_TrkMuArb",&_mumi_TrkMuArb,"_mumi_TrkMuArb/O");
UpsilonTree->Branch("_mumi_TMOneStaTight",&_mumi_TMOneStaTight,"_mumi_TMOneStaTight/O"); // new bool, unused in upsilon(?)
UpsilonTree->Branch("_mumi_nMuValHits",&_mumi_nMuValHits,"_mumi_nMuValHits/I"); // new int, unused in upsilon
UpsilonTree->Branch("_mumi_nPixWMea",&_mumi_nPixWMea,"_mumi_nPixWMea/I"); // new int, unused in upsilon
UpsilonTree->Branch("_mumi_nTrkWMea",&_mumi_nTrkWMea,"_mumi_nTrkWMea/I"); // new int, unused in upsilon
UpsilonTree->Branch("_mumi_StationsMatched",&_mumi_StationsMatched,"_mumi_StationsMatched/I"); // new int, unused in Upsilon
UpsilonTree->Branch("_mumi_pt_inner",&_mumi_pt_inner,"_mumi_pt_inner/F"); // new float, unused.
UpsilonTree->Branch("_mumi_pt_global",&_mumi_pt_global,"_mumi_pt_global/F"); //new float, unused.
UpsilonTree->Branch("_mumi_ptErr_inner",&_mumi_ptErr_inner,"_mumi_ptErr_inner/F"); // new float, unused.
UpsilonTree->Branch("_mumi_ptErr_global",&_mumi_ptErr_global,"_mumi_ptErr_global/F"); //new float, unused.
UpsilonTree->Branch("_mumi_nTrkHits",&_mumi_nTrkHits," _mumi_nTrkHits/I");
UpsilonTree->Branch("_mumi_normChi2_inner", &_mumi_normChi2_inner," _mumi_normChi2_inner/F");
UpsilonTree->Branch("_mumi_normChi2_global",&_mumi_normChi2_global,"_mumi_normChi2_global/F");
UpsilonTree->Branch("_mumi_dxy",&_mumi_dxy,"_mumi_dxy/F");
UpsilonTree->Branch("_mumi_dxyErr",&_mumi_dxyErr,"_mumi_dxyErr/F");
UpsilonTree->Branch("_mumi_dz",&_mumi_dz,"_mumi_dz/F");
UpsilonTree->Branch("_mumi_dzErr",&_mumi_dzErr,"_mumi_dzErr/F");
//dimuon variables
UpsilonTree->Branch("QQtrig", &QQtrig, "QQtrig/I");
UpsilonTree->Branch("_dca",&_dca,"_dca/F");// new float, unused in upsilon
UpsilonTree->Branch("_ctau",&_ctau,"_ctau/F");// new float, unused in upsilon
UpsilonTree->Branch("_ctauErr",&_ctauErr,"_ctauErr/F");// new float, unused in upsilon
UpsilonTree->Branch("_ctauTrue",&_ctauTrue,"_ctauTrue/F");// new float, unused in upsilon
UpsilonTree->Branch("_zVtx", &_zVtx,"_zVtx/F");
UpsilonTree->Branch("vProb", &vProb, "vProb/F");
if(addExtraCentrality)
{
UpsilonTree->Branch("Npix",&Npix,"Npix/I");
UpsilonTree->Branch("NpixelTracks",&NpixelTracks,"NpixelTracks/I");
UpsilonTree->Branch("Ntracks", &Ntracks, "Ntracks/I");
UpsilonTree->Branch("SumET_HF",&SumET_HF,"SumET_HF/F");
UpsilonTree->Branch("SumET_HFplus",&SumET_HFplus,"SumET_HFplus/F");
UpsilonTree->Branch("SumET_HFminus",&SumET_HFminus,"SumET_HFminus/F");
UpsilonTree->Branch("SumET_HFplusEta4",&SumET_HFplusEta4,"SumET_HFplusEta4/F");
UpsilonTree->Branch("SumET_HFminusEta4",&SumET_HFminusEta4,"SumET_HFminusEta4/F");
UpsilonTree->Branch("SumET_ET",&SumET_ET,"SumET_ET/F");
UpsilonTree->Branch("SumET_EE",&SumET_EE,"SumET_EE/F");
UpsilonTree->Branch("SumET_EB",&SumET_EB,"SumET_EB/F");
UpsilonTree->Branch("SumET_EEplus",&SumET_EEplus,"SumET_EEplus/F");
UpsilonTree->Branch("SumET_EEminus",&SumET_EEminus,"SumET_EEminus/F");
UpsilonTree->Branch("SumET_ZDC",&SumET_ZDC,"SumET_ZDC/F");
UpsilonTree->Branch("SumET_ZDCplus",&SumET_ZDCplus,"SumET_ZDCplus/F");
UpsilonTree->Branch("SumET_ZDCminus",&SumET_ZDCminus,"SumET_ZDCminus/F");
}
UpsilonTree_allsign->Branch("Centrality", &Centrality, "Centrality/I");
UpsilonTree_allsign->Branch("HLTriggers", &HLTriggers, "HLTriggers/I");
UpsilonTree_allsign->Branch("QQtrig", &QQtrig, "QQtrig/I");
UpsilonTree_allsign->Branch("QQsign", &QQsign, "QQsign/I");
UpsilonTree_allsign->Branch("QQTrkDr03", &QQTrkDr03, "QQTrkDr03/I");
UpsilonTree_allsign->Branch("QQTrkDr04", &QQTrkDr04, "QQTrkDr04/I");
UpsilonTree_allsign->Branch("QQTrkDr05", &QQTrkDr05, "QQTrkDr05/I");
UpsilonTree_allsign->Branch("QQTrkPt04", &QQTrkPt04, "QQTrkPt04/I");
UpsilonTree_allsign->Branch("QQTrkPt03", &QQTrkPt03, "QQTrkPt03/I");
UpsilonTree_allsign->Branch("QQTrkPt02", &QQTrkPt02, "QQTrkPt02/I");
UpsilonTree_allsign->Branch("weight", &weight, "weight/F");
UpsilonTree_allsign->Branch("weight2", &weight2, "weight2/F");
UpsilonTree_allsign->Branch("vProb", &vProb, "vProb/F");
UpsilonTree_allsign->Branch("eventNb", &eventNb, "eventNb/I");
UpsilonTree_allsign->Branch("runNb", &runNb, "runNb/I");
UpsilonTree_allsign->Branch("invariantMass", &invariantMass, "invariantMass/F");
UpsilonTree_allsign->Branch("upsPt", &upsPt, "upsPt/F");
UpsilonTree_allsign->Branch("upsEta", &upsEta, "upsEta/F");
UpsilonTree_allsign->Branch("upsPhi", &upsPhi, "upsPhi/F");
UpsilonTree_allsign->Branch("upsRapidity",&upsRapidity, "upsRapidity/F");
UpsilonTree_allsign->Branch("muPlusPt", &muPlusPt, "muPlusPt/F");
UpsilonTree_allsign->Branch("muMinusPt", &muMinusPt, "muMinusPt/F");
UpsilonTree_allsign->Branch("muPlusEta", &muPlusEta, "muPlusEta/F");
UpsilonTree_allsign->Branch("muMinusEta", &muMinusEta, "muMinusEta/F");
UpsilonTree_allsign->Branch("muPlusPhi", &muPlusPhi, "muPlusPhi/F");
UpsilonTree_allsign->Branch("muMinusPhi", &muMinusPhi, "muMinusPhi/F");
if(addExtraCentrality)
{
UpsilonTree_allsign->Branch("Npix",&Npix,"Npix/I");
UpsilonTree_allsign->Branch("NpixelTracks",&NpixelTracks,"NpixelTracks/I");
UpsilonTree_allsign->Branch("Ntracks", &Ntracks, "Ntracks/I");
UpsilonTree_allsign->Branch("SumET_HF",&SumET_HF,"SumET_HF/F");
UpsilonTree_allsign->Branch("SumET_HFplus",&SumET_HFplus,"SumET_HFplus/F");
UpsilonTree_allsign->Branch("SumET_HFminus",&SumET_HFminus,"SumET_HFminus/F");
UpsilonTree_allsign->Branch("SumET_HFplusEta4",&SumET_HFplusEta4,"SumET_HFplusEta4/F");
UpsilonTree_allsign->Branch("SumET_HFminusEta4",&SumET_HFminusEta4,"SumET_HFminusEta4/F");
UpsilonTree_allsign->Branch("SumET_ET",&SumET_ET,"SumET_ET/F");
UpsilonTree_allsign->Branch("SumET_EE",&SumET_EE,"SumET_EE/F");
UpsilonTree_allsign->Branch("SumET_EB",&SumET_EB,"SumET_EB/F");
UpsilonTree_allsign->Branch("SumET_EEplus",&SumET_EEplus,"SumET_EEplus/F");
UpsilonTree_allsign->Branch("SumET_EEminus",&SumET_EEminus,"SumET_EEminus/F");
UpsilonTree_allsign->Branch("SumET_ZDC",&SumET_ZDC,"SumET_ZDC/F");
UpsilonTree_allsign->Branch("SumET_ZDCplus",&SumET_ZDCplus,"SumET_ZDCplus/F");
UpsilonTree_allsign->Branch("SumET_ZDCminus",&SumET_ZDCminus,"SumET_ZDCminus/F");
}
UpsilonTree_trkRot->Branch("Centrality", &Centrality, "Centrality/I");
UpsilonTree_trkRot->Branch("HLTriggers", &HLTriggers, "HLTriggers/I");
UpsilonTree_trkRot->Branch("QQtrig", &QQtrig, "QQtrig/I");
UpsilonTree_trkRot->Branch("QQsign", &QQsign, "QQsign/I");
UpsilonTree_trkRot->Branch("QQTrkDr03", &QQTrkDr03, "QQTrkDr03/I");
UpsilonTree_trkRot->Branch("QQTrkDr04", &QQTrkDr04, "QQTrkDr04/I");
UpsilonTree_trkRot->Branch("QQTrkDr05", &QQTrkDr05, "QQTrkDr05/I");
UpsilonTree_trkRot->Branch("QQTrkPt04", &QQTrkPt04, "QQTrkPt04/I");
UpsilonTree_trkRot->Branch("QQTrkPt03", &QQTrkPt03, "QQTrkPt03/I");
UpsilonTree_trkRot->Branch("QQTrkPt02", &QQTrkPt02, "QQTrkPt02/I");
UpsilonTree_trkRot->Branch("weight", &weight, "weight/F");
UpsilonTree_trkRot->Branch("weight2", &weight2, "weight2/F");
UpsilonTree_trkRot->Branch("vProb", &vProb, "vProb/F");
UpsilonTree_trkRot->Branch("eventNb", &eventNb, "eventNb/I");
UpsilonTree_trkRot->Branch("runNb", &runNb, "runNb/I");
UpsilonTree_trkRot->Branch("invariantMass", &invariantMass, "invariantMass/F");
UpsilonTree_trkRot->Branch("upsPt", &upsPt, "upsPt/F");
UpsilonTree_trkRot->Branch("upsEta", &upsEta, "upsEta/F");
UpsilonTree_trkRot->Branch("upsPhi", &upsPhi, "upsPhi/F");
UpsilonTree_trkRot->Branch("upsRapidity",&upsRapidity, "upsRapidity/F");
UpsilonTree_trkRot->Branch("muPlusPt", &muPlusPt, "muPlusPt/F");
UpsilonTree_trkRot->Branch("muMinusPt", &muMinusPt, "muMinusPt/F");
UpsilonTree_trkRot->Branch("muPlusEta", &muPlusEta, "muPlusEta/F");
UpsilonTree_trkRot->Branch("muMinusEta", &muMinusEta, "muMinusEta/F");
UpsilonTree_trkRot->Branch("muPlusPhi", &muPlusPhi, "muPlusPhi/F");
UpsilonTree_trkRot->Branch("muMinusPhi", &muMinusPhi, "muMinusPhi/F");
if(addExtraCentrality)
{
UpsilonTree_trkRot->Branch("Npix",&Npix,"Npix/I");
UpsilonTree_trkRot->Branch("NpixelTracks",&NpixelTracks,"NpixelTracks/I");
UpsilonTree_trkRot->Branch("Ntracks", &Ntracks, "Ntracks/I");
UpsilonTree_trkRot->Branch("SumET_HF",&SumET_HF,"SumET_HF/F");
UpsilonTree_trkRot->Branch("SumET_HFplus",&SumET_HFplus,"SumET_HFplus/F");
UpsilonTree_trkRot->Branch("SumET_HFminus",&SumET_HFminus,"SumET_HFminus/F");
UpsilonTree_trkRot->Branch("SumET_HFplusEta4",&SumET_HFplusEta4,"SumET_HFplusEta4/F");
UpsilonTree_trkRot->Branch("SumET_HFminusEta4",&SumET_HFminusEta4,"SumET_HFminusEta4/F");
UpsilonTree_trkRot->Branch("SumET_ET",&SumET_ET,"SumET_ET/F");
UpsilonTree_trkRot->Branch("SumET_EE",&SumET_EE,"SumET_EE/F");
UpsilonTree_trkRot->Branch("SumET_EB",&SumET_EB,"SumET_EB/F");
UpsilonTree_trkRot->Branch("SumET_EEplus",&SumET_EEplus,"SumET_EEplus/F");
UpsilonTree_trkRot->Branch("SumET_EEminus",&SumET_EEminus,"SumET_EEminus/F");
UpsilonTree_trkRot->Branch("SumET_ZDC",&SumET_ZDC,"SumET_ZDC/F");
UpsilonTree_trkRot->Branch("SumET_ZDCplus",&SumET_ZDCplus,"SumET_ZDCplus/F");
UpsilonTree_trkRot->Branch("SumET_ZDCminus",&SumET_ZDCminus,"SumET_ZDCminus/F");
}
//____________________________________ loop over all events
for (int i=0; i<nentries; i++)
{
t->GetEntry(i);
// if(excludeWrongAlign_pa && runNb<=210658) continue;
// ##### single muon tree
// countng + and - single muons
nPlusMu=0;
nMinusMu=0;
for(int iMu = 0; iMu < Reco_mu_size; iMu++)
{
if (Reco_mu_charge[iMu] == 1) nPlusMu++;
else nMinusMu++;
TLorentzVector *Reco_mu = (TLorentzVector *) Reco_mu_4mom->At(iMu);
muPt[iMu]=Reco_mu->Pt();
muEta[iMu]=Reco_mu->Eta();
muPhi[iMu]=Reco_mu->Phi();
}
MuTree->Fill();
// // ntrk loop
// for(int iTrk = 0; iTrk < Reco_trk_size; iTrk++)
// {
// TLorentzVector *Reco_trk = (TLorentzVector *) Reco_trk_4mom->At(iTrk);
// trkPt[iTrk]=Reco_trk->Pt();
// trkEta[iTrk]=Reco_trk->Eta();
// trkPhi[iTrk]=Reco_trk->Phi();
// }
//----------------------------------------------------
for(int iQQ = 0; iQQ < Reco_QQ_size; iQQ++)
{
vProb = Reco_QQ_VtxProb[iQQ];
QQsign = Reco_QQ_sign[iQQ];
QQTrkDr03 = Reco_QQ_NtrkDeltaR03[iQQ];
QQTrkDr04 = Reco_QQ_NtrkDeltaR04[iQQ];
QQTrkDr05 = Reco_QQ_NtrkDeltaR05[iQQ];
QQTrkPt04 = Reco_QQ_NtrkPt04[iQQ];
QQTrkPt03 = Reco_QQ_NtrkPt03[iQQ];
QQTrkPt02 = Reco_QQ_NtrkPt02[iQQ];
// have to red a bit about the weighting Zhen calculates ...
if (Reco_QQ_sign[iQQ] == 0) // opposite sign
{
weight = 1;
weight2 = 1;
}
else // same sign
{
weight = -1;
float likesign_comb = (float)nPlusMu*(nPlusMu-1.0)/2.0+(float)nMinusMu*(nMinusMu-1.0)/2.0; // number of combinatorial pairs C(nplus)^2, C(nminus)^2
float unlikesign_bkgd_comb = (float)nPlusMu*nMinusMu - (nPlusMu>nMinusMu?nMinusMu:nPlusMu);
weight2 = -1.0 * unlikesign_bkgd_comb/likesign_comb;
}
// dimuon variables
TLorentzVector *Reco_QQ = (TLorentzVector *) Reco_QQ_4mom->At(iQQ);
TLorentzVector *Reco_QQ_mupl = (TLorentzVector *) Reco_QQ_mupl_4mom->At(iQQ);
TLorentzVector *Reco_QQ_mumi = (TLorentzVector *) Reco_QQ_mumi_4mom->At(iQQ);
invariantMass = Reco_QQ->M();
upsPt = Reco_QQ->Pt();
upsEta = Reco_QQ->Eta();
upsPhi = Reco_QQ->Phi();
upsRapidity = Reco_QQ->Rapidity();
// single muon variables
muMinusPt = Reco_QQ_mumi->Pt();
muMinusEta = Reco_QQ_mumi->Eta();
muMinusPhi = Reco_QQ_mumi->Phi();
muPlusPt = Reco_QQ_mupl->Pt();
muPlusEta = Reco_QQ_mupl->Eta();
muPlusPhi = Reco_QQ_mupl->Phi();
// apply extra selection
// id muplus
_mupl_nTrkHits = Reco_QQ_mupl_nTrkHits[iQQ];
_mupl_normChi2_inner = Reco_QQ_mupl_normChi2_inner[iQQ];
_mupl_normChi2_global= Reco_QQ_mupl_normChi2_global[iQQ];
_mupl_dxy = Reco_QQ_mupl_dxy[iQQ];
_mupl_dxyErr = Reco_QQ_mupl_dxyErr[iQQ];
_mupl_dz = Reco_QQ_mupl_dz[iQQ];
_mupl_dzErr = Reco_QQ_mupl_dzErr[iQQ];
_mupl_TrkMuArb = Reco_QQ_mupl_TrkMuArb[iQQ];
_mupl_TMOneStaTight = Reco_QQ_mupl_TMOneStaTight[iQQ];
_mupl_nMuValHits = Reco_QQ_mupl_nMuValHits[iQQ];
_mupl_nPixWMea = Reco_QQ_mupl_nPixWMea[iQQ];
_mupl_nTrkWMea = Reco_QQ_mupl_nTrkWMea[iQQ];
_mupl_StationsMatched = Reco_QQ_mupl_StationsMatched[iQQ];
_mupl_pt_inner = Reco_QQ_mupl_pt_inner[iQQ];
_mupl_pt_global = Reco_QQ_mupl_pt_global[iQQ];
_mupl_ptErr_inner = Reco_QQ_mupl_ptErr_inner[iQQ];
_mupl_ptErr_global = Reco_QQ_mupl_ptErr_global[iQQ];
// id muminus
_mumi_nTrkHits = Reco_QQ_mumi_nTrkHits[iQQ];
_mumi_normChi2_inner = Reco_QQ_mumi_normChi2_inner[iQQ];
_mumi_normChi2_global= Reco_QQ_mumi_normChi2_global[iQQ];
_mumi_dxy = Reco_QQ_mumi_dxy[iQQ];
_mumi_dxyErr = Reco_QQ_mumi_dxyErr[iQQ];
_mumi_dz = Reco_QQ_mumi_dz[iQQ];
_mumi_dzErr = Reco_QQ_mumi_dzErr[iQQ];
_mumi_TrkMuArb = Reco_QQ_mumi_TrkMuArb[iQQ];
_mumi_TMOneStaTight =Reco_QQ_mumi_TMOneStaTight[iQQ];
_mumi_nMuValHits = Reco_QQ_mumi_nMuValHits[iQQ];
_mumi_nPixWMea = Reco_QQ_mumi_nPixWMea[iQQ];
_mumi_nTrkWMea = Reco_QQ_mumi_nTrkWMea[iQQ];
_mumi_StationsMatched = Reco_QQ_mumi_StationsMatched[iQQ];
_mumi_pt_inner = Reco_QQ_mumi_pt_inner[iQQ];
_mumi_pt_global = Reco_QQ_mumi_pt_global[iQQ];
_mumi_ptErr_inner = Reco_QQ_mumi_ptErr_inner[iQQ];
_mumi_ptErr_global = Reco_QQ_mumi_ptErr_global[iQQ];
//dimuon variables
QQtrig = Reco_QQ_trig[iQQ];
_ctau = (invariantMass/3.0968)*Reco_QQ_ctau[iQQ];
_ctauTrue = (invariantMass/3.0968)*Reco_QQ_ctauTrue[iQQ];
_ctauErr = (invariantMass/3.0968)*Reco_QQ_ctauErr[iQQ];
_zVtx=zVtx[iQQ];
_dca=Reco_QQ_dca[iQQ];
bool bProcess = false;
if(!bAllTriggers) bProcess = ((HLTriggers&nTriggerBit)==nTriggerBit && (Reco_QQ_trig[iQQ]&nTriggerBit)==nTriggerBit &&
vProb>newVtxProbCut && muMinusPt>ptcut && muPlusPt>ptcut);
// for PbPB sample, the v1 and v2 same trigger is in nNtriggerBit=1 and nTriggerBit=2 respectivelly
/* if(isAArereco) bProcess = (( ( (HLTriggers&nTriggerBit)==nTriggerBit && (Reco_QQ_trig[iQQ]&nTriggerBit)==nTriggerBit ) ||
( (HLTriggers&(nTriggerBit+1))==(nTriggerBit+1) && (Reco_QQ_trig[iQQ]&(nTriggerBit+1))==(nTriggerBit+1) ) )
&& vProb>newVtxProbCut && muMinusPt>ptcut && muPlusPt>ptcut);*/
//special case of a new tree in which I match only by filter (I assume this is equivalent as having HLTriggers fired)
if(isAArereco) bProcess = (( (Reco_QQ_trig[iQQ]&(nTriggerBit+1))==(nTriggerBit+1) || (Reco_QQ_trig[iQQ]&nTriggerBit)==nTriggerBit )&& vProb>newVtxProbCut && muMinusPt>ptcut && muPlusPt>ptcut );
if (bProcess)
{
if (i%1000==0) cout << i << endl;
UpsilonTree_allsign->Fill();// all sign and all mass
if (QQsign==0) // opposite sign
{
UpsilonTree->Fill();// OS and all mass
if (Reco_QQ->M()>mass_min && Reco_QQ->M()<mass_max)
{
h_QQ_mass->Fill(Reco_QQ->M());// all upsilons in 7->14
}
if (Reco_QQ_mupl->Pt()>=ptcut && Reco_QQ_mumi->Pt()>=ptcut && Reco_QQ->M()>mass_min && Reco_QQ->M()<mass_max)
{
h_QQ_mass_1->Fill(Reco_QQ->M()); // all OS upsilons in 7->14 and pt_mu>4GeV/c
}
}//opposite sign
else // same sign in the acceptance
if (Reco_QQ_mupl->Pt()>=ptcut && Reco_QQ_mumi->Pt()>=ptcut && Reco_QQ->M()>mass_min && Reco_QQ->M()<mass_max)
{
h_QQ_mass_2->Fill(Reco_QQ->M());// all SS upsilons in 7->14 and pt_mu>4GeV/c
}
//--------------------------------------------------------
// %%%%%%%%%% track rotation: redefine some of the variables, the others remain the same
Double_t ran = gRandom->Rndm();
if(ran < 0.5 ) RmuPlusPhi = muPlusPhi + TMath::Pi();
else RmuMinusPhi = muMinusPhi + TMath::Pi();
TLorentzVector mu1;
mu1.SetPtEtaPhiM( muPlusPt, muPlusEta, RmuPlusPhi, 0.105);
TLorentzVector mu2;
mu2.SetPtEtaPhiM( muMinusPt, muMinusEta, RmuMinusPhi, 0.105);
TLorentzVector dimuon;
dimuon = mu1 + mu2;
invariantMass = dimuon.M();
upsPt = dimuon.Pt();
upsEta = dimuon.Eta();
upsRapidity = dimuon.Rapidity();
UpsilonTree_trkRot->Fill();
}// if bProcess
}// for each QQ pair
}// for each event in the tree
// __________________________________________________________________
// ###### plotting
TH1 * phMAxis = new TH1D("phMAxis",";m_{#mu#mu} [GeV/c^{2}];Events/(0.1 GeV/c^{2})",1,mass_min,mass_max);
phMAxis->SetDirectory(0);
phMAxis->SetMinimum(1);
phMAxis->SetMaximum(4e4);
TCanvas *c1 = new TCanvas("c1","c1");
phMAxis->Draw();
//h_QQ_mass->GetYaxis()->SetRangeUser(0,180);
h_QQ_mass->SetMarkerColor(kRed);
h_QQ_mass->SetMarkerStyle(22);
h_QQ_mass->Draw("PEsame");
h_QQ_mass_1->SetMarkerColor(kBlue);
h_QQ_mass_1->SetMarkerStyle(20);
h_QQ_mass_1->GetXaxis()->CenterTitle(kTRUE);
h_QQ_mass_1->Draw("PEsame");
//h_QQ_mass_2->GetYaxis()->SetRangeUser(0,400);
h_QQ_mass_2->SetMarkerColor(kRed);
h_QQ_mass_2->SetMarkerStyle(24);
h_QQ_mass_2->GetXaxis()->CenterTitle(kTRUE);
h_QQ_mass_2->Draw("PEsame");
TLegend *legend = new TLegend(.4,.7,.8,.9);
legend->SetTextSize(0.025);
legend->AddEntry(h_QQ_mass, Form("OS && M [%.1f,%.1f]GeV: %.0f",mass_min, mass_max,h_QQ_mass->Integral(1,nBins)),"P");
legend->AddEntry(h_QQ_mass_1,Form("OS && M [%.1f,%.1f]GeV && p_{T}>%.1fGeV/c: %.0f",mass_min, mass_max,ptcut,h_QQ_mass_1->Integral(1,nBins)),"P");
legend->AddEntry(h_QQ_mass_2,Form("SS && M [%.1f,%.1f]GeV && p_{T}>%.1fGeV/c:%.0f",mass_min, mass_max,ptcut,h_QQ_mass_2->Integral(1,nBins)),"P");
legend->Draw();
h_QQ_mass->Write();
h_QQ_mass_1->Write();
h_QQ_mass_2->Write();
c1->SaveAs(Form("dimuonDistribution_%s_Run%s_trigBit%d_allTriggers%d.pdf",dataSource,runNumber,nTriggerBit,bAllTriggers));
c1->SaveAs(Form("dimuonDistribution_%s_Run%s_trigBit%d_allTriggers%d.gif",dataSource,runNumber,nTriggerBit,bAllTriggers));
c1->Write();
f1->Write();
}
void check1SLimits(
const char* workDir, // workDir: usual tag where to look for files in Output
const char* lFileName="cLimits_683_NominalABCD_Asym_2SPL_woSyst.csv", // file name to save limits results
bool dosyst = false,
int mode = 1, // mode=0 -> pass, mode=1 -> prompt, mode=2 -> nonprompt
const char* workDirFail=""
)
{
TString slFileName(lFileName);
if ( dosyst && !slFileName.Contains("wSys") )
{
cout << "Comparison requires systematics but limits file does not contain them" << endl;
return;
}
// list of files
set<anabin> thebins = allbins();
const char* ppp = "../Fitter";
// systematic uncertainties for fit
map<anabin, syst> syst_All;
if ( dosyst )
{
if (mode==0) syst_All = readSyst_all_pass("",ppp,workDir);
if (mode==1) syst_All = readSyst_all_prompt("",ppp,workDir,workDirFail);
if (mode==2) syst_All = readSyst_all_nonprompt("",ppp,workDir,workDirFail);
}
// bin edges
float ptmin, ptmax, ymin, ymax, centmin, centmax;
// histo for 1sigma limits checks
TH1* hCL = new TH1D("hOneSigmaCLComparison","",thebins.size(),0,thebins.size());
hCL->GetYaxis()->SetTitle("CL_{1#sigma}/#sigma");
hCL->GetYaxis()->SetTitleOffset(1.15);
hCL->SetStats(0);
hCL->SetDirectory(0);
hCL->SetMarkerColor(1);
hCL->SetMarkerStyle(20);
hCL->SetMarkerSize(1);
hCL->SetLineColor(1);
TLine* l1 = new TLine(0.,1.,hCL->GetXaxis()->GetXmax(),1.);
l1->SetLineWidth(3);
hCL->GetListOfFunctions()->Add(l1);
map<anabin,limits> maplim = readLimits(Form("csv/%s",slFileName.Data()));
int cnt=1;
for (set<anabin>::const_iterator it=thebins.begin(); it!=thebins.end(); it++)
{
cout << "Checking 1 sigma limits for analysis bin " << cnt << endl;
anabin thebin = *it;
ptmin = thebin.ptbin().low();
ptmax = thebin.ptbin().high();
ymin = thebin.rapbin().low();
ymax = thebin.rapbin().high();
centmin = thebin.centbin().low();
centmax = thebin.centbin().high();
double sigmaDoubleR = 0;
double doubleR = 0;
if (mode==0) {
doubleR = doubleratio_pass_nominal(workDir,thebin,ppp);
sigmaDoubleR = doubleratio_pass_stat(workDir,thebin,ppp);
}
if (mode==1) {
doubleR = doubleratio_prompt_nominal(workDir,workDirFail,thebin,ppp);
sigmaDoubleR = doubleratio_prompt_stat(workDir,workDirFail,thebin,ppp);
}
if (mode==2) {
doubleR = doubleratio_nonprompt_nominal(workDir,workDirFail,thebin,ppp);
sigmaDoubleR = doubleratio_nonprompt_stat(workDir,workDirFail,thebin,ppp);
}
double systAll=0;
if ( dosyst )
{
systAll = syst_All[thebin].value_dR;
sigmaDoubleR = sqrt(pow(sigmaDoubleR,2)+pow(systAll,2));
}
limits lim = maplim[thebin];
TString binName(Form("Pt[%.1f,%.1f]-Y[%.1f,%.1f]-C[%.1f,%.1f]",ptmin,ptmax,ymin,ymax,centmin,centmax));
double comp = -1.;
if ( sigmaDoubleR != 0 ) comp = (lim.val.second-lim.val.first)/(2.*sigmaDoubleR);
hCL->SetBinContent(cnt,comp);
hCL->GetXaxis()->SetBinLabel(cnt,binName.Data());
cnt++;
} // loop on the files
TFile* fSave = new TFile("oneSigmaCLComparison.root","RECREATE");
TCanvas* c = new TCanvas("cOneSigmaCLComparison","",90,116,1265,535);
c->Range(-3.690909,-0.01066472,33.30606,0.01252061);
c->SetFillColor(0);
c->SetBorderMode(0);
c->SetBorderSize(2);
c->SetRightMargin(0.1163896);
c->SetTopMargin(0.03732809);
c->SetBottomMargin(0.1630648);
c->SetFrameBorderMode(0);
c->SetFrameBorderMode(0);
gPad->SetGridx();
gPad->SetGridy();
hCL->Draw("p");
c->Write("cOneSigmaCLComparison", TObject::kOverwrite | TObject::kSingleKey);
fSave->Close(); delete fSave;
}
void diffrac(){
gROOT->Reset();
//gROOT->ProcessLine(".x rootlogon.C");
//=========Macro generated from canvas: cEvtSel/EvtSel
//========= (Wed Apr 14 17:19:02 2010) by ROOT version5.22/00d
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",550,600);
/*
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",0,22,550,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
cEvtSel->Range(-32.99367,-0.009375,158.1456,0.053125);
cEvtSel->SetFillColor(0);
cEvtSel->SetBorderMode(0);
cEvtSel->SetBorderSize(0);
cEvtSel->SetTickx(1);
cEvtSel->SetTicky(1);
cEvtSel->SetLeftMargin(0.17);
cEvtSel->SetRightMargin(0.04);
cEvtSel->SetTopMargin(0.05);
cEvtSel->SetBottomMargin(0.15);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
*/
//TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,60.5,1,0,0.06);
TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,150.5,1,0,0.05);
hFrame2->SetDirectory(0);
hFrame2->SetStats(0);
hFrame2->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame2->GetXaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetTitle("Fraction of events");
hFrame2->GetYaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetTitleOffset(1.5);
hFrame2->Draw("");
hFrame2->GetXaxis()->SetNdivisions(312);
hFrame2->GetYaxis()->SetNdivisions(305);
/*
TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,150.5,1,0,0.05);
hFrame2->SetDirectory(0);
hFrame2->SetStats(0);
hFrame2->SetFillColor(1);
hFrame2->SetFillStyle(0);
hFrame2->SetLineStyle(0);
hFrame2->SetMarkerStyle(20);
hFrame2->SetMarkerSize(1.5);
hFrame2->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame2->GetXaxis()->CenterTitle(true);
hFrame2->GetXaxis()->SetNdivisions(312);
hFrame2->GetXaxis()->SetLabelFont(42);
hFrame2->GetXaxis()->SetLabelOffset(0.01);
hFrame2->GetXaxis()->SetLabelSize(0.045);
hFrame2->GetXaxis()->SetTitleSize(0.055);
hFrame2->GetXaxis()->SetTitleFont(42);
hFrame2->GetYaxis()->SetTitle("Fraction of events");
hFrame2->GetYaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetLabelFont(42);
hFrame2->GetYaxis()->SetLabelOffset(0.01);
hFrame2->GetYaxis()->SetLabelSize(0.045);
hFrame2->GetYaxis()->SetTitleSize(0.055);
hFrame2->GetYaxis()->SetTitleOffset(1.5);
hFrame2->GetYaxis()->SetTitleFont(42);
hFrame2->GetZaxis()->SetLabelFont(42);
hFrame2->GetZaxis()->SetLabelSize(0.045);
hFrame2->GetZaxis()->SetTitleFont(42);
hFrame2->Draw("");
*/
TH1 *diffrac = new TH1D("diffrac","diffrac",200,0,200);
diffrac->SetBinContent(1,0.0004697663);
diffrac->SetBinContent(2,0.008010118);
diffrac->SetBinContent(3,0.0127921);
diffrac->SetBinContent(4,0.01698988);
diffrac->SetBinContent(5,0.02012166);
diffrac->SetBinContent(6,0.022341);
diffrac->SetBinContent(7,0.02315105);
diffrac->SetBinContent(8,0.02518068);
diffrac->SetBinContent(9,0.02668032);
diffrac->SetBinContent(10,0.02875512);
diffrac->SetBinContent(11,0.03089617);
diffrac->SetBinContent(12,0.0324741);
diffrac->SetBinContent(13,0.03311853);
diffrac->SetBinContent(14,0.03265478);
diffrac->SetBinContent(15,0.03213081);
diffrac->SetBinContent(16,0.03054987);
diffrac->SetBinContent(17,0.0283245);
diffrac->SetBinContent(18,0.02640026);
diffrac->SetBinContent(19,0.02394001);
diffrac->SetBinContent(20,0.02234401);
diffrac->SetBinContent(21,0.02026921);
diffrac->SetBinContent(22,0.01865213);
diffrac->SetBinContent(23,0.01720369);
diffrac->SetBinContent(24,0.01639665);
diffrac->SetBinContent(25,0.01546013);
diffrac->SetBinContent(26,0.01423151);
diffrac->SetBinContent(27,0.01359311);
diffrac->SetBinContent(28,0.01247892);
diffrac->SetBinContent(29,0.01204529);
diffrac->SetBinContent(30,0.01130752);
diffrac->SetBinContent(31,0.01089798);
diffrac->SetBinContent(32,0.01070826);
diffrac->SetBinContent(33,0.009497711);
diffrac->SetBinContent(34,0.009579017);
diffrac->SetBinContent(35,0.008805107);
diffrac->SetBinContent(36,0.008741869);
diffrac->SetBinContent(37,0.008522043);
diffrac->SetBinContent(38,0.00790171);
diffrac->SetBinContent(39,0.007799325);
diffrac->SetBinContent(40,0.007486148);
diffrac->SetBinContent(41,0.006838714);
diffrac->SetBinContent(42,0.006947121);
diffrac->SetBinContent(43,0.006504457);
diffrac->SetBinContent(44,0.0063298);
diffrac->SetBinContent(45,0.006122019);
diffrac->SetBinContent(46,0.006061792);
diffrac->SetBinContent(47,0.005823898);
diffrac->SetBinContent(48,0.005661286);
diffrac->SetBinContent(49,0.005543845);
diffrac->SetBinContent(50,0.005363166);
diffrac->SetBinContent(51,0.005215611);
diffrac->SetBinContent(52,0.00503192);
diffrac->SetBinContent(53,0.004800048);
diffrac->SetBinContent(54,0.004839195);
diffrac->SetBinContent(55,0.004583233);
diffrac->SetBinContent(56,0.004544086);
diffrac->SetBinContent(57,0.004471814);
diffrac->SetBinContent(58,0.004146591);
diffrac->SetBinContent(59,0.004267044);
diffrac->SetBinContent(60,0.003990002);
diffrac->SetBinContent(61,0.004083353);
diffrac->SetBinContent(62,0.003806312);
diffrac->SetBinContent(63,0.003782221);
diffrac->SetBinContent(64,0.003812334);
diffrac->SetBinContent(65,0.003472055);
diffrac->SetBinContent(66,0.00366478);
diffrac->SetBinContent(67,0.003195013);
diffrac->SetBinContent(68,0.003285353);
diffrac->SetBinContent(69,0.00323416);
diffrac->SetBinContent(70,0.0031649);
diffrac->SetBinContent(71,0.003110696);
diffrac->SetBinContent(72,0.003170923);
diffrac->SetBinContent(73,0.002966153);
diffrac->SetBinContent(74,0.002957119);
diffrac->SetBinContent(75,0.002905926);
diffrac->SetBinContent(76,0.002954107);
diffrac->SetBinContent(77,0.002785473);
diffrac->SetBinContent(78,0.002836666);
diffrac->SetBinContent(79,0.002725247);
diffrac->SetBinContent(80,0.002728258);
diffrac->SetBinContent(81,0.002568658);
diffrac->SetBinContent(82,0.002288605);
diffrac->SetBinContent(83,0.002499398);
diffrac->SetBinContent(84,0.002445194);
diffrac->SetBinContent(85,0.002378945);
diffrac->SetBinContent(86,0.00227656);
diffrac->SetBinContent(87,0.002418092);
diffrac->SetBinContent(88,0.002351843);
diffrac->SetBinContent(89,0.002381956);
diffrac->SetBinContent(90,0.002189232);
diffrac->SetBinContent(91,0.002222356);
diffrac->SetBinContent(92,0.002198265);
diffrac->SetBinContent(93,0.002219345);
diffrac->SetBinContent(94,0.002198265);
diffrac->SetBinContent(95,0.002089858);
diffrac->SetBinContent(96,0.001996507);
diffrac->SetBinContent(97,0.001972416);
diffrac->SetBinContent(98,0.001903156);
diffrac->SetBinContent(99,0.001818839);
diffrac->SetBinContent(100,0.001876054);
diffrac->SetBinContent(101,0.001864009);
diffrac->SetBinContent(102,0.001767646);
diffrac->SetBinContent(103,0.001879065);
diffrac->SetBinContent(104,0.001894122);
diffrac->SetBinContent(105,0.001695375);
diffrac->SetBinContent(106,0.001674295);
diffrac->SetBinContent(107,0.001611058);
diffrac->SetBinContent(108,0.001556854);
diffrac->SetBinContent(109,0.001620092);
diffrac->SetBinContent(110,0.001556854);
diffrac->SetBinContent(111,0.001568899);
diffrac->SetBinContent(112,0.001475548);
diffrac->SetBinContent(113,0.001376174);
diffrac->SetBinContent(114,0.001448446);
diffrac->SetBinContent(115,0.001520718);
diffrac->SetBinContent(116,0.001261744);
diffrac->SetBinContent(117,0.001448446);
diffrac->SetBinContent(118,0.001282823);
diffrac->SetBinContent(119,0.001219586);
diffrac->SetBinContent(120,0.001201518);
diffrac->SetBinContent(121,0.001237654);
diffrac->SetBinContent(122,0.001141291);
diffrac->SetBinContent(123,0.001195495);
diffrac->SetBinContent(124,0.001150325);
diffrac->SetBinContent(125,0.001195495);
diffrac->SetBinContent(126,0.0009816912);
diffrac->SetBinContent(127,0.001135269);
diffrac->SetBinContent(128,0.00100277);
diffrac->SetBinContent(129,0.001005782);
diffrac->SetBinContent(130,0.0009003854);
diffrac->SetBinContent(131,0.0008823175);
diffrac->SetBinContent(132,0.0009576006);
diffrac->SetBinContent(133,0.0008732835);
diffrac->SetBinContent(134,0.0008220911);
diffrac->SetBinContent(135,0.000831125);
diffrac->SetBinContent(136,0.0007437967);
diffrac->SetBinContent(137,0.000662491);
diffrac->SetBinContent(138,0.0007046495);
diffrac->SetBinContent(139,0.0007287401);
diffrac->SetBinContent(140,0.0007407854);
diffrac->SetBinContent(141,0.0006263551);
diffrac->SetBinContent(142,0.0006745363);
diffrac->SetBinContent(143,0.000653457);
diffrac->SetBinContent(144,0.0006082872);
diffrac->SetBinContent(145,0.0005420381);
diffrac->SetBinContent(146,0.0005631173);
diffrac->SetBinContent(147,0.0005059022);
diffrac->SetBinContent(148,0.0005781739);
diffrac->SetBinContent(149,0.0005239701);
diffrac->SetBinContent(150,0.0004547097);
diffrac->SetBinContent(151,0.0004697663);
diffrac->SetBinContent(152,0.0004547097);
diffrac->SetBinContent(153,0.0004396531);
diffrac->SetBinContent(154,0.0004697663);
diffrac->SetBinContent(155,0.0003884606);
diffrac->SetBinContent(156,0.0003613587);
diffrac->SetBinContent(157,0.0003523247);
diffrac->SetBinContent(158,0.0003703927);
diffrac->SetBinContent(159,0.0003794266);
diffrac->SetBinContent(160,0.0003041436);
diffrac->SetBinContent(161,0.0003192002);
diffrac->SetBinContent(162,0.000280053);
diffrac->SetBinContent(163,0.0002770417);
diffrac->SetBinContent(164,0.0002228379);
diffrac->SetBinContent(165,0.0002529511);
diffrac->SetBinContent(166,0.0002469285);
diffrac->SetBinContent(167,0.0002318718);
diffrac->SetBinContent(168,0.0003041436);
diffrac->SetBinContent(169,0.0002198265);
diffrac->SetBinContent(170,0.0002499398);
diffrac->SetBinContent(171,0.0001565888);
diffrac->SetBinContent(172,0.0001656227);
diffrac->SetBinContent(173,0.0001535775);
diffrac->SetBinContent(174,0.0001626114);
diffrac->SetBinContent(175,0.0001987473);
diffrac->SetBinContent(176,0.0001445435);
diffrac->SetBinContent(177,0.0001174416);
diffrac->SetBinContent(178,0.0001445435);
diffrac->SetBinContent(179,0.0001415322);
diffrac->SetBinContent(180,0.0001445435);
diffrac->SetBinContent(181,0.0001264755);
diffrac->SetBinContent(182,6.62491e-05);
diffrac->SetBinContent(183,7.227174e-05);
diffrac->SetBinContent(184,0.0001053963);
diffrac->SetBinContent(185,9.033968e-05);
diffrac->SetBinContent(186,8.732835e-05);
diffrac->SetBinContent(187,6.022645e-05);
diffrac->SetBinContent(188,9.3351e-05);
diffrac->SetBinContent(189,8.732835e-05);
diffrac->SetBinContent(190,8.431703e-05);
diffrac->SetBinContent(191,9.033968e-05);
diffrac->SetBinContent(192,4.215852e-05);
diffrac->SetBinContent(193,6.62491e-05);
diffrac->SetBinContent(194,7.528306e-05);
diffrac->SetBinContent(195,4.215852e-05);
diffrac->SetBinContent(196,4.516984e-05);
diffrac->SetBinContent(197,3.613587e-05);
diffrac->SetBinContent(198,6.022645e-05);
diffrac->SetBinContent(199,4.516984e-05);
diffrac->SetBinContent(200,3.011323e-05);
diffrac->SetBinContent(201,0.000457721);
diffrac->SetBinError(1,3.761141e-05);
diffrac->SetBinError(2,0.0001553095);
diffrac->SetBinError(3,0.000196268);
diffrac->SetBinError(4,0.0002261902);
diffrac->SetBinError(5,0.0002461561);
diffrac->SetBinError(6,0.0002593761);
diffrac->SetBinError(7,0.0002640365);
diffrac->SetBinError(8,0.0002753673);
diffrac->SetBinError(9,0.0002834485);
diffrac->SetBinError(10,0.0002942634);
diffrac->SetBinError(11,0.0003050219);
diffrac->SetBinError(12,0.0003127139);
diffrac->SetBinError(13,0.0003158015);
diffrac->SetBinError(14,0.0003135827);
diffrac->SetBinError(15,0.0003110566);
diffrac->SetBinError(16,0.0003033076);
diffrac->SetBinError(17,0.0002920517);
diffrac->SetBinError(18,0.0002819569);
diffrac->SetBinError(19,0.0002684979);
diffrac->SetBinError(20,0.0002593936);
diffrac->SetBinError(21,0.0002470569);
diffrac->SetBinError(22,0.000236997);
diffrac->SetBinError(23,0.000227609);
diffrac->SetBinError(24,0.0002222062);
diffrac->SetBinError(25,0.0002157671);
diffrac->SetBinError(26,0.0002070161);
diffrac->SetBinError(27,0.0002023196);
diffrac->SetBinError(28,0.0001938506);
diffrac->SetBinError(29,0.0001904528);
diffrac->SetBinError(30,0.000184528);
diffrac->SetBinError(31,0.0001811555);
diffrac->SetBinError(32,0.0001795718);
diffrac->SetBinError(33,0.0001691173);
diffrac->SetBinError(34,0.0001698397);
diffrac->SetBinError(35,0.0001628343);
diffrac->SetBinError(36,0.0001622485);
diffrac->SetBinError(37,0.0001601956);
diffrac->SetBinError(38,0.000154255);
diffrac->SetBinError(39,0.0001532524);
diffrac->SetBinError(40,0.000150144);
diffrac->SetBinError(41,0.0001435046);
diffrac->SetBinError(42,0.0001446376);
diffrac->SetBinError(43,0.0001399536);
diffrac->SetBinError(44,0.0001380618);
diffrac->SetBinError(45,0.0001357769);
diffrac->SetBinError(46,0.0001351074);
diffrac->SetBinError(47,0.0001324297);
diffrac->SetBinError(48,0.0001305678);
diffrac->SetBinError(49,0.0001292064);
diffrac->SetBinError(50,0.0001270835);
diffrac->SetBinError(51,0.0001253231);
diffrac->SetBinError(52,0.0001230964);
diffrac->SetBinError(53,0.0001202268);
diffrac->SetBinError(54,0.0001207161);
diffrac->SetBinError(55,0.0001174802);
diffrac->SetBinError(56,0.0001169774);
diffrac->SetBinError(57,0.0001160434);
diffrac->SetBinError(58,0.000111744);
diffrac->SetBinError(59,0.0001133554);
diffrac->SetBinError(60,0.0001096138);
diffrac->SetBinError(61,0.0001108887);
diffrac->SetBinError(62,0.0001070609);
diffrac->SetBinError(63,0.0001067215);
diffrac->SetBinError(64,0.0001071455);
diffrac->SetBinError(65,0.000102252);
diffrac->SetBinError(66,0.0001050516);
diffrac->SetBinError(67,9.808779e-05);
diffrac->SetBinError(68,9.946486e-05);
diffrac->SetBinError(69,9.868688e-05);
diffrac->SetBinError(70,9.762446e-05);
diffrac->SetBinError(71,9.678486e-05);
diffrac->SetBinError(72,9.77173e-05);
diffrac->SetBinError(73,9.450948e-05);
diffrac->SetBinError(74,9.436545e-05);
diffrac->SetBinError(75,9.354508e-05);
diffrac->SetBinError(76,9.431739e-05);
diffrac->SetBinError(77,9.15858e-05);
diffrac->SetBinError(78,9.242357e-05);
diffrac->SetBinError(79,9.059027e-05);
diffrac->SetBinError(80,9.064031e-05);
diffrac->SetBinError(81,8.794918e-05);
diffrac->SetBinError(82,8.301643e-05);
diffrac->SetBinError(83,8.675536e-05);
diffrac->SetBinError(84,8.580948e-05);
diffrac->SetBinError(85,8.463906e-05);
diffrac->SetBinError(86,8.279768e-05);
diffrac->SetBinError(87,8.533261e-05);
diffrac->SetBinError(88,8.415556e-05);
diffrac->SetBinError(89,8.469261e-05);
diffrac->SetBinError(90,8.11941e-05);
diffrac->SetBinError(91,8.180606e-05);
diffrac->SetBinError(92,8.136146e-05);
diffrac->SetBinError(93,8.175061e-05);
diffrac->SetBinError(94,8.136146e-05);
diffrac->SetBinError(95,7.932992e-05);
diffrac->SetBinError(96,7.75379e-05);
diffrac->SetBinError(97,7.706868e-05);
diffrac->SetBinError(98,7.570348e-05);
diffrac->SetBinError(99,7.40075e-05);
diffrac->SetBinError(100,7.516251e-05);
diffrac->SetBinError(101,7.492083e-05);
diffrac->SetBinError(102,7.295857e-05);
diffrac->SetBinError(103,7.522281e-05);
diffrac->SetBinError(104,7.552359e-05);
diffrac->SetBinError(105,7.145152e-05);
diffrac->SetBinError(106,7.100594e-05);
diffrac->SetBinError(107,6.965209e-05);
diffrac->SetBinError(108,6.847035e-05);
diffrac->SetBinError(109,6.984711e-05);
diffrac->SetBinError(110,6.847035e-05);
diffrac->SetBinError(111,6.873472e-05);
diffrac->SetBinError(112,6.665847e-05);
diffrac->SetBinError(113,6.437472e-05);
diffrac->SetBinError(114,6.604346e-05);
diffrac->SetBinError(115,6.767106e-05);
diffrac->SetBinError(116,6.164024e-05);
diffrac->SetBinError(117,6.604346e-05);
diffrac->SetBinError(118,6.2153e-05);
diffrac->SetBinError(119,6.06017e-05);
diffrac->SetBinError(120,6.015112e-05);
diffrac->SetBinError(121,6.104895e-05);
diffrac->SetBinError(122,5.862419e-05);
diffrac->SetBinError(123,6.000018e-05);
diffrac->SetBinError(124,5.885576e-05);
diffrac->SetBinError(125,6.000018e-05);
diffrac->SetBinError(126,5.437084e-05);
diffrac->SetBinError(127,5.846931e-05);
diffrac->SetBinError(128,5.495148e-05);
diffrac->SetBinError(129,5.503393e-05);
diffrac->SetBinError(130,5.207063e-05);
diffrac->SetBinError(131,5.154554e-05);
diffrac->SetBinError(132,5.369957e-05);
diffrac->SetBinError(133,5.128098e-05);
diffrac->SetBinError(134,4.975521e-05);
diffrac->SetBinError(135,5.002785e-05);
diffrac->SetBinError(136,4.732665e-05);
diffrac->SetBinError(137,4.466513e-05);
diffrac->SetBinError(138,4.606438e-05);
diffrac->SetBinError(139,4.684519e-05);
diffrac->SetBinError(140,4.723075e-05);
diffrac->SetBinError(141,4.342991e-05);
diffrac->SetBinError(142,4.506935e-05);
diffrac->SetBinError(143,4.435955e-05);
diffrac->SetBinError(144,4.279894e-05);
diffrac->SetBinError(145,4.040113e-05);
diffrac->SetBinError(146,4.117922e-05);
diffrac->SetBinError(147,3.90312e-05);
diffrac->SetBinError(148,4.172611e-05);
diffrac->SetBinError(149,3.972207e-05);
diffrac->SetBinError(150,3.700375e-05);
diffrac->SetBinError(151,3.761141e-05);
diffrac->SetBinError(152,3.700375e-05);
diffrac->SetBinError(153,3.638595e-05);
diffrac->SetBinError(154,3.761141e-05);
diffrac->SetBinError(155,3.420205e-05);
diffrac->SetBinError(156,3.298739e-05);
diffrac->SetBinError(157,3.257243e-05);
diffrac->SetBinError(158,3.339718e-05);
diffrac->SetBinError(159,3.380201e-05);
diffrac->SetBinError(160,3.026342e-05);
diffrac->SetBinError(161,3.100346e-05);
diffrac->SetBinError(162,2.904014e-05);
diffrac->SetBinError(163,2.888359e-05);
diffrac->SetBinError(164,2.590438e-05);
diffrac->SetBinError(165,2.759923e-05);
diffrac->SetBinError(166,2.726869e-05);
diffrac->SetBinError(167,2.642425e-05);
diffrac->SetBinError(168,3.026342e-05);
diffrac->SetBinError(169,2.572875e-05);
diffrac->SetBinError(170,2.743445e-05);
diffrac->SetBinError(171,2.171496e-05);
diffrac->SetBinError(172,2.233257e-05);
diffrac->SetBinError(173,2.150514e-05);
diffrac->SetBinError(174,2.212861e-05);
diffrac->SetBinError(175,2.44641e-05);
diffrac->SetBinError(176,2.086305e-05);
diffrac->SetBinError(177,1.88057e-05);
diffrac->SetBinError(178,2.086305e-05);
diffrac->SetBinError(179,2.064459e-05);
diffrac->SetBinError(180,2.086305e-05);
diffrac->SetBinError(181,1.95156e-05);
diffrac->SetBinError(182,1.412435e-05);
diffrac->SetBinError(183,1.475241e-05);
diffrac->SetBinError(184,1.781522e-05);
diffrac->SetBinError(185,1.649369e-05);
diffrac->SetBinError(186,1.621647e-05);
diffrac->SetBinError(187,1.346704e-05);
diffrac->SetBinError(188,1.676633e-05);
diffrac->SetBinError(189,1.621647e-05);
diffrac->SetBinError(190,1.593442e-05);
diffrac->SetBinError(191,1.649369e-05);
diffrac->SetBinError(192,1.126734e-05);
diffrac->SetBinError(193,1.412435e-05);
diffrac->SetBinError(194,1.505661e-05);
diffrac->SetBinError(195,1.126734e-05);
diffrac->SetBinError(196,1.16628e-05);
diffrac->SetBinError(197,1.043153e-05);
diffrac->SetBinError(198,1.346704e-05);
diffrac->SetBinError(199,1.16628e-05);
diffrac->SetBinError(200,9.522638e-06);
diffrac->SetBinError(201,3.712608e-05);
diffrac->SetEntries(332232);
diffrac->SetDirectory(0);
diffrac->SetFillColor(1);
diffrac->SetFillStyle(0);
diffrac->SetLineStyle(0);
diffrac->SetLineWidth(2);
diffrac->SetMarkerStyle(20);
diffrac->SetMarkerSize(1.5);
diffrac->GetXaxis()->SetTitle("M");
diffrac->GetXaxis()->SetLabelFont(42);
diffrac->GetXaxis()->SetLabelOffset(0.01);
diffrac->GetXaxis()->SetLabelSize(0.045);
diffrac->GetXaxis()->SetTitleSize(0.055);
diffrac->GetXaxis()->SetTitleFont(42);
diffrac->GetYaxis()->SetTitle("Fraction of events");
diffrac->GetYaxis()->SetLabelFont(42);
diffrac->GetYaxis()->SetLabelOffset(0.01);
diffrac->GetYaxis()->SetLabelSize(0.045);
diffrac->GetYaxis()->SetTitleSize(0.055);
diffrac->GetYaxis()->SetTitleOffset(1.6);
diffrac->GetYaxis()->SetTitleFont(42);
diffrac->GetZaxis()->SetLabelFont(42);
diffrac->GetZaxis()->SetLabelSize(0.045);
diffrac->GetZaxis()->SetTitleFont(42);
diffrac->Draw("hist same");
TH1 *diffrac = new TH1D("diffrac","diffrac",200,0,200);
diffrac->SetBinContent(1,0.0001535956);
diffrac->SetBinContent(2,0.002138746);
diffrac->SetBinContent(3,0.003918136);
diffrac->SetBinContent(4,0.006984252);
diffrac->SetBinContent(5,0.01149359);
diffrac->SetBinContent(6,0.01725487);
diffrac->SetBinContent(7,0.02335522);
diffrac->SetBinContent(8,0.02994824);
diffrac->SetBinContent(9,0.03493575);
diffrac->SetBinContent(10,0.03668616);
diffrac->SetBinContent(11,0.03929439);
diffrac->SetBinContent(12,0.03968852);
diffrac->SetBinContent(13,0.03844526);
diffrac->SetBinContent(14,0.0360341);
diffrac->SetBinContent(15,0.03434745);
diffrac->SetBinContent(16,0.03306942);
diffrac->SetBinContent(17,0.03029311);
diffrac->SetBinContent(18,0.02782978);
diffrac->SetBinContent(19,0.02716903);
diffrac->SetBinContent(20,0.02540413);
diffrac->SetBinContent(21,0.02289154);
diffrac->SetBinContent(22,0.02272345);
diffrac->SetBinContent(23,0.02145412);
diffrac->SetBinContent(24,0.02181927);
diffrac->SetBinContent(25,0.02003698);
diffrac->SetBinContent(26,0.01887487);
diffrac->SetBinContent(27,0.01739977);
diffrac->SetBinContent(28,0.01641734);
diffrac->SetBinContent(29,0.01567544);
diffrac->SetBinContent(30,0.01542621);
diffrac->SetBinContent(31,0.01473069);
diffrac->SetBinContent(32,0.01400618);
diffrac->SetBinContent(33,0.01286146);
diffrac->SetBinContent(34,0.01269917);
diffrac->SetBinContent(35,0.0127919);
diffrac->SetBinContent(36,0.01181527);
diffrac->SetBinContent(37,0.01151387);
diffrac->SetBinContent(38,0.01042421);
diffrac->SetBinContent(39,0.01025613);
diffrac->SetBinContent(40,0.009320064);
diffrac->SetBinContent(41,0.009027363);
diffrac->SetBinContent(42,0.008412981);
diffrac->SetBinContent(43,0.00834053);
diffrac->SetBinContent(44,0.007647901);
diffrac->SetBinContent(45,0.007917418);
diffrac->SetBinContent(46,0.007523286);
diffrac->SetBinContent(47,0.006679959);
diffrac->SetBinContent(48,0.006526363);
diffrac->SetBinContent(49,0.006004718);
diffrac->SetBinContent(50,0.005914879);
diffrac->SetBinContent(51,0.006233662);
diffrac->SetBinContent(52,0.006123537);
diffrac->SetBinContent(53,0.005494665);
diffrac->SetBinContent(54,0.005019388);
diffrac->SetBinContent(55,0.004778851);
diffrac->SetBinContent(56,0.004686114);
diffrac->SetBinContent(57,0.004355739);
diffrac->SetBinContent(58,0.004112304);
diffrac->SetBinContent(59,0.004112304);
diffrac->SetBinContent(60,0.004187653);
diffrac->SetBinContent(61,0.003448656);
diffrac->SetBinContent(62,0.003593557);
diffrac->SetBinContent(63,0.003376205);
diffrac->SetBinContent(64,0.003054524);
diffrac->SetBinContent(65,0.002628513);
diffrac->SetBinContent(66,0.003097994);
diffrac->SetBinContent(67,0.002509694);
diffrac->SetBinContent(68,0.002495204);
diffrac->SetBinContent(69,0.002547368);
diffrac->SetBinContent(70,0.002153236);
diffrac->SetBinContent(71,0.002222789);
diffrac->SetBinContent(72,0.001904006);
diffrac->SetBinContent(73,0.002008335);
diffrac->SetBinContent(74,0.001762002);
diffrac->SetBinContent(75,0.001617101);
diffrac->SetBinContent(76,0.001834453);
diffrac->SetBinContent(77,0.001770696);
diffrac->SetBinContent(78,0.001463505);
diffrac->SetBinContent(79,0.001312808);
diffrac->SetBinContent(80,0.001193988);
diffrac->SetBinContent(81,0.001240357);
diffrac->SetBinContent(82,0.001307011);
diffrac->SetBinContent(83,0.001101251);
diffrac->SetBinContent(84,0.001008514);
diffrac->SetBinContent(85,0.0008838991);
diffrac->SetBinContent(86,0.0009969223);
diffrac->SetBinContent(87,0.0008896952);
diffrac->SetBinContent(88,0.001011412);
diffrac->SetBinContent(89,0.0008867972);
diffrac->SetBinContent(90,0.0007563858);
diffrac->SetBinContent(91,0.000681037);
diffrac->SetBinContent(92,0.0005911981);
diffrac->SetBinContent(93,0.0007360996);
diffrac->SetBinContent(94,0.0006259745);
diffrac->SetBinContent(95,0.0004955631);
diffrac->SetBinContent(96,0.000486869);
diffrac->SetBinContent(97,0.0004462966);
diffrac->SetBinContent(98,0.0003970301);
diffrac->SetBinContent(99,0.0003448656);
diffrac->SetBinContent(100,0.0002782109);
diffrac->SetBinContent(101,0.0003042931);
diffrac->SetBinContent(102,0.0002550266);
diffrac->SetBinContent(103,0.0003361715);
diffrac->SetBinContent(104,0.0001854739);
diffrac->SetBinContent(105,0.0003158853);
diffrac->SetBinContent(106,0.0002144542);
diffrac->SetBinContent(107,0.0001767798);
diffrac->SetBinContent(108,0.0001477995);
diffrac->SetBinContent(109,0.0001506976);
diffrac->SetBinContent(110,0.0001362074);
diffrac->SetBinContent(111,0.0002463325);
diffrac->SetBinContent(112,0.0001391054);
diffrac->SetBinContent(113,0.0002173522);
diffrac->SetBinContent(114,9.853302e-05);
diffrac->SetBinContent(115,0.0001420035);
diffrac->SetBinContent(116,0.0001159212);
diffrac->SetBinContent(117,8.983893e-05);
diffrac->SetBinContent(118,6.085863e-05);
diffrac->SetBinContent(119,6.375666e-05);
diffrac->SetBinContent(120,6.375666e-05);
diffrac->SetBinContent(121,5.79606e-05);
diffrac->SetBinContent(122,6.665469e-05);
diffrac->SetBinContent(123,4.926651e-05);
diffrac->SetBinContent(124,4.347045e-05);
diffrac->SetBinContent(125,4.636848e-05);
diffrac->SetBinContent(126,5.216454e-05);
diffrac->SetBinContent(127,3.477636e-05);
diffrac->SetBinContent(128,3.767439e-05);
diffrac->SetBinContent(129,2.318424e-05);
diffrac->SetBinContent(130,2.028621e-05);
diffrac->SetBinContent(131,3.187833e-05);
diffrac->SetBinContent(132,2.608227e-05);
diffrac->SetBinContent(133,3.477636e-05);
diffrac->SetBinContent(134,1.738818e-05);
diffrac->SetBinContent(135,1.738818e-05);
diffrac->SetBinContent(136,8.69409e-06);
diffrac->SetBinContent(137,1.449015e-05);
diffrac->SetBinContent(138,1.449015e-05);
diffrac->SetBinContent(139,2.89803e-06);
diffrac->SetBinContent(140,5.79606e-06);
diffrac->SetBinContent(141,8.69409e-06);
diffrac->SetBinContent(142,1.159212e-05);
diffrac->SetBinContent(143,2.89803e-06);
diffrac->SetBinContent(144,1.159212e-05);
diffrac->SetBinContent(145,2.89803e-06);
diffrac->SetBinContent(146,2.89803e-06);
diffrac->SetBinContent(147,5.79606e-06);
diffrac->SetBinContent(149,8.69409e-06);
diffrac->SetBinContent(151,5.79606e-06);
diffrac->SetBinContent(152,8.69409e-06);
diffrac->SetBinContent(154,2.89803e-06);
diffrac->SetBinContent(155,2.89803e-06);
diffrac->SetBinContent(157,5.79606e-06);
diffrac->SetBinContent(170,2.89803e-06);
diffrac->SetBinContent(173,5.79606e-06);
diffrac->SetBinContent(178,2.89803e-06);
diffrac->SetBinError(1,2.109798e-05);
diffrac->SetBinError(2,7.872833e-05);
diffrac->SetBinError(3,0.0001065593);
diffrac->SetBinError(4,0.0001422694);
diffrac->SetBinError(5,0.0001825069);
diffrac->SetBinError(6,0.0002236183);
diffrac->SetBinError(7,0.0002601617);
diffrac->SetBinError(8,0.000294603);
diffrac->SetBinError(9,0.00031819);
diffrac->SetBinError(10,0.0003260638);
diffrac->SetBinError(11,0.0003374556);
diffrac->SetBinError(12,0.0003391438);
diffrac->SetBinError(13,0.0003337896);
diffrac->SetBinError(14,0.0003231531);
diffrac->SetBinError(15,0.0003154995);
diffrac->SetBinError(16,0.0003095742);
diffrac->SetBinError(17,0.0002962943);
diffrac->SetBinError(18,0.0002839921);
diffrac->SetBinError(19,0.0002806005);
diffrac->SetBinError(20,0.0002713336);
diffrac->SetBinError(21,0.0002575662);
diffrac->SetBinError(22,0.0002566189);
diffrac->SetBinError(23,0.0002493485);
diffrac->SetBinError(24,0.0002514615);
diffrac->SetBinError(25,0.0002409725);
diffrac->SetBinError(26,0.0002338802);
diffrac->SetBinError(27,0.0002245552);
diffrac->SetBinError(28,0.0002181237);
diffrac->SetBinError(29,0.0002131382);
diffrac->SetBinError(30,0.0002114371);
diffrac->SetBinError(31,0.0002066155);
diffrac->SetBinError(32,0.0002014704);
diffrac->SetBinError(33,0.0001930619);
diffrac->SetBinError(34,0.0001918399);
diffrac->SetBinError(35,0.0001925391);
diffrac->SetBinError(36,0.0001850432);
diffrac->SetBinError(37,0.0001826679);
diffrac->SetBinError(38,0.0001738093);
diffrac->SetBinError(39,0.0001724023);
diffrac->SetBinError(40,0.0001643467);
diffrac->SetBinError(41,0.0001617454);
diffrac->SetBinError(42,0.0001561444);
diffrac->SetBinError(43,0.0001554706);
diffrac->SetBinError(44,0.0001488753);
diffrac->SetBinError(45,0.0001514758);
diffrac->SetBinError(46,0.0001476574);
diffrac->SetBinError(47,0.0001391356);
diffrac->SetBinError(48,0.0001375267);
diffrac->SetBinError(49,0.0001319161);
diffrac->SetBinError(50,0.0001309255);
diffrac->SetBinError(51,0.0001344074);
diffrac->SetBinError(52,0.0001332148);
diffrac->SetBinError(53,0.0001261892);
diffrac->SetBinError(54,0.0001206082);
diffrac->SetBinError(55,0.0001176829);
diffrac->SetBinError(56,0.0001165354);
diffrac->SetBinError(57,0.0001123524);
diffrac->SetBinError(58,0.0001091677);
diffrac->SetBinError(59,0.0001091677);
diffrac->SetBinError(60,0.0001101633);
diffrac->SetBinError(61,9.997153e-05);
diffrac->SetBinError(62,0.0001020502);
diffrac->SetBinError(63,9.891584e-05);
diffrac->SetBinError(64,9.40856e-05);
diffrac->SetBinError(65,8.727835e-05);
diffrac->SetBinError(66,9.475273e-05);
diffrac->SetBinError(67,8.528287e-05);
diffrac->SetBinError(68,8.503632e-05);
diffrac->SetBinError(69,8.59206e-05);
diffrac->SetBinError(70,7.899458e-05);
diffrac->SetBinError(71,8.026026e-05);
diffrac->SetBinError(72,7.428234e-05);
diffrac->SetBinError(73,7.629033e-05);
diffrac->SetBinError(74,7.145862e-05);
diffrac->SetBinError(75,6.845733e-05);
diffrac->SetBinError(76,7.291296e-05);
diffrac->SetBinError(77,7.16347e-05);
diffrac->SetBinError(78,6.512512e-05);
diffrac->SetBinError(79,6.168108e-05);
diffrac->SetBinError(80,5.882358e-05);
diffrac->SetBinError(81,5.995491e-05);
diffrac->SetBinError(82,6.154477e-05);
diffrac->SetBinError(83,5.6493e-05);
diffrac->SetBinError(84,5.406205e-05);
diffrac->SetBinError(85,5.061192e-05);
diffrac->SetBinError(86,5.375045e-05);
diffrac->SetBinError(87,5.077759e-05);
diffrac->SetBinError(88,5.413967e-05);
diffrac->SetBinError(89,5.069482e-05);
diffrac->SetBinError(90,4.681911e-05);
diffrac->SetBinError(91,4.442596e-05);
diffrac->SetBinError(92,4.139215e-05);
diffrac->SetBinError(93,4.6187e-05);
diffrac->SetBinError(94,4.259217e-05);
diffrac->SetBinError(95,3.789666e-05);
diffrac->SetBinError(96,3.756276e-05);
diffrac->SetBinError(97,3.596361e-05);
diffrac->SetBinError(98,3.392057e-05);
diffrac->SetBinError(99,3.161377e-05);
diffrac->SetBinError(100,2.839478e-05);
diffrac->SetBinError(101,2.969597e-05);
diffrac->SetBinError(102,2.718593e-05);
diffrac->SetBinError(103,3.121274e-05);
diffrac->SetBinError(104,2.318424e-05);
diffrac->SetBinError(105,3.025632e-05);
diffrac->SetBinError(106,2.49298e-05);
diffrac->SetBinError(107,2.263434e-05);
diffrac->SetBinError(108,2.069607e-05);
diffrac->SetBinError(109,2.089799e-05);
diffrac->SetBinError(110,1.986789e-05);
diffrac->SetBinError(111,2.671852e-05);
diffrac->SetBinError(112,2.007814e-05);
diffrac->SetBinError(113,2.509768e-05);
diffrac->SetBinError(114,1.689827e-05);
diffrac->SetBinError(115,2.028621e-05);
diffrac->SetBinError(116,1.832875e-05);
diffrac->SetBinError(117,1.613555e-05);
diffrac->SetBinError(118,1.328044e-05);
diffrac->SetBinError(119,1.359297e-05);
diffrac->SetBinError(120,1.359297e-05);
diffrac->SetBinError(121,1.296038e-05);
diffrac->SetBinError(122,1.389846e-05);
diffrac->SetBinError(123,1.194888e-05);
diffrac->SetBinError(124,1.122402e-05);
diffrac->SetBinError(125,1.159212e-05);
diffrac->SetBinError(126,1.22953e-05);
diffrac->SetBinError(127,1.003907e-05);
diffrac->SetBinError(128,1.0449e-05);
diffrac->SetBinError(129,8.196866e-06);
diffrac->SetBinError(130,7.667466e-06);
diffrac->SetBinError(131,9.611678e-06);
diffrac->SetBinError(132,8.69409e-06);
diffrac->SetBinError(133,1.003907e-05);
diffrac->SetBinError(134,7.098695e-06);
diffrac->SetBinError(135,7.098695e-06);
diffrac->SetBinError(136,5.019535e-06);
diffrac->SetBinError(137,6.480192e-06);
diffrac->SetBinError(138,6.480192e-06);
diffrac->SetBinError(139,2.89803e-06);
diffrac->SetBinError(140,4.098433e-06);
diffrac->SetBinError(141,5.019535e-06);
diffrac->SetBinError(142,5.79606e-06);
diffrac->SetBinError(143,2.89803e-06);
diffrac->SetBinError(144,5.79606e-06);
diffrac->SetBinError(145,2.89803e-06);
diffrac->SetBinError(146,2.89803e-06);
diffrac->SetBinError(147,4.098433e-06);
diffrac->SetBinError(149,5.019535e-06);
diffrac->SetBinError(151,4.098433e-06);
diffrac->SetBinError(152,5.019535e-06);
diffrac->SetBinError(154,2.89803e-06);
diffrac->SetBinError(155,2.89803e-06);
diffrac->SetBinError(157,4.098433e-06);
diffrac->SetBinError(170,2.89803e-06);
diffrac->SetBinError(173,4.098433e-06);
diffrac->SetBinError(178,2.89803e-06);
diffrac->SetEntries(345062);
diffrac->SetDirectory(0);
diffrac->SetFillColor(1);
diffrac->SetFillStyle(0);
diffrac->SetLineStyle(2);
diffrac->SetLineWidth(3);
diffrac->SetMarkerStyle(20);
diffrac->GetXaxis()->SetTitle("M");
diffrac->GetXaxis()->SetLabelFont(42);
diffrac->GetXaxis()->SetLabelOffset(0.01);
diffrac->GetXaxis()->SetLabelSize(0.045);
diffrac->GetXaxis()->SetTitleSize(0.055);
diffrac->GetXaxis()->SetTitleFont(42);
diffrac->GetYaxis()->SetTitle("Fraction of events");
diffrac->GetYaxis()->SetLabelFont(42);
diffrac->GetYaxis()->SetLabelOffset(0.01);
diffrac->GetYaxis()->SetLabelSize(0.045);
diffrac->GetYaxis()->SetTitleSize(0.055);
diffrac->GetYaxis()->SetTitleOffset(1.6);
diffrac->GetYaxis()->SetTitleFont(42);
diffrac->GetZaxis()->SetLabelFont(42);
diffrac->GetZaxis()->SetLabelSize(0.045);
diffrac->GetZaxis()->SetTitleFont(42);
diffrac->Draw("p same");
TLegend *leg = new TLegend(0.61,0.67,0.91,0.87,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(62);
leg->SetTextSize(0.035);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(2);
leg->SetFillColor(19);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("diffrac","PYTHIA 7 TeV","l");
entry->SetLineColor(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
//entry=leg->AddEntry("diffrac","(Atlas tune)","");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry=leg->AddEntry("diffrac","PHOJET 7 TeV","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
leg->Draw();
printFinalCanvases(cEvtSel,"diffrac");
/*
TLatex * tex = new TLatex(0.85,0.9,"CMS");
tex->SetNDC();
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
cEvtSel->Modified();
cEvtSel->cd();
cEvtSel->SetSelected(cEvtSel);
*/
}
void calculateTriggerRates(
TString inFile0Name = "root://eoscms//eos/cms/store/caf/user/velicanu/PA2013_merged_HiForest/pPb_hiForest2_pilotRun_200kHz_v3.root",
// TString inFile0Name = "/castor/cern.ch/user/m/miheejo/openHLT/cms442/r181530_reco_v1_2/HIExpressPhysics_hiexp-hirun2011-r181530-reco-v1_2.root",
// "/castor/cern.ch/user/k/kimy/openHLT//openhlt_run181531.root",
// "/castor/cern.ch/user/v/velicanu/HIHLT_Validation_Test_GRIF_v10.root",
Int_t runNum = 202792,
TString outdir = "output",
char *projectTitle = "HIpARun2013",
string source = "data"
)
{
char szBuf[256];
int scale = 23;
// event selectoin
//Form("&&Run==%d&&LumiBlock>%d",runNum,goodLumiStart)
// trigger under investigation
// const int ntrigs = 8;
// const char* triggerPath[ntrigs] = {"","HLT_HIMinBiasHfOrBSC",
// "L1_SingleMu3_BptxAND","HLT_HIL1SingleMu3","HLT_HIL2Mu3",
// "L1_DoubleMuOpen_BptxAND","HLT_HIL1DoubleMuOpen","HLT_HIL2DoubleMu3"};
/* const int ntrigs = 9;
const char* triggerPath[ntrigs] = {
"",
"HLT_PAL1SingleMuOpen_v1",
"HLT_PAL1SingleMu3_v1",
"HLT_PAL1SingleMu7_v1",
"HLT_PAL1SingleMu12_v1",
"HLT_PAL1DoubleMu0_v1",
"HLT_PADimuon0_NoVertexing_v1",
"HLT_PAMu5_v1",
"HLT_PAMu8_v1"
}; */
//trigger list for singleMu rate plot
const int ntrigs = 4 ;
const char* triggerPath[ntrigs] = {
"",
"HLT_PAMu3_v1",
"HLT_PAMu7_v1",
"HLT_PAMu12_v1"
};
/*
//trigger list for DoubleMu rate plot
const int ntrigs = 4 ;
const char* triggerPath[ntrigs] = {
"",
"HLT_PAL1DoubleMuOpen_v1",
"HLT_PAL1DoubleMu0_HighQ_v1",
"HLT_PAL2DoubleMu3_v1"
};
//trigger list fo bJet+Mu rate plot
const int ntrigs =5;
const char* triggerPath[ntrigs] = {
"",
"HLT_PAMu3PFJet20_v1",
"HLT_PAMu3PFJet40_v1",
"HLT_PAMu7PFJet20_v1",
"HLT_PABTagMu_Jet20_Mu4_v1"
};*/
TString str;
TH1D *ahTemp[ntrigs];
double ahTempRate[ntrigs]; //Rates (Integrated over lumisections)
// Load input
TChain * HltTree = new TChain("hltanalysis/HltTree","HI OpenHLT Tree");
HltTree->Add(inFile0Name);
cout << inFile0Name << endl;
cout << " # entries: " << HltTree->GetEntries() << endl;
int nEvents = HltTree->GetEntries();
for(int it=1; it<ntrigs; it++)
{
TH1D *ph = new TH1D("ph",";Lumi Section; Counts ",1100,0,1100);
HltTree->Draw("LumiBlock>>ph",str.Format("%s",triggerPath[it]));
TLegend *lTemp= new TLegend(0.2,0.8,0.8,0.9);
lTemp->SetHeader(str.Format("Run : %d",runNum));
lTemp->SetMargin(0.05);
lTemp->SetFillStyle(0);
lTemp->SetLineColor(0);
lTemp->SetLineWidth(5.0);
lTemp->SetTextSize(0.03);
lTemp->AddEntry(ph,str.Format("%s",triggerPath[it],"l"));
lTemp->Draw("same");
c1->SaveAs(str.Format("%d_%s.pdf",runNum,triggerPath[it]));
TH1D *phLumi = (TH1D*)gDirectory->Get("ph");
phLumi->SetDirectory(0);
phLumi->Scale(1./(phLumi->GetBinWidth(1)*23));// 1lumi unit=23 sec
ahTempRate[it] = phLumi->Integral()/phLumi->GetNbinsX();
ahTemp[it] = phLumi;
cout<< triggerPath[it]<<"\t"<<phLumi->GetEntries()<< "\t" << ahTempRate[it] << endl;
}
//----------------------------
// drawing part
// axis
// TH1D * phLumiAxis = new TH1D("phLumiAxis",";Lumi Section;dEvt/dLumiSec",1100,0,1100);
TH1D * phLumiAxis = new TH1D("phLumiAxis",";Lumi Section;Rate [Hz]",1,0,1200);
phLumiAxis->SetMinimum(0.01);
phLumiAxis->SetMaximum(1e+3);
gStyle->SetOptStat(kFALSE);
// legend
TLegend *l0= new TLegend(0.2,0.7,0.8,0.9);
l0->SetHeader(str.Format("Run : %d",runNum));
l0->SetMargin(0.03);
l0->SetFillStyle(0);
l0->SetLineColor(0);
l0->SetLineWidth(1.0);
l0->SetTextSize(0.03);
// canvas
TCanvas *pcLumi = new TCanvas("pcLumi","pcLumi");
pcLumi->cd();
phLumiAxis->Draw();
pcLumi->SetLogy();
for(int it=1; it<ntrigs; it++)
{
TH1 *phLocal = (TH1 *)(ahTemp[it]->Clone("phLocal"));
phLocal->SetDirectory(0);
phLocal->SetLineColor(it);
if (it >= 10) phLocal->SetLineColor(it+20);
if(it==5) phLocal->SetLineColor(kOrange+2);
phLocal->Draw("same");
l0->AddEntry(phLocal,str.Format("%s: %.2f Hz",triggerPath[it],ahTempRate[it]),"l");
pcLumi->Update();
}
l0->Draw("same");
pcLumi->SaveAs(str.Format("%d_ratedMu.png",runNum));
}
void trigeff(){
gROOT->Reset();
//=========Macro generated from canvas: cEvtSel/EvtSel
//========= (Wed Apr 14 17:19:34 2010) by ROOT version5.22/00d
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",550,600);
/*
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",0,22,550,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
cEvtSel->Range(-13.62658,-0.215625,63.58861,1.221875);
cEvtSel->SetFillColor(0);
cEvtSel->SetBorderMode(0);
cEvtSel->SetBorderSize(0);
cEvtSel->SetTickx(1);
cEvtSel->SetTicky(1);
cEvtSel->SetLeftMargin(0.17);
cEvtSel->SetRightMargin(0.04);
cEvtSel->SetTopMargin(0.05);
cEvtSel->SetBottomMargin(0.15);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
*/
TH1 *hFrame1 = new TH2D("hFrame1","",1,-0.5,60.5,1,0,1.15);
hFrame1->SetDirectory(0);
hFrame1->SetStats(0);
hFrame1->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame1->GetXaxis()->CenterTitle(true);
hFrame1->GetYaxis()->SetTitle("Selection efficiency");
hFrame1->GetYaxis()->CenterTitle(true);
hFrame1->Draw("");
hFrame1->GetXaxis()->SetNdivisions(312);
/*
TH1 *hFrame1 = new TH2D("hFrame1","",1,-0.5,60.5,1,0,1.15);
hFrame1->SetDirectory(0);
hFrame1->SetStats(0);
hFrame1->SetFillColor(1);
hFrame1->SetFillStyle(0);
hFrame1->SetLineStyle(0);
hFrame1->SetMarkerStyle(20);
hFrame1->SetMarkerSize(1.5);
hFrame1->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame1->GetXaxis()->CenterTitle(true);
hFrame1->GetXaxis()->SetNdivisions(312);
hFrame1->GetXaxis()->SetLabelFont(42);
hFrame1->GetXaxis()->SetLabelOffset(0.01);
hFrame1->GetXaxis()->SetLabelSize(0.045);
hFrame1->GetXaxis()->SetTitleSize(0.055);
hFrame1->GetXaxis()->SetTitleFont(42);
hFrame1->GetYaxis()->SetTitle("Selection efficiency");
hFrame1->GetYaxis()->CenterTitle(true);
hFrame1->GetYaxis()->SetLabelFont(42);
hFrame1->GetYaxis()->SetLabelOffset(0.01);
hFrame1->GetYaxis()->SetLabelSize(0.045);
hFrame1->GetYaxis()->SetTitleSize(0.055);
hFrame1->GetYaxis()->SetTitleOffset(1.6);
hFrame1->GetYaxis()->SetTitleFont(42);
hFrame1->GetZaxis()->SetLabelFont(42);
hFrame1->GetZaxis()->SetLabelSize(0.045);
hFrame1->GetZaxis()->SetTitleFont(42);
hFrame1->Draw("");
*/
TH1 *trigeff = new TH1D("trigeff","trigeff",200,0,200);
trigeff->SetBinContent(1,0.007879584);
trigeff->SetBinContent(2,0.3524112);
trigeff->SetBinContent(3,0.5050529);
trigeff->SetBinContent(4,0.5978595);
trigeff->SetBinContent(5,0.6587795);
trigeff->SetBinContent(6,0.7034895);
trigeff->SetBinContent(7,0.7451056);
trigeff->SetBinContent(8,0.7911818);
trigeff->SetBinContent(9,0.8363224);
trigeff->SetBinContent(10,0.873251);
trigeff->SetBinContent(11,0.9012649);
trigeff->SetBinContent(12,0.9177872);
trigeff->SetBinContent(13,0.9395182);
trigeff->SetBinContent(14,0.9502278);
trigeff->SetBinContent(15,0.9600504);
trigeff->SetBinContent(16,0.9667429);
trigeff->SetBinContent(17,0.9722969);
trigeff->SetBinContent(18,0.977478);
trigeff->SetBinContent(19,0.9801504);
trigeff->SetBinContent(20,0.9840849);
trigeff->SetBinContent(21,0.9843521);
trigeff->SetBinContent(22,0.9856779);
trigeff->SetBinContent(23,0.9894354);
trigeff->SetBinContent(24,0.9892805);
trigeff->SetBinContent(25,0.9913111);
trigeff->SetBinContent(26,0.9934833);
trigeff->SetBinContent(27,0.9907814);
trigeff->SetBinContent(28,0.9928126);
trigeff->SetBinContent(29,0.990099);
trigeff->SetBinContent(30,0.9918119);
trigeff->SetBinContent(31,0.994504);
trigeff->SetBinContent(32,0.9938513);
trigeff->SetBinContent(33,0.993073);
trigeff->SetBinContent(34,0.9965539);
trigeff->SetBinContent(35,0.9955737);
trigeff->SetBinContent(36,0.9952005);
trigeff->SetBinContent(37,0.9940288);
trigeff->SetBinContent(38,0.9946929);
trigeff->SetBinContent(39,0.9973046);
trigeff->SetBinContent(40,0.9959936);
trigeff->SetBinContent(41,0.9964897);
trigeff->SetBinContent(42,0.9943966);
trigeff->SetBinContent(43,0.9940175);
trigeff->SetBinContent(44,0.9947941);
trigeff->SetBinContent(45,0.9960804);
trigeff->SetBinContent(46,0.9970282);
trigeff->SetBinContent(47,0.9963936);
trigeff->SetBinContent(48,0.9968187);
trigeff->SetBinContent(49,0.9956733);
trigeff->SetBinContent(50,0.996085);
trigeff->SetBinContent(51,0.9988466);
trigeff->SetBinContent(52,0.9982079);
trigeff->SetBinContent(53,0.99625);
trigeff->SetBinContent(54,0.9962802);
trigeff->SetBinContent(55,0.9980328);
trigeff->SetBinContent(56,0.9960396);
trigeff->SetBinContent(57,0.9993271);
trigeff->SetBinContent(58,0.9978261);
trigeff->SetBinContent(59,0.9950843);
trigeff->SetBinContent(60,0.9992459);
trigeff->SetBinContent(61,0.9977925);
trigeff->SetBinContent(62,0.9960599);
trigeff->SetBinContent(63,0.9952456);
trigeff->SetBinContent(64,0.9960661);
trigeff->SetBinContent(65,0.9965428);
trigeff->SetBinContent(66,0.995094);
trigeff->SetBinContent(67,0.9962441);
trigeff->SetBinContent(68,0.9990842);
trigeff->SetBinContent(69,0.9981413);
trigeff->SetBinContent(70,0.9981007);
trigeff->SetBinContent(71,0.9980676);
trigeff->SetBinContent(72,0.9990512);
trigeff->SetBinContent(73,0.9969636);
trigeff->SetBinContent(74,0.9959432);
trigeff->SetBinContent(75,0.9969008);
trigeff->SetBinContent(76,0.994929);
trigeff->SetBinContent(77,0.9978425);
trigeff->SetBinContent(78,0.9989396);
trigeff->SetBinContent(79,0.9955996);
trigeff->SetBinContent(80,0.9988975);
trigeff->SetBinContent(81,0.998829);
trigeff->SetBinContent(82,0.9960682);
trigeff->SetBinContent(83,0.9963986);
trigeff->SetBinContent(84,0.995098);
trigeff->SetBinContent(85,0.9962169);
trigeff->SetBinContent(86,0.9973615);
trigeff->SetBinContent(87,0.9987562);
trigeff->SetBinContent(88,0.9987212);
trigeff->SetBinContent(89,0.9987374);
trigeff->SetBinContent(90,0.9986264);
trigeff->SetBinContent(91,0.9972973);
trigeff->SetBinContent(92,1);
trigeff->SetBinContent(93,0.9959459);
trigeff->SetBinContent(94,0.9945504);
trigeff->SetBinContent(95,0.9985612);
trigeff->SetBinContent(96,1);
trigeff->SetBinContent(97,1);
trigeff->SetBinContent(98,0.9968454);
trigeff->SetBinContent(99,0.9983471);
trigeff->SetBinContent(100,0.9968);
trigeff->SetBinContent(101,0.9983871);
trigeff->SetBinContent(102,0.9966044);
trigeff->SetBinContent(103,0.9984);
trigeff->SetBinContent(104,1);
trigeff->SetBinContent(105,0.9946996);
trigeff->SetBinContent(106,0.9946333);
trigeff->SetBinContent(107,0.9981343);
trigeff->SetBinContent(108,1);
trigeff->SetBinContent(109,0.9962963);
trigeff->SetBinContent(110,0.9923225);
trigeff->SetBinContent(111,1);
trigeff->SetBinContent(112,0.9979633);
trigeff->SetBinContent(113,0.9978166);
trigeff->SetBinContent(114,1);
trigeff->SetBinContent(115,0.9980237);
trigeff->SetBinContent(116,0.9952494);
trigeff->SetBinContent(117,0.9979253);
trigeff->SetBinContent(118,1);
trigeff->SetBinContent(119,1);
trigeff->SetBinContent(120,0.9950125);
trigeff->SetBinContent(121,0.9975728);
trigeff->SetBinContent(122,0.9921466);
trigeff->SetBinContent(123,0.9974874);
trigeff->SetBinContent(124,1);
trigeff->SetBinContent(125,0.9974874);
trigeff->SetBinContent(126,0.9969419);
trigeff->SetBinContent(127,0.994723);
trigeff->SetBinContent(128,0.9940299);
trigeff->SetBinContent(129,1);
trigeff->SetBinContent(130,0.9966667);
trigeff->SetBinContent(131,1);
trigeff->SetBinContent(132,1);
trigeff->SetBinContent(133,0.9931507);
trigeff->SetBinContent(134,0.9963504);
trigeff->SetBinContent(135,1);
trigeff->SetBinContent(136,0.9959677);
trigeff->SetBinContent(137,1);
trigeff->SetBinContent(138,1);
trigeff->SetBinContent(139,1);
trigeff->SetBinContent(140,0.9959514);
trigeff->SetBinContent(141,1);
trigeff->SetBinContent(142,0.9955556);
trigeff->SetBinContent(143,1);
trigeff->SetBinContent(144,1);
trigeff->SetBinContent(145,1);
trigeff->SetBinContent(146,0.989418);
trigeff->SetBinContent(147,0.9940828);
trigeff->SetBinContent(148,1);
trigeff->SetBinContent(149,0.9942857);
trigeff->SetBinContent(150,1);
trigeff->SetBinContent(151,1);
trigeff->SetBinContent(152,1);
trigeff->SetBinContent(153,1);
trigeff->SetBinContent(154,1);
trigeff->SetBinContent(155,0.9923077);
trigeff->SetBinContent(156,1);
trigeff->SetBinContent(157,1);
trigeff->SetBinContent(158,1);
trigeff->SetBinContent(159,1);
trigeff->SetBinContent(160,0.9901961);
trigeff->SetBinContent(161,1);
trigeff->SetBinContent(162,1);
trigeff->SetBinContent(163,1);
trigeff->SetBinContent(164,1);
trigeff->SetBinContent(165,0.9767442);
trigeff->SetBinContent(166,1);
trigeff->SetBinContent(167,1);
trigeff->SetBinContent(168,1);
trigeff->SetBinContent(169,1);
trigeff->SetBinContent(170,1);
trigeff->SetBinContent(171,1);
trigeff->SetBinContent(172,1);
trigeff->SetBinContent(173,0.9807692);
trigeff->SetBinContent(174,1);
trigeff->SetBinContent(175,0.9850746);
trigeff->SetBinContent(176,1);
trigeff->SetBinContent(177,1);
trigeff->SetBinContent(178,1);
trigeff->SetBinContent(179,1);
trigeff->SetBinContent(180,1);
trigeff->SetBinContent(181,1);
trigeff->SetBinContent(182,1);
trigeff->SetBinContent(183,1);
trigeff->SetBinContent(184,1);
trigeff->SetBinContent(185,1);
trigeff->SetBinContent(186,1);
trigeff->SetBinContent(187,1);
trigeff->SetBinContent(188,1);
trigeff->SetBinContent(189,1);
trigeff->SetBinContent(190,1);
trigeff->SetBinContent(191,1);
trigeff->SetBinContent(192,1);
trigeff->SetBinContent(193,1);
trigeff->SetBinContent(194,1);
trigeff->SetBinContent(195,0.9333333);
trigeff->SetBinContent(196,1);
trigeff->SetBinContent(197,0.9230769);
trigeff->SetBinContent(198,1);
trigeff->SetBinContent(199,1);
trigeff->SetBinContent(200,1);
trigeff->SetBinContent(201,1);
trigeff->SetBinError(1,0.0006283812);
trigeff->SetBinError(2,0.005498682);
trigeff->SetBinError(3,0.0054516);
trigeff->SetBinError(4,0.005047444);
trigeff->SetBinError(5,0.004707652);
trigeff->SetBinError(6,0.004447388);
trigeff->SetBinError(7,0.004290336);
trigeff->SetBinError(8,0.003953715);
trigeff->SetBinError(9,0.003594607);
trigeff->SetBinError(10,0.003181503);
trigeff->SetBinError(11,0.002795854);
trigeff->SetBinError(12,0.002534088);
trigeff->SetBinError(13,0.002203234);
trigeff->SetBinError(14,0.002035759);
trigeff->SetBinError(15,0.001857668);
trigeff->SetBinError(16,0.001750359);
trigeff->SetBinError(17,0.001668633);
trigeff->SetBinError(18,0.001566698);
trigeff->SetBinError(19,0.001548763);
trigeff->SetBinError(20,0.001441238);
trigeff->SetBinError(21,0.001500853);
trigeff->SetBinError(22,0.001498831);
trigeff->SetBinError(23,0.001345494);
trigeff->SetBinError(24,0.001388057);
trigeff->SetBinError(25,0.001289631);
trigeff->SetBinError(26,0.001166616);
trigeff->SetBinError(27,0.001415891);
trigeff->SetBinError(28,0.0013075);
trigeff->SetBinError(29,0.001557715);
trigeff->SetBinError(30,0.001464586);
trigeff->SetBinError(31,0.001225565);
trigeff->SetBinError(32,0.001306868);
trigeff->SetBinError(33,0.001471707);
trigeff->SetBinError(34,0.001037251);
trigeff->SetBinError(35,0.001224911);
trigeff->SetBinError(36,0.001279626);
trigeff->SetBinError(37,0.001443898);
trigeff->SetBinError(38,0.0014146);
trigeff->SetBinError(39,0.001017398);
trigeff->SetBinError(40,0.001264398);
trigeff->SetBinError(41,0.001238902);
trigeff->SetBinError(42,0.001549757);
trigeff->SetBinError(43,0.00165428);
trigeff->SetBinError(44,0.001565537);
trigeff->SetBinError(45,0.001383086);
trigeff->SetBinError(46,0.001211415);
trigeff->SetBinError(47,0.001360627);
trigeff->SetBinError(48,0.001296707);
trigeff->SetBinError(49,0.001526394);
trigeff->SetBinError(50,0.001476827);
trigeff->SetBinError(51,0.0008151083);
trigeff->SetBinError(52,0.00103375);
trigeff->SetBinError(53,0.001528058);
trigeff->SetBinError(54,0.001515765);
trigeff->SetBinError(55,0.001134653);
trigeff->SetBinError(56,0.00161362);
trigeff->SetBinError(57,0.000672721);
trigeff->SetBinError(58,0.001253744);
trigeff->SetBinError(59,0.001853399);
trigeff->SetBinError(60,0.0007538634);
trigeff->SetBinError(61,0.001273096);
trigeff->SetBinError(62,0.001758596);
trigeff->SetBinError(63,0.001936339);
trigeff->SetBinError(64,0.001755834);
trigeff->SetBinError(65,0.001725618);
trigeff->SetBinError(66,0.001997934);
trigeff->SetBinError(67,0.001874404);
trigeff->SetBinError(68,0.0009153315);
trigeff->SetBinError(69,0.001313103);
trigeff->SetBinError(70,0.001341757);
trigeff->SetBinError(71,0.001365069);
trigeff->SetBinError(72,0.0009483164);
trigeff->SetBinError(73,0.001750424);
trigeff->SetBinError(74,0.002024279);
trigeff->SetBinError(75,0.001786534);
trigeff->SetBinError(76,0.00226206);
trigeff->SetBinError(77,0.001523934);
trigeff->SetBinError(78,0.001059883);
trigeff->SetBinError(79,0.002195374);
trigeff->SetBinError(80,0.001101928);
trigeff->SetBinError(81,0.001170274);
trigeff->SetBinError(82,0.002265586);
trigeff->SetBinError(83,0.002075545);
trigeff->SetBinError(84,0.002444966);
trigeff->SetBinError(85,0.00218004);
trigeff->SetBinError(86,0.001863254);
trigeff->SetBinError(87,0.001243007);
trigeff->SetBinError(88,0.001277954);
trigeff->SetBinError(89,0.001261829);
trigeff->SetBinError(90,0.001372683);
trigeff->SetBinError(91,0.001908515);
trigeff->SetBinError(93,0.00233586);
trigeff->SetBinError(94,0.002717361);
trigeff->SetBinError(95,0.001437813);
trigeff->SetBinError(98,0.0022271);
trigeff->SetBinError(99,0.001651526);
trigeff->SetBinError(100,0.002259118);
trigeff->SetBinError(101,0.001611602);
trigeff->SetBinError(102,0.002396962);
trigeff->SetBinError(103,0.001598719);
trigeff->SetBinError(105,0.00305204);
trigeff->SetBinError(106,0.003090155);
trigeff->SetBinError(107,0.00186393);
trigeff->SetBinError(109,0.00261406);
trigeff->SetBinError(110,0.003824007);
trigeff->SetBinError(112,0.002034585);
trigeff->SetBinError(113,0.002181021);
trigeff->SetBinError(115,0.001974331);
trigeff->SetBinError(116,0.003351189);
trigeff->SetBinError(117,0.002072536);
trigeff->SetBinError(120,0.003517911);
trigeff->SetBinError(121,0.002424237);
trigeff->SetBinError(122,0.004516325);
trigeff->SetBinError(123,0.002509404);
trigeff->SetBinError(125,0.002509404);
trigeff->SetBinError(126,0.003053424);
trigeff->SetBinError(127,0.003721576);
trigeff->SetBinError(128,0.004208913);
trigeff->SetBinError(130,0.003327773);
trigeff->SetBinError(133,0.004826582);
trigeff->SetBinError(134,0.003642969);
trigeff->SetBinError(136,0.00402412);
trigeff->SetBinError(140,0.004040379);
trigeff->SetBinError(142,0.004434557);
trigeff->SetBinError(146,0.007442916);
trigeff->SetBinError(147,0.005899627);
trigeff->SetBinError(149,0.005697936);
trigeff->SetBinError(155,0.007662665);
trigeff->SetBinError(160,0.009755745);
trigeff->SetBinError(165,0.01625201);
trigeff->SetBinError(173,0.01904496);
trigeff->SetBinError(175,0.01481357);
trigeff->SetBinError(195,0.06440612);
trigeff->SetBinError(197,0.0739053);
trigeff->SetEntries(385140);
trigeff->SetDirectory(0);
trigeff->SetFillColor(1);
trigeff->SetFillStyle(0);
trigeff->SetLineStyle(0);
trigeff->SetLineWidth(2);
trigeff->SetMarkerStyle(20);
trigeff->SetMarkerSize(1.5);
trigeff->GetXaxis()->SetTitle("M");
trigeff->GetXaxis()->SetLabelFont(42);
trigeff->GetXaxis()->SetLabelOffset(0.01);
trigeff->GetXaxis()->SetLabelSize(0.045);
trigeff->GetXaxis()->SetTitleSize(0.055);
trigeff->GetXaxis()->SetTitleFont(42);
trigeff->GetYaxis()->SetTitle("Selection efficiency");
trigeff->GetYaxis()->SetLabelFont(42);
trigeff->GetYaxis()->SetLabelOffset(0.01);
trigeff->GetYaxis()->SetLabelSize(0.045);
trigeff->GetYaxis()->SetTitleSize(0.055);
trigeff->GetYaxis()->SetTitleOffset(1.6);
trigeff->GetYaxis()->SetTitleFont(42);
trigeff->GetZaxis()->SetLabelFont(42);
trigeff->GetZaxis()->SetLabelSize(0.045);
trigeff->GetZaxis()->SetTitleFont(42);
trigeff->Draw("hist same");
TH1 *trigeff = new TH1D("trigeff","trigeff",200,0,200);
trigeff->SetBinContent(1,0.009007478);
trigeff->SetBinContent(2,0.2935561);
trigeff->SetBinContent(3,0.4702609);
trigeff->SetBinContent(4,0.6518799);
trigeff->SetBinContent(5,0.7428357);
trigeff->SetBinContent(6,0.8347119);
trigeff->SetBinContent(7,0.8777911);
trigeff->SetBinContent(8,0.904666);
trigeff->SetBinContent(9,0.9195271);
trigeff->SetBinContent(10,0.9292373);
trigeff->SetBinContent(11,0.9375605);
trigeff->SetBinContent(12,0.9489987);
trigeff->SetBinContent(13,0.9535653);
trigeff->SetBinContent(14,0.9493052);
trigeff->SetBinContent(15,0.9572732);
trigeff->SetBinContent(16,0.9589076);
trigeff->SetBinContent(17,0.9627003);
trigeff->SetBinContent(18,0.9629964);
trigeff->SetBinContent(19,0.9683917);
trigeff->SetBinContent(20,0.9674429);
trigeff->SetBinContent(21,0.9771153);
trigeff->SetBinContent(22,0.9762201);
trigeff->SetBinContent(23,0.9766491);
trigeff->SetBinContent(24,0.9828982);
trigeff->SetBinContent(25,0.9802921);
trigeff->SetBinContent(26,0.9826494);
trigeff->SetBinContent(27,0.9759428);
trigeff->SetBinContent(28,0.9843614);
trigeff->SetBinContent(29,0.9879452);
trigeff->SetBinContent(30,0.9855582);
trigeff->SetBinContent(31,0.9875656);
trigeff->SetBinContent(32,0.9883436);
trigeff->SetBinContent(33,0.9886389);
trigeff->SetBinContent(34,0.9900587);
trigeff->SetBinContent(35,0.9925793);
trigeff->SetBinContent(36,0.9926954);
trigeff->SetBinContent(37,0.9905261);
trigeff->SetBinContent(38,0.993372);
trigeff->SetBinContent(39,0.9899301);
trigeff->SetBinContent(40,0.9913687);
trigeff->SetBinContent(41,0.9920382);
trigeff->SetBinContent(42,0.9901091);
trigeff->SetBinContent(43,0.9941278);
trigeff->SetBinContent(44,0.9865421);
trigeff->SetBinContent(45,0.9902138);
trigeff->SetBinContent(46,0.9965451);
trigeff->SetBinContent(47,0.9961106);
trigeff->SetBinContent(48,0.9951392);
trigeff->SetBinContent(49,0.9951969);
trigeff->SetBinContent(50,0.9960957);
trigeff->SetBinContent(51,0.9981439);
trigeff->SetBinContent(52,0.9962282);
trigeff->SetBinContent(53,0.9973698);
trigeff->SetBinContent(54,0.9976959);
trigeff->SetBinContent(55,0.9933735);
trigeff->SetBinContent(56,0.9956897);
trigeff->SetBinContent(57,0.9953642);
trigeff->SetBinContent(58,0.9902303);
trigeff->SetBinContent(59,0.9985925);
trigeff->SetBinContent(60,0.9986178);
trigeff->SetBinContent(61,0.9991604);
trigeff->SetBinContent(62,0.9983897);
trigeff->SetBinContent(63,0.9940273);
trigeff->SetBinContent(64,0.9952786);
trigeff->SetBinContent(65,0.9977998);
trigeff->SetBinContent(66,0.9972015);
trigeff->SetBinContent(67,0.9908467);
trigeff->SetBinContent(68,1);
trigeff->SetBinContent(69,0.9988636);
trigeff->SetBinContent(70,0.9933155);
trigeff->SetBinContent(71,0.9986979);
trigeff->SetBinContent(72,0.9969651);
trigeff->SetBinContent(73,0.9971223);
trigeff->SetBinContent(74,0.9967213);
trigeff->SetBinContent(75,0.9982111);
trigeff->SetBinContent(76,0.9968504);
trigeff->SetBinContent(77,0.9967374);
trigeff->SetBinContent(78,0.9980237);
trigeff->SetBinContent(79,0.9977974);
trigeff->SetBinContent(80,1);
trigeff->SetBinContent(81,0.997669);
trigeff->SetBinContent(82,0.9977876);
trigeff->SetBinContent(83,0.9921671);
trigeff->SetBinContent(84,0.9942857);
trigeff->SetBinContent(85,1);
trigeff->SetBinContent(86,1);
trigeff->SetBinContent(87,0.9967532);
trigeff->SetBinContent(88,1);
trigeff->SetBinContent(89,0.9967427);
trigeff->SetBinContent(90,0.9961832);
trigeff->SetBinContent(91,1);
trigeff->SetBinContent(92,1);
trigeff->SetBinContent(93,1);
trigeff->SetBinContent(94,1);
trigeff->SetBinContent(95,1);
trigeff->SetBinContent(96,0.9940828);
trigeff->SetBinContent(97,1);
trigeff->SetBinContent(98,0.9927536);
trigeff->SetBinContent(99,1);
trigeff->SetBinContent(100,0.9896907);
trigeff->SetBinContent(101,0.990566);
trigeff->SetBinContent(102,0.988764);
trigeff->SetBinContent(103,1);
trigeff->SetBinContent(104,1);
trigeff->SetBinContent(105,1);
trigeff->SetBinContent(106,1);
trigeff->SetBinContent(107,1);
trigeff->SetBinContent(108,1);
trigeff->SetBinContent(109,1);
trigeff->SetBinContent(110,1);
trigeff->SetBinContent(111,1);
trigeff->SetBinContent(112,1);
trigeff->SetBinContent(113,1);
trigeff->SetBinContent(114,1);
trigeff->SetBinContent(115,1);
trigeff->SetBinContent(116,1);
trigeff->SetBinContent(117,1);
trigeff->SetBinContent(118,1);
trigeff->SetBinContent(119,1);
trigeff->SetBinContent(120,1);
trigeff->SetBinContent(121,1);
trigeff->SetBinContent(122,1);
trigeff->SetBinContent(123,1);
trigeff->SetBinContent(124,1);
trigeff->SetBinContent(125,1);
trigeff->SetBinContent(126,1);
trigeff->SetBinContent(127,1);
trigeff->SetBinContent(128,1);
trigeff->SetBinContent(129,1);
trigeff->SetBinContent(130,1);
trigeff->SetBinContent(131,1);
trigeff->SetBinContent(132,1);
trigeff->SetBinContent(133,1);
trigeff->SetBinContent(134,1);
trigeff->SetBinContent(135,1);
trigeff->SetBinContent(136,1);
trigeff->SetBinContent(137,1);
trigeff->SetBinContent(138,1);
trigeff->SetBinContent(139,1);
trigeff->SetBinContent(140,1);
trigeff->SetBinContent(141,1);
trigeff->SetBinContent(142,1);
trigeff->SetBinContent(143,1);
trigeff->SetBinContent(144,1);
trigeff->SetBinContent(145,1);
trigeff->SetBinContent(146,1);
trigeff->SetBinContent(147,1);
trigeff->SetBinContent(149,1);
trigeff->SetBinContent(151,1);
trigeff->SetBinContent(152,1);
trigeff->SetBinContent(154,1);
trigeff->SetBinContent(155,1);
trigeff->SetBinContent(157,1);
trigeff->SetBinContent(170,1);
trigeff->SetBinContent(173,1);
trigeff->SetBinContent(178,1);
trigeff->SetBinError(1,0.001231687);
trigeff->SetBinError(2,0.009082424);
trigeff->SetBinError(3,0.009308539);
trigeff->SetBinError(4,0.007834723);
trigeff->SetBinError(5,0.00598166);
trigeff->SetBinError(6,0.004397977);
trigeff->SetBinError(7,0.003418236);
trigeff->SetBinError(8,0.002747754);
trigeff->SetBinError(9,0.002375778);
trigeff->SetBinError(10,0.002196995);
trigeff->SetBinError(11,0.002011941);
trigeff->SetBinError(12,0.001831367);
trigeff->SetBinError(13,0.001784029);
trigeff->SetBinError(14,0.001916823);
trigeff->SetBinError(15,0.001817566);
trigeff->SetBinError(16,0.001819683);
trigeff->SetBinError(17,0.001818542);
trigeff->SetBinError(18,0.001890354);
trigeff->SetBinError(19,0.00177814);
trigeff->SetBinError(20,0.001864436);
trigeff->SetBinError(21,0.001663154);
trigeff->SetBinError(22,0.00170007);
trigeff->SetBinError(23,0.00173455);
trigeff->SetBinError(24,0.001481362);
trigeff->SetBinError(25,0.001655051);
trigeff->SetBinError(26,0.001603857);
trigeff->SetBinError(27,0.00195356);
trigeff->SetBinError(28,0.00163551);
trigeff->SetBinError(29,0.001474872);
trigeff->SetBinError(30,0.001623358);
trigeff->SetBinError(31,0.00154461);
trigeff->SetBinError(32,0.001534909);
trigeff->SetBinError(33,0.00158181);
trigeff->SetBinError(34,0.001491233);
trigeff->SetBinError(35,0.001286982);
trigeff->SetBinError(36,0.001328752);
trigeff->SetBinError(37,0.00152958);
trigeff->SetBinError(38,0.001348444);
trigeff->SetBinError(39,0.00166985);
trigeff->SetBinError(40,0.001624111);
trigeff->SetBinError(41,0.001586005);
trigeff->SetBinError(42,0.001827581);
trigeff->SetBinError(43,0.001420028);
trigeff->SetBinError(44,0.002227847);
trigeff->SetBinError(45,0.001874108);
trigeff->SetBinError(46,0.00114964);
trigeff->SetBinError(47,0.001293933);
trigeff->SetBinError(48,0.001462021);
trigeff->SetBinError(49,0.001515213);
trigeff->SetBinError(50,0.001377697);
trigeff->SetBinError(51,0.0009272125);
trigeff->SetBinError(52,0.001331017);
trigeff->SetBinError(53,0.001174711);
trigeff->SetBinError(54,0.001150746);
trigeff->SetBinError(55,0.001991336);
trigeff->SetBinError(56,0.001625642);
trigeff->SetBinError(57,0.001748087);
trigeff->SetBinError(58,0.00259828);
trigeff->SetBinError(59,0.0009945236);
trigeff->SetBinError(60,0.0009766661);
trigeff->SetBinError(61,0.000839278);
trigeff->SetBinError(62,0.001137741);
trigeff->SetBinError(63,0.002250715);
trigeff->SetBinError(64,0.0021065);
trigeff->SetBinError(65,0.001554078);
trigeff->SetBinError(66,0.001613457);
trigeff->SetBinError(67,0.003221342);
trigeff->SetBinError(69,0.001135718);
trigeff->SetBinError(70,0.002979388);
trigeff->SetBinError(71,0.001301235);
trigeff->SetBinError(72,0.00214274);
trigeff->SetBinError(73,0.00203191);
trigeff->SetBinError(74,0.002314579);
trigeff->SetBinError(75,0.001787308);
trigeff->SetBinError(76,0.002223598);
trigeff->SetBinError(77,0.00230327);
trigeff->SetBinError(78,0.001974331);
trigeff->SetBinError(79,0.002200216);
trigeff->SetBinError(81,0.002328284);
trigeff->SetBinError(82,0.002209941);
trigeff->SetBinError(83,0.00450458);
trigeff->SetBinError(84,0.004029049);
trigeff->SetBinError(87,0.003241478);
trigeff->SetBinError(89,0.00325202);
trigeff->SetBinError(90,0.003809503);
trigeff->SetBinError(96,0.005899627);
trigeff->SetBinError(98,0.007220074);
trigeff->SetBinError(100,0.010256);
trigeff->SetBinError(101,0.009389357);
trigeff->SetBinError(102,0.01117265);
trigeff->SetEntries(369636);
trigeff->SetDirectory(0);
trigeff->SetFillColor(1);
trigeff->SetFillStyle(0);
trigeff->SetLineStyle(2);
trigeff->SetLineWidth(3);
trigeff->SetMarkerStyle(20);
trigeff->GetXaxis()->SetTitle("M");
trigeff->GetXaxis()->SetLabelFont(42);
trigeff->GetXaxis()->SetLabelOffset(0.01);
trigeff->GetXaxis()->SetLabelSize(0.045);
trigeff->GetXaxis()->SetTitleSize(0.055);
trigeff->GetXaxis()->SetTitleFont(42);
trigeff->GetYaxis()->SetTitle("Selection efficiency");
trigeff->GetYaxis()->SetLabelFont(42);
trigeff->GetYaxis()->SetLabelOffset(0.01);
trigeff->GetYaxis()->SetLabelSize(0.045);
trigeff->GetYaxis()->SetTitleSize(0.055);
trigeff->GetYaxis()->SetTitleOffset(1.6);
trigeff->GetYaxis()->SetTitleFont(42);
trigeff->GetZaxis()->SetLabelFont(42);
trigeff->GetZaxis()->SetLabelSize(0.045);
trigeff->GetZaxis()->SetTitleFont(42);
trigeff->Draw("p same");
TLegend *leg = new TLegend(0.57,0.22,1,0.42,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(62);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(19);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("trigeff","PYTHIA 7 TeV","l");
entry->SetLineColor(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
//entry=leg->AddEntry("trigeff","(Atlas tune)","");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry=leg->AddEntry("trigeff","PHOJET 7 TeV","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
leg->Draw();
printFinalCanvases(cEvtSel,"trigeff");
/*
TLatex * tex = new TLatex(0.85,0.9,"CMS");
tex->SetNDC();
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
cEvtSel->Modified();
cEvtSel->cd();
cEvtSel->SetSelected(cEvtSel);
*/
}
//------------------------------------------
TH1* GetHistoClSize(int npix,int id,TObjArray* harr)
{
// book histos
TH1* h = 0;
if (!harr) harr = &histoArr;
//
if (npix<1) {
if (harr->GetEntriesFast()>=id && (h=(TH1*)harr->At(id))) return h;
h = new TH1F("npixAll","npixAll",150,0.5,54.5);
h->SetDirectory(0);
h->SetLineColor(kRed);
harr->AddAtAndExpand(h, kNPixAll);
//
h = new TH1F("npixSpl","npixSpl",150,0.5,54.5);
h->SetLineColor(kBlue);
h->SetDirectory(0);
harr->AddAtAndExpand(h, kNPixSPL);
//
h = (TH1*)harr->At(id);
if (!h) {printf("Unknown histo id=%d\n",id); exit(1);}
return h;
}
//
int idh = npix*10+id;
if (harr->GetEntriesFast()>=idh && (h=(TH1*)harr->At(idh))) return h;
//
const int nbin=100;
const double kdiff=80;
// need to create set of histos
//
h = new TH1F(Form("dxy_npix%d",npix),Form("dr_npix%d",npix),nbin,-kdiff,kdiff);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDR);
//
h = new TH1F(Form("dtxODD_npix%d",npix),Form("dtxODD_npix%d",npix),nbin,-kdiff,kdiff);
h->SetDirectory(0);
h->SetLineColor(kRed);
harr->AddAtAndExpand(h, npix*10 + kDTXodd);
h = new TH1F(Form("dtxEVN_npix%d",npix),Form("dtxEVN_npix%d",npix),nbin,-kdiff,kdiff);
h->SetDirectory(0);
h->SetLineColor(kBlue);
harr->AddAtAndExpand(h, npix*10 + kDTXeven);
//
h = new TH1F(Form("dtz_npix%d",npix),Form("dtz_npix%d",npix),nbin,-kdiff,kdiff);
h->SetLineColor(kGreen);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDTZ);
//
//
h = new TH1F(Form("SPL_dtxODD_npix%d",npix),Form("SPL_dtxODD_npix%d",npix),nbin,-kdiff,kdiff);
h->SetLineColor(kMagenta);
h->SetFillColor(kMagenta);
h->SetFillStyle(3001);
h->SetLineStyle(2);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDTXoddSPL);
h = new TH1F(Form("SPL_dtxEVN_npix%d",npix),Form("SPL_dtxEVN_npix%d",npix),nbin,-kdiff,kdiff);
h->SetLineColor(kCyan);
h->SetFillColor(kCyan);
h->SetFillStyle(3006);
h->SetLineStyle(2);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDTXevenSPL);
//
h = new TH1F(Form("SPL_dtz_npix%d",npix),Form("SPLdtz_npix%d",npix),nbin,-kdiff,kdiff);
harr->AddAtAndExpand(h, npix*10 + kDTZSPL);
h->SetDirectory(0);
//
h->SetLineColor(kGreen+2);
h->SetFillColor(kGreen+2);
h->SetLineStyle(2);
h->SetFillStyle(3001);
h = (TH1*)harr->At(idh);
if (!h) {printf("Unknown histo id=%d\n",idh); exit(1);}
return h;
}
void mergeSearchBins()
{
vector<string> histnames;
histnames.push_back("smeared_signal");
histnames.push_back("smeared_signalFineBin");
histnames.push_back("smeared_fail0");
histnames.push_back("smeared_fail1");
histnames.push_back("smeared_fail2");
histnames.push_back("smeared_fail3");
histnames.push_back("smeared_fail4");
histnames.push_back("smeared_failFineBin0");
histnames.push_back("smeared_failFineBin1");
histnames.push_back("smeared_failFineBin2");
histnames.push_back("smeared_failFineBin3");
histnames.push_back("smeared_failFineBin4");
histnames.push_back("reco_mht");
histnames.push_back("reco_ht");
histnames.push_back("recojet1_pt");
histnames.push_back("recojet2_pt");
//jetbins
vector<pair<unsigned, unsigned> > jetBins;
vector<pair<float, float> > htBins, mhtBins;
pair<float, float> jetbin1(2,2);
pair<float, float> jetbin2(3,5);
pair<float, float> jetbin3(6,7);
pair<float, float> jetbin4(8,1000);
pair<float, float> htbin1(500,800);
pair<float, float> htbin2(800,1000);
pair<float, float> htbin3(1000,1250);
pair<float, float> htbin4(1500,8000);
pair<float, float> mhtbin1(0,8000);
jetBins.push_back(jetbin1);
jetBins.push_back(jetbin2);
jetBins.push_back(jetbin3);
jetBins.push_back(jetbin4);
htBins.push_back(htbin1);
htBins.push_back(htbin2);
htBins.push_back(htbin3);
htBins.push_back(htbin4);
mhtBins.push_back(mhtbin1);
vector<string> dphibins;
dphibins.push_back("0.15");
dphibins.push_back("0.20");
dphibins.push_back("0.25");
dphibins.push_back("0.30");
dphibins.push_back("0.35");
dphibins.push_back("0.40");
TFile fold("qcd_all.root");
if (fold.IsZombie())
{
cout << "Input root file not found!" << endl;
assert(false);
}
TFile fnew("qcd_all_HTranged.root","RECREATE");
fnew.mkdir("Hist");
for (unsigned jetbin = 0; jetbin < jetBins.size(); ++jetbin)
{
stringstream jetbinfolder;
jetbinfolder << "Njet" << jetBins.at(jetbin).first << "to" << jetBins.at(jetbin).second;
fnew.cd("Hist");
gDirectory->mkdir(jetbinfolder.str().c_str());
gDirectory->cd(jetbinfolder.str().c_str());
gDirectory->pwd();
gDirectory->ls();
for (unsigned h = 0; h < histnames.size(); ++h)
{
TH1* hist_temp = 0;
for (unsigned htbin = 0; htbin < htBins.size(); ++htbin)
{
for (unsigned mhtbin = 0; mhtbin < mhtBins.size(); ++mhtbin)
{
stringstream folder;
folder << "Hist/" << jetbinfolder.str()
<< "HT" << htBins.at(htbin).first << "to" << htBins.at(htbin).second
<< "MHT" << mhtBins.at(mhtbin).first << "to" << mhtBins.at(mhtbin).second;
stringstream histname;
histname << folder.str() << "/" << histnames.at(h);
TH1* temp = dynamic_cast<TH1*> (fold.Get(histname.str().c_str()));
if (temp == NULL){
cout << "hist not found = " << histname.str() << endl;
continue;
}
temp->SetDirectory(0);
if (htbin ==0 && mhtbin==0) hist_temp = (TH1*) temp->Clone();
else hist_temp->Add(temp);
}
}
//if (h==0 || h == 1)
if (hist_temp != 0) hist_temp->Write();
}
}
}
