BCH2D Class Reference

A class for handling 2D distributions. More...

#include <BCH2D.h>

Public Member Functions
Constructors and destructors
	BCH2D (TH2D *h=0)
	~BCH2D ()
Member functions (get)
TH2D *	GetHistogram ()
int	GetColor (int index)
Member functions (set)
void	SetColorScheme (int scheme)
void	SetHistogram (TH2D *hist)
void	SetGlobalMode (double mode[2])
Member functions (miscellaneous methods)
void	Print (const char *filename, std::string options="BTfB3CS1meangmode", std::vector< double > intervals=std::vector< double >(0), int ww=0, int wh=0)
void	Print (const char *filename, std::string options, double interval, int ww=0, int wh=0)
void	Draw (std::string options="BTfB3CS1meangmodelmode", std::vector< double > intervals=std::vector< double >(0))
void	Draw (std::string options, double interval)
void	CalculateIntegratedHistogram ()
void	PrintIntegratedHistogram (const char *filename)
double	GetLevel (double p)
double	GetArea (double p)
std::vector< int >	GetNIntervalsY (TH2D *h, int &nfoundmax)
TGraph *	CalculateProfileGraph (int axis, std::string options="mode")
TGraph *	DrawProfile (int axis, std::string options, std::string drawoptions="blacksolid")
TGraph *	DrawProfileX (std::string options, std::string drawoptions)
TGraph *	DrawProfileY (std::string options, std::string drawoptions)

Static Private Member Functions
static unsigned int	getNextIndex ()

Private Attributes
TH2D *	fHistogram
TH1D *	fIntegratedHistogram
double	fMode [2]
int	fModeFlag
std::vector< int >	fColors
std::vector< TObject * >	fROOTObjects

Static Private Attributes
static unsigned int	fHCounter =0

Detailed Description

A class for handling 2D distributions.

Author

Daniel Kollar

Kevin Kröninger

Version

1.0

Date

08.2008 This class contains a TH2D histogram and some additional functions. It is used for marginalized distributions.

Definition at line 37 of file BCH2D.h.

Constructor & Destructor Documentation

BCH2D::BCH2D

(

TH2D *

h = 0)

The complete constructor.

Definition at line 36 of file BCH2D.cxx.

   : fHistogram(0)
   , fIntegratedHistogram(0)
   , fModeFlag(0)
{
   if (h)
      SetHistogram(h);
}

BCH2D::~BCH2D

(

)

The default destructor.

Definition at line 46 of file BCH2D.cxx.

{
   if (fIntegratedHistogram)
      delete fIntegratedHistogram;

   for (unsigned i = 0; i < fROOTObjects.size(); ++i)
      delete fROOTObjects[i];
}

Member Function Documentation

void BCH2D::CalculateIntegratedHistogram

(

)

Calculates the integral of the distribution as a function of the height.

Definition at line 564 of file BCH2D.cxx.

{
   int nz = 100;

   double zmin = fHistogram->GetMinimum();
   double zmax = fHistogram->GetMaximum();
   double dz   = (zmax-zmin);

   double nx = fHistogram->GetNbinsX();
   double ny = fHistogram->GetNbinsY();

   // create histogram
   if (fIntegratedHistogram)
      delete fIntegratedHistogram;

   fIntegratedHistogram = new TH1D(
      TString::Format("%s_int_prob_%d",fHistogram->GetName(),BCLog::GetHIndex()), "", nz, zmin, zmax+0.05*dz);
   fIntegratedHistogram->SetXTitle("z");
   fIntegratedHistogram->SetYTitle("Integrated probability");
   fIntegratedHistogram->SetStats(kFALSE);

   // loop over histogram
   for (int ix = 1; ix <= nx; ix++) {
      for (int iy = 1; iy <= ny; iy++) {
         double p = fHistogram->GetBinContent(ix, iy);
         fIntegratedHistogram->Fill(p, p);
      }
   }

   // normalize histogram
   fIntegratedHistogram->Scale(1.0/fIntegratedHistogram->GetEntries());

}

TGraph * BCH2D::CalculateProfileGraph	(	int	axis,
		std::string	options = "mode"
	)

Return a graph of the profile along x or y. The profile is calculated by scanning through the one axis, e.g., y, and finding the mode, mean, median, etc. with respect to the other axis, e.g. x.

Parameters

axis	x-axis (0) or y-axis (1)
options	Options: mode : calculate the profile using the mode [default] mean : calculate the profile using the mean median : calculate the profile using the median

Definition at line 691 of file BCH2D.cxx.

{
  // option flags
  bool flag_mode = true;
  bool flag_mean = false;
  bool flag_median = false;

  // check content of options string
  if (options.find("mode") < options.size()) {
    flag_mode = true;
  }

  if (options.find("mean") < options.size()) {
    flag_mean = true;
    flag_mode = false;
    flag_median = false;
  }

  if (options.find("median") < options.size()) {
    flag_median = true;
    flag_mode = false;
    flag_mean = false;
  }

  // define profile graph
  TGraph* graph_profile = new TGraph();

  // define limits of running
  int nx = fHistogram->GetNbinsX();
  int ny = fHistogram->GetNbinsY();

  double xmin = fHistogram->GetXaxis()->GetBinLowEdge(1);
  double xmax = fHistogram->GetXaxis()->GetBinLowEdge(nx+1);

  double ymin = fHistogram->GetYaxis()->GetBinLowEdge(1);
  double ymax = fHistogram->GetYaxis()->GetBinLowEdge(nx+1);

  int nbins_outer = 0;
  int nbins_inner = 0;
  double axis_min = 0;
  double axis_max = 0;

  if (axis==0) {
    nbins_outer = nx;
    nbins_inner = ny;
    axis_min = ymin;
    axis_max = ymax;
  }
  else {
    nbins_outer = ny;
    nbins_inner = nx;
    axis_min = xmin;
    axis_max = xmax;
  }

  // loop over outer axis of choice
  for (int ibin_outer = 1; ibin_outer <= nbins_outer ; ibin_outer++) {

     // copy slice at a fixed value into a 1D histogram
     TH1D* hist_temp = new TH1D("", "", nbins_inner, axis_min, axis_max);

     for (int ibin_inner = 1; ibin_inner <= nbins_inner; ibin_inner++) {
        int ix = 0;
        int iy = 0;
        if (axis == 0) {
           ix = ibin_outer;
           iy = ibin_inner;
        }
        else {
           ix = ibin_inner;
           iy = ibin_outer;
        }
        double content = fHistogram->GetBinContent(ix, iy);
        hist_temp->SetBinContent(ibin_inner, content);
     }
     // normalize to unity
     hist_temp->Scale(1.0/hist_temp->Integral());

     // create BAT histogram
     BCH1D* bchist_temp = new BCH1D(hist_temp);

     // calculate (x,y) of new point
     double x = fHistogram->GetXaxis()->GetBinCenter(ibin_outer);
     double y = fHistogram->GetYaxis()->GetBinCenter(ibin_outer);

     double temp = 0;

     if (flag_mode)
        temp = bchist_temp->GetMode();
     else if (flag_mean)
        temp = bchist_temp->GetMean();
     else if (flag_median)
        temp = bchist_temp->GetMedian();

     if (axis == 0)
        y = temp;
     else
        x = temp;

     // add new point to graph
     graph_profile->SetPoint(ibin_outer-1, x, y);

     // clean up
     delete bchist_temp;
  }

  // return the graph
  return graph_profile;
}

void BCH2D::Draw	(	std::string	options = "BTfB3CS1meangmodelmode",
		std::vector< double >	intervals = std::vector<double>(0)
	)

Draw distribution into the active canvas.

Parameters

options

Drawing options: BTf : band type a filled area [default] BTc : band type is a contour B1 : draw one band corresponding to an integrated probability specified in intervals B2 : draw two bands corresponding to an integrated probability specified in intervals B3 : draw three bands corresponding to an integrated probability specified in intervals [default] CS0 : choose color scheme 0 (B&W) CS1 : choose color scheme 1 (green/yellow/red) [default] CS2 : choose color scheme 2 (blueish colors) CS3 : choose color scheme 3 (redish colors) smooth1 : use ROOT smoothing algorithm once smooth3 : use ROOT smoothing algorithm three times smooth5 : use ROOT smoothing algorithm five times smooth10 : use ROOT smoothing algorithm ten times mean : draw mean value and standard deviation [default] gmode : draw global mode [default] lmode : draw global mode [default] profilex : draw the profile line vs. x using the mode profiley : draw the profile line vs. y using the mode nL : remove legend

intervals

the intervals for the bands

Definition at line 171 of file BCH2D.cxx.

{
   // option flags
   bool flag_legend      = true;
   bool flag_mode_global = false;
   bool flag_mode_local  = false;
   bool flag_mean        = false;
   bool flag_smooth1     = false;
   bool flag_smooth3     = false;
   bool flag_smooth5     = false;
   bool flag_smooth10    = false;
   bool flag_profilex    = false;
   bool flag_profiley    = false;

   // band type
   int bandtype = 0;

   // number of bands
   int nbands = 1; // number of shaded bands
   intervals.push_back(0.6827);

   // define draw options called in TH1D::Draw(...)
   std::string draw_options = "COLZ";

   // check content of options string
   if (options.find("smooth1") < options.size()) {
      flag_smooth1 = true;
   }

   if (options.find("smooth3") < options.size()) {
      flag_smooth3 = true;
   }

   if (options.find("smooth5") < options.size()) {
      flag_smooth5 = true;
   }

   if (options.find("smooth10") < options.size()) {
      flag_smooth10 = true;
   }

   if (options.find("nL") < options.size()) {
      flag_legend = false;
   }

   if (options.find("BTf") < options.size()) {
      bandtype = 0;
   }
   else if (options.find("BTc") < options.size()) {
      bandtype = 1;
   }
   else {
      bandtype = 0;
   }

   if (options.find("profilex") < options.size()) {
      flag_profilex = true;
   }

   if (options.find("profiley") < options.size()) {
      flag_profiley = true;
   }

   if (options.find("gmode") < options.size()) {
      if (fModeFlag)
         flag_mode_global = true;
   }

   if (options.find("lmode") < options.size()) {
      flag_mode_local = true;
   }

   if (options.find("mean") < options.size()) {
      flag_mean = true;
   }

   if (options.find("B1") < options.size()) {
      nbands = 1;
      if (intervals.size() != 1) {
         intervals.clear();
         intervals.push_back(0.6827);
      }
   }

   if (options.find("B2") < options.size()) {
      nbands = 2;
      if (intervals.size() != 2) {
         intervals.clear();
         intervals.push_back(0.6827);
         intervals.push_back(0.9545);
      }
   }

   if (options.find("B3") < options.size()) {
      nbands = 3;
      if (intervals.size() != 3) {
         intervals.clear();
         intervals.push_back(0.6827);
         intervals.push_back(0.9545);
         intervals.push_back(0.9973);
      }
   }

   if (options.find("CS0") < options.size()) {
      SetColorScheme(0);
   }
   else if (options.find("CS1") < options.size()) {
      SetColorScheme(1);
   }
   else if (options.find("CS2") < options.size()) {
      SetColorScheme(2);
   }
   else if (options.find("CS3") < options.size()) {
      SetColorScheme(3);
   }
   else  {
      SetColorScheme(1);
   }

   // prepare size of histogram
   double xmin     = fHistogram->GetXaxis()->GetXmin();
   double xmax     = fHistogram->GetXaxis()->GetXmax();
   double ymin     = fHistogram->GetYaxis()->GetXmin();
   double ymaxhist = fHistogram->GetYaxis()->GetXmax();
   double ymax     = ymaxhist;

   // prepare legend
   TLegend* legend = new TLegend();
   legend->SetBorderSize(0);
   legend->SetFillColor(kWhite);
   legend->SetTextAlign(12);
   legend->SetTextFont(62);
   legend->SetTextSize(0.03);

   // add legend to list of objects
   fROOTObjects.push_back(legend);

   // copy histograms for bands
   TH2D* hist_band = new TH2D(*fHistogram);

   // add hist_band to list of ROOT objects
   fROOTObjects.push_back(hist_band);

   // calculate integrated histogram
   CalculateIntegratedHistogram();

   for (int ix = 1; ix <= fHistogram->GetNbinsX(); ++ix) {
      for (int iy = 1; iy <= fHistogram->GetNbinsY(); ++iy) {
         double p = fHistogram->GetBinContent(ix, iy);
         hist_band->SetBinContent(ix, iy, p);
      }
   }

   // define levels and colors
   std::vector<double> levels(nbands+2);
   levels[0] = 0.;

   std::vector<int> colors(nbands+1);
   colors[0] = kWhite;

   for (int i = 1; i <= nbands; ++i) {
      levels[i] = GetLevel((1.-intervals[nbands-i]));
      colors[i] = GetColor(nbands-i);
   }
   levels[nbands+1] = fIntegratedHistogram->GetXaxis()->GetXmax();

   // set contour
   hist_band->SetContour(nbands+2, &levels[0]);

   // set colors
   gStyle->SetPalette(nbands+1, &colors[0]);

   // add hist_band to legend
   for (int i = 0; i < nbands; ++i) {
      if (bandtype == 0) {
         TLegendEntry* le = legend->AddEntry((TObject*)0, Form("smallest %.1f%% interval(s)", intervals[nbands-1-i]*100), "F");
         le->SetFillColor(GetColor(nbands-1-i));
         le->SetFillStyle(1001);
         le->SetLineColor(GetColor(nbands-1-i));
         le->SetTextAlign(12);
         le->SetTextFont(62);
         le->SetTextSize(0.03);
      }
      else if (bandtype == 1) {
         TLegendEntry* le = legend->AddEntry((TObject*)0, Form("smallest %.1f%% interval(s)", intervals[nbands-1-i]*100), "F");
         fROOTObjects.push_back(le);
         le->SetLineColor(GetColor(nbands-1-i));
         le->SetTextAlign(12);
         le->SetTextFont(62);
         le->SetTextSize(0.03);
      }
   }

   // mean, mode, median
   TMarker* marker_mode_global = new TMarker(fMode[0], fMode[1], 24);
   marker_mode_global->SetMarkerColor(GetColor(4));
   marker_mode_global->SetMarkerSize(1.5);

   int binx, biny, binz;
   fHistogram->GetBinXYZ( fHistogram->GetMaximumBin(), binx, biny, binz);
   TMarker* marker_mode_local = new TMarker(fHistogram->GetXaxis()->GetBinCenter(binx), fHistogram->GetYaxis()->GetBinCenter(biny), 25);
   marker_mode_local->SetMarkerColor(GetColor(4));
   marker_mode_local->SetMarkerSize(1.5);

   double xmean = fHistogram->GetMean(1);
   double ymean = fHistogram->GetMean(2);
   double xrms = fHistogram->GetRMS(1);
   double yrms = fHistogram->GetRMS(2);

   TMarker* marker_mean = new TMarker(xmean, ymean, 32);
   marker_mean->SetMarkerColor(GetColor(4));
   marker_mean->SetMarkerSize(1.5);

   // standard deviation
   TArrow* arrow_std1 = new TArrow(xmean-xrms, ymean,
                                   xmean+xrms, ymean,
                                   0.02, "<|>");
   arrow_std1->SetLineColor(GetColor(4));
   arrow_std1->SetFillColor(GetColor(4));

   TArrow* arrow_std2 = new TArrow(xmean, ymean-yrms,
                                   xmean, ymean+yrms,
                                   0.02, "<|>");
   arrow_std2->SetLineColor(GetColor(4));
   arrow_std2->SetFillColor(GetColor(4));

   // add marker_mean and arrow_std to list of ROOT objects
   fROOTObjects.push_back(marker_mean);
   fROOTObjects.push_back(marker_mode_global);
   fROOTObjects.push_back(marker_mode_local);
   fROOTObjects.push_back(arrow_std1);
   fROOTObjects.push_back(arrow_std2);

   if (flag_mode_global) {
      TLegendEntry* le = legend->AddEntry(marker_mode_global, "global mode", "P");
      le->SetMarkerStyle(24);
      le->SetMarkerSize(1.5);
      le->SetMarkerColor(GetColor(4));
   }

   if (flag_mode_local) {
      TLegendEntry* le = legend->AddEntry(marker_mode_local, "local mode", "P");
      le->SetMarkerStyle(25);
      le->SetMarkerSize(1.5);
      le->SetMarkerColor(GetColor(4));
   }

   if (flag_mean) {
      TLegendEntry* le = legend->AddEntry(arrow_std1, "mean and standard deviation", "PL");
      le->SetLineColor(GetColor(4));
      le->SetMarkerStyle(32);
      le->SetMarkerSize(1.5);
      le->SetMarkerColor(GetColor(4));
   }

   TGraph* graph_profilex = 0;
   TGraph* graph_profiley = 0;

   if (flag_profilex) {
      TLegendEntry* le = legend->AddEntry(graph_profilex, "profile x", "L");
      le->SetLineStyle(2);
   }

   if (flag_profiley) {
      TLegendEntry* le = legend->AddEntry(graph_profiley, "profile y", "L");
      le->SetLineStyle(3);
   }

   // calculate legend height in NDC coordinates
   double height = 0.03*legend->GetNRows();

   // make room for legend
   if (flag_legend)
      ymax+=(ymax-ymin)*(0.1+height);

   double deltax = 0.0015*(xmax - xmin);
   double deltay = 0.0015*(ymaxhist - ymin);
   TH2D* hist_axes = new TH2D("", "", 1, xmin-deltax, xmax+deltax, 1, ymin-deltay, ymaxhist+deltay);
   hist_axes->SetXTitle(fHistogram->GetXaxis()->GetTitle());
   hist_axes->SetYTitle(fHistogram->GetYaxis()->GetTitle());
   hist_axes->SetLineWidth(fHistogram->GetLineWidth());
   hist_axes->SetStats(kFALSE);
   fROOTObjects.push_back(hist_axes);

   // draw axes
   hist_axes->Draw("COL");

   // smooth
   if (flag_smooth1) {
      fHistogram->Smooth(1);
      fHistogram->Scale(1.0/fHistogram->Integral("width"));
   }
   if (flag_smooth3) {
      fHistogram->Smooth(3);
      fHistogram->Scale(1.0/fHistogram->Integral("width"));
   }
   if (flag_smooth5) {
      fHistogram->Smooth(5);
      fHistogram->Scale(1.0/fHistogram->Integral("width"));
   }
   if (flag_smooth10) {
      fHistogram->Smooth(10);
      fHistogram->Scale(1.0/fHistogram->Integral("width"));
   }

   // draw histogram
   if (bandtype == 0)
      hist_band->Draw("COL SAME");
   else if (bandtype == 1)
      hist_band->Draw("CONT1 SAME");

   // draw profiles
   if (flag_profilex) {
      graph_profilex = DrawProfileX("mode", "dashed");

      // add graph to list of objects
      fROOTObjects.push_back(graph_profilex);
   }

   if (flag_profiley) {
      graph_profiley = DrawProfileY("mode", "dotted");

      // add graph to list of objects
      fROOTObjects.push_back(graph_profiley);
   }

   // mean, mode, median
   if (flag_mode_global) {
      marker_mode_global->Draw();
   }

   if (flag_mode_local) {
      marker_mode_local->Draw();
   }

   if (flag_mean) {
      arrow_std1->Draw();
      arrow_std2->Draw();
      marker_mean->Draw();
   }

   if (flag_legend)
      gPad->SetTopMargin(0.02);

   double xlegend1 = gPad->GetLeftMargin();
   double xlegend2 = 1.0-gPad->GetRightMargin();
   double ylegend1 = 1.-gPad->GetTopMargin()-height;
   double ylegend2 = 1.-gPad->GetTopMargin();

   // place legend on top of histogram
   legend->SetX1NDC(xlegend1);
   legend->SetX2NDC(xlegend2);
   legend->SetY1NDC(ylegend1);
   legend->SetY2NDC(ylegend2);

   // draw legend
   if (flag_legend) {
      legend->Draw();
   }

   // draw axes again
   hist_axes->Draw("SAME");

   // rescale
   gPad->SetTopMargin(1.-ylegend1+0.01);

   gPad->RedrawAxis();

   return;
}

void BCH2D::Draw	(	std::string	options,
		double	interval
	)

Draw distribution into the active canvas.

Parameters

options

Drawing options,

See Also

Draw(std::string options="BTfB3CS1meangmodelmode", std::vector<double> intervals=std::vector<double>(0))

Parameters

interval

an upper or lower limit

See Also

Draw(std::string options="BTfB3CS1meangmodelmode", std::vector<double> intervals=std::vector<double>(0))

Definition at line 543 of file BCH2D.cxx.

{
   std::vector<double> tempvec;
   tempvec.push_back(interval);
   Draw(options, tempvec);
}

TGraph * BCH2D::DrawProfile	(	int	axis,
		std::string	options,
		std::string	drawoptions = "blacksolid"
	)

Draw the profile along x or y

Parameters

options	The options of the calculation of the profile
drawoptions	The drawing options: black : line color is black [default] red : line color is red solid : line is solid [default] dashed : line is dashed dotted : line is dotted

Returns

The profile graph

Definition at line 802 of file BCH2D.cxx.

{
  // option flags
  bool flag_black = false;
  bool flag_red = false;
  bool flag_solid = false;
  bool flag_dashed = false;
  bool flag_dotted = false;

  // check content of options string
  if (drawoptions.find("black") < options.size()) {
    flag_black = true;
  }

  else if (drawoptions.find("red") < options.size()) {
    flag_red = true;
  }

  else {
    flag_black = true;
  }

  if (drawoptions.find("solid") < options.size()) {
    flag_solid = true;
  }

  else if (drawoptions.find("dashed") < options.size()) {
    flag_dashed = true;
  }

  else if (drawoptions.find("dotted") < options.size()) {
    flag_dotted = true;
  }

  else {
    flag_solid = true;
  }

  // get the profile graph
  TGraph* graph_profile = CalculateProfileGraph(axis, options);

  // change drawing options
  if (flag_black)
    graph_profile->SetLineColor(kBlack);

  if (flag_red)
    graph_profile->SetLineColor(kRed);

  if (flag_solid)
    graph_profile->SetLineStyle(1);

  if (flag_dashed)
    graph_profile->SetLineStyle(2);

  if (flag_dotted)
    graph_profile->SetLineStyle(3);

  // draw
  graph_profile->Draw("L");

  // return graph
  return graph_profile;
}

TGraph* BCH2D::DrawProfileX ( std::string  options, std::string  drawoptions  )

inline

Draw the profile along x

Parameters

options	The options defined in DrawProfile
drawoptions	The drawoptions defined DrawProfile

Returns

The profile graph

Definition at line 218 of file BCH2D.h.

   { return DrawProfile(0, options, drawoptions); };

TGraph* BCH2D::DrawProfileY ( std::string  options, std::string  drawoptions  )

inline

Draw the profile along y

Parameters

options	The options defined in DrawProfile
drawoptions	The drawoptions defined DrawProfile

Returns

The profile graph

Definition at line 226 of file BCH2D.h.

   { return DrawProfile(1, options, drawoptions); };

double BCH2D::GetArea

(

double

p)

Calculate the smallest area over which the integral of the function is p

Parameters

p	The integrated probability in the region below the height to be estimated.

Definition at line 611 of file BCH2D.cxx.

{
   // copy histograms for bands
   TH2D hist_temp(*fHistogram);

   // calculate total number of bins
   int nbins = hist_temp.GetNbinsX() * hist_temp.GetNbinsY();

   // area
   double area = 0;

   // integrated probability
   double intp = 0;

   // a counter
   int counter = 0;

   // loop over bins
   while ( (intp < p) && (counter < nbins) ) {

      // find maximum bin
      int binx;
      int biny;
      int binz;
      hist_temp.GetBinXYZ(hist_temp.GetMaximumBin(), binx, biny, binz);

      // increase probability
      double dp = hist_temp.GetBinContent(binx, biny);
      intp += dp * hist_temp.GetXaxis()->GetBinWidth(binx) * hist_temp.GetYaxis()->GetBinWidth(biny);

      // reset maximum bin
      hist_temp.SetBinContent(binx, biny, 0.);

      // increase area
      area += hist_temp.GetXaxis()->GetBinWidth(binx) * hist_temp.GetYaxis()->GetBinWidth(biny);

      // increase counter
      counter++;
   }

   // return area
   return area;
}

int BCH2D::GetColor ( int  index)

inline

Returns a color of the current color scheme.

Parameters

index

the color index

Returns

the color number.

Definition at line 67 of file BCH2D.h.

   { return fColors.at(index); };

TH2D* BCH2D::GetHistogram ( )

inline

Return the TH2D histogram

Returns

The TH2D histogram.

Definition at line 60 of file BCH2D.h.

   { return fHistogram; };

double BCH2D::GetLevel

(

double

p)

Calculates the height below which the integrated probability has a certain value.

Parameters

p	The integrated probability in the region below the height to be estimated.

Definition at line 599 of file BCH2D.cxx.

{
   double quantiles[1];
   double probsum[1];
   probsum[0] = p;

   fIntegratedHistogram->GetQuantiles( 1, quantiles, probsum);

   return quantiles[0];
}

static unsigned int BCH2D::getNextIndex ( )

inlinestaticprivate

Helper method to get an unique number to be used in histogram naming

Definition at line 258 of file BCH2D.h.

   { return ++fHCounter; }

std::vector< int > BCH2D::GetNIntervalsY	(	TH2D *	h,
		int &	nfoundmax
	)

Returns the number of intervals as a function of x

Parameters

h	The histogram.
nfoundmax	The maximum number of intervals.

Returns

A vector containing the number of intervals for all bins in x.

Definition at line 656 of file BCH2D.cxx.

{
   std::vector<int> nint;

   int nx = h->GetNbinsX();
   int ny = h->GetNbinsY();

   nfoundmax=0;

   // loop over histogram bins in x
   for (int ix=1; ix<=nx; ix++)
   {
      int nfound=0;

      // loop over histogram bins in y
      // count nonzero intervals in y
      for (int iy=1; iy<=ny; iy++)
         if(h->GetBinContent(ix,iy)>0.)
         {
            while(h->GetBinContent(ix,++iy)>0.)
               ;
            nfound++;
         }

      // store maximum number of nonzero intervals for the histogram
      if(nfound>nfoundmax)
         nfoundmax=nfound;

      nint.push_back(nfound);
   }

   return nint;
}

void BCH2D::Print	(	const char *	filename,
		std::string	options = "BTfB3CS1meangmode",
		std::vector< double >	intervals = std::vector<double>(0),
		int	ww = 0,
		int	wh = 0
	)

Print distribution into a PostScript file.

Parameters

filename	Output filename
option	the draw options (see myDraw()) plus
intervals	the intervals for the bands logz : draw z-axis in log-scale R : rescale canvas to have a squared histogram
ww	canvas size in pixels along X
ww	canvas size in pixels along Y If ww and wh are set to 0, default ROOT canvas size is used.

Definition at line 107 of file BCH2D.cxx.

{
   // option flags
   bool flag_logz = false;
   bool flag_rescale = false;

   // check content of options string
   if (options.find("logz") < options.size()) {
      flag_logz = true;
   }

   if (options.find("R") < options.size()) {
      flag_rescale = true;
   }

   // create temporary canvas
   TCanvas * c;
   unsigned int cindex = getNextIndex();
   if(ww > 0 && wh > 0)
      c = new TCanvas(TString::Format("c_bch2d_%d",cindex), TString::Format("c_bch2d_%d",cindex), ww, wh);
   else
      c = new TCanvas(TString::Format("c_bch2d_%d",cindex));

   // add c to list of objects
   fROOTObjects.push_back(c);

   // set log axis
   if (flag_logz) {
      c->SetLogz();
   }

   // draw histogram
   Draw(options, intervals);

   if (flag_rescale) {
      double top = gPad->GetTopMargin();
      double bottom = gPad->GetBottomMargin();
      double left = gPad->GetLeftMargin();
      double right = gPad->GetRightMargin();

      double dx = 1.-right - left;
      double dy = 1.-top-bottom;
      double ratio = dy/dx;
      double ynew = c->GetWindowWidth()/ratio;
      c->SetCanvasSize(c->GetWindowWidth(), (int) ynew);
      gPad->RedrawAxis();

      c->Modified();
      c->Update();
   }

   // print to file
   c->Print(filename);
}

void BCH2D::Print	(	const char *	filename,
		std::string	options,
		double	interval,
		int	ww = 0,
		int	wh = 0
	)

Print distribution into a PostScript file.

Parameters

filename	Output filename
option	the draw options,

See Also

Print(const char* filename, std::string options="BTfB3CS1meangmode", std::vector<double> intervals=std::vector<double>(0), int ww=0, int wh=0)

Parameters

interval	an upper or lower limit
ww	canvas size in pixels along X
ww	canvas size in pixels along Y

See Also

Print(const char* filename, std::string options="BTfB3CS1meangmode", std::vector<double> intervals=std::vector<double>(0), int ww=0, int wh=0)

Definition at line 163 of file BCH2D.cxx.

{
   std::vector<double> tempvec;
   tempvec.push_back(interval);
   Print(filename, options, tempvec, ww, wh);
}

void BCH2D::PrintIntegratedHistogram

(

const char *

filename)

Print the integrated histogram.

Parameters

filename

the name of the file.

Definition at line 551 of file BCH2D.cxx.

{
   TCanvas c;
   c.Flush();

   c.cd();
   c.SetLogy();
   CalculateIntegratedHistogram();
   fIntegratedHistogram->Draw();
   c.Print(filename);
}

void BCH2D::SetColorScheme

(

int

scheme)

Sets the color scheme.

Parameters

scheme

the scheme index 0 : black and white 1 : yellow-green-red 2 : blueish colors 2 : redish colors 2 : blueish colors

Definition at line 56 of file BCH2D.cxx.

{
   fColors.clear();

   // color numbering
   // 0,1,2 : intervals
   // 3 : quantile lines
   // 4 : mean, mode, median

   if (scheme == 0) {
      fColors.push_back(18);
      fColors.push_back(16);
      fColors.push_back(14);
      fColors.push_back(kBlack);
      fColors.push_back(kBlack);
   }
   else if (scheme == 1) {
      fColors.push_back(kGreen);
      fColors.push_back(kYellow);
      fColors.push_back(kRed);
      fColors.push_back(kBlack);
      fColors.push_back(kBlack);
   }
   else if (scheme == 2) {
      fColors.push_back(kBlue+4);
      fColors.push_back(kBlue+2);
      fColors.push_back(kBlue);
      fColors.push_back(kOrange);
      fColors.push_back(kOrange);
   }
   else if (scheme == 3) {
      fColors.push_back(kRed+4);
      fColors.push_back(kRed+2);
      fColors.push_back(kRed);
      fColors.push_back(kGreen);
      fColors.push_back(kGreen);
   }
   else {
      SetColorScheme(1);
   }
}

void BCH2D::SetGlobalMode ( double  mode[2])

inline

Set global mode.

Parameters

The	global mode.

Definition at line 92 of file BCH2D.h.

   { fMode[0] = mode[0];
     fMode[1] = mode[1];
     fModeFlag =1; };

void BCH2D::SetHistogram

(

TH2D *

hist)

Set the 2D histogram.

Definition at line 99 of file BCH2D.cxx.

{
   fHistogram = hist;
   if (fHistogram and fHistogram->Integral() > 0)
      fHistogram->Scale(1.0/fHistogram->Integral("width"));
}

Member Data Documentation

std::vector<int> BCH2D::fColors

private

The colors of the color scheme.

Definition at line 251 of file BCH2D.h.

unsigned int BCH2D::fHCounter =0

staticprivate

helper variable to get an unique number to be used in histogram naming

Definition at line 262 of file BCH2D.h.

TH2D* BCH2D::fHistogram

private

The 2D histogram

Definition at line 227 of file BCH2D.h.

TH1D* BCH2D::fIntegratedHistogram

private

The integrated 2D histogram

Definition at line 239 of file BCH2D.h.

double BCH2D::fMode[2]

private

Global mode

Definition at line 243 of file BCH2D.h.

int BCH2D::fModeFlag

private

"Is there a global mode?" flag

Definition at line 247 of file BCH2D.h.

std::vector<TObject*> BCH2D::fROOTObjects

private

The colors of the color scheme.

Definition at line 255 of file BCH2D.h.

---

The documentation for this class was generated from the following files:

• BCH2D.h
• BCH2D.cxx