/** comapre axis for equalitiy * * check whether the cass histogram axis and the root histogram axis are the * same. Test for number of bins, low and high ends and the title of the axis. * * @return true when both axis are the same * @param ca the axis of the cass histogram * @param ra the axis of the root histogram * * @author Lutz Foucar */ bool operator== (const cass::Result<float>::axe_t &ca, const TAxis &ra) { return (static_cast<int>(ca.nBins) == ra.GetNbins() && fabs(ca.low - ra.GetXmin()) < sqrt(numeric_limits<double>::epsilon()) && fabs(ca.up - ra.GetXmax()) < sqrt(numeric_limits<double>::epsilon()) && ca.title == ra.GetTitle()); }
void getLimits (TH1D *cutFlow, TDirectoryFile *dir) { string histName = cutFlow->GetName (); TH1D *lowerLimit = (TH1D *) cutFlow->Clone ((histName + "LowerLimit").c_str ()), *upperLimit = (TH1D *) cutFlow->Clone ((histName + "UpperLimit").c_str ()); TAxis *x = cutFlow->GetXaxis (); for (int i = 1; i <= x->GetNbins (); i++) { double events = cutFlow->GetBinContent (i), eventsLowerLimit, eventsUpperLimit; // The calculation of upper and lower limits is taken from the PDG Statistics chapter. // "Poisson or binomal data", section 37.4.2.3 in 2013 version; Eqns. 37.71a, 37.71b. // Here ALPHA is the confidence level, so ALPHA = 0.68 corresponds to a 68% C.L. // The PDG uses a different convention: the C.L is 1 - \alpha. // For example, the 68% CL upper limit on an observation of 0 events is: // 0.5 * TMath::ChisquareQuantile (0.68, 2) = 1.139 eventsLowerLimit = 0.5 * TMath::ChisquareQuantile (1 - ALPHA, 2 * events); eventsUpperLimit = 0.5 * TMath::ChisquareQuantile (ALPHA, 2 * (events + 1)); lowerLimit->SetBinContent (i, eventsLowerLimit); upperLimit->SetBinContent (i, eventsUpperLimit); } dir->cd (); lowerLimit->Write ((histName + "LowerLimit").c_str ()); upperLimit->Write ((histName + "UpperLimit").c_str ()); }
//______________________________________________________________________________ void drawsparse_draw(THnSparse* h) { // Draw a THnSparse using TParallelCoord, creating a temporary TTree. TTree* tree = toTree(h); TString whatToDraw; TIter iLeaf(tree->GetListOfLeaves()); const TLeaf* leaf = 0; while ((leaf = (const TLeaf*)iLeaf())) { if (whatToDraw.Length()) whatToDraw += ":"; whatToDraw += leaf->GetName(); } tree->Draw(whatToDraw, "", "para"); TParallelCoord* parallelCoord = (TParallelCoord*)gPad->GetListOfPrimitives()->FindObject("ParaCoord"); TIter iVar(parallelCoord->GetVarList()); TParallelCoordVar* var = 0; for (Int_t d = 0;(var = (TParallelCoordVar*) iVar()) && d < h->GetNdimensions(); ++d) { TAxis* axis = h->GetAxis(d); var->SetHistogramBinning(axis->GetNbins()); var->SetCurrentLimits(axis->GetXmin(), axis->GetXmax()); var->SetTitle(axis->GetTitle()); } var->SetTitle("bin content"); }
TH1* linearizeHistogram(TH1* histogram) { if ( !histogram ) return 0; TH1* histogram2d = dynamic_cast<TH2*>(histogram); if ( !histogram2d ) return histogram; TAxis* xAxis = histogram2d->GetXaxis(); int numBinsX = xAxis->GetNbins(); TAxis* yAxis = histogram2d->GetYaxis(); int numBinsY = yAxis->GetNbins(); std::string histogramName1d = Form("%s_1d", histogram->GetName()); int numBins1d = numBinsX*numBinsY; TH1* histogram1d = new TH1D(histogramName1d.data(),histogramName1d.data(), numBins1d, -0.5, numBins1d - 0.5); int iBin1d = 1; for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) { for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) { double binContent = histogram2d->GetBinContent(iBinX, iBinY); double binError = histogram2d->GetBinError(iBinX, iBinY); histogram1d->SetBinContent(iBin1d, binContent); histogram1d->SetBinError(iBin1d, binError); ++iBin1d; } } return histogram1d; }
////////////////////////////////////////////////// // addXAxis - add X axis information unsigned int addXAxis(SEXP data, SEXP dataNames, unsigned int j, TH1* hist) { int n = hist->GetNbinsX(); TAxis* axis = hist->GetXaxis(); // Determine breaks-- // Add to list SEXP breaks = addNumericVector(data, dataNames, j++, n+1, "breaks"); // Get information for ( unsigned int i=0; i<n; ++i ) { NUMERIC_POINTER(breaks)[i] = axis->GetBinLowEdge(i+1); } // Add the high edge NUMERIC_POINTER(breaks)[n] = axis->GetBinUpEdge(n); // Determine mids-- SEXP mids = addNumericVector(data, dataNames, j++, n, "mids"); // Get information for ( unsigned int i=0; i<n; ++i ) { NUMERIC_POINTER(mids)[i] = axis->GetBinCenter(i+1); } // Get name of axis SEXP xname = addCharVector(data, dataNames, j++, 1, "xname"); SET_STRING_ELT( xname, 0, mkChar( axis->GetTitle() ) ); // Done return j; }
//______________________________________________________________________________ void ArgusHistoDisplay::SetLimits(TGraph *g) { const Int_t n = g->GetN(); if (n<=1) { return; } int i; double xmin, xmax, ymin, ymax; double *x; double *y; x = g->GetX(); y = g->GetY(); xmin = xmax = x[0]; ymin = ymax = y[0]; for (i=1;i<n;i++) { if (xmin>x[i]) xmin = x[i]; if (xmax<x[i]) xmax = x[i]; if (ymin>y[i]) ymin = y[i]; if (ymax<y[i]) ymax = y[i]; } if (xmin<xmax && ymin<ymax) { g->SetMinimum(ymin-(ymax-ymin)/10.); g->SetMaximum(ymax+(ymax-ymin)/10.); TAxis *axis = g->GetXaxis(); if(axis) { axis->SetLimits(xmin, xmax); } } }
void checkTriggers() { triggers.clear(); triggers.push_back("HLT_Mu23_TrkIsoVVL_Ele8_CaloIdL_TrackIdL_IsoVL_v*"); triggers.push_back("HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v*"); triggers.push_back("HLT_Ele27_eta2p1_WPLoose_Gsf_v*"); triggers.push_back("HLT_IsoMu22_v*"); triggers.push_back("HLT_IsoTkMu22_v*"); triggers.push_back("HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v*"); triggers.push_back("HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v*"); triggers.push_back("HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v*"); TFile* file = new TFile(_lxplus + "21Jun2016_Run2016B_PromptReco/l2loose__hadd__EpTCorr__l2tight/latino_Run2016B_PromptReco_MuonEG.root"); TH1F* selectedTriggers = (TH1F*)file->Get("selectedTriggers"); TAxis* xaxis = (TAxis*)selectedTriggers->GetXaxis(); printf("\n Checking %d triggers\n\n", (int)triggers.size()); for (int i=0; i<triggers.size(); i++) { for (int j=0; j<=selectedTriggers->GetNbinsX(); j++) { TString label = (TString)xaxis->GetBinLabel(j); if (label.Length() < 1) continue; if (triggers[i].EqualTo(label)) printf(" found [%d] %s\n", i, label.Data()); } } printf("\n"); }
//________________________________________________________________ void KVCanvas::DynamicZoomTH1(Int_t Sign, Int_t px, Int_t) { // Zoom in or out of histogram with mouse wheel if (!fSelected) return; TH1* TheHisto = (TH1*) FindHisto();//fSelected; Double_t percent = 0.15 - Sign * 0.05; Int_t dX = 0; px = AbsPixeltoX(px); TAxis* ax = TheHisto->GetXaxis(); Int_t NbinsXtmp = ax->GetNbins(); Int_t X0tmp = ax->GetFirst(); Int_t X1tmp = ax->GetLast(); Int_t step = TMath::Min(TMath::Max(1, (Int_t)(percent * (X1tmp - X0tmp))), NbinsXtmp / 2); step *= Sign; X0tmp = TMath::Min(TMath::Max(X0tmp + step, 1), X1tmp - step); X1tmp = TMath::Max(TMath::Min(X1tmp - step, NbinsXtmp), X0tmp); if (X0tmp >= X1tmp) X0tmp = X1tmp - 1; if (Sign > 0) dX = (Int_t)(X0tmp + (X1tmp - X0tmp) * 0.5 - ax->FindBin(px)); if ((X0tmp - dX) < 0) ax->SetRange(0, X1tmp - X0tmp); else if ((X1tmp - dX) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (X1tmp - X0tmp), ax->GetNbins()); else ax->SetRange(X0tmp - dX, X1tmp - dX); Modified(); Update(); return; }
void BinLog(TH2F *h) { TAxis *axis = h->GetXaxis(); int bins = axis->GetNbins(); Axis_t from = axis->GetXmin(); Axis_t to = axis->GetXmax(); Axis_t width = (to - from) / bins; Axis_t *new_bins = new Axis_t[bins + 1]; for (int i = 0; i <= bins; i++) { new_bins[i] = TMath::Power(10, from + i * width); } axis->Set(bins, new_bins); TAxis *axis2 = h->GetYaxis(); int bins2 = axis2->GetNbins(); Axis_t from2 = axis2->GetXmin(); Axis_t to2 = axis2->GetXmax(); Axis_t width2 = (to2 - from2) / bins2; Axis_t *new_bins2 = new Axis_t[bins2 + 1]; for (int i = 0; i <= bins2; i++) { new_bins2[i] = TMath::Power(10, from2 + i * width2); } axis2->Set(bins2, new_bins2); delete new_bins; delete new_bins2; }
void Draw_ALICEMid_JPsi_RaaVsNpart(TLegend *lgd) { //ALICE MID rapidity int nbinsALICEMid=3; Double_t NPartALICEMid[3]={357,193,46}; Double_t ErrNPartALICEMid[3]={0}; Double_t RaaALICEMid[3] = {0.82,0.65,0.73}; Double_t SystErrALICEMid[3] = {0.15,0.10,0.16}; TGraphErrors *grRaaALICEMid = new TGraphErrors(nbinsALICEMid, NPartALICEMid, RaaALICEMid, ErrNPartALICEMid, SystErrALICEMid); grRaaALICEMid->SetMarkerStyle(20); grRaaALICEMid->SetMarkerColor(2); //grRaaALICEMid->SetLineColor(2); grRaaALICEMid->GetYaxis()->SetRangeUser(0,1.5); TAxis *Xaxis = grRaaALICEMid->GetXaxis(); Xaxis->SetLimits(0.,430.0); grRaaALICEMid->GetXaxis()->SetTitle("N_{Part}"); grRaaALICEMid->GetYaxis()->SetTitle("R_{AA}"); grRaaALICEMid->Draw("Psame"); //TLatex *tb= new TLatex; //tb->SetNDC(); //tb->SetTextAlign(12); //tb->SetTextColor(1); //tb->SetTextSize(0.040); //tb->DrawLatex(0.55,0.90,"PbPb #sqrt{s_{NN}} = 2.76 TeV"); //tb->DrawLatex(0.22,0.16,"J/#psi #rightarrow #mu^{+} #mu^{-}, p_{T}^{J/#psi} > 0.0 GeV/c"); //tb->DrawLatex(0.55,0.85,"p_{T}^{J/#psi} > 0.0 GeV/c"); TLine *lh3 = new TLine(0.0,1.0,420,1.0); lh3->SetLineColor(1); lh3->SetLineStyle(1); lh3->SetLineWidth(1.5); lh3->Draw("same"); TBox *RaaJPsiALICEMidSys[12]; for(int j=0;j<3;j++){ RaaJPsiALICEMidSys[j] = new TBox(NPartALICEMid[j]-3, RaaALICEMid[j]-SystErrALICEMid[j], NPartALICEMid[j]+3, RaaALICEMid[j]+SystErrALICEMid[j]); } for(int j=0;j<3;j++){ RaaJPsiALICEMidSys[j]->SetFillStyle(0000); RaaJPsiALICEMidSys[j]->SetLineColor(2); RaaJPsiALICEMidSys[j]->Draw("same"); } TBox *ALICEMidGlobalSysJPsi; ALICEMidGlobalSysJPsi = new TBox(385-5, 1 - 0.26, 385+5, 1 + 0.26); ALICEMidGlobalSysJPsi->SetFillStyle(3001); ALICEMidGlobalSysJPsi->SetLineColor(2); ALICEMidGlobalSysJPsi->SetFillColor(2); ALICEMidGlobalSysJPsi->Draw("same"); lgd->AddEntry(grRaaALICEMid,"ALICE Data p_{T}^{J/#psi} > 0.0 GeV/c, |y^{J/#psi}| #leq 1.0","P"); }
void labelBins( TH1F* hist ) { TAxis* xaxis = hist->GetXaxis() ; for ( int mbi=0; mbi<hist->GetNbinsX(); mbi++ ) { char label[1000] ; sprintf( label, "MET%d", mbi+1 ) ; xaxis->SetBinLabel( mbi+1, label ) ; } // mbi. }
//Get background counts on NRS from Geant4 simulation template (histogram) void ResonanceSimulator::get_background(){ TAxis *xaxis = hbkg->GetXaxis(); int binx = xaxis->FindBin(e_cut); int binmax = xaxis->GetXmax(); N_background = hbkg->Integral(binx,binmax); return; }
void Draw_CMS_JPsi_RaaVsRap(TLegend *lgd) { //=============== CMS Raa Vs Rap Data ===============================================================// //AvpT 10.92,9.65,8.92 int nbinsRapCMS=3; Double_t RapCMSD[3]={0.6,1.4,2.0}; Double_t ErrRapCMS[3]={0.6,0.2,0.4}; Double_t RaaRapCMS[3] = {0.31,0.33,0.36}; Double_t RaaRapStatErrCMS[3] = {0.02,0.03,0.03}; Double_t RaaRapSystErrCMS[3] = {0.03,0.04,0.04}; TGraphErrors *grRaaRapCMS = new TGraphErrors(nbinsRapCMS, RapCMSD, RaaRapCMS, ErrRapCMS, RaaRapStatErrCMS); grRaaRapCMS->SetMarkerStyle(20); grRaaRapCMS->SetMarkerColor(2); grRaaRapCMS->GetYaxis()->SetRangeUser(0,1.5); grRaaRapCMS->GetXaxis()->SetTitle("|y|"); grRaaRapCMS->GetYaxis()->SetTitle("R_{AA}"); TAxis *XaxisgrRaaRapCMS = grRaaRapCMS->GetXaxis(); XaxisgrRaaRapCMS->SetLimits(0.0,2.4); grRaaRapCMS->Draw("AP"); TLine *lh_grRaaRapCMS = new TLine(0.0,1.0,2.4,1.0); lh_grRaaRapCMS->SetLineColor(1); lh_grRaaRapCMS->SetLineStyle(1); lh_grRaaRapCMS->SetLineWidth(1.5); lh_grRaaRapCMS->Draw("same"); TLatex *tb= new TLatex; tb->SetNDC(); tb->SetTextAlign(12); tb->SetTextColor(1); tb->SetTextSize(0.040); tb->DrawLatex(0.20,0.20,"Pb+Pb #sqrt{s_{NN}} = 2.76 TeV"); tb->DrawLatex(0.20,0.15,"J/#psi #rightarrow #mu^{+} #mu^{-}, p_{T}^{J/#psi} > 6.5 GeV/c"); TBox *RaaRapJPsiCMSSys[4]; for(int j=0;j<3;j++){ RaaRapJPsiCMSSys[j] = new TBox(RapCMSD[j]-0.05, RaaRapCMS[j]-RaaRapSystErrCMS[j], RapCMSD[j]+0.05, RaaRapCMS[j]+RaaRapSystErrCMS[j]); } for(int j=0;j<3;j++){ RaaRapJPsiCMSSys[j]->SetFillStyle(0000); RaaRapJPsiCMSSys[j]->SetLineColor(2); RaaRapJPsiCMSSys[j]->Draw("same"); } TBox *CMSGlobalSysJPsiRap; CMSGlobalSysJPsiRap = new TBox(0.2-0.05, 1 - 0.05, 0.2+0.05, 1 + 0.05); CMSGlobalSysJPsiRap->SetFillStyle(3001); CMSGlobalSysJPsiRap->SetLineColor(2); CMSGlobalSysJPsiRap->SetFillColor(2); CMSGlobalSysJPsiRap->Draw("same"); lgd->AddEntry(grRaaRapCMS,"CMS Data", "P"); }
void TPTiming () { TAxis * ax = TPMatchEmul2D->GetZaxis() ; ax->SetRangeUser(-1,6) ; TCanvas* canv = new TCanvas("canv", "canv") ; canv->SetLogz(0) ; gStyle->SetOptStat(10) ; int color[10]= {1,10,3,4,5,6,7,8,9,2} ; gStyle->SetPalette(7, color) ; TPMatchEmul2D->GetXaxis()->SetTitle("Phi index"); TPMatchEmul2D->GetYaxis()->SetTitle("Eta index"); TPMatchEmul2D->Draw("colz") ; TH2I * label = new TH2I("label", "",72, 1, 73, 38, -19, 19) ; label->SetMarkerSize(0.6); label->SetBit(kCanDelete); for (int x=3 ; x<73 ; x+=4) { for (int y=21; y<=37; y++) { int towernb = 4*(y-21)+1 ; label->SetBinContent(x-1, y, towernb) ; //EB+ label->SetBinContent(x, 40-y, towernb) ; //EB- } } label->Draw("same text") ; TLatex txt; txt.SetTextSize(0.02); TLine line; line.SetLineColor(1) ; line.SetLineStyle(1) ; line.SetLineWidth(1) ; TAxis* xAxis = TPMatchEmul2D->GetXaxis(); TAxis* yAxis = TPMatchEmul2D->GetYaxis(); // draw SM borders and numbers float sm ; for (int i=0; i<36 ; i++ ) { if (i<18) { sm = 4*i+3 ; line.DrawLine(sm, 1, sm, 18) ; txt.SetTextAlign(32); txt.DrawText(sm-1+0.3, -17.7, Form("-%d",i+1)); } else { sm = 4*(i-18)+3 ; line.DrawLine(sm, 0, sm, -17) ; txt.SetTextAlign(12); txt.DrawText(sm-2+0.3, 18.5, Form("+%d",i-17)); } } line.DrawLine(1, 0, 73, 0) ; line.DrawLine(1, -17, 73, -17) ; line.DrawLine(1, 1, 73, 1) ; line.DrawLine(1, 18, 73, 18) ; }
/** * Make a GraphSysErr object * * @param o Output stream * @param h Histogram * @param c1 Lower centrality bound * @param c2 Upper centrality bound * @param reweigh True if reweighed * @param fac Scaling factor */ void MakeGSE(std::ostream& o, const TH1* h, Double_t c1, Double_t c2, Bool_t reweigh, Double_t fac=1) { // These are correlated Double_t bgMid = CSysEval(c2, 100*0.02, 100*0.002); Double_t cSys = CSysEval(c2, 100*0.005, 100*0.075); Double_t strMid = 100*0.005; Double_t strFwd = 100*0.05; Double_t pidMid = 100*0; Double_t pidFwd = 100*0.01; // Double_t bgSys = (1-c1/100)*(2-0.2) + 0.2; // Double_t cSys = TMath::Power(c1/100,2)*(7.5-0.5) + 0.5; o << "*dataset:\n" << "*dscomment: The pseudo-rapidity density of charged particle\n" << "*reackey: PB PB --> CHARGED X\n" << "*obskey: DN/DETARAP\n" << "*qual: CENTRALITY IN PCT : " << c1 << " TO " << c2 << "\n" << "*qual: SQRT(S)/NUCLEON IN GEV : 5023\n"; if (!reweigh) { o << "*dserror: " << strMid << " PCT : Weak decays\n" << "*dserror: " << pidMid << " PCT : Particle composition\n" << "*dserror: " << bgMid << " PCT : Background subtraction\n"; } o << "*dserror: 1 PCT : pT extrapolation\n" << "*dserror: " << cSys << " PCT : Centrality\n" << "*xheader: ETARAP\n" << "*yheader: DN/DETARAP\n" << "*data: x : y" << std::endl; // Define points TAxis* xa = h->GetXaxis(); for (Int_t i = 0; i < h->GetNbinsX(); i++) { Int_t j = i+1; Double_t cc = h->GetBinContent(j)*fac; Double_t x = h->GetXaxis()->GetBinCenter(j); Double_t ex = h->GetXaxis()->GetBinWidth(j)/2; Double_t xo = TMath::Abs(x)+ex; if (cc < 1e-8) continue; o << " " << xa->GetBinLowEdge(j) << " TO " << xa->GetBinUpEdge(j) << "; " << cc << " +-" << h->GetBinError(j) << " (DSYS=" << 0.01+0.01*TMath::Power(xo/2,2) << " PCT:Acceptance"; if (reweigh) { Double_t bg = EtaSysEval(xo, bgMid, 3*bgMid); Double_t pid = EtaSysEval(xo, pidMid, pidFwd); Double_t str = EtaSysEval(xo, strMid, strFwd); o << ",DSYS=" << bg << " PCT:Background subtraction" << ",DSYS=" << pid << " PCT:Particle composition" << ",DSYS=" << str << " PCT:Weak decay"; } o << ");" << std::endl; } o << "*dataend:\n" << std::endl; }
void plotImportance(const char* canvas, const char* title, const unsigned nVars, const char vars[][200], const double* importance, const double* error, bool automaticRange=false) { TCanvas *c = new TCanvas(canvas,"SPR Variable Importance",200,10,600,400); gStyle->SetPalette(1); TH1D* h1 = new TH1D("importance",title,nVars,0,nVars); double ymin(0), ymax(0); for( int i=0;i<nVars;i++ ) { h1->Fill(vars[i],importance[i]); if( automaticRange ) { ymin = ( ymin>importance[i] ? importance[i] : ymin ); ymax = ( ymax<importance[i] ? importance[i] : ymax ); } } if( automaticRange ) { ymin = ( ymin<0 ? ymin*1.2 : ymin*0.8 ); ymax *= 1.2; } else { ymin = 0.; ymax = 1.; } if( error == 0 ) { for( int i=0;i<nVars;i++ ) h1->SetBinError(i+1,0.); } else { for( int i=0;i<nVars;i++ ) h1->SetBinError(i+1,error[i]); } h1->LabelsDeflate("X"); h1->LabelsOption("v"); h1->SetLabelSize(0.06,"X"); h1->SetLineColor(4); h1->SetMarkerStyle(21); h1->SetMarkerColor(4); h1->SetLineWidth(2); TAxis* yaxis = h1->GetYaxis(); yaxis->SetRangeUser(ymin,ymax); if( error == 0 ) { h1->SetLineColor(4); h1->SetFillColor(4); h1->SetBarWidth(0.8); h1->SetBarOffset(0.1); h1->Draw("B"); } else h1->Draw("E0P"); l = new TLine(0,0,nVars,0); l->Draw(); }
void divideByBinWidth(TH1* histogram) { if ( !histogram ) return; 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); histogram->SetBinContent(iBin, binContent/binWidth); histogram->SetBinError(iBin, binError/binWidth); } }
void dumpHistogram(TH1* histogram) { std::cout << "<dumpHistogram>:" << std::endl; std::cout << " histogram: name = " << histogram->GetName() << ", title = " << histogram->GetTitle() << std::endl; std::cout << " fillColor = " << histogram->GetFillColor() << ", fillStyle = " << histogram->GetFillStyle() << "," << " lineColor = " << histogram->GetLineColor() << ", lineStyle = " << histogram->GetLineStyle() << ", lineWidth = " << histogram->GetLineWidth() << "," << " markerColor = " << histogram->GetMarkerColor() << ", markerStyle = " << histogram->GetMarkerStyle() << ", markerSize = " << histogram->GetMarkerSize() << std::endl; TAxis* xAxis = histogram->GetXaxis(); int numBins = xAxis->GetNbins(); for ( int iBin = 1; iBin <= numBins; ++iBin ) { std::cout << "bin #" << iBin << " (x = " << xAxis->GetBinCenter(iBin) << "): " << histogram->GetBinContent(iBin) << " +/- " << histogram->GetBinError(iBin) << std::endl; } std::cout << "integral = " << compIntegral(histogram, true, true) << std::endl; }
// Report cut flow findings to screen void DileptonAnalyzer::reportCutFlow( TFile & outputFile ) { // Store in a TProfile TProfile *cutFlow = new TProfile("cutFlow","Cut flow for final set of analysis cuts",20,0.5,20.5,-9.9e9,9.9e9); TAxis *cutFlowAxis = cutFlow->GetXaxis(); for ( unsigned int iCut = 0; iCut < cutNamesInOrder_.size(); iCut++ ) { cutFlow->Fill( iCut+1, cutFlowMap_[cutNamesInOrder_[iCut]]); cutFlowAxis->SetBinLabel( iCut+1, cutNamesInOrder_[iCut]); } outputFile.cd(); cutFlow->Write(); }
int getBin(TH1* theHist, double x) { // Find the bin number for the given x value if (!theHist) {return 0;} TAxis* xAxis = theHist->GetXaxis(); double xMin = xAxis->GetXmin(); double xMax = xAxis->GetXmax(); int nX = theHist->GetNbinsX(); double dx = (xMax - xMin)/(nX*1.0); int theBin = int(((x - xMin)/dx) + 0.5); return theBin; }
static bool CheckAxisCompatibility(const TAxis& a, const TAxis& b) { static const double delta_max = 0.001; static const double rel_delta_max = 0.01; if(a.GetNbins() != b.GetNbins()) return false; for(Int_t n = 1; n <= a.GetNbins(); ++n) { const double c_a = a.GetBinCenter(n); const double c_b = b.GetBinCenter(n); const double delta = c_a - c_b; if( ( c_a && std::abs(delta/c_a) > rel_delta_max ) || ( !c_a && std::abs(delta) > delta_max ) ) return false; } return true; }
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; }
void GetSlices(Double_t start, Double_t end, TH3D *source, TH2D **target) { TAxis *zAxis = source->GetZaxis(); Int_t startBin = zAxis->FindBin(start); Int_t endBin = zAxis->FindBin(end); Int_t it = 0; for(Int_t iBin = startBin; iBin < endBin; iBin += 10){ zAxis->SetRange(iBin, iBin + 9); //cout << iBin << endl; TString name = Form("yx%d", it); target[it++] = (TH2D*)source->Project3D(name); } source->GetZaxis()->UnZoom(); //zAxis->UnZoom(); }
void writeDataBackgroundHistosForModel(const std::map<TString,TGraph*>& m_bkgds, const std::vector<TH1D *>& vchans, TFile *allHistFile) { for (std::map<TString,TGraph*>::const_iterator it = m_bkgds.begin(); it != m_bkgds.end(); it++) { const TString& name = it->first; // determine binning from the signal histogram for this channel // - (sigh) have to find it first... // TString channame = name.Copy().Remove(0,strlen("Bckgrndtot_")); TH1D *sigh=(TH1D*)0; for (int ichan=0; ichan<NUMCHAN; ichan++) { sigh = vchans.at(ichan); if (strstr(sigh->GetName(),channame.Data())) break; } assert (sigh); // for variable binning - all histos must have the same binning per channel TAxis *xax = sigh->GetXaxis(); TVectorD xbins = TVectorD(sigh->GetNbinsX(),xax->GetXbins()->GetArray()); int lobin = xax->FindFixBin(sumwinmin); int hibin = xax->FindFixBin(sumwinmax)-1; int nbins = hibin-lobin+1; TVectorD xwindow = xbins.GetSub(lobin-1,hibin); printf("Booking TH1D(%s,%s,%d,xwindowarray)\n", name.Data(),name.Data(),nbins); TH1D *h = new TH1D(name.Data(),name.Data(),nbins,xwindow.GetMatrixArray()); for (int ibin=1; ibin <= nbins; ibin++) h->SetBinContent(ibin, it->second->Eval(h->GetBinCenter(ibin)) * h->GetBinWidth(ibin) ); allHistFile->WriteTObject(h); } } // writeDataBackgroundHistosForModel
//------------------------------------------------------------------------------ // ZeroOutOfRangeBins //------------------------------------------------------------------------------ void ZeroOutOfRangeBins(TH1* h, Double_t xmin, Double_t xmax) { UInt_t nbins = h->GetNbinsX(); TAxis* axis = (TAxis*)h->GetXaxis(); Int_t firstBin = (xmin != -999) ? axis->FindBin(xmin) : 1; Int_t lastBin = (xmax != 999) ? axis->FindBin(xmax) : nbins; for (UInt_t i=0; i<=nbins+1; i++) { if (i < firstBin || i > lastBin) { h->SetBinContent(i, 0); h->SetBinError (i, 0); } } }
//______________________________________________________________________________ void ROMETGraphErrors::SetLimits() { Double_t rwxmin,rwxmax, rwymin, rwymax, dx, dy; ComputeRange(rwxmin, rwymin, rwxmax, rwymax); if (rwxmin == rwxmax) rwxmax += 1.; if (rwymin == rwymax) rwymax += 1.; dx = 0.1 * (rwxmax - rwxmin); dy = 0.1 * (rwymax - rwymin); fMinimum = rwymin - dy; fMaximum = rwymax + dy; TAxis *axis = GetXaxis(); if(axis) { axis->SetLimits(rwxmin - dx, rwxmax + dx); } }
void findFilterEnergyLoss::BinLogY(TH2 *h) { TAxis *axis = h->GetYaxis(); int bins = axis->GetNbins(); Axis_t from = axis->GetXmin(); Axis_t to = axis->GetXmax(); Axis_t width = (to - from) / bins; Axis_t *new_bins = new Axis_t[bins+1]; for (int i=0; i <= bins; i++) { new_bins[i] = TMath::Power(10, from + i * width); } axis->Set(bins, new_bins); delete new_bins; }
void Bin2DTree::constrainSplit(int axis, double& cut, bool& veto) /*****************************************************************/ { if(m_gridConstraint && !m_vetoSplitXY[axis]) { TAxis* gridAxis = NULL; if(axis==0) { gridAxis = m_gridConstraint->GetXaxis(); } else { gridAxis = m_gridConstraint->GetYaxis(); } // Find the closest grid constraint for the cut // And modify the cut according to this constraint int b = gridAxis->FindBin(cut); double low = gridAxis->GetBinLowEdge(b); double up = gridAxis->GetBinUpEdge(b); if(fabs(up-cut)<fabs(cut-low)) { cut = up; // If the constrained cut is outside the bin boundaries, try the other grid constraint if(cut>=getBinBoundaries()[axis].second) { cut = low; } } else { cut = low; // If the constrained cut is outside the bin boundaries, try the other grid constraint if(cut<=getBinBoundaries()[axis].first) { cut = up; } } // If the constrained cut is still outside the bin boundaries, veto this bin and axis if(cut<=getBinBoundaries()[axis].first || cut>=getBinBoundaries()[axis].second) { m_vetoSplitXY[axis] = true; } } veto = m_vetoSplitXY[axis]; }
//________________________________________________________________ void KVCanvas::ZoomSelected(TH2* TheHisto) { if (!TheHisto) return; TAxis* ax = TheHisto->GetXaxis(); Double_t ratio1 = (xmin - GetUxmin()) / (GetUxmax() - GetUxmin()); Double_t ratio2 = (xmax - GetUxmin()) / (GetUxmax() - GetUxmin()); if ((ratio2 - ratio1 > 0.05)) ax->SetRangeUser(xmin, xmax); ax = TheHisto->GetYaxis(); ratio1 = (ymin - GetUymin()) / (GetUymax() - GetUymin()); ratio2 = (ymax - GetUymin()) / (GetUymax() - GetUymin()); if ((ratio2 - ratio1 > 0.05)) ax->SetRangeUser(ymin, ymax); xmax = xmin = ymax = ymin = 0.; return; }
//________________________________________________________________________ void CorrectFromTheWidth(TH1D *h1) { // // Correct from the width of the bins --> dN/dp_{T} (GeV/c)^{-1} // TAxis *axis = h1->GetXaxis(); Int_t nbinX = h1->GetNbinsX(); for(Int_t i = 1; i <= nbinX; i++) { Double_t width = axis->GetBinWidth(i); Double_t content = h1->GetBinContent(i); Double_t error = h1->GetBinError(i); h1->SetBinContent(i,content/width); h1->SetBinError(i,error/width); } }