/** * Create ratios to other data * * @param ib Bin number * @param res Result * @param alice ALICE result if any * @param cms CMS result if any * @param all Stack to add ratio to */ void Ratio2Stack(Int_t ib, TH1* res, TGraph* alice, TGraph* cms, THStack* all) { if (!all || !res || !(alice || cms)) return; Int_t off = 5*ib; TGraph* gs[] = { (alice ? alice : cms), (alice ? cms : 0), 0 }; TGraph** pg = gs; while (*pg) { TGraph* g = *pg; const char* n = (g == alice ? "ALICE" : "CMS"); TH1* r = static_cast<TH1*>(res->Clone(Form("ratio%s", n))); TString tit(r->GetTitle()); tit.ReplaceAll("Corrected", Form("Ratio to %s", n)); r->SetTitle(tit); r->SetMarkerColor(g->GetMarkerColor()); r->SetLineColor(g->GetLineColor()); TObject* tst = r->FindObject("legend"); if (tst) r->GetListOfFunctions()->Remove(tst); for (Int_t i = 1; i <= r->GetNbinsX(); i++) { Double_t c = r->GetBinContent(i); Double_t e = r->GetBinError(i); Double_t o = g->Eval(r->GetBinCenter(i)); if (o < 1e-12) { r->SetBinContent(i, 0); r->SetBinError(i, 0); continue; } r->SetBinContent(i, (c - o) / o + off); r->SetBinError(i, e / o); } all->Add(r); pg++; } TLegend* leg = StackLegend(all); if (!leg) return; TString txt = res->GetTitle(); txt.ReplaceAll("Corrected P(#it{N}_{ch}) in ", ""); if (ib == 0) txt.Append(" "); // (#times1)"); // else if (ib == 1) txt.Append(" (#times10)"); else txt.Append(Form(" (+%d)", off)); TObject* dummy = 0; TLegendEntry* e = leg->AddEntry(dummy, txt, "p"); e->SetMarkerStyle(res->GetMarkerStyle()); e->SetMarkerSize(res->GetMarkerSize()); e->SetMarkerColor(kBlack); e->SetFillColor(0); e->SetFillStyle(0); e->SetLineColor(kBlack); }
TH1* getWeightedAverage(TH1* h1, TH1* h2, char* histName) { TH1* h = h1->Clone(histName); int NBinsMax = h1->GetNbinsX() +2; for(int i=0; i < NBinsMax; ++i) { double x1 = h1->GetBinContent(i); double e1 = h1->GetBinError(i); double x2 = h2->GetBinContent(i); double e2 = h2->GetBinError(i); double x = 0.0; double e = 0.0; if(x1 < 0.1) {x = x2; e = e2; } else if(x2 < 0.1) {x = x1; e = e1; } else { x = (x1/(e1*e1) + x2/(e2*e2)) / (1.0/(e1*e1) + 1.0/(e2*e2)); e = 1.0 / sqrt(1.0/(e1*e1) + 1.0/(e2*e2)); } h->SetBinContent(i, x); h->SetBinError(i, e); } return h; }
TH1* GenerateConsistentHist(TH1* hbg, TH1* hprod) { TH1* hpprod = 0; if (hbg!=NULL && hprod!=NULL) { hpprod = dynamic_cast<TH1*>(hbg->Clone(hprod->GetName())); if (hpprod!=NULL) { Reset(hpprod); Double_t binctr=0, x=0, ex=0; // cout << hpprod->GetName() << endl; for(Int_t i=1; i<=hpprod->GetNbinsX(); i++) { binctr = hbg->GetBinCenter(i); x = hprod->GetBinContent(hprod->GetXaxis()->FindBin(binctr)); ex = hprod->GetBinError(hprod->GetXaxis()->FindBin(binctr)); if (x!=0 && ex/x > 1.0001) cout << "bin:" << i << "\tcontent:" << x << "\terr:" << ex << " \terr/content:" << ex/x << endl; hpprod->SetBinContent(i,x); hpprod->SetBinError(i,ex); } } } return hpprod; }
void dominik() { TH1* matHistogramRoman = static_cast<TH1*>(extractObjectFromFile("lyRoman.root", "lightYieldProjectionY")->At(0)); TList* objects = extractObjectFromFile("c.root", "chargeBins"); TH1* matHistogramDominik = new TH1D("matHistogramDominik", ";channel;light yield / pixels", 512, -0.5, 512-0.5); int sipmIt = 0; for (int i = 0; i < objects->GetSize(); ++i) { TH1* h = static_cast<TH1*>(objects->At(i)); if (h->GetLineColor() == 8) { for (int bin = 1; bin <= 128; ++bin) { matHistogramDominik->SetBinContent(512 - (sipmIt * 128 + bin - 1), h->GetBinContent(bin)); if (h->GetBinError(bin) > 0) matHistogramDominik->SetBinError(512 - (sipmIt * 128 + bin - 1), h->GetBinError(bin)); } ++sipmIt; } } TCanvas* c = new TCanvas; c->Divide(1, 2); c->cd(1); matHistogramDominik->Draw(); matHistogramRoman->Draw("SAME"); c->cd(2); TH1* h = static_cast<TH1*>(matHistogramDominik->Clone()); h->Add(matHistogramRoman, -1); h->Draw(); }
// === FUNCTION ============================================================ // Name: TPlot::GetEffHist // Description: // =========================================================================== TH1* TPlot::GetEffHist(std::string Eff, std::string det, std::string algo) { TH1* hNum = GetHist1D(listEff[Eff].first, det, algo); TH1* hDem = GetHist1D(listEff[Eff].second, det, algo); TH1* temp = (TH1*)hNum->Clone(Eff.c_str()); assert(hNum->GetNbinsX() == hDem->GetNbinsX()); for (int i = 0; i < hNum->GetNbinsX(); ++i) { double val = hNum->GetBinContent(i) / hDem->GetBinContent(i); double valerr = val * sqrt( pow(hNum->GetBinError(i)/hNum->GetBinContent(i), 2) + pow(hDem->GetBinError(i)/hDem->GetBinContent(i), 2) ); if (isnan(val)) { val = 0; valerr = 0; } temp->SetBinContent(i, val); temp->SetBinError(i, valerr); std::cout << " bin " <<i <<" val " << val << std::endl; } //temp->Divide(hDem); temp->GetYaxis()->SetTitle("Efficiency"); return temp; } // ----- end of function TPlot::GetEffHist -----
TH1* subtractHistograms(const std::string& newHistogramName, const TH1* histogram_central, const TH1* histogram_shift, int mode) { const TH1* histogramMinuend = 0; const TH1* histogramSubtrahend = 0; if ( compIntegral(histogram_central) >= compIntegral(histogram_shift) ) { histogramMinuend = histogram_central; histogramSubtrahend = histogram_shift; } else { histogramMinuend = histogram_shift; histogramSubtrahend = histogram_central; } if ( !(histogramMinuend && histogramSubtrahend) ) return 0; TH1* newHistogram = (TH1*)histogramMinuend->Clone(newHistogramName.data()); newHistogram->Reset(); if ( !newHistogram->GetSumw2N() ) newHistogram->Sumw2(); int numBins = newHistogram->GetNbinsX(); for ( int iBin = 0; iBin <= (numBins + 1); ++iBin ) { double newBinContent = histogramMinuend->GetBinContent(iBin) - histogramSubtrahend->GetBinContent(iBin); double newBinError2 = square(histogramMinuend->GetBinError(iBin)) + square(histogramSubtrahend->GetBinError(iBin)); if ( mode == kRelative ) { if ( histogram_central->GetBinContent(iBin) > 0. ) { newBinContent /= histogram_central->GetBinContent(iBin); newBinError2 /= square(histogram_central->GetBinContent(iBin)); } else { newBinContent = 0.; newBinError2 = 0.; } } newHistogram->SetBinContent(iBin, newBinContent); assert(newBinError2 >= 0.); newHistogram->SetBinError(iBin, TMath::Sqrt(newBinError2)); } return newHistogram; }
TH1 * YieldMean_HighExtrapolationHisto(TH1 *h, TF1 *f, Double_t max, Double_t binwidth) { /* find highest edge in histo */ Int_t binhi; Double_t hi; for (Int_t ibin = h->GetNbinsX(); ibin > 0; ibin--) { if (h->GetBinContent(ibin) != 0.) { binhi = ibin + 1; hi = h->GetBinLowEdge(ibin + 1); break; } } if(max<hi) { Printf("Warning! You should probably set a higher max value (Max = %f, hi = %f)", max, hi); return 0x0; } Int_t nbins = (max - hi) / binwidth; if(nbins<1) return 0x0; TH1 *hhi = new TH1F("hhi", "", nbins, hi, max); /* integrate function in histogram bins */ Double_t cont, err, width; for (Int_t ibin = 0; ibin < hhi->GetNbinsX(); ibin++) { width = hhi->GetBinWidth(ibin + 1); cont = f->Integral(hhi->GetBinLowEdge(ibin + 1), hhi->GetBinLowEdge(ibin + 2), (Double_t *)0, 1.e-6); err = f->IntegralError(hhi->GetBinLowEdge(ibin + 1), hhi->GetBinLowEdge(ibin + 2), (Double_t *)0, (Double_t *)0, 1.e-6); hhi->SetBinContent(ibin + 1, cont / width); hhi->SetBinError(ibin + 1, err / width); } return hhi; }
TH1 * YieldMean_LowExtrapolationHisto(TH1 *h, TF1 *f, Double_t min, Double_t binwidth) { /* find lowest edge in histo */ Int_t binlo; Double_t lo; for (Int_t ibin = 1; ibin < h->GetNbinsX() + 1; ibin++) { if (h->GetBinContent(ibin) != 0.) { binlo = ibin; lo = h->GetBinLowEdge(ibin); break; } } Int_t nbins = (lo - min) / binwidth; if(nbins<1) return 0x0; TH1 *hlo = new TH1F("hlo", "", nbins, min, lo); /* integrate function in histogram bins */ Double_t cont, err, width; for (Int_t ibin = 0; ibin < hlo->GetNbinsX(); ibin++) { width = hlo->GetBinWidth(ibin + 1); cont = f->Integral(hlo->GetBinLowEdge(ibin + 1), hlo->GetBinLowEdge(ibin + 2), (Double_t *)0, 1.e-6); err = f->IntegralError(hlo->GetBinLowEdge(ibin + 1), hlo->GetBinLowEdge(ibin + 2), (Double_t *)0, (Double_t *)0, 1.e-6); hlo->SetBinContent(ibin + 1, cont / width); hlo->SetBinError(ibin + 1, err / width); } return hlo; }
//____________________________________________________________________ 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 ScaleTo10pb( TH1& hist) { int bins = hist.GetNbinsX(); double error = 0; for(int i=1; i<= bins; i++) { error = 8.0 * hist.GetBinError(i); // if( error > 1.0 ) error = 1.0; hist.SetBinError(i, error); } }
makeMuonTriggerEfficiencyLUT() { TH1* histoLUT = new TH2F("muonTriggerEfficiencyCorrection", "muonTriggerEfficiencyCorrection", 1, -2.5, +2.5, 1, 0., 10000.); histoLUT->SetBinContent(1, 1, 0.98); histoLUT->SetBinError(1, 1, 0.02); TFile* outputFile = new TFile("../data/muonTriggerEfficiencyCorrection.root", "RECREATE"); histoLUT->Write(); delete outputFile; }
TH1* compHistogramErr(const TH1* histogram) { if ( !histogram ) return 0; std::string histogramErrName = Form("%sErr", histogram->GetName()); TH1* histogramErr = (TH1*)histogram->Clone(); int numBins = histogram->GetNbinsX(); for ( int iBin = 1; iBin <= numBins; ++iBin ) { double binError = histogram->GetBinError(iBin); histogramErr->SetBinContent(iBin, binError); histogramErr->SetBinError(iBin, 0.); } return histogramErr; }
TH1 * YieldMean_ReturnRandom(TH1 *hin) { TH1 *hout = (TH1 *)hin->Clone("hout"); hout->Reset(); Double_t cont, err; for (Int_t ibin = 0; ibin < hin->GetNbinsX(); ibin++) { if (hin->GetBinError(ibin + 1) <= 0.) continue; cont = hin->GetBinContent(ibin + 1); err = hin->GetBinError(ibin + 1); hout->SetBinContent(ibin + 1, gRandom->Gaus(cont, err)); hout->SetBinError(ibin + 1, err); } return hout; }
TH1* divideHistogramByBinWidth(TH1* histogram) { std::string histogramDensityName = Form("%s_density", histogram->GetName()); TH1* histogramDensity = (TH1*)histogram->Clone(histogramDensityName.data()); TAxis* xAxis = histogram->GetXaxis(); int numBins = xAxis->GetNbins(); for ( int iBin = 1; iBin <= numBins; ++iBin ) { double binContent = histogram->GetBinContent(iBin); double binError = histogram->GetBinError(iBin); double binWidth = xAxis->GetBinWidth(iBin); histogramDensity->SetBinContent(iBin, binContent/binWidth); histogramDensity->SetBinError(iBin, binError/binWidth); } return histogramDensity; }
TH1 *computeEffVsCut(TH1 *discrShape, double total) { TH1 *h = discrShape->Clone(Form("%s_effVsCut", discrShape->GetName())); h->Sumw2(); h->SetMaximum(1.5); h->SetMinimum(1e-3); unsigned int n = h->GetNbinsX(); for(unsigned int bin = 1; bin <= n; bin++) { double efficiency = h->Integral(bin, n + 1) / total; double error = sqrt(efficiency * (1 - efficiency) / total); h->SetBinContent(bin, efficiency); h->SetBinError(bin, error); } return h; }
TH1 * YieldMean_ReturnCoherentRandom(TH1 *hin) { if(!hin) return 0x0; TH1 *hout = (TH1 *)hin->Clone("hout"); hout->Reset(); Double_t cont, err, cohe; cohe = gRandom->Gaus(0., 1.); for (Int_t ibin = 0; ibin < hin->GetNbinsX(); ibin++) { if (hin->GetBinError(ibin + 1) <= 0.) continue; cont = hin->GetBinContent(ibin + 1); err = hin->GetBinError(ibin + 1); hout->SetBinContent(ibin + 1, cont + cohe * err); hout->SetBinError(ibin + 1, err); } return hout; }
// A function that get histogram and sets contents to 0 // if entries are too small TH1 * getHisto(TFile * file, const char * name, unsigned int rebin) { TObject * h = file->Get(name); if(h == 0) throw edm::Exception(edm::errors::Configuration) << "Can't find object " << name << "\n"; TH1 * histo = dynamic_cast<TH1*>(h); if(histo == 0) throw edm::Exception(edm::errors::Configuration) << "Object " << name << " is of type " << h->ClassName() << ", not TH1\n"; histo->Rebin(rebin); for(int i = 1; i <= histo->GetNbinsX(); ++i) { if(histo->GetBinContent(i) < 0.1) { histo->SetBinContent(i, 0.0); histo->SetBinError(i, 0.0); } } return histo; }
TH1 *computeEffVsBEff(TH1 *effVsCut, TH1 *effVsCutB) { TH1 *h = new TH1F(Form("%s_effVsBEff", effVsCut->GetName()), "effVsBEff", 100, 0, 1); h->SetMaximum(1.5); h->SetMinimum(1e-3); unsigned int n = effVsCut->GetNbinsX(); for(unsigned int bin = 1; bin <= n; bin++) { double eff = effVsCut->GetBinContent(bin); double error = effVsCut->GetBinError(bin); double effB = effVsCutB->GetBinContent(bin); h->SetBinContent(h->FindBin(effB), eff); h->SetBinError(h->FindBin(effB), error); // FIXME: The error in effB is not propagated } return h; }
TH1* Cumulate(TH1* histo, Bool_t doErr, const char* copyName) { // create cumulative histo TString nname = copyName; if (nname.IsNull()) { nname = histo->GetName(); nname += "_cml"; } TH1* cml = (TH1*) histo->Clone(nname.Data()); int nb = histo->GetNbinsX(); double sm = 0; double sme = 0; // for (int i=1;i<=nb;i++) { sm += histo->GetBinContent(i); cml->SetBinContent(i,sm); if (!doErr) continue; double ee = histo->GetBinError(i); sme += ee*ee; cml->SetBinError(i, sme>0 ? TMath::Sqrt(sme):0.); } return cml; }
TH1 *Draw(const plotVar_t& pv, const TCut& cut, const TCut& cutSQ ) { cout << "\tDrawing " << pv.plotvar << " for sample = " << info_.samplename << " ... "; TString hname = TString("th1")+ pv.outfile + Form("%d",info_.index); TH1 *histo = new TH1D(hname, hname, pv.NBINS, pv.MINRange, pv.MAXRange); assert(histo); histo->Sumw2(); assert(tree_); cout << tree_->Draw(pv.plotvar+TString(">>")+hname, cut, "goff") << " events" << endl; if (strlen((const char *)cutSQ)) { hname = TString("th1") + pv.outfile + Form("%d",info_.index) + TString("SQ"); TH1 *histoSQ = new TH1D(hname, hname, pv.NBINS, pv.MINRange, pv.MAXRange); tree_->Draw(pv.plotvar+TString(">>")+hname, cutSQ, "goff"); for(int hi=1;hi<=pv.NBINS;hi++) { histo->SetBinError(hi,sqrt(histoSQ->GetBinContent(hi))); } delete histoSQ; } if (info_.nMCevents) histo->Scale(info_.xsecpblumi*info_.otherscale/(double)info_.nMCevents); return histo; }
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); */ }
void PlotAll(TString wsname) { char* binLabels[19] = {"60","70","80","90","100","110","120","130","140","150","160","170","180","190","200","250","300","400","1000"}; //get the stuff from the workspace: TFile* file=TFile::Open(wsname); RooWorkspace* ws = (RooWorkspace*)file->Get("combined"); ModelConfig *mc = (ModelConfig*)ws->obj("ModelConfig"); RooAbsData *data = ws->data("obsData"); RooSimultaneous* simPdf=(RooSimultaneous*)(mc->GetPdf()); RooAbsReal* nll=simPdf->createNLL(*data); // FPT 0 ************************************** // EM channel RooCategory* chanCat = (RooCategory*) (&simPdf->indexCat()); TIterator* iterat = chanCat->typeIterator() ; RooCatType* ttype = (RooCatType*)iterat->Next(); RooAbsPdf *pdf_stateEM = simPdf->getPdf(ttype->GetName()) ; RooArgSet *obstmpEM = pdf_stateEM->getObservables( *mc->GetObservables() ) ; // get EM data RooAbsData *dataEM = data->reduce(Form("%s==%s::%s",chanCat->GetName(),chanCat->GetName(),ttype->GetName())); RooRealVar *obsEM = ((RooRealVar*) obstmpEM->first()); TString chanName1(ttype->GetName()); // create data histogram TH1* hdataEM = dataEM->createHistogram("Data "+chanName1,*obsEM); // set errors to gaussian for (int ib=0 ; ib<hdataEM->GetNbinsX()+1 ; ib++) hdataEM->SetBinError(ib, sqrt(hdataEM->GetBinContent(ib))); double EMnorm = pdf_stateEM->expectedEvents(*obsEM); //**************************** // ME channel ttype = (RooCatType*)iterat->Next(); RooAbsPdf* pdf_stateME = simPdf->getPdf(ttype->GetName()) ; RooArgSet* obstmpME = pdf_stateME->getObservables( *mc->GetObservables() ) ; // get ME data RooAbsData *dataME = data->reduce(Form("%s==%s::%s",chanCat->GetName(),chanCat->GetName(),ttype->GetName())); RooRealVar* obsME = ((RooRealVar*) obstmpME->first()); TString chanName2(ttype->GetName()); // create data histogram TH1* hdataME = dataME->createHistogram("Data "+chanName2,*obsME); // set errors to gaussian for (int ib=0 ; ib<hdataME->GetNbinsX()+1 ; ib++) hdataME->SetBinError(ib, sqrt(hdataME->GetBinContent(ib))); // get initial BG histogram //TH1* h_initial_BG_EM = pdf_stateEM->createHistogram("initial_BG_EM",*obsEM); //TH1* h_initial_BG_ME = pdf_stateME->createHistogram("initial_BG_ME",*obsME); double MEnorm = pdf_stateME->expectedEvents(*obsME); cout << "EM expected events = " << EMnorm << ", ME expected events = " << MEnorm << "." << endl; //h_initial_BG_EM->Scale(EMnorm); //h_initial_BG_ME->Scale(MEnorm); // get initial gammas int nbins = hdataEM->GetNbinsX(); double InitGamma[nbins]; for (int i=0; i<nbins; i++) { TString varname = "gamma_B0_l1pt0_bin_"+NumberToString(i); InitGamma[i] = ws->var(varname)->getVal(); cout << "initial gamma"+NumberToString(i)+" = " << InitGamma[i] << endl; } double InitFpt = ws->var("fl1pt_l1pt0")->getVal(); cout << "initial fpt_l1pt0 = " << InitFpt << endl; // DO THE GLOBAL FIT minimize(nll); // get final BG histograms TH1* h_final_BG_EM = pdf_stateEM->createHistogram("final_BG_EM",*obsEM); TH1* h_final_BG_ME = pdf_stateME->createHistogram("final_BG_ME",*obsME); h_final_BG_EM->Scale(EMnorm); h_final_BG_ME->Scale(MEnorm); // uncertainty bands TH1D* BuncertaintyEM = new TH1D("BuncertaintyEM","BuncertaintyEM",nbins,0,nbins); TH1D* BuncertaintyME = new TH1D("BuncertaintyME","BuncertaintyME",nbins,0,nbins); for (int i=1; i<=nbins; i++){ double sigbEM = h_final_BG_EM->GetBinError(i); double bEM = h_final_BG_EM->GetBinContent(i); BuncertaintyEM->SetBinError(i,sigbEM); BuncertaintyEM->SetBinContent(i,bEM); double sigbME = h_final_BG_ME->GetBinError(i); double bME = h_final_BG_ME->GetBinContent(i); BuncertaintyME->SetBinError(i,sigbME); BuncertaintyME->SetBinContent(i,bME); } //BuncertaintyEM->SetFillStyle(3004); BuncertaintyEM->SetFillColor(kGreen-9); BuncertaintyEM->SetLineColor(kBlack); BuncertaintyEM->SetLineStyle(2); //BuncertaintyME->SetFillStyle(3004); BuncertaintyME->SetFillColor(kBlue-9); BuncertaintyME->SetLineColor(kBlack); BuncertaintyME->SetLineStyle(2); // get gammas after fit double FinalGamma[nbins]; //TH1* h_initBG_times_gamma = (TH1*)h_initial_BG_EM->Clone("initBGEM_times_gamma"); for (int i=0; i<nbins; i++) { TString varname = "gamma_B0_l1pt0_bin_"+NumberToString(i); FinalGamma[i] = ws->var(varname)->getVal(); cout << "Final gamma in bin "+NumberToString(i)+" = " << FinalGamma[i] << endl; // h_initBG_times_gamma->SetBinContent(i+1,h_initial_BG_EM->GetBinContent(i+1)*FinalGamma[i]); } //double FinalFpt = ws->var("fl1pt_l1pt0")->getVal(); // get final alpha (pull) RooRealVar* alphaVar = ws->var("alpha_l1ptsys_l1pt0"); double alpha, alphaErr; if (alphaVar != NULL) { alpha = ws->var("alpha_l1ptsys_l1pt0")->getVal(); alphaErr = ws->var("alpha_l1ptsys_l1pt0")->getError(); } //FOR UNCONSTRAINED FPT - get final fpts double FinalFpt[5]; double FinalFptErr[5]; for (int k=0; k<5; k++){ TString varname = "fl1pt_l1pt"+NumberToString(k); FinalFpt[k] = ws->var(varname)->getVal(); FinalFptErr[k] = ws->var(varname)->getError(); cout << varname << " = " << FinalFpt[k] << " +- " << FinalFptErr[k] << endl; } // get POI value double mu = ws->var("mu_BR_htm")->getVal(); double muErr = ws->var("mu_BR_htm")->getError(); // Draw TCanvas* c1 = new TCanvas("BG and Data "+chanName1+" "+chanName2,"BG and Data "+chanName1+" "+chanName2,600,600); BuncertaintyEM->Draw("E3 sames"); BuncertaintyME->Draw("E3 sames"); //h_initial_BG_EM->SetLineColor(kGreen+2); h_initial_BG_EM->SetLineStyle(2); h_initial_BG_EM->Draw("sames"); hdataEM->SetLineColor(kGreen+2); hdataEM->SetMarkerStyle(20); hdataEM->SetMarkerColor(kGreen+2); hdataEM->Draw("e1 sames"); //h_initial_BG_ME->SetLineColor(kBlue); h_initial_BG_ME->SetLineStyle(2); h_initial_BG_ME->Draw("sames"); hdataME->SetLineColor(kBlue); hdataME->SetMarkerStyle(20); hdataME->SetMarkerColor(kBlue); hdataME->Draw("e1 sames"); h_final_BG_EM->SetLineColor(kGreen+2); h_final_BG_EM->SetLineWidth(2); h_final_BG_EM->Draw("sames"); h_final_BG_ME->SetLineColor(kBlue); h_final_BG_ME->SetLineWidth(2); h_final_BG_ME->Draw("sames"); TLegend* leg = new TLegend(0.5,0.45,0.85,0.65); leg->SetFillColor(kWhite); leg->SetBorderSize(1); leg->SetLineColor(0); //leg->SetTextFont(14); leg->SetTextSize(.03); leg->AddEntry(hdataME,"DATA #mue","lep"); leg->AddEntry(hdataEM,"DATA e#mu","lep"); //leg->AddEntry(h_initial_BG_ME,"Initial #mue PDF","l"); //leg->AddEntry(h_initial_BG_EM,"Initial e#mu PDF","l"); leg->AddEntry(h_final_BG_ME,"#mue PDF = #gamma_{i}B_{i} + #muS_{i}","l"); leg->AddEntry(h_final_BG_EM,"e#mu PDF = f(1+#alpha#sigma)(#gamma_{i}B_{i}+#muW_{i})","l"); leg->Draw(); cout << " ********************* Fit Values **************************** " << endl; if (alphaVar != NULL){cout << "alpha = " << alpha << " +- " << alphaErr << endl;} cout << "mu = " << mu << " +- " << muErr << endl; TString WriteDownAlphaValue; TString WriteDownMuValue; WriteDownAlphaValue = "Fpt0 = "; WriteDownMuValue = "#mu = "; WriteDownAlphaValue += Form("%4.4f",FinalFpt[0]); WriteDownAlphaValue += "#pm"; WriteDownAlphaValue += Form("%4.4f",FinalFptErr[0]); WriteDownMuValue += Form("%4.4f",mu); WriteDownMuValue += "#pm"; WriteDownMuValue += Form("%4.4f",muErr); TLatex *texl = new TLatex(12,25,WriteDownAlphaValue); texl->SetTextAlign(22); texl->SetTextSize(0.03); TLatex *texl2 = new TLatex(12,23,WriteDownMuValue); texl2->SetTextAlign(22); texl2->SetTextSize(0.03); texl->Draw(); texl2->Draw(); //FPT 1 *********************************** ttype = (RooCatType*)iterat->Next(); RooAbsPdf *pdf_stateEM1 = simPdf->getPdf(ttype->GetName()) ; RooArgSet *obstmpEM1 = pdf_stateEM1->getObservables( *mc->GetObservables() ) ; RooAbsData *dataEM1 = data->reduce(Form("%s==%s::%s",chanCat->GetName(),chanCat->GetName(),ttype->GetName())); RooRealVar *obsEM1 = ((RooRealVar*) obstmpEM1->first()); TString chanName11(ttype->GetName()); TH1* hdataEM1 = dataEM1->createHistogram("Data "+chanName11,*obsEM1); for (int ib=0 ; ib<hdataEM1->GetNbinsX()+1 ; ib++) hdataEM1->SetBinError(ib, sqrt(hdataEM1->GetBinContent(ib))); double EMnorm1 = pdf_stateEM1->expectedEvents(*obsEM1); ttype = (RooCatType*)iterat->Next(); RooAbsPdf* pdf_stateME1 = simPdf->getPdf(ttype->GetName()) ; RooArgSet* obstmpME1 = pdf_stateME1->getObservables( *mc->GetObservables() ) ; RooAbsData *dataME1 = data->reduce(Form("%s==%s::%s",chanCat->GetName(),chanCat->GetName(),ttype->GetName())); RooRealVar* obsME1 = ((RooRealVar*) obstmpME1->first()); TString chanName21(ttype->GetName()); TH1* hdataME1 = dataME1->createHistogram("Data "+chanName21,*obsME1); for (int ib=0 ; ib<hdataME1->GetNbinsX()+1 ; ib++) hdataME1->SetBinError(ib, sqrt(hdataME1->GetBinContent(ib))); double MEnorm1 = pdf_stateME1->expectedEvents(*obsME1); TH1* h_final_BG_EM1 = pdf_stateEM1->createHistogram("final_BG_EM1",*obsEM1); TH1* h_final_BG_ME1 = pdf_stateME1->createHistogram("final_BG_ME1",*obsME1); h_final_BG_EM1->Scale(EMnorm1); h_final_BG_ME1->Scale(MEnorm1); TH1D* BuncertaintyEM1 = new TH1D("BuncertaintyEM1","BuncertaintyEM1",nbins,0,nbins); TH1D* BuncertaintyME1 = new TH1D("BuncertaintyME1","BuncertaintyME1",nbins,0,nbins); for (int i=1; i<=nbins; i++){ double sigbEM = h_final_BG_EM1->GetBinError(i); double bEM = h_final_BG_EM1->GetBinContent(i); BuncertaintyEM1->SetBinError(i,sigbEM); BuncertaintyEM1->SetBinContent(i,bEM); double sigbME = h_final_BG_ME1->GetBinError(i); double bME = h_final_BG_ME1->GetBinContent(i); BuncertaintyME1->SetBinError(i,sigbME); BuncertaintyME1->SetBinContent(i,bME); } BuncertaintyEM1->SetFillColor(kGreen-9); BuncertaintyEM1->SetLineColor(kBlack); BuncertaintyEM1->SetLineStyle(2); BuncertaintyME1->SetFillColor(kBlue-9); BuncertaintyME1->SetLineColor(kBlack); BuncertaintyME1->SetLineStyle(2); double FinalGamma1[nbins]; for (int i=0; i<nbins; i++) { TString varname = "gamma_B0_l1pt1_bin_"+NumberToString(i); FinalGamma1[i] = ws->var(varname)->getVal(); cout << "Final gamma in bin "+NumberToString(i)+" = " << FinalGamma1[i] << endl; } TCanvas* c2 = new TCanvas("BG and Data "+chanName11+" "+chanName21,"BG and Data "+chanName11+" "+chanName21,600,600); BuncertaintyEM1->Draw("E3 sames"); BuncertaintyME1->Draw("E3 sames"); hdataEM1->SetLineColor(kGreen+2); hdataEM1->SetMarkerStyle(20); hdataEM1->SetMarkerColor(kGreen+2); hdataEM1->Draw("e1 sames"); hdataME1->SetLineColor(kBlue); hdataME1->SetMarkerStyle(20); hdataME1->SetMarkerColor(kBlue); hdataME1->Draw("e1 sames"); h_final_BG_EM1->SetLineColor(kGreen+2); h_final_BG_EM1->SetLineWidth(2); h_final_BG_EM1->Draw("sames"); h_final_BG_ME1->SetLineColor(kBlue); h_final_BG_ME1->SetLineWidth(2); h_final_BG_ME1->Draw("sames"); leg->Draw(); cout << " ********************* Fit Values **************************** " << endl; cout << "mu = " << mu << " +- " << muErr << endl; TString WriteDownAlphaValue1; WriteDownAlphaValue1 = "Fpt1 = "; WriteDownAlphaValue1 += Form("%4.4f",FinalFpt[1]); WriteDownAlphaValue1 += "#pm"; WriteDownAlphaValue1 += Form("%4.4f",FinalFptErr[1]); TLatex *texl11 = new TLatex(12,25,WriteDownAlphaValue1); texl11->SetTextAlign(22); texl11->SetTextSize(0.03); texl11->Draw(); texl2->Draw(); }
void Plot_BG(TString wsname) { //get the stuff from the workspace: TFile* file=TFile::Open(wsname); RooWorkspace* ws = (RooWorkspace*)file->Get("combined"); mc = (ModelConfig*)ws->obj("ModelConfig"); data = ws->data("obsData"); RooSimultaneous* simPdf=(RooSimultaneous*)(mc->GetPdf()); RooAbsReal* nll=simPdf->createNLL(*data); //run on channels RooCategory* chanCat = (RooCategory*) (&simPdf->indexCat()); TIterator* iterat = chanCat->typeIterator() ; RooCatType* ttype; bool stop = kFALSE; while ((ttype = (RooCatType*) iterat->Next())&&!stop) { // bool toggle to run on one channel or all stop = kTRUE; RooAbsPdf *pdf_state = simPdf->getPdf(ttype->GetName()) ; RooArgSet *obstmp = pdf_state->getObservables( *mc->GetObservables() ) ; RooAbsData *datatmp = data->reduce(Form("%s==%s::%s",chanCat->GetName(),chanCat->GetName(),ttype->GetName())); RooRealVar *obs = ((RooRealVar*) obstmp->first()); TString chanName(ttype->GetName()); // get data TH1* hdata = datatmp->createHistogram("Data "+chanName,*obs); // set errors to gaussian for (int ib=0 ; ib<hdata->GetNbinsX()+1 ; ib++) hdata->SetBinError(ib, sqrt(hdata->GetBinContent(ib))); // get initial BG TH1* h_initial_BG = pdf_state->createHistogram("initial_BG_"+chanName,*obs); // get initial gammas int nbins = h_initial_BG->GetNbinsX(); double InitGamma[nbins]; for (int i=0; i<nbins; i++) { TString varname = "gamma_B0_0j_l1pt0_bin_"+NumberToString(i); InitGamma[i] = ws->var(varname)->getVal(); cout << "initial gamma"+NumberToString(i)+" = " << InitGamma[i] << endl; } double InitFpt = ws->var("fl1pt_l1pt0")->getVal(); cout << "initial fpt_l1pt0 = " << InitFpt << endl; TCanvas* c1 = new TCanvas("BG and Data "+chanName,"BG and Data "+chanName,600,600); h_initial_BG->Draw(); //hdata->DrawNormalized("sames E1"); // DO THE GLOBAL FIT RooMinimizer minim(*nll); //set some options: minim.setPrintLevel(0); minim.optimizeConst(1); minim.setOffsetting(true); minim.setMinimizerType("Minuit2"); minim.minimize("Minuit2"); minim.setStrategy(3); //0-3 where 0 is the fastest minim.migrad(); // get gammas after fit double FinalGamma[nbins]; TH1* h_initBG_times_gamma = (TH1*)h_initial_BG->Clone("initBG_times_gamma"); for (int i=0; i<nbins; i++) { TString varname = "gamma_B0_0j_l1pt0_bin_"+NumberToString(i); FinalGamma[i] = ws->var(varname)->getVal(); cout << "Final gamma in bin "+NumberToString(i)+" = " << FinalGamma[i] << endl; h_initBG_times_gamma->SetBinContent(i+1,h_initial_BG->GetBinContent(i+1)*FinalGamma[i]); } double FinalFpt = ws->var("fl1pt_l1pt0")->getVal(); cout << "initial fpt_l1pt0 = " << InitFpt << endl; cout << "final fpt_l1pt0 = " << FinalFpt << endl; TH1* h_final_BG = pdf_state->createHistogram("final_BG_"+chanName,*obs); //TCanvas* cf = new TCanvas("final BG","final BG",600,600); h_final_BG->Draw("sames"); h_initBG_times_gamma->Draw("sames"); TH1* h_ratio = (TH1*)h_initial_BG->Clone("h_ratio"); h_ratio->Divide(h_final_BG); //h_ratio->Draw(); cout << "channel name = " << chanName << endl; for ( int j=1; j<=nbins; j++) { double init = h_initial_BG->GetBinContent(j); double fina = h_final_BG->GetBinContent(j); double r = (fina)/init; cout << "in bin " << j << ", initial B = " << init << ", final B = " << fina << ", ratio = " << r << ", Gamma = " << FinalGamma[j-1] << endl; } } }
TH1* VariableSizeRebin(TH1* inhisto, unsigned int nbinsx, double *xbins, TString axisname="x", TString newhistoname="newhist") { if ( nbinsx == 0 ) { cout << "Error! nbinsx must be non-zero." << endl; return 0; } if ( inhisto == 0 ) { cout << "Error! Input histogram pointer is null." << endl; return 0; } if ( axisname == "y" && !inhisto->InheritsFrom("TH2") ) { cout << "No y-axis defined for " << inhisto->GetName() << endl; return 0; } if ( newhistoname == "" ) { cout << "Error! Output histogram name is null."<< endl; return 0; } double *edgeArr = new double[nbinsx+2]; // an extra bin for safety TAxis *axis = (axisname=="y" ? inhisto->GetYaxis() : inhisto->GetXaxis()); unsigned int nbins = 0; // number of bins for the new histogram unsigned int j = 0; // dummy bin index (to be used as a pointer) for ( unsigned int i=0; i<=axis->GetNbins()+1; ++i ) { if ( j > nbinsx ) break; double ble = axis->GetBinLowEdge(i); if ( xbins[j] > ble ) continue; edgeArr[nbins] = ble; j++; nbins++; if ( xbins[j-1] < ble ) { cout << "Warning! Bin edge at " << xbins[j-1] << " does not align with" << " input histo. Realigning at " << ble << ".\n"; // check if the upcoming bin edges become obsolete after realigning. while ( j<=nbinsx && xbins[j] <= ble ) j++; } } // if we finished the loop normally, ie. not 'break'ing out, it must be // that the input histogram xrange is shorter than what the new binning // tried to get. So handle that. if ( j <= nbinsx ) { double xmax = axis->GetBinLowEdge(axis->GetNbins()+1); if ( xmax>edgeArr[nbins-1] ) { edgeArr[nbins]=xmax; cout << "Warning! Input histo reached max value of its x-range. " << "Last bin to be closed at " << edgeArr[nbins] << "." << endl; nbins++; } } // we go out of the loop when index j overshoots. So our nbins is // always one more than actual number of bins. Fix that. nbins--; if ( nbinsx != nbins ) cout << "Warning! nbinsx set to " << nbins << " instead of " << nbinsx << "." << endl; //for ( unsigned int i=0; i<=nbins; i++ ) // cout << "For bin " << i+1 << "\tlowedge= " << edgeArr[i] << endl; // Now generate the new histogram TH1 *newhist = 0; if ( !inhisto->InheritsFrom("TH2") ) newhist = inhisto->Rebin(nbins,newhistoname.Data(),edgeArr); else { // Copy the perpendicular axis as it is. TAxis *axisp = (axisname=="y" ? inhisto->GetXaxis() : inhisto->GetYaxis()); unsigned int nbinsp = axisp->GetNbins(); double *edgeArrp = new double[nbinsp+1]; for ( unsigned int i=1; i<=nbinsp+1; ++i ) edgeArrp[i] = axisp->GetBinLowEdge(i); if ( axisname == "y" ) { if ( axisp->IsVariableBinSize() ) newhist = new TH2D(newhistoname, inhisto->GetTitle(), nbinsp, edgeArrp, nbins, edgeArr); else newhist = new TH2D(newhistoname, inhisto->GetTitle(), nbinsp, edgeArrp[0], edgeArrp[nbinsp+1], nbins, edgeArr); if ( axisp->GetLabels() ) for ( unsigned int i=1; i<=nbinsp; ++i ) newhist->GetXaxis()->SetBinLabel(i, axisp->GetBinLabel(i)); } else // ToDo: Have not yet implemented the above nice stuff for axisname=="x" newhist = new TH2D(newhistoname, inhisto->GetTitle(), nbins, edgeArr, nbinsp, edgeArrp); newhist->GetYaxis()->SetTitle(inhisto->GetYaxis()->GetTitle()); newhist->GetXaxis()->SetTitle(inhisto->GetXaxis()->GetTitle()); bool sw2 = ( inhisto->GetSumw2N() != 0 ); // Fill the new histogram from the input histogram j=0; // reset the dummy bin index for ( unsigned int i=0; i<=axis->GetNbins()+1; ++i ) { double ble = axis->GetBinLowEdge(i); if ( edgeArr[j] == ble ) j++; for ( unsigned int k=0; k<=nbinsp+1; ++k ) { int newbin(0), oldbin(0); // Equivalent 1D bin number = binx + (fXaxis.GetNbins()+2)*biny if ( axisname == "y" ) { newbin = k+j*(nbinsp+2); oldbin = k+i*(nbinsp+2); } else { newbin = j+k*(nbins+2); oldbin = i+k*(axis->GetNbins()+2); } newhist->SetBinContent( newbin, newhist->GetBinContent(newbin) + inhisto->GetBinContent(oldbin) ); if ( sw2 ) newhist->SetBinError( newbin, sqrt(pow(newhist->GetBinError(newbin),2) + pow(inhisto->GetBinError(oldbin),2)) ); } } newhist->SetEntries(inhisto->GetEntries()); } //newhist->Draw(); delete [] edgeArr; return newhist; }
TH1 * UnfoldMe_MB2(const Char_t *data, const Char_t *mc, const Char_t *anatag, Int_t bin, Bool_t useMBcorr , Bool_t usecorrfit , Bool_t ismc , Float_t smooth , Int_t iter , Int_t regul , Float_t weight , Bool_t bayesian , Int_t nloop ) { // MF comments: // usedMBcorr: changes the matrix used for unfonding, from effMatrix to bin matrix (I think this is just to use mult dependent v s mb correction_) // usecorrfit: if I understand correctly, fits the response matrix and uses fit to extrapolate it TFile *fdt =0; if (ismc) fdt = TFile::Open(data); else fdt = TFile::Open(data); TFile *fmc = TFile::Open(mc); TList *ldt = (TList *)fdt->Get(Form("%s", anatag)); TList *lmc = (TList *)fmc->Get(Form("%s", anatag)); TH2 *hmatdt = (TH2 *)ldt->FindObject(Form(responseMatrix, bin)); TH2 *hmatmc = 0; if (useMBcorr){ hmatmc = (TH2 *)lmc->FindObject("effMatrix"); std::cout << "USING MB" << std::endl; } else { hmatmc = (TH2 *)lmc->FindObject(Form(responseMatrix, bin)); } TH1 *hdata = hmatdt->ProjectionY("hdata"); // TH1 *hdata = hmatdt->ProjectionY("htrue"); // For truth Only Calculations hdata->Sumw2(); hdata->SetBinContent(1, 0.); hdata->SetBinError(1, 0.); // hdata->Scale(1. / hdata->Integral()); hdata->SetMarkerStyle(25); TH1 *htrue = hmatdt->ProjectionX("htrue"); htrue->Sumw2(); // htrue->Scale(1. / htrue->Integral()); htrue->SetMarkerStyle(7); htrue->SetMarkerColor(2); htrue->SetBinContent(1, 0.); htrue->SetBinError(1, 0.); TH2 *hcorr = (TH2 *)hmatmc->Clone("hcorr"); TH1 *hinit = (TH1 *)hdata->Clone("hinit"); TH1 *hresu = (TH1 *)hdata->Clone("hresu"); TH1 *hbias = (TH1 *)hdata->Clone("hbias"); hresu->SetMarkerStyle(20); hresu->SetMarkerColor(4); hresu->Reset(); TH1 *hnum = hcorr->ProjectionY("hnum"); TH1 *hden = hcorr->ProjectionY("hden"); TH1 *heff = hcorr->ProjectionY("heff"); hnum->Reset(); hnum->Sumw2(); hden->Reset(); hden->Sumw2(); heff->Reset(); for (Int_t i = 0; i < heff->GetNbinsX(); i++) { Float_t int1 = hcorr->Integral(i + 1, i + 1, 0, -1); if (int1 <= 0.) continue; Float_t int2 = hcorr->Integral(i + 1, i + 1, 2, -1); hnum->SetBinContent(i + 1, int2); hnum->SetBinError(i + 1, TMath::Sqrt(int2)); hden->SetBinContent(i + 1, int1); hden->SetBinError(i + 1, TMath::Sqrt(int1)); } TCanvas *cEfficiency = new TCanvas("cEfficiency", "cEfficiency"); cEfficiency->SetLogx(); cEfficiency->SetLogy(); heff->Divide(hnum, hden, 1., 1., "B"); heff->Draw(); #if 0 for (Int_t ii = 0; ii < heff->GetNbinsX(); ii++) { heff->SetBinContent(ii + 1, 1.); heff->SetBinError(ii + 1, 0.); } #endif for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) { hcorr->SetBinContent(i + 1, 1, 0.); hcorr->SetBinError(i + 1, 1, 0.); } for (Int_t i = 0; i < hcorr->GetNbinsY(); i++) { hcorr->SetBinContent(1, i + 1, 0.); hcorr->SetBinError(1, i + 1, 0.); } TH2 *hcorrfit = ReturnCorrFromFit(hcorr); // Docs from AliUnfolding //Int_t AliUnfolding::Unfold(TH2* correlation, TH1* efficiency, TH1* measured, TH1* initialConditions, TH1* result, Bool_t check) // unfolds with unfolding method fgMethodType // // parameters: // correlation: response matrix as measured vs. generated // efficiency: (optional) efficiency that is applied on the unfolded spectrum, i.e. it has to be in unfolded variables. If 0 no efficiency is applied. // measured: the measured spectrum // initialConditions: (optional) initial conditions for the unfolding. if 0 the measured spectrum is used as initial conditions. // result: target for the unfolded result // check: depends on the unfolding method, see comments in specific functions for (Int_t iloop = 0; iloop < nloop; iloop++) { if (bayesian) { AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian); AliUnfolding::SetBayesianParameters(smooth, iter); } else { AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization); AliUnfolding::SetChi2Regularization(AliUnfolding::RegularizationType(regul), weight); } AliUnfolding::SetSkip0BinInChi2(kTRUE); AliUnfolding::SetSkipBinsBegin(1); AliUnfolding::SetNbins(150, 150); AliUnfolding::Unfold(usecorrfit ? hcorrfit : hcorr, heff, hdata, hinit, hresu); hinit = (TH1 *)hresu->Clone(Form("hinit_%d", iloop)); } printf("hdata->Integral(2, -1) = %f\n", hdata->Integral(2, -1)); printf("hresu->Integral(2, -1) = %f\n", hresu->Integral(2, -1)); TCanvas *cUnfolded = new TCanvas ("cUnfolded", "cUnfolded", 400, 800); cUnfolded->Divide(1, 2); cUnfolded->cd(1)->SetLogx(); cUnfolded->cd(1)->SetLogy(); hdata->Draw(); hresu->Draw("same"); htrue->Draw("same"); cUnfolded->cd(2)->SetLogx(); cUnfolded->cd(2)->DrawFrame(1., 0, 300., 10); TH1 *hrat = (TH1 *)hresu->Clone("hrat"); hrat->Divide(htrue); hrat->Draw("same"); TH1 *htrig = (TH1 *)hresu->Clone("htrig"); htrig->Multiply(heff); Float_t dndeta_resu = 0.; Float_t integr_resu = 0.; Float_t dndeta_trig = 0.; Float_t integr_trig = 0.; for (Int_t i = 1; i < hresu->GetNbinsX(); i++) { dndeta_resu += hresu->GetBinContent(i + 1) * hresu->GetBinLowEdge(i + 1); integr_resu += hresu->GetBinContent(i + 1); dndeta_trig += htrig->GetBinContent(i + 1) * htrig->GetBinLowEdge(i + 1); integr_trig += htrig->GetBinContent(i + 1); } cUnfolded->SaveAs("unfold_efficiency.pdf"); integr_eff = integr_trig / integr_resu; integr_eff_err = TMath::Sqrt(integr_eff * (1. - integr_eff) / integr_resu); dndeta_eff = dndeta_trig / dndeta_resu; dndeta_eff_err = TMath::Sqrt(dndeta_eff * (1. - dndeta_eff) / dndeta_resu); printf("INEL > 0 efficiency: %.3f +- %.3f\n", integr_eff, integr_eff_err); printf("dN/dEta correction: %.3f +- %.3f\n", dndeta_eff, dndeta_eff_err); return hresu; }
TH1 * UnfoldMe(Char_t *data, Char_t *mc, Char_t *anatag, Int_t bin, Bool_t useMBcorr = kTRUE, Bool_t usecorrfit = kFALSE, Bool_t ismc = kFALSE, Float_t smooth = 0.001, Int_t iter = 50, Int_t regul = AliUnfolding::kPowerLaw, Float_t weight = 100., Bool_t bayesian = kTRUE, Int_t nloop = 1) { if (ismc) TFile *fdt = TFile::Open(data); else TFile *fdt = TFile::Open(data); TFile *fmc = TFile::Open(mc); TList *ldt = (TList *)fdt->Get(Form("clist_%s", anatag)); TList *lmc = (TList *)fmc->Get(Form("clist_%s", anatag)); TH2 *hmatdt = (TH2 *)ldt->FindObject(Form("b%d_corrMatrix", bin)); if (useMBcorr) TH2 *hmatmc = (TH2 *)lmc->FindObject("effMatrix"); else TH2 *hmatmc = (TH2 *)lmc->FindObject(Form("b%d_corrMatrix", bin)); TH1 *hdata = hmatdt->ProjectionY("hdata"); hdata->Sumw2(); hdata->SetBinContent(1, 0.); hdata->SetBinError(1, 0.); // hdata->Scale(1. / hdata->Integral()); hdata->SetMarkerStyle(25); TH1 *htrue = hmatdt->ProjectionX("htrue"); htrue->Sumw2(); // htrue->Scale(1. / htrue->Integral()); htrue->SetMarkerStyle(7); htrue->SetMarkerColor(2); htrue->SetBinContent(1, 0.); htrue->SetBinError(1, 0.); TH2 *hcorr = (TH2 *)hmatmc->Clone("hcorr"); TH1 *hinit = (TH1 *)hdata->Clone("hinit"); TH1 *hresu = (TH1 *)hdata->Clone("hresu"); TH1 *hbias = (TH1 *)hdata->Clone("hbias"); hresu->SetMarkerStyle(20); hresu->SetMarkerColor(4); hresu->Reset(); TH1 *hnum = hcorr->ProjectionY("hnum"); TH1 *hden = hcorr->ProjectionY("hden"); TH1 *heff = hcorr->ProjectionY("heff"); hnum->Reset(); hnum->Sumw2(); hden->Reset(); hden->Sumw2(); heff->Reset(); for (Int_t i = 0; i < heff->GetNbinsX(); i++) { Float_t int1 = hcorr->Integral(i + 1, i + 1, 0, -1); if (int1 <= 0.) continue; Float_t int2 = hcorr->Integral(i + 1, i + 1, 2, -1); hnum->SetBinContent(i + 1, int2); hnum->SetBinError(i + 1, TMath::Sqrt(int2)); hden->SetBinContent(i + 1, int1); hden->SetBinError(i + 1, TMath::Sqrt(int1)); } new TCanvas("cEfficiency"); heff->Divide(hnum, hden, 1., 1., "B"); heff->Draw(); #if 0 for (Int_t ii = 0; ii < heff->GetNbinsX(); ii++) { heff->SetBinContent(ii + 1, 1.); heff->SetBinError(ii + 1, 0.); } #endif for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) { hcorr->SetBinContent(i + 1, 1, 0.); hcorr->SetBinError(i + 1, 1, 0.); } for (Int_t i = 0; i < hcorr->GetNbinsY(); i++) { hcorr->SetBinContent(1, i + 1, 0.); hcorr->SetBinError(1, i + 1, 0.); } TH2 *hcorrfit = ReturnCorrFromFit(hcorr); for (Int_t iloop = 0; iloop < nloop; iloop++) { if (bayesian) { AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian); AliUnfolding::SetBayesianParameters(smooth, iter); } else { AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization); AliUnfolding::SetChi2Regularization(regul, weight); } AliUnfolding::SetSkip0BinInChi2(kTRUE); AliUnfolding::SetSkipBinsBegin(1); AliUnfolding::SetNbins(150, 150); AliUnfolding::Unfold(usecorrfit ? hcorrfit : hcorr, heff, hdata, hinit, hresu); hinit = (TH1 *)hresu->Clone(Form("hinit_%d", iloop)); } printf("hdata->Integral(2, -1) = %f\n", hdata->Integral(2, -1)); printf("hresu->Integral(2, -1) = %f\n", hresu->Integral(2, -1)); TCanvas *cUnfolded = new TCanvas ("cUnfolded", "", 400, 800); cUnfolded->Divide(1, 2); cUnfolded->cd(1)->SetLogx(); cUnfolded->cd(1)->SetLogy(); hdata->Draw(); hresu->Draw("same"); htrue->Draw("same"); cUnfolded->cd(2)->SetLogx(); cUnfolded->cd(2)->DrawFrame(1., 0.75, 300., 1.25); TH1 *hrat = (TH1 *)hresu->Clone("hrat"); hrat->Divide(htrue); hrat->Draw("same"); TH1 *htrig = (TH1 *)hresu->Clone("htrig"); htrig->Multiply(heff); Float_t dndeta_resu = 0.; Float_t integr_resu = 0.; Float_t dndeta_trig = 0.; Float_t integr_trig = 0.; for (Int_t i = 1; i < hresu->GetNbinsX(); i++) { dndeta_resu += hresu->GetBinContent(i + 1) * hresu->GetBinLowEdge(i + 1); integr_resu += hresu->GetBinContent(i + 1); dndeta_trig += htrig->GetBinContent(i + 1) * htrig->GetBinLowEdge(i + 1); integr_trig += htrig->GetBinContent(i + 1); } // dndeta_resu /= integr_resu; // dndeta_trig /= integr_trig; integr_eff = integr_trig / integr_resu; integr_eff_err = TMath::Sqrt(integr_eff * (1. - integr_eff) / integr_resu); dndeta_eff = dndeta_trig / dndeta_resu; dndeta_eff_err = TMath::Sqrt(dndeta_eff * (1. - dndeta_eff) / dndeta_resu); printf("INEL > 0 efficiency: %.3f +- %.3f\n", integr_eff, integr_eff_err); printf("dN/dEta correction: %.3f +- %.3f\n", dndeta_eff, dndeta_eff_err); return hresu; }
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 dNdEta_ThreeMethods_FullTrackingRebinned_DividedByMidRapidValue() { //=========Macro generated from canvas: MyCanvas/MyCanvas //========= (Thu Dec 10 11:52:00 2009) by ROOT version5.22/00d gROOT->Reset(); gROOT->ProcessLine(".x rootlogon.C"); gStyle->SetTitleYOffset(1.4); TCanvas *MyCanvas = new TCanvas("MyCanvas", "Final result",1,360,550,600); TH1 *corr_result_all = new TH1D("corr_result_all","",14,-3.5,3.5); corr_result_all->GetXaxis()->SetRange(2,13); // ========================= Cluster Counting ======================= corr_result_all->SetBinContent(4,4.043821); // -2.0 to -1.5 corr_result_all->SetBinContent(5,3.821537); // -1.5 to -1.0 corr_result_all->SetBinContent(6,3.611029); // -1.0 to -0.5 corr_result_all->SetBinContent(7,3.501129); // -0.5 to 0.0 corr_result_all->SetBinContent(8,3.51732); corr_result_all->SetBinContent(9,3.632249); corr_result_all->SetBinContent(10,3.747706); corr_result_all->SetBinContent(11,4.01596); corr_result_all->SetBinError(4,0.177928124); corr_result_all->SetBinError(5,0.168147628); corr_result_all->SetBinError(6,0.158885276); corr_result_all->SetBinError(7,0.154049676); corr_result_all->SetBinError(8,0.15476208); corr_result_all->SetBinError(9,0.159818956); corr_result_all->SetBinError(10,0.164899064); corr_result_all->SetBinError(11,0.17670224); /* corr_result_all->SetBinContent(4,3.954); // -2.0 to -1.5 corr_result_all->SetBinContent(5,3.770); // -1.5 to -1.0 corr_result_all->SetBinContent(6,3.607); // -1.0 to -0.5 corr_result_all->SetBinContent(7,3.548); // -0.5 to 0.0 corr_result_all->SetBinContent(8,3.567); corr_result_all->SetBinContent(9,3.681); corr_result_all->SetBinContent(10,3.791); corr_result_all->SetBinContent(11,4.025); corr_result_all->SetBinError(4,0.1779); corr_result_all->SetBinError(5,0.1697); corr_result_all->SetBinError(6,0.1623); corr_result_all->SetBinError(7,0.1597); corr_result_all->SetBinError(8,0.1605); corr_result_all->SetBinError(9,0.1657); corr_result_all->SetBinError(10,0.1706); corr_result_all->SetBinError(11,0.1811); */ corr_result_all->SetMarkerStyle(20); //corr_result_all->SetMarkerSize(1.5); // use rootlogon size corr_result_all->SetMarkerColor(kRed); corr_result_all->SetLineColor(2); corr_result_all->GetYaxis()->SetTitle("dN_{ch}/d#eta/dN_{ch,mid}/d#eta"); corr_result_all->GetXaxis()->SetTitle("#eta"); corr_result_all->GetXaxis()->CenterTitle(); corr_result_all->GetYaxis()->CenterTitle(); corr_result_all->GetXaxis()->SetNdivisions(405); //corr_result_all->GetYaxis()->SetNdivisions(1005); corr_result_all->GetYaxis()->SetNdivisions(506); Float_t midrapid = 0.5*(corr_result_all->GetBinContent(7)+corr_result_all->GetBinContent(8)); cout<<"mid rapid value = "<<midrapid<<endl; corr_result_all->Scale(1/midrapid); corr_result_all->SetMinimum(0.95); corr_result_all->SetMaximum(1.3); corr_result_all->Draw("pz"); // ======= YJ Tracklet three layer combination averaged (updated with dead modules..) ====== // 1 2 3 4 5 6 7 8 9 10 11 12 Double_t xAxis5[13] = {-3, -2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3}; TH1 *hMeasuredFinal = new TH1D("hMeasuredFinal","",12, xAxis5); hMeasuredFinal->SetBinContent(3,3.7459); hMeasuredFinal->SetBinContent(4,3.65462); hMeasuredFinal->SetBinContent(5,3.55475); hMeasuredFinal->SetBinContent(6,3.45008); hMeasuredFinal->SetBinContent(7,3.44329); hMeasuredFinal->SetBinContent(8,3.5244); hMeasuredFinal->SetBinContent(9,3.59575); hMeasuredFinal->SetBinContent(10,3.6612); hMeasuredFinal->SetBinError(3,0.142344); hMeasuredFinal->SetBinError(4,0.138876); hMeasuredFinal->SetBinError(5,0.13508); hMeasuredFinal->SetBinError(6,0.131103); hMeasuredFinal->SetBinError(7,0.130845); hMeasuredFinal->SetBinError(8,0.133927); hMeasuredFinal->SetBinError(9,0.136638); hMeasuredFinal->SetBinError(10,0.139126); hMeasuredFinal->SetMarkerColor(kBlue); hMeasuredFinal->SetLineColor(4); hMeasuredFinal->SetMarkerStyle(21); //hMeasuredFinal->SetMarkerSize(1.5); // use rootlogon size midrapid = 0.5*(hMeasuredFinal->GetBinContent(6)+hMeasuredFinal->GetBinContent(7)); cout<<"mid rapid value = "<<midrapid<<endl; hMeasuredFinal->Scale(1/midrapid); hMeasuredFinal->Draw("pzsame"); /// ==================================================== Ferenc's dN/dEta (rebinned) Double_t xAxis6[13] = {-3, -2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3}; TH1 *hMeasuredFinal2 = new TH1D("hMeasuredFinal2","",12, xAxis6); // Hight Stat hMeasuredFinal2->SetBinContent(2,3.65413); hMeasuredFinal2->SetBinContent(3,3.68883); hMeasuredFinal2->SetBinContent(4,3.73805); hMeasuredFinal2->SetBinContent(5,3.62817); hMeasuredFinal2->SetBinContent(6,3.52704); hMeasuredFinal2->SetBinContent(7,3.47443); hMeasuredFinal2->SetBinContent(8,3.63319); hMeasuredFinal2->SetBinContent(9,3.7577); hMeasuredFinal2->SetBinContent(10,3.67975); hMeasuredFinal2->SetBinContent(11,3.65413); // Systematic error of 3.1% --> to 2.4% hMeasuredFinal2->SetBinError(2,0.08769912); hMeasuredFinal2->SetBinError(3,0.08853192); hMeasuredFinal2->SetBinError(4,0.0897132); hMeasuredFinal2->SetBinError(5,0.08707608); hMeasuredFinal2->SetBinError(6,0.08464896); hMeasuredFinal2->SetBinError(7,0.08338632); hMeasuredFinal2->SetBinError(8,0.08719656); hMeasuredFinal2->SetBinError(9,0.0901848); hMeasuredFinal2->SetBinError(10,0.088314); hMeasuredFinal2->SetBinError(11,0.08769912); /* // Systematic error of 3.1% --> to 2.3% hMeasuredFinal2->SetBinError(2,0.084045); hMeasuredFinal2->SetBinError(3,0.0848431); hMeasuredFinal2->SetBinError(4,0.0859752); hMeasuredFinal2->SetBinError(5,0.0834479); hMeasuredFinal2->SetBinError(6,0.0811219); hMeasuredFinal2->SetBinError(7,0.0799119); hMeasuredFinal2->SetBinError(8,0.0835634); hMeasuredFinal2->SetBinError(9,0.0864271); hMeasuredFinal2->SetBinError(10,0.0846342); hMeasuredFinal2->SetBinError(11,0.084045); */ hMeasuredFinal2->SetMarkerColor(kBlack); hMeasuredFinal2->SetLineColor(1); hMeasuredFinal2->SetMarkerStyle(22); //hMeasuredFinal2->SetMarkerSize(1.5); use root logon size midrapid = 0.5*(hMeasuredFinal2->GetBinContent(6)+hMeasuredFinal2->GetBinContent(7)); cout<<"mid rapid value = "<<midrapid<<endl; hMeasuredFinal2->Scale(1/midrapid); hMeasuredFinal2->Draw("pzsame"); // ================== 2.36 TeV // ========================= Cluster Counting ======================= TH1 *corr_result_all236 = new TH1D("corr_result_all236","",14,-3.5,3.5); corr_result_all236->GetXaxis()->SetRange(2,13); corr_result_all236->SetBinContent(4,5.203552); corr_result_all236->SetBinContent(5,4.913457); corr_result_all236->SetBinContent(6,4.710017); corr_result_all236->SetBinContent(7,4.44485); corr_result_all236->SetBinContent(8,4.448675); corr_result_all236->SetBinContent(9,4.659581); corr_result_all236->SetBinContent(10,4.856712); corr_result_all236->SetBinContent(11,5.065867); corr_result_all236->SetBinError(4,0.23416); corr_result_all236->SetBinError(5,0.221106); corr_result_all236->SetBinError(6,0.211951); corr_result_all236->SetBinError(7,0.200018); corr_result_all236->SetBinError(8,0.20019); corr_result_all236->SetBinError(9,0.209681); corr_result_all236->SetBinError(10,0.218552); corr_result_all236->SetBinError(11,0.227964); corr_result_all236->SetMarkerColor(kRed); corr_result_all236->SetLineColor(2); corr_result_all236->SetMarkerStyle(24); midrapid = 0.5*(corr_result_all236->GetBinContent(7)+corr_result_all236->GetBinContent(8)); cout<<"mid rapid value = "<<midrapid<<endl; corr_result_all236->Scale(1./midrapid); corr_result_all236->Draw("pzsame"); /// ==================================================== Yenjie 2.36 TeV // 1 2 3 4 5 6 7 8 9 10 11 12 TH1 *hTracklet236 = new TH1D("hTracklet236","",12, xAxis5); hTracklet236->SetBinContent(3,4.73663); hTracklet236->SetBinContent(4,4.69978); hTracklet236->SetBinContent(5,4.61061); hTracklet236->SetBinContent(6,4.40814); hTracklet236->SetBinContent(7,4.38437); hTracklet236->SetBinContent(8,4.51905); hTracklet236->SetBinContent(9,4.6502); hTracklet236->SetBinContent(10,4.80977); // 4.8 % Systematic Error hTracklet236->SetBinError(3,0.179992); hTracklet236->SetBinError(4,0.178592); hTracklet236->SetBinError(5,0.175203); hTracklet236->SetBinError(6,0.167509); hTracklet236->SetBinError(7,0.166606); hTracklet236->SetBinError(8,0.171724); hTracklet236->SetBinError(9,0.176707); hTracklet236->SetBinError(10,0.182771); hTracklet236->SetMarkerColor(4); hTracklet236->SetLineColor(4); hTracklet236->SetMarkerStyle(kOpenSquare); //hTracklet236->SetMarkerSize(1.5); // use rootlogon size midrapid = 0.5*(hTracklet236->GetBinContent(6)+hTracklet236->GetBinContent(7)); cout<<"mid rapid value = "<<midrapid<<endl; hTracklet236->Scale(1./midrapid); hTracklet236->Draw("pzsame"); /// ==================================================== Ferenc's dN/dEta (rebinned) Double_t xAxis7[13] = {-3, -2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3}; TH1 *hMeasuredFinal2236 = new TH1D("hMeasuredFinal2","",12, xAxis7); hMeasuredFinal2236->SetBinContent(2,4.9689); hMeasuredFinal2236->SetBinContent(3,4.93581); hMeasuredFinal2236->SetBinContent(4,4.67197); hMeasuredFinal2236->SetBinContent(5,4.70044); hMeasuredFinal2236->SetBinContent(6,4.52142); hMeasuredFinal2236->SetBinContent(7,4.55674); hMeasuredFinal2236->SetBinContent(8,4.61255); hMeasuredFinal2236->SetBinContent(9,4.67611); hMeasuredFinal2236->SetBinContent(10,4.87402); hMeasuredFinal2236->SetBinContent(11,4.96891); // Systematic error of 3.1% --> 2.3% hMeasuredFinal2236->SetBinError(2,0.114285); hMeasuredFinal2236->SetBinError(3,0.113524); hMeasuredFinal2236->SetBinError(4,0.107455); hMeasuredFinal2236->SetBinError(5,0.10811); hMeasuredFinal2236->SetBinError(6,0.103993); hMeasuredFinal2236->SetBinError(7,0.104805); hMeasuredFinal2236->SetBinError(8,0.106089); hMeasuredFinal2236->SetBinError(9,0.107551); hMeasuredFinal2236->SetBinError(10,0.112102); hMeasuredFinal2236->SetBinError(11,0.114285); hMeasuredFinal2236->SetMarkerColor(kBlack); hMeasuredFinal2236->SetLineColor(1); hMeasuredFinal2236->SetMarkerStyle(26); //hMeasuredFinal2->SetMarkerSize(1.5); use root logon size midrapid = 0.5*(hMeasuredFinal2236->GetBinContent(6)+hMeasuredFinal2236->GetBinContent(7)); cout<<"mid rapid value = "<<midrapid<<endl; hMeasuredFinal2236->Scale(1./midrapid); //hMeasuredFinal2236->Scale(1/4.53908); hMeasuredFinal2236->Draw("pzsame"); /// ==================================================== UA5 Data TH1F* hEta_UA5_NSD = new TH1F("hEta_UA5_NSD",";#eta;dN/d#eta",50,-3,3); // positive eta hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.125),3.48); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.375),3.38); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.625),3.52); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(0.875),3.68); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.125),3.71); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.375),3.86); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.625),3.76); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(1.875),3.66); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.125),3.72); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.375),3.69); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.625),3.56); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(2.875),3.41); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(3.125),3.15); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.125),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.375),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.625),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(0.875),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.125),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.375),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.625),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(1.875),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.125),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.375),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.625),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(2.875),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(3.125),0.07); //negative eta hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.125),3.48); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.375),3.38); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.625),3.52); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-0.875),3.68); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.125),3.71); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.375),3.86); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.625),3.76); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-1.875),3.66); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.125),3.72); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.375),3.69); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.625),3.56); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-2.875),3.41); hEta_UA5_NSD->SetBinContent(hEta_UA5_NSD->FindBin(-3.125),3.15); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.125),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.375),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.625),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-0.875),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.125),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.375),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.625),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-1.875),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.125),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.375),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.625),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-2.875),0.07); hEta_UA5_NSD->SetBinError(hEta_UA5_NSD->FindBin(-3.125),0.07); hEta_UA5_NSD->SetMarkerStyle(25); hEta_UA5_NSD->SetMarkerSize(1.0); //hEta_UA5_NSD->Draw("psame"); //TLegend *leg = new TLegend(0.20,0.27,0.53,0.47,NULL,"brNDC"); //TLegend *leg = new TLegend(0.20,0.35,0.53,0.47,NULL,"brNDC"); Float_t ywidth = 0.045*4; //TLegend *leg = new TLegend(0.27,0.26,0.70,0.26+ywidth,NULL,"brNDC"); //TLegend *leg = new TLegend(0.39,0.21,0.82,0.21+ywidth,NULL,"brNDC"); TLegend *leg = new TLegend(0.45,0.753,0.892,0.93,NULL,"brNDC"); //leg->SetNColumns(2); leg->SetBorderSize(0); leg->SetMargin(0.5); leg->SetTextFont(62); leg->SetLineColor(1); leg->SetLineStyle(1); leg->SetLineWidth(1); leg->SetFillColor(0); leg->SetFillStyle(0); leg->SetTextSize(0.03); leg->SetHeader(" 2.36 TeV"); leg->AddEntry(corr_result_all236,"Hit counting","P"); leg->AddEntry(hTracklet236,"Tracklet","P"); leg->AddEntry(hMeasuredFinal2236,"Global tracking","P"); //cout<<"Number of column "<<leg->GetNColumns()<<endl; /* leg->AddEntry(corr_result_all236,"","P"); leg->AddEntry(hTracklet236,"","P"); leg->AddEntry(hMeasuredFinal2236,"","P"); */ //TLegend *leg2 = new TLegend(0.20,0.22,0.53,0.35,NULL,"brNDC"); //TLegend *leg2 = new TLegend(0.50,0.26,0.93,0.47,NULL,"brNDC"); //TLegend *leg2 = new TLegend(0.39,0.26,0.82,0.26+ywidth,NULL,"brNDC"); //TLegend *leg2 = new TLegend(0.27,0.21,0.70,0.21+ywidth,NULL,"brNDC"); TLegend *leg2 = new TLegend(0.35,0.75,0.782,0.932,NULL,"brNDC"); leg2->SetMargin(0.37); leg2->SetBorderSize(0); leg2->SetTextFont(62); leg2->SetLineColor(1); leg2->SetLineStyle(1); leg2->SetLineWidth(1); leg2->SetFillColor(0); //leg2->SetFillStyle(1001); leg2->SetFillStyle(0); leg2->SetTextSize(0.03); leg2->SetHeader(" 0.9 TeV"); leg2->AddEntry(corr_result_all,"","P"); leg2->AddEntry(hMeasuredFinal,"","P"); leg2->AddEntry(hMeasuredFinal2,"","P"); leg->Draw(); leg2->Draw(); printFinalCanvases(MyCanvas,"dNdeta_ThreeMethods_Divided",0,2); }
void makeSystPlot( TFile * f, TString oldFolder, RooWorkspace *WS, string channel, string syst, int toMassNo, int fromMassNo, int rightBinNo, int addRightBin, int addRightBinm1) //massNo 0-51, see xSec7TeV.h { std::cout << "oldFolder, channel , addRightBin, addRightBinm1: " << oldFolder << " , " <<channel << " , " << addRightBin << " , "<< addRightBinm1 << std::endl; RooArgList * hobs = new RooArgList("hobs"); // RooRealVar BDT("BDT", "BDT", -1, 1);///OLD VARIABLE NAME HERE RooRealVar BDT("CMS_vhbb_BDT_Wln", "CMS_vhbb_BDT_Wln", -1, 1);///OLD VARIABLE NAME HERE hobs->add(*WS->var("CMS_vhbb_BDT_Wln")); ///NEW VARIABLE NAME HERE RooWorkspace *tempWS = (RooWorkspace*) f->Get(oldFolder.Data()); TString systT(syst); TString chanT(channel); if((kount < 3) && (channel=="data_obs")) { kount++; std::string namen = channel; std::cout << oldFolder.Data() << std::endl; std::cout << namen << std::endl; RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str()); TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,RooFit::Binning(bins)); tempHistNom->Rebin(rebin); if(addRightBin == 1) { float err0 = tempHistNom->GetBinError(rightBinNo); float con0 = tempHistNom->GetBinContent(rightBinNo); float err1 = tempHistNom->GetBinError(rightBinNo-1); float con1 = tempHistNom->GetBinContent(rightBinNo-1); tempHistNom->SetBinContent(rightBinNo,0); tempHistNom->SetBinError(rightBinNo,0); tempHistNom->SetBinContent(rightBinNo-1,con0+con1); tempHistNom->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1)); } if(addRightBinm1 == 1) { float err0 = tempHistNom->GetBinError(rightBinNo-1); float con0 = tempHistNom->GetBinContent(rightBinNo-1); float err1 = tempHistNom->GetBinError(rightBinNo-2); float con1 = tempHistNom->GetBinContent(rightBinNo-2); tempHistNom->SetBinContent(rightBinNo-1,0); tempHistNom->SetBinError(rightBinNo-1,0); tempHistNom->SetBinContent(rightBinNo-2,con0+con1); tempHistNom->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1)); } RooDataHist *DHnom = new RooDataHist(channel.c_str(),"",*hobs,tempHistNom); WS->import(*(new RooHistPdf(channel.c_str(),"",*hobs,*DHnom))); } if (channel!="data_obs") { std::string nameUp; std::string namen; std::string nameDown; if(syst == "stat") { if(oldFolder.Contains("Wenu")) { nameUp = channel + "_CMS_vhbb_stat" + channel + "_WenuUp"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_WenuDown"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_WenuUp"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_WenuDown"; } } else { nameUp = channel + "_CMS_vhbb_stat" + channel + "_WmunuUp"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_WmunuDown"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_WmunuUp"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_WmunuDown"; } } } else { nameUp = channel + "_CMS_" + syst + "Up"; namen = channel; nameDown = channel + "_CMS_" + syst + "Down"; } if((syst == "stat") && (oldFolder.Contains("2"))) { if(oldFolder.Contains("Wenu")) { nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wenu2Up"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wenu2Down"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_Wenu2Up"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_Wenu2Down"; } } else { nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wmunu2Up"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wmunu2Down"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_Wmunu2Up"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_Wmunu2Down"; } } } if(systT.Contains("Model")) { nameUp = channel + "_CMS_vhbb_WModelUp"; namen = channel; nameDown = channel + "_CMS_vhbb_WModelDown"; } if( systT.Contains("stat") && (oldFolder.Contains("Wenu")) && IFILE.Contains("8TeV") && !(oldFolder.Contains("2"))) { nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wenu_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wenu_8TeVDown"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_Wenu_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_Wenu_8TeVDown"; } } if( systT.Contains("stat") && (oldFolder.Contains("Wmunu")) && IFILE.Contains("8TeV") && !(oldFolder.Contains("2"))) { nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wmnu_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wmnu_8TeVDown"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_Wmnu_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_Wmnu_8TeVDown"; } } if( systT.Contains("stat") && (oldFolder.Contains("Wenu")) && IFILE.Contains("8TeV") && (oldFolder.Contains("2"))) { nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wenu2_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wenu2_8TeVDown"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_Wenu2_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_Wenu2_8TeVDown"; } } if( systT.Contains("stat") && (oldFolder.Contains("Wmunu")) && IFILE.Contains("8TeV") && (oldFolder.Contains("2"))) { nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wmnu2_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wmnu2_8TeVDown"; if(channel == "s_Top") { nameUp = channel + "_CMS_vhbb_statsTop_Wmnu2_8TeVUp"; namen = channel; nameDown = channel + "_CMS_vhbb_statsTop_Wmnu2_8TeVDown"; } } RooDataHist* tempRooDataHistUp = (RooDataHist*) tempWS->data(nameUp.c_str()); RooDataHist* tempRooDataHistDown = (RooDataHist*) tempWS->data(nameDown.c_str()); RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str()); std::cout << oldFolder.Data() << std::endl; std::cout << nameUp.c_str() << std::endl; TH1 *tempHistUp = tempRooDataHistUp->createHistogram(nameUp.c_str(),BDT,RooFit::Binning(bins)); TH1 *tempHistDown = tempRooDataHistDown->createHistogram(nameDown.c_str(),BDT,RooFit::Binning(bins)); TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,RooFit::Binning(bins)); if(chanT.Contains("WH") && IFILE.Contains("7TeV")) { tempHistUp->Scale(xSec7WH[toMassNo]/xSec7WH[fromMassNo]); tempHistDown->Scale(xSec7WH[toMassNo]/xSec7WH[fromMassNo]); tempHistNom->Scale(xSec7WH[toMassNo]/xSec7WH[fromMassNo]); } if(chanT.Contains("WH") && IFILE.Contains("8TeV")) { tempHistUp->Scale(xSec8WH[toMassNo]/xSec8WH[fromMassNo]); tempHistDown->Scale(xSec8WH[toMassNo]/xSec8WH[fromMassNo]); tempHistNom->Scale(xSec8WH[toMassNo]/xSec8WH[fromMassNo]); } std::cout<< "channel--> " << channel << std::endl; tempHistUp->SetLineColor(kRed); tempHistUp->SetLineWidth(3); tempHistUp->SetFillColor(0); tempHistDown->SetLineColor(kBlue); tempHistDown->SetFillColor(0); tempHistDown->SetLineWidth(3); tempHistNom->SetFillColor(0); tempHistNom->SetMarkerStyle(20); tempHistUp->SetTitle((channel + syst).c_str()); tempHistNom->Rebin(rebin); tempHistUp->Rebin(rebin); tempHistDown->Rebin(rebin); if(addRightBin == 1) { float err0 = tempHistNom->GetBinError(rightBinNo); float con0 = tempHistNom->GetBinContent(rightBinNo); float err1 = tempHistNom->GetBinError(rightBinNo-1); float con1 = tempHistNom->GetBinContent(rightBinNo-1); tempHistNom->SetBinContent(rightBinNo,0); tempHistNom->SetBinError(rightBinNo,0); tempHistNom->SetBinContent(rightBinNo-1,con0+con1); tempHistNom->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1)); err0 = tempHistUp->GetBinError(rightBinNo); con0 = tempHistUp->GetBinContent(rightBinNo); err1 = tempHistUp->GetBinError(rightBinNo-1); con1 = tempHistUp->GetBinContent(rightBinNo-1); tempHistUp->SetBinContent(rightBinNo,0); tempHistUp->SetBinError(rightBinNo,0); tempHistUp->SetBinContent(rightBinNo-1,con0+con1); tempHistUp->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1)); err0 = tempHistDown->GetBinError(rightBinNo); con0 = tempHistDown->GetBinContent(rightBinNo); err1 = tempHistDown->GetBinError(rightBinNo-1); con1 = tempHistDown->GetBinContent(rightBinNo-1); tempHistDown->SetBinContent(rightBinNo,0); tempHistDown->SetBinError(rightBinNo,0); tempHistDown->SetBinContent(rightBinNo-1,con0+con1); tempHistDown->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1)); } if(addRightBinm1 == 1) { float err0 = tempHistNom->GetBinError(rightBinNo-1); float con0 = tempHistNom->GetBinContent(rightBinNo-1); float err1 = tempHistNom->GetBinError(rightBinNo-2); float con1 = tempHistNom->GetBinContent(rightBinNo-2); tempHistNom->SetBinContent(rightBinNo-1,0); tempHistNom->SetBinError(rightBinNo-1,0); tempHistNom->SetBinContent(rightBinNo-2,con0+con1); tempHistNom->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1)); err0 = tempHistUp->GetBinError(rightBinNo-1); con0 = tempHistUp->GetBinContent(rightBinNo-1); err1 = tempHistUp->GetBinError(rightBinNo-2); con1 = tempHistUp->GetBinContent(rightBinNo-2); tempHistUp->SetBinContent(rightBinNo-1,0); tempHistUp->SetBinError(rightBinNo-1,0); tempHistUp->SetBinContent(rightBinNo-2,con0+con1); tempHistUp->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1)); err0 = tempHistDown->GetBinError(rightBinNo-1); con0 = tempHistDown->GetBinContent(rightBinNo-1); err1 = tempHistDown->GetBinError(rightBinNo-2); con1 = tempHistDown->GetBinContent(rightBinNo-2); tempHistDown->SetBinContent(rightBinNo-1,0); tempHistDown->SetBinError(rightBinNo-1,0); tempHistDown->SetBinContent(rightBinNo-2,con0+con1); tempHistDown->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1)); } RooDataHist *DHnom; RooDataHist *DHup = new RooDataHist(nameUp.c_str(),"",*hobs,tempHistUp); if(kount2 < 3) DHnom = new RooDataHist(namen.c_str(),"",*hobs,tempHistNom); RooDataHist *DHdown = new RooDataHist(nameDown.c_str(),"",*hobs,tempHistDown); WS->import(*(new RooHistPdf(nameUp.c_str(),"",*hobs,*DHup))); WS->import(*(new RooHistPdf(nameDown.c_str(),"",*hobs,*DHdown))); if(kount2 < 3){ WS->import(*(new RooHistPdf(namen.c_str(),"",*hobs,*DHnom))); kount2++;} } }
TH1* GetCentK(TDirectory* top, Double_t c1, Double_t c2, Int_t s, TLegend* l) { TString dname; dname.Form("cent%06.2f_%06.2f", c1, c2); dname.ReplaceAll(".", "d"); TDirectory* d = top->GetDirectory(dname); if (!d) { Warning("GetCetnK", "Directory %s not found in %s", dname.Data(), top->GetName()); return; } TDirectory* det = d->GetDirectory("details"); if (!det) { Warning("GetCetnK", "Directory details not found in %s", d->GetName()); d->ls(); return; } TObject* o = det->Get("scalar"); if (!o) { Warning("GetCetnK", "Object scalar not found in %s", det->GetName()); return; } if (!o->IsA()->InheritsFrom(TH1::Class())) { Warning("GetCetnK", "Object %s is not a TH1, but a %s", o->GetName(), o->ClassName()); return; } TH1* h = static_cast<TH1*>(o->Clone()); Color_t col = cc[(s-1)%10]; h->SetLineColor(col); h->SetMarkerColor(col); h->SetFillColor(col); h->SetFillStyle(1001); // h->SetTitle(Form("%5.2f-%5.2f%% #times %d", c1, c2, s)); h->SetTitle(Form("%2.0f-%2.0f%% + %d", c1, c2, s-1)); TF1* f = new TF1("", "[0]",-2.2,2.2); f->SetParameter(0,s-1); f->SetLineColor(col); f->SetLineStyle(7); f->SetLineWidth(1); // h->Scale(s); h->Add(f); h->GetListOfFunctions()->Add(f); f->SetParameter(0,s); for (Int_t i = 1; i <= h->GetNbinsX(); i++) { if (TMath::Abs(h->GetBinCenter(i)) > 2) { h->SetBinContent(i,0); h->SetBinError(i,0); } } TLegendEntry* e = l->AddEntry(h, h->GetTitle(), "f"); e->SetFillColor(col); e->SetFillStyle(1001); e->SetLineColor(col); return h; }