ROOT logo
#include "AliPoissonCalculator.h"
// #include "AliForwardCorrectionManager.h"
#include <TH2D.h>
#include <TBrowser.h>
#include <TROOT.h>
#include <TMath.h>
#include <TList.h>
#include <iostream>
#include <TAxis.h>

// 
// A class to calculate the multiplicity in @f$(x,y)@f$ bins
// using Poisson statistics. 
//
// The input is assumed to be binned in @f$(x,y)@f$ as described by
// the 2D histogram passed to the Reset member function.
//
// The data is grouped in to regions as defined by the parameters
// fXLumping and fYLumping.  The total number of cells and number of
// empty cells is then calculate in each region.  The mean
// multiplicity over the region is then determined as
//
// @f[
// \lange m\rangle = -\log\left(\frac{e}{t}\right)
// @f]
// where @f$ e@f$ is the number of empty cells and @f$t@f$ is the
// total number of cells in the region.  A correction for counting
// statistics, is then applied 
// @f{eqnarray*}
//    c &=& \frac{1}{1 - \exp{-\lange m\rangle}}
//      &=& \frac{1}{1 - \frac{e}{t}}
// @f{eqnarray*}
// and the final number in each cell is then 
// @f[
//   h_i c \lange m\rangle 
// @f] 
// where @f$h_i@f$ is the number of hits in the cell @f$i@f$ 
// 
//

namespace {
  const char* kBasicN = "basic";
  const char* kEmptyN = "empty";
  const char* kTotalN = "total";
  const char* kBasicT = "Basic number of hits";
  const char* kEmptyT = "Empty number of bins/region";
  const char* kTotalT = "Total number of bins/region";
}




//____________________________________________________________________
AliPoissonCalculator::AliPoissonCalculator()
  : TNamed(),
    fXLumping(32), 
    fYLumping(4), 
    fTotal(0), 
    fEmpty(0), 
    fBasic(0),
    fEmptyVsTotal(0),
    fMean(0), 
    fOcc(0),
    fCorr(0)
{
  //
  // CTOR
  // 
}

//____________________________________________________________________
AliPoissonCalculator::AliPoissonCalculator(const char*)
  : TNamed("poissonCalculator", "Calculate N_ch using Poisson stat"),
    fXLumping(32), 
    fYLumping(4), 
    fTotal(0), 
    fEmpty(0), 
    fBasic(0),
    fEmptyVsTotal(0),
    fMean(0), 
    fOcc(0),
    fCorr(0)
{
  //
  // CTOR
  //
}
//____________________________________________________________________
AliPoissonCalculator::AliPoissonCalculator(const AliPoissonCalculator& o)
  : TNamed(o),
    fXLumping(o.fXLumping),
    fYLumping(o.fYLumping),
    fTotal(0), 
    fEmpty(0),
    fBasic(0), 
    fEmptyVsTotal(0),
    fMean(0), 
    fOcc(0),
    fCorr(0)
{
  Init();
  Reset(o.fBasic);
}

//____________________________________________________________________
AliPoissonCalculator::~AliPoissonCalculator()
{
  // CleanUp();
}

//____________________________________________________________________
void
AliPoissonCalculator::CleanUp()
{
  if (fTotal)        { delete fTotal;        fTotal        = 0; }
  if (fEmpty)        { delete fEmpty;        fEmpty        = 0; }
  if (fBasic)        { delete fBasic;        fBasic        = 0; }
  if (fEmptyVsTotal) { delete fEmptyVsTotal; fEmptyVsTotal = 0; }
  if (fMean)         { delete fMean;         fMean         = 0; }
  if (fOcc)          { delete fOcc;          fOcc          = 0; } 
  if (fCorr)         { delete fCorr;         fCorr         = 0; }
}
//____________________________________________________________________
AliPoissonCalculator&
AliPoissonCalculator::operator=(const AliPoissonCalculator& o)
{
  if (&o == this) return *this;
  TNamed::operator=(o);
  fXLumping = o.fXLumping;
  fYLumping = o.fYLumping;
  CleanUp();
  Init();
  Reset(o.fBasic);
  return *this;
}

//____________________________________________________________________
void
AliPoissonCalculator::Init(Int_t xLumping, Int_t yLumping)
{
  // 
  // Initialize 
  // 
  if (xLumping > 0) fXLumping = xLumping;
  if (yLumping > 0) fYLumping = yLumping;

  //Create diagnostics if void
  if (fEmptyVsTotal) return;
  
  MakeOutput();  
}
//____________________________________________________________________
void
AliPoissonCalculator::Define(const TAxis& xaxis, const TAxis& yaxis)
{
  // 
  // Initialize 
  // 
  const Double_t* xBins = xaxis.GetXbins()->GetArray();
  const Double_t* yBins = yaxis.GetXbins()->GetArray();
  Int_t           nX    = xaxis.GetNbins();
  Int_t           nY    = yaxis.GetNbins();
  Double_t        lX    = xaxis.GetXmin();
  Double_t        hX    = xaxis.GetXmax();
  Double_t        lY    = yaxis.GetXmin();
  Double_t        hY    = yaxis.GetXmax();
  
  if (xBins) { 
    if (yBins) fBasic = new TH2D(kBasicN, kBasicT, nX, xBins, nY, yBins);
    else       fBasic = new TH2D(kBasicN, kBasicT, nX, xBins, nY, lY, hY);
  }
  else { 
    if (yBins) fBasic = new TH2D(kBasicN, kBasicT, nX, lX, hX, nY, yBins);
    else       fBasic = new TH2D(kBasicN, kBasicT, nX, lX, hX, nY, lY, hY);
  }
  fBasic->SetXTitle(xaxis.GetTitle());
  fBasic->SetYTitle(yaxis.GetTitle());

  Reset(fBasic);
}
//____________________________________________________________________
void AliPoissonCalculator::MakeOutput() 
{
  Int_t n = fXLumping * fYLumping + 1;
  fEmptyVsTotal = new TH2D("emptyVsTotal", 
			   "# of empty # bins vs total # bins", 
			   n, -.5, n-.5, n, -.5, n-.5);
  fEmptyVsTotal->SetXTitle("Total # bins");
  fEmptyVsTotal->SetYTitle("# empty bins");
  fEmptyVsTotal->SetZTitle("Correlation");
  fEmptyVsTotal->SetOption("colz");
  fEmptyVsTotal->SetDirectory(0);

  n = (fXLumping + fYLumping);
  fMean = new TH1D("poissonMean", "Mean N_{ch} as calculated by Poisson",
		   10*n+1, -.1, n+.1);
  fMean->SetXTitle("#bar{N_{ch}}=log(empty/total)");
  fMean->SetYTitle("Events");
  fMean->SetFillColor(kRed+1);
  fMean->SetFillStyle(3001);
  fMean->SetLineColor(kBlack);
  fMean->SetDirectory(0);

  fOcc = new TH1D("occupancy", "Occupancy = #int_{1}^{#infty}dN P(N)",
		  101, -.5, 100.5);
  fOcc->SetXTitle("#int_{1}^{#infty}dN P(N) [%]");
  fOcc->SetYTitle("Events");
  fOcc->SetFillColor(kBlue+1);
  fOcc->SetFillStyle(3001);
  fOcc->SetLineColor(kBlack);
  fOcc->SetDirectory(0);

  fCorr = new TH2D("correction", "Correction as function of mean N_{ch}", 
		   10*n+1, -.1, n+.1, 100, 0, 10);
  fCorr->SetXTitle("#bar{N_{ch}}");
  fCorr->SetYTitle("Correction 1/(1-e^{#bar{N_{c}}})");
  fCorr->SetZTitle("Events");
  fCorr->SetOption("colz");
  fCorr->SetDirectory(0); 
}
//____________________________________________________________________
void
AliPoissonCalculator::Output(TList* d)
{
  if (!d) return;
  if (!fEmptyVsTotal) MakeOutput();
  d->Add(fEmptyVsTotal);
  d->Add(fMean);
  d->Add(fOcc);
  d->Add(fCorr);
}

//____________________________________________________________________
void 
AliPoissonCalculator::SetLumping(UShort_t nx, UShort_t ny) 
{ 
  if (nx == fXLumping && ny == fYLumping && 
      fEmptyVsTotal && fTotal) 
    // Check if we have something to do. 
    return;
  CleanUp(); 
  Init(nx, ny);
}

//____________________________________________________________________
Int_t
AliPoissonCalculator::CheckLumping(char which, Int_t nBins, Int_t lumping) const
{
  if ((nBins % lumping) == 0) return lumping;
  Int_t l = lumping;
  do { 
    l--;
  } while (l > 0 && ((nBins % l) != 0));
  Warning("CheckLumping", "%c lumping %d is not a divisor of %d, set to %d", 
	  which, lumping, nBins, l);
  return l;
}

//____________________________________________________________________
void
AliPoissonCalculator::Reset(const TH2D* base)
{
  // 
  // Reset histogram 
  // 
  if (fBasic && fTotal && fEmpty) {
    fBasic->Reset();
    fTotal->Reset();
    fEmpty->Reset();
    return;
  }

  if (!base) return;

  Int_t    nXF   = base->GetNbinsX();
  Double_t xMin  = base->GetXaxis()->GetXmin();
  Double_t xMax  = base->GetXaxis()->GetXmax();
  Int_t    nYF   = base->GetNbinsY();
  Double_t yMin  = base->GetYaxis()->GetXmin();
  Double_t yMax  = base->GetYaxis()->GetXmax();

  fXLumping = CheckLumping('X', nXF, fXLumping);
  fYLumping = CheckLumping('Y', nYF, fYLumping);
  
  Int_t    nY    = nYF / fYLumping;
  Int_t    nX    = nXF / fXLumping;

  if (fBasic != base) { 
    fBasic = static_cast<TH2D*>(base->Clone(kBasicN));
    fBasic->SetTitle(kBasicT);
    fBasic->SetDirectory(0);
    fBasic->Sumw2();
  }

  fTotal = new TH2D(kTotalN, kTotalT, nX, xMin, xMax, nY, yMin, yMax);
  fTotal->SetDirectory(0);
  fTotal->SetXTitle(fBasic->GetXaxis()->GetTitle());
  fTotal->SetYTitle(fBasic->GetYaxis()->GetTitle());
  fTotal->Sumw2();
    
  fEmpty = static_cast<TH2D*>(fTotal->Clone(kEmptyN));
  fEmpty->SetTitle(kEmptyT);
  fEmpty->SetDirectory(0);
  // fEmpty->Sumw2();
}

//____________________________________________________________________
void
AliPoissonCalculator::Fill(UShort_t x, UShort_t y, Bool_t hit, Double_t weight)
{
  // 
  // Fill in an observation 
  // 
  // Parameters:
  //    x       X value 
  //    Y       Y value
  //    hit     True if hit 
  //    weight  Weight if this 
  //
  fTotal->Fill(x, y);
  if (hit) fBasic->Fill(x, y, weight);
  else     fEmpty->Fill(x, y);
}

//____________________________________________________________________
Double_t 
AliPoissonCalculator::CalculateMean(Double_t empty, Double_t total) const
{
  if (total <= 0) return 0;
  if (empty < .001) empty = .001;
  return -TMath::Log(empty/total);
}
//____________________________________________________________________
Double_t 
AliPoissonCalculator::CalculateCorrection(Double_t empty, Double_t total) const
{
  if (total <= 0) return 0;
  if (TMath::Abs(empty-total) < .001) empty = total - .001;
  return 1 / (1 - empty / total);
}

//____________________________________________________________________
Int_t
AliPoissonCalculator::GetReducedXBin(Int_t ix) const
{
  if (!fBasic) return 0;
  Double_t mx = fBasic->GetXaxis()->GetBinCenter(ix);
  return GetReducedXBin(mx);
}
//____________________________________________________________________
Int_t
AliPoissonCalculator::GetReducedXBin(Double_t x) const
{
  if (!fEmpty) return 0;
  return fEmpty->GetXaxis()->FindBin(x);
}
//____________________________________________________________________
Int_t
AliPoissonCalculator::GetReducedYBin(Int_t iy) const
{
  if (!fBasic) return 0;
  Double_t my = fBasic->GetYaxis()->GetBinCenter(iy);
  return GetReducedYBin(my);
}
//____________________________________________________________________
Int_t
AliPoissonCalculator::GetReducedYBin(Double_t y) const
{
  if (!fEmpty) return 0;
  return fEmpty->GetYaxis()->FindBin(y);
}



//____________________________________________________________________
TH2D*
AliPoissonCalculator::Result(Bool_t correct)
{
  // 
  // Calculate result and store in @a output
  // 
  // Return:
  //    The result histogram (fBase overwritten)
  //
  
  // Double_t total = fXLumping * fYLumping;
  
  for (Int_t ix = 1; ix <= fBasic->GetNbinsX(); ix++) { 
    // Double_t x        = fBasic->GetXaxis()->GetBinCenter(ix);
    Int_t    jx       = GetReducedXBin(ix); // fEmpty->GetXaxis()->FindBin(x);
    for (Int_t iy = 1; iy <= fBasic->GetNbinsY(); iy++) { 
      // Double_t y        = fBasic->GetYaxis()->GetBinCenter(iy);
      Int_t    jy       = GetReducedYBin(iy); // fEmpty->GetYaxis()->FindBin(y);
      Double_t empty    = fEmpty->GetBinContent(jx, jy);
      Double_t total    = fTotal->GetBinContent(jx, jy);
      Double_t hits     = fBasic->GetBinContent(ix,iy);
      // Mean in region of interest 
      Double_t poissonM = CalculateMean(empty, total);
      Double_t poissonC = (correct ? CalculateCorrection(empty, total) : 1);
      
      Double_t poissonV = hits * poissonM * poissonC;
      Double_t poissonE = TMath::Sqrt(poissonV);
      if(poissonV > 0) poissonE = TMath::Sqrt(poissonV);
	  
      fBasic->SetBinContent(ix,iy,poissonV);
      fBasic->SetBinError(ix,iy,poissonE);
    }
  }
  return fBasic;
}
  
//____________________________________________________________________
void
AliPoissonCalculator::FillDiagnostics()
{
  for (Int_t ix = 1; ix <= fEmpty->GetNbinsX(); ix++) { 
    for (Int_t iy = 1; iy <= fEmpty->GetNbinsY(); iy++) { 
      Double_t empty    = fEmpty->GetBinContent(ix, iy);
      Double_t total    = fTotal->GetBinContent(ix, iy);
      Double_t mean     = CalculateMean(empty, total);
      Double_t corr     = CalculateCorrection(empty, total);
      fEmptyVsTotal->Fill(total, empty);
      fMean->Fill(mean);
      if (total > 1e-6) fOcc->Fill(100 * (1 - empty/total));
      //Old fOcc->Fill(100 * (1 - TMath::PoissonI(0,mean)));
      fCorr->Fill(mean, corr);
    }
  }
}
//____________________________________________________________________
void
AliPoissonCalculator::Print(const Option_t*) const
{
  // 
  // Print information 
  // 
  // Parameters:
  //    option Not used
  //
  char ind[gROOT->GetDirLevel()+3];
  for (Int_t i = 0; i < gROOT->GetDirLevel(); i++) ind[i] = ' ';
  ind[gROOT->GetDirLevel()] = '\0';
  std::cout << ind << ClassName() << ": " << GetName() << '\n'
	    << std::boolalpha 
	    << ind << " X lumping:              " << fXLumping << '\n'
	    << ind << " Y lumping:              " << fYLumping << '\n'
	    << std::noboolalpha << std::endl;
}
//____________________________________________________________________
void
AliPoissonCalculator::Browse(TBrowser* b)
{
  // 
  // Browse this object
  // 
  // Parameters:
  //    b Object to browse 
  //
  if (fTotal)        b->Add(fTotal);
  if (fEmpty)        b->Add(fEmpty);
  if (fBasic)        b->Add(fBasic);
  if (fEmptyVsTotal) b->Add(fEmptyVsTotal);
  if (fMean)         b->Add(fMean);
  if (fOcc)          b->Add(fOcc);
  if (fCorr)         b->Add(fCorr);
}
// 
// EOF
//
 AliPoissonCalculator.cxx:1
 AliPoissonCalculator.cxx:2
 AliPoissonCalculator.cxx:3
 AliPoissonCalculator.cxx:4
 AliPoissonCalculator.cxx:5
 AliPoissonCalculator.cxx:6
 AliPoissonCalculator.cxx:7
 AliPoissonCalculator.cxx:8
 AliPoissonCalculator.cxx:9
 AliPoissonCalculator.cxx:10
 AliPoissonCalculator.cxx:11
 AliPoissonCalculator.cxx:12
 AliPoissonCalculator.cxx:13
 AliPoissonCalculator.cxx:14
 AliPoissonCalculator.cxx:15
 AliPoissonCalculator.cxx:16
 AliPoissonCalculator.cxx:17
 AliPoissonCalculator.cxx:18
 AliPoissonCalculator.cxx:19
 AliPoissonCalculator.cxx:20
 AliPoissonCalculator.cxx:21
 AliPoissonCalculator.cxx:22
 AliPoissonCalculator.cxx:23
 AliPoissonCalculator.cxx:24
 AliPoissonCalculator.cxx:25
 AliPoissonCalculator.cxx:26
 AliPoissonCalculator.cxx:27
 AliPoissonCalculator.cxx:28
 AliPoissonCalculator.cxx:29
 AliPoissonCalculator.cxx:30
 AliPoissonCalculator.cxx:31
 AliPoissonCalculator.cxx:32
 AliPoissonCalculator.cxx:33
 AliPoissonCalculator.cxx:34
 AliPoissonCalculator.cxx:35
 AliPoissonCalculator.cxx:36
 AliPoissonCalculator.cxx:37
 AliPoissonCalculator.cxx:38
 AliPoissonCalculator.cxx:39
 AliPoissonCalculator.cxx:40
 AliPoissonCalculator.cxx:41
 AliPoissonCalculator.cxx:42
 AliPoissonCalculator.cxx:43
 AliPoissonCalculator.cxx:44
 AliPoissonCalculator.cxx:45
 AliPoissonCalculator.cxx:46
 AliPoissonCalculator.cxx:47
 AliPoissonCalculator.cxx:48
 AliPoissonCalculator.cxx:49
 AliPoissonCalculator.cxx:50
 AliPoissonCalculator.cxx:51
 AliPoissonCalculator.cxx:52
 AliPoissonCalculator.cxx:53
 AliPoissonCalculator.cxx:54
 AliPoissonCalculator.cxx:55
 AliPoissonCalculator.cxx:56
 AliPoissonCalculator.cxx:57
 AliPoissonCalculator.cxx:58
 AliPoissonCalculator.cxx:59
 AliPoissonCalculator.cxx:60
 AliPoissonCalculator.cxx:61
 AliPoissonCalculator.cxx:62
 AliPoissonCalculator.cxx:63
 AliPoissonCalculator.cxx:64
 AliPoissonCalculator.cxx:65
 AliPoissonCalculator.cxx:66
 AliPoissonCalculator.cxx:67
 AliPoissonCalculator.cxx:68
 AliPoissonCalculator.cxx:69
 AliPoissonCalculator.cxx:70
 AliPoissonCalculator.cxx:71
 AliPoissonCalculator.cxx:72
 AliPoissonCalculator.cxx:73
 AliPoissonCalculator.cxx:74
 AliPoissonCalculator.cxx:75
 AliPoissonCalculator.cxx:76
 AliPoissonCalculator.cxx:77
 AliPoissonCalculator.cxx:78
 AliPoissonCalculator.cxx:79
 AliPoissonCalculator.cxx:80
 AliPoissonCalculator.cxx:81
 AliPoissonCalculator.cxx:82
 AliPoissonCalculator.cxx:83
 AliPoissonCalculator.cxx:84
 AliPoissonCalculator.cxx:85
 AliPoissonCalculator.cxx:86
 AliPoissonCalculator.cxx:87
 AliPoissonCalculator.cxx:88
 AliPoissonCalculator.cxx:89
 AliPoissonCalculator.cxx:90
 AliPoissonCalculator.cxx:91
 AliPoissonCalculator.cxx:92
 AliPoissonCalculator.cxx:93
 AliPoissonCalculator.cxx:94
 AliPoissonCalculator.cxx:95
 AliPoissonCalculator.cxx:96
 AliPoissonCalculator.cxx:97
 AliPoissonCalculator.cxx:98
 AliPoissonCalculator.cxx:99
 AliPoissonCalculator.cxx:100
 AliPoissonCalculator.cxx:101
 AliPoissonCalculator.cxx:102
 AliPoissonCalculator.cxx:103
 AliPoissonCalculator.cxx:104
 AliPoissonCalculator.cxx:105
 AliPoissonCalculator.cxx:106
 AliPoissonCalculator.cxx:107
 AliPoissonCalculator.cxx:108
 AliPoissonCalculator.cxx:109
 AliPoissonCalculator.cxx:110
 AliPoissonCalculator.cxx:111
 AliPoissonCalculator.cxx:112
 AliPoissonCalculator.cxx:113
 AliPoissonCalculator.cxx:114
 AliPoissonCalculator.cxx:115
 AliPoissonCalculator.cxx:116
 AliPoissonCalculator.cxx:117
 AliPoissonCalculator.cxx:118
 AliPoissonCalculator.cxx:119
 AliPoissonCalculator.cxx:120
 AliPoissonCalculator.cxx:121
 AliPoissonCalculator.cxx:122
 AliPoissonCalculator.cxx:123
 AliPoissonCalculator.cxx:124
 AliPoissonCalculator.cxx:125
 AliPoissonCalculator.cxx:126
 AliPoissonCalculator.cxx:127
 AliPoissonCalculator.cxx:128
 AliPoissonCalculator.cxx:129
 AliPoissonCalculator.cxx:130
 AliPoissonCalculator.cxx:131
 AliPoissonCalculator.cxx:132
 AliPoissonCalculator.cxx:133
 AliPoissonCalculator.cxx:134
 AliPoissonCalculator.cxx:135
 AliPoissonCalculator.cxx:136
 AliPoissonCalculator.cxx:137
 AliPoissonCalculator.cxx:138
 AliPoissonCalculator.cxx:139
 AliPoissonCalculator.cxx:140
 AliPoissonCalculator.cxx:141
 AliPoissonCalculator.cxx:142
 AliPoissonCalculator.cxx:143
 AliPoissonCalculator.cxx:144
 AliPoissonCalculator.cxx:145
 AliPoissonCalculator.cxx:146
 AliPoissonCalculator.cxx:147
 AliPoissonCalculator.cxx:148
 AliPoissonCalculator.cxx:149
 AliPoissonCalculator.cxx:150
 AliPoissonCalculator.cxx:151
 AliPoissonCalculator.cxx:152
 AliPoissonCalculator.cxx:153
 AliPoissonCalculator.cxx:154
 AliPoissonCalculator.cxx:155
 AliPoissonCalculator.cxx:156
 AliPoissonCalculator.cxx:157
 AliPoissonCalculator.cxx:158
 AliPoissonCalculator.cxx:159
 AliPoissonCalculator.cxx:160
 AliPoissonCalculator.cxx:161
 AliPoissonCalculator.cxx:162
 AliPoissonCalculator.cxx:163
 AliPoissonCalculator.cxx:164
 AliPoissonCalculator.cxx:165
 AliPoissonCalculator.cxx:166
 AliPoissonCalculator.cxx:167
 AliPoissonCalculator.cxx:168
 AliPoissonCalculator.cxx:169
 AliPoissonCalculator.cxx:170
 AliPoissonCalculator.cxx:171
 AliPoissonCalculator.cxx:172
 AliPoissonCalculator.cxx:173
 AliPoissonCalculator.cxx:174
 AliPoissonCalculator.cxx:175
 AliPoissonCalculator.cxx:176
 AliPoissonCalculator.cxx:177
 AliPoissonCalculator.cxx:178
 AliPoissonCalculator.cxx:179
 AliPoissonCalculator.cxx:180
 AliPoissonCalculator.cxx:181
 AliPoissonCalculator.cxx:182
 AliPoissonCalculator.cxx:183
 AliPoissonCalculator.cxx:184
 AliPoissonCalculator.cxx:185
 AliPoissonCalculator.cxx:186
 AliPoissonCalculator.cxx:187
 AliPoissonCalculator.cxx:188
 AliPoissonCalculator.cxx:189
 AliPoissonCalculator.cxx:190
 AliPoissonCalculator.cxx:191
 AliPoissonCalculator.cxx:192
 AliPoissonCalculator.cxx:193
 AliPoissonCalculator.cxx:194
 AliPoissonCalculator.cxx:195
 AliPoissonCalculator.cxx:196
 AliPoissonCalculator.cxx:197
 AliPoissonCalculator.cxx:198
 AliPoissonCalculator.cxx:199
 AliPoissonCalculator.cxx:200
 AliPoissonCalculator.cxx:201
 AliPoissonCalculator.cxx:202
 AliPoissonCalculator.cxx:203
 AliPoissonCalculator.cxx:204
 AliPoissonCalculator.cxx:205
 AliPoissonCalculator.cxx:206
 AliPoissonCalculator.cxx:207
 AliPoissonCalculator.cxx:208
 AliPoissonCalculator.cxx:209
 AliPoissonCalculator.cxx:210
 AliPoissonCalculator.cxx:211
 AliPoissonCalculator.cxx:212
 AliPoissonCalculator.cxx:213
 AliPoissonCalculator.cxx:214
 AliPoissonCalculator.cxx:215
 AliPoissonCalculator.cxx:216
 AliPoissonCalculator.cxx:217
 AliPoissonCalculator.cxx:218
 AliPoissonCalculator.cxx:219
 AliPoissonCalculator.cxx:220
 AliPoissonCalculator.cxx:221
 AliPoissonCalculator.cxx:222
 AliPoissonCalculator.cxx:223
 AliPoissonCalculator.cxx:224
 AliPoissonCalculator.cxx:225
 AliPoissonCalculator.cxx:226
 AliPoissonCalculator.cxx:227
 AliPoissonCalculator.cxx:228
 AliPoissonCalculator.cxx:229
 AliPoissonCalculator.cxx:230
 AliPoissonCalculator.cxx:231
 AliPoissonCalculator.cxx:232
 AliPoissonCalculator.cxx:233
 AliPoissonCalculator.cxx:234
 AliPoissonCalculator.cxx:235
 AliPoissonCalculator.cxx:236
 AliPoissonCalculator.cxx:237
 AliPoissonCalculator.cxx:238
 AliPoissonCalculator.cxx:239
 AliPoissonCalculator.cxx:240
 AliPoissonCalculator.cxx:241
 AliPoissonCalculator.cxx:242
 AliPoissonCalculator.cxx:243
 AliPoissonCalculator.cxx:244
 AliPoissonCalculator.cxx:245
 AliPoissonCalculator.cxx:246
 AliPoissonCalculator.cxx:247
 AliPoissonCalculator.cxx:248
 AliPoissonCalculator.cxx:249
 AliPoissonCalculator.cxx:250
 AliPoissonCalculator.cxx:251
 AliPoissonCalculator.cxx:252
 AliPoissonCalculator.cxx:253
 AliPoissonCalculator.cxx:254
 AliPoissonCalculator.cxx:255
 AliPoissonCalculator.cxx:256
 AliPoissonCalculator.cxx:257
 AliPoissonCalculator.cxx:258
 AliPoissonCalculator.cxx:259
 AliPoissonCalculator.cxx:260
 AliPoissonCalculator.cxx:261
 AliPoissonCalculator.cxx:262
 AliPoissonCalculator.cxx:263
 AliPoissonCalculator.cxx:264
 AliPoissonCalculator.cxx:265
 AliPoissonCalculator.cxx:266
 AliPoissonCalculator.cxx:267
 AliPoissonCalculator.cxx:268
 AliPoissonCalculator.cxx:269
 AliPoissonCalculator.cxx:270
 AliPoissonCalculator.cxx:271
 AliPoissonCalculator.cxx:272
 AliPoissonCalculator.cxx:273
 AliPoissonCalculator.cxx:274
 AliPoissonCalculator.cxx:275
 AliPoissonCalculator.cxx:276
 AliPoissonCalculator.cxx:277
 AliPoissonCalculator.cxx:278
 AliPoissonCalculator.cxx:279
 AliPoissonCalculator.cxx:280
 AliPoissonCalculator.cxx:281
 AliPoissonCalculator.cxx:282
 AliPoissonCalculator.cxx:283
 AliPoissonCalculator.cxx:284
 AliPoissonCalculator.cxx:285
 AliPoissonCalculator.cxx:286
 AliPoissonCalculator.cxx:287
 AliPoissonCalculator.cxx:288
 AliPoissonCalculator.cxx:289
 AliPoissonCalculator.cxx:290
 AliPoissonCalculator.cxx:291
 AliPoissonCalculator.cxx:292
 AliPoissonCalculator.cxx:293
 AliPoissonCalculator.cxx:294
 AliPoissonCalculator.cxx:295
 AliPoissonCalculator.cxx:296
 AliPoissonCalculator.cxx:297
 AliPoissonCalculator.cxx:298
 AliPoissonCalculator.cxx:299
 AliPoissonCalculator.cxx:300
 AliPoissonCalculator.cxx:301
 AliPoissonCalculator.cxx:302
 AliPoissonCalculator.cxx:303
 AliPoissonCalculator.cxx:304
 AliPoissonCalculator.cxx:305
 AliPoissonCalculator.cxx:306
 AliPoissonCalculator.cxx:307
 AliPoissonCalculator.cxx:308
 AliPoissonCalculator.cxx:309
 AliPoissonCalculator.cxx:310
 AliPoissonCalculator.cxx:311
 AliPoissonCalculator.cxx:312
 AliPoissonCalculator.cxx:313
 AliPoissonCalculator.cxx:314
 AliPoissonCalculator.cxx:315
 AliPoissonCalculator.cxx:316
 AliPoissonCalculator.cxx:317
 AliPoissonCalculator.cxx:318
 AliPoissonCalculator.cxx:319
 AliPoissonCalculator.cxx:320
 AliPoissonCalculator.cxx:321
 AliPoissonCalculator.cxx:322
 AliPoissonCalculator.cxx:323
 AliPoissonCalculator.cxx:324
 AliPoissonCalculator.cxx:325
 AliPoissonCalculator.cxx:326
 AliPoissonCalculator.cxx:327
 AliPoissonCalculator.cxx:328
 AliPoissonCalculator.cxx:329
 AliPoissonCalculator.cxx:330
 AliPoissonCalculator.cxx:331
 AliPoissonCalculator.cxx:332
 AliPoissonCalculator.cxx:333
 AliPoissonCalculator.cxx:334
 AliPoissonCalculator.cxx:335
 AliPoissonCalculator.cxx:336
 AliPoissonCalculator.cxx:337
 AliPoissonCalculator.cxx:338
 AliPoissonCalculator.cxx:339
 AliPoissonCalculator.cxx:340
 AliPoissonCalculator.cxx:341
 AliPoissonCalculator.cxx:342
 AliPoissonCalculator.cxx:343
 AliPoissonCalculator.cxx:344
 AliPoissonCalculator.cxx:345
 AliPoissonCalculator.cxx:346
 AliPoissonCalculator.cxx:347
 AliPoissonCalculator.cxx:348
 AliPoissonCalculator.cxx:349
 AliPoissonCalculator.cxx:350
 AliPoissonCalculator.cxx:351
 AliPoissonCalculator.cxx:352
 AliPoissonCalculator.cxx:353
 AliPoissonCalculator.cxx:354
 AliPoissonCalculator.cxx:355
 AliPoissonCalculator.cxx:356
 AliPoissonCalculator.cxx:357
 AliPoissonCalculator.cxx:358
 AliPoissonCalculator.cxx:359
 AliPoissonCalculator.cxx:360
 AliPoissonCalculator.cxx:361
 AliPoissonCalculator.cxx:362
 AliPoissonCalculator.cxx:363
 AliPoissonCalculator.cxx:364
 AliPoissonCalculator.cxx:365
 AliPoissonCalculator.cxx:366
 AliPoissonCalculator.cxx:367
 AliPoissonCalculator.cxx:368
 AliPoissonCalculator.cxx:369
 AliPoissonCalculator.cxx:370
 AliPoissonCalculator.cxx:371
 AliPoissonCalculator.cxx:372
 AliPoissonCalculator.cxx:373
 AliPoissonCalculator.cxx:374
 AliPoissonCalculator.cxx:375
 AliPoissonCalculator.cxx:376
 AliPoissonCalculator.cxx:377
 AliPoissonCalculator.cxx:378
 AliPoissonCalculator.cxx:379
 AliPoissonCalculator.cxx:380
 AliPoissonCalculator.cxx:381
 AliPoissonCalculator.cxx:382
 AliPoissonCalculator.cxx:383
 AliPoissonCalculator.cxx:384
 AliPoissonCalculator.cxx:385
 AliPoissonCalculator.cxx:386
 AliPoissonCalculator.cxx:387
 AliPoissonCalculator.cxx:388
 AliPoissonCalculator.cxx:389
 AliPoissonCalculator.cxx:390
 AliPoissonCalculator.cxx:391
 AliPoissonCalculator.cxx:392
 AliPoissonCalculator.cxx:393
 AliPoissonCalculator.cxx:394
 AliPoissonCalculator.cxx:395
 AliPoissonCalculator.cxx:396
 AliPoissonCalculator.cxx:397
 AliPoissonCalculator.cxx:398
 AliPoissonCalculator.cxx:399
 AliPoissonCalculator.cxx:400
 AliPoissonCalculator.cxx:401
 AliPoissonCalculator.cxx:402
 AliPoissonCalculator.cxx:403
 AliPoissonCalculator.cxx:404
 AliPoissonCalculator.cxx:405
 AliPoissonCalculator.cxx:406
 AliPoissonCalculator.cxx:407
 AliPoissonCalculator.cxx:408
 AliPoissonCalculator.cxx:409
 AliPoissonCalculator.cxx:410
 AliPoissonCalculator.cxx:411
 AliPoissonCalculator.cxx:412
 AliPoissonCalculator.cxx:413
 AliPoissonCalculator.cxx:414
 AliPoissonCalculator.cxx:415
 AliPoissonCalculator.cxx:416
 AliPoissonCalculator.cxx:417
 AliPoissonCalculator.cxx:418
 AliPoissonCalculator.cxx:419
 AliPoissonCalculator.cxx:420
 AliPoissonCalculator.cxx:421
 AliPoissonCalculator.cxx:422
 AliPoissonCalculator.cxx:423
 AliPoissonCalculator.cxx:424
 AliPoissonCalculator.cxx:425
 AliPoissonCalculator.cxx:426
 AliPoissonCalculator.cxx:427
 AliPoissonCalculator.cxx:428
 AliPoissonCalculator.cxx:429
 AliPoissonCalculator.cxx:430
 AliPoissonCalculator.cxx:431
 AliPoissonCalculator.cxx:432
 AliPoissonCalculator.cxx:433
 AliPoissonCalculator.cxx:434
 AliPoissonCalculator.cxx:435
 AliPoissonCalculator.cxx:436
 AliPoissonCalculator.cxx:437
 AliPoissonCalculator.cxx:438
 AliPoissonCalculator.cxx:439
 AliPoissonCalculator.cxx:440
 AliPoissonCalculator.cxx:441
 AliPoissonCalculator.cxx:442
 AliPoissonCalculator.cxx:443
 AliPoissonCalculator.cxx:444
 AliPoissonCalculator.cxx:445
 AliPoissonCalculator.cxx:446
 AliPoissonCalculator.cxx:447
 AliPoissonCalculator.cxx:448
 AliPoissonCalculator.cxx:449
 AliPoissonCalculator.cxx:450
 AliPoissonCalculator.cxx:451
 AliPoissonCalculator.cxx:452
 AliPoissonCalculator.cxx:453
 AliPoissonCalculator.cxx:454
 AliPoissonCalculator.cxx:455
 AliPoissonCalculator.cxx:456
 AliPoissonCalculator.cxx:457
 AliPoissonCalculator.cxx:458
 AliPoissonCalculator.cxx:459
 AliPoissonCalculator.cxx:460
 AliPoissonCalculator.cxx:461
 AliPoissonCalculator.cxx:462
 AliPoissonCalculator.cxx:463
 AliPoissonCalculator.cxx:464
 AliPoissonCalculator.cxx:465
 AliPoissonCalculator.cxx:466
 AliPoissonCalculator.cxx:467
 AliPoissonCalculator.cxx:468
 AliPoissonCalculator.cxx:469