/** 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);
}
}
